@bluelibs/runner 3.4.2 → 4.0.1

package/dist/types/storeTypes.d.ts

@@ -0,0 +1,40 @@
+import { DependencyMapType, DependencyValuesType, ResourceDependencyValuesType } from "./utilities";
+import { IResource } from "./resource";
+import { ITask } from "./task";
+import { IHook } from "./hook";
+import { ITaskMiddleware } from "./taskMiddleware";
+import { IResourceMiddleware } from "./resourceMiddleware";
+import { IEvent } from "./event";
+import { IEventDefinition } from "./event";
+import { TaskLocalInterceptor } from "./utilities";
+export type ResourceStoreElementType<C = any, V extends Promise<any> = any, D extends DependencyMapType = {}, TContext = any> = {
+    resource: IResource<C, V, D>;
+    computedDependencies?: ResourceDependencyValuesType<D>;
+    config: C;
+    value: V;
+    context: TContext;
+    isInitialized?: boolean;
+};
+export type TaskStoreElementType<Input = any, Output extends Promise<any> = any, D extends DependencyMapType = any> = {
+    task: ITask<Input, Output, D>;
+    computedDependencies: DependencyValuesType<D>;
+    isInitialized: boolean;
+    interceptors?: Array<TaskLocalInterceptor<any, any>>;
+};
+export type HookStoreElementType<D extends DependencyMapType = any, TOn extends "*" | IEventDefinition = any> = {
+    hook: IHook<D, TOn>;
+    computedDependencies: DependencyValuesType<D>;
+};
+export type TaskMiddlewareStoreElementType<TDeps extends DependencyMapType = any> = {
+    middleware: ITaskMiddleware<any, TDeps>;
+    computedDependencies: DependencyValuesType<TDeps>;
+    isInitialized: boolean;
+};
+export type ResourceMiddlewareStoreElementType<TDeps extends DependencyMapType = any> = {
+    middleware: IResourceMiddleware<any, TDeps>;
+    computedDependencies: DependencyValuesType<TDeps>;
+    isInitialized: boolean;
+};
+export type EventStoreElementType = {
+    event: IEvent<any>;
+};

package/dist/types/{metadata.js → storeTypes.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=metadata.js.map
+//# sourceMappingURL=storeTypes.js.map

package/dist/types/storeTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeTypes.js","sourceRoot":"","sources":["../../src/types/storeTypes.ts"],"names":[],"mappings":""}

package/dist/types/symbols.d.ts

@@ -9,10 +9,17 @@ export declare const symbolResource: unique symbol;
 export declare const symbolResourceWithConfig: unique symbol;
 export declare const symbolEvent: unique symbol;
 export declare const symbolMiddleware: unique symbol;
+/** New brands for separated middleware kinds */
+export declare const symbolTaskMiddleware: unique symbol;
+export declare const symbolResourceMiddleware: unique symbol;
 export declare const symbolMiddlewareConfigured: unique symbol;
-export declare const symbolMiddlewareGlobal: unique symbol;
-export declare const symbolMiddlewareEverywhereTasks: unique symbol;
-export declare const symbolMiddlewareEverywhereResources: unique symbol;
+/** @internal Marks hook definitions (event listeners without middleware) */
+export declare const symbolHook: unique symbol;
+/** @internal Marks a tag definition */
+export declare const symbolTag: unique symbol;
+export declare const symbolTagConfigured: unique symbol;
+/** @internal Marks an optional dependency wrapper */
+export declare const symbolOptionalDependency: unique symbol;
 /** @internal Path to aid anonymous id generation and error messages */
 export declare const symbolFilePath: unique symbol;
 /** @internal Marks disposable instances */
@@ -21,21 +28,3 @@ export declare const symbolDispose: unique symbol;
 export declare const symbolStore: unique symbol;
 /** @internal Brand used by index() resources */
 export declare const symbolIndexResource: unique symbol;
-/**
- * Convenience bag of internal symbols. Intended for framework internals;
- * consumers should not rely on this shape.
- * @internal
- */
-export declare const symbols: {
-    task: symbol;
-    resource: symbol;
-    resourceWithConfig: symbol;
-    indexResource: symbol;
-    event: symbol;
-    middleware: symbol;
-    middlewareEverywhereTasks: symbol;
-    middlewareEverywhereResources: symbol;
-    filePath: symbol;
-    dispose: symbol;
-    store: symbol;
-};

package/dist/types/symbols.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.symbols = exports.symbolIndexResource = exports.symbolStore = exports.symbolDispose = exports.symbolFilePath = exports.symbolMiddlewareEverywhereResources = exports.symbolMiddlewareEverywhereTasks = exports.symbolMiddlewareGlobal = exports.symbolMiddlewareConfigured = exports.symbolMiddleware = exports.symbolEvent = exports.symbolResourceWithConfig = exports.symbolResource = exports.symbolTask = void 0;
+exports.symbolIndexResource = exports.symbolStore = exports.symbolDispose = exports.symbolFilePath = exports.symbolOptionalDependency = exports.symbolTagConfigured = exports.symbolTag = exports.symbolHook = exports.symbolMiddlewareConfigured = exports.symbolResourceMiddleware = exports.symbolTaskMiddleware = exports.symbolMiddleware = exports.symbolEvent = exports.symbolResourceWithConfig = exports.symbolResource = exports.symbolTask = void 0;
 /**
  * Internal brand symbols used to tag created objects at runtime and help with
  * type‑narrowing. Prefer the `isTask`/`isResource`/`isEvent`/`isMiddleware`
@@ -12,10 +12,23 @@ exports.symbolResource = Symbol("runner.resource");
 exports.symbolResourceWithConfig = Symbol("runner.resourceWithConfig");
 exports.symbolEvent = Symbol("runner.event");
 exports.symbolMiddleware = Symbol("runner.middleware");
+/** New brands for separated middleware kinds */
+exports.symbolTaskMiddleware = Symbol("runner.taskMiddleware");
+exports.symbolResourceMiddleware = Symbol("runner.resourceMiddleware");
 exports.symbolMiddlewareConfigured = Symbol("runner.middlewareConfigured");
-exports.symbolMiddlewareGlobal = Symbol("runner.middlewareGlobal");
-exports.symbolMiddlewareEverywhereTasks = Symbol("runner.middlewareGlobalTasks");
-exports.symbolMiddlewareEverywhereResources = Symbol("runner.middlewareGlobalResources");
+/** @internal Marks hook definitions (event listeners without middleware) */
+exports.symbolHook = Symbol("runner.hook");
+// export const symbolMiddlewareEverywhereTasks: unique symbol = Symbol(
+//   "runner.middlewareGlobalTasks",
+// );
+// export const symbolMiddlewareEverywhereResources: unique symbol = Symbol(
+//   "runner.middlewareGlobalResources",
+// );
+/** @internal Marks a tag definition */
+exports.symbolTag = Symbol("runner.tag");
+exports.symbolTagConfigured = Symbol("runner.tagConfigured");
+/** @internal Marks an optional dependency wrapper */
+exports.symbolOptionalDependency = Symbol("runner.optionalDependency");
 /** @internal Path to aid anonymous id generation and error messages */
 exports.symbolFilePath = Symbol("runner.filePath");
 /** @internal Marks disposable instances */
@@ -24,22 +37,4 @@ exports.symbolDispose = Symbol("runner.dispose");
 exports.symbolStore = Symbol("runner.store");
 /** @internal Brand used by index() resources */
 exports.symbolIndexResource = Symbol("runner.indexResource");
-/**
- * Convenience bag of internal symbols. Intended for framework internals;
- * consumers should not rely on this shape.
- * @internal
- */
-exports.symbols = {
-    task: exports.symbolTask,
-    resource: exports.symbolResource,
-    resourceWithConfig: exports.symbolResourceWithConfig,
-    indexResource: exports.symbolIndexResource,
-    event: exports.symbolEvent,
-    middleware: exports.symbolMiddleware,
-    middlewareEverywhereTasks: exports.symbolMiddlewareEverywhereTasks,
-    middlewareEverywhereResources: exports.symbolMiddlewareEverywhereResources,
-    filePath: exports.symbolFilePath,
-    dispose: exports.symbolDispose,
-    store: exports.symbolStore,
-};
 //# sourceMappingURL=symbols.js.map

package/dist/types/symbols.js.map

@@ -1 +1 @@
-{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../src/types/symbols.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,UAAU,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AAClD,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AACW,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AACpD,QAAA,gBAAgB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC9D,QAAA,0BAA0B,GAAkB,MAAM,CAC7D,6BAA6B,CAC9B,CAAC;AACW,QAAA,sBAAsB,GAAkB,MAAM,CACzD,yBAAyB,CAC1B,CAAC;AACW,QAAA,+BAA+B,GAAkB,MAAM,CAClE,8BAA8B,CAC/B,CAAC;AACW,QAAA,mCAAmC,GAAkB,MAAM,CACtE,kCAAkC,CACnC,CAAC;AAEF,uEAAuE;AAC1D,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AACvE,2CAA2C;AAC9B,QAAA,aAAa,GAAkB,MAAM,CAAC,gBAAgB,CAAC,CAAC;AACrE,uCAAuC;AAC1B,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AAEjE,gDAAgD;AACnC,QAAA,mBAAmB,GAAkB,MAAM,CACtD,sBAAsB,CACvB,CAAC;AAEF;;;;GAIG;AACU,QAAA,OAAO,GAAG;IACrB,IAAI,EAAE,kBAAU;IAChB,QAAQ,EAAE,sBAAc;IACxB,kBAAkB,EAAE,gCAAwB;IAC5C,aAAa,EAAE,2BAAmB;IAClC,KAAK,EAAE,mBAAW;IAClB,UAAU,EAAE,wBAAgB;IAC5B,yBAAyB,EAAE,uCAA+B;IAC1D,6BAA6B,EAAE,2CAAmC;IAClE,QAAQ,EAAE,sBAAc;IACxB,OAAO,EAAE,qBAAa;IACtB,KAAK,EAAE,mBAAW;CACnB,CAAC"}
+{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../src/types/symbols.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,UAAU,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AAClD,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AACW,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AACpD,QAAA,gBAAgB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC3E,gDAAgD;AACnC,QAAA,oBAAoB,GAAkB,MAAM,CACvD,uBAAuB,CACxB,CAAC;AACW,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AACW,QAAA,0BAA0B,GAAkB,MAAM,CAC7D,6BAA6B,CAC9B,CAAC;AACF,4EAA4E;AAC/D,QAAA,UAAU,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AAC/D,wEAAwE;AACxE,oCAAoC;AACpC,KAAK;AACL,4EAA4E;AAC5E,wCAAwC;AACxC,KAAK;AACL,uCAAuC;AAC1B,QAAA,SAAS,GAAkB,MAAM,CAAC,YAAY,CAAC,CAAC;AAChD,QAAA,mBAAmB,GAAkB,MAAM,CACtD,sBAAsB,CACvB,CAAC;AAEF,qDAAqD;AACxC,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AAEF,uEAAuE;AAC1D,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AACvE,2CAA2C;AAC9B,QAAA,aAAa,GAAkB,MAAM,CAAC,gBAAgB,CAAC,CAAC;AACrE,uCAAuC;AAC1B,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AAEjE,gDAAgD;AACnC,QAAA,mBAAmB,GAAkB,MAAM,CACtD,sBAAsB,CACvB,CAAC"}

package/dist/types/tag.d.ts

@@ -0,0 +1,46 @@
+import { IContractable } from "./contracts";
+import { ITagMeta } from "./meta";
+import { IValidationSchema, RequiredKeys, symbolFilePath, symbolTag, symbolTagConfigured } from "./utilities";
+export interface ITaggable {
+    tags: TagType[];
+}
+export interface ITagDefinition<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> {
+    id: string;
+    meta?: ITagMeta;
+    configSchema?: IValidationSchema<TConfig>;
+    /**
+     * Utilizing config at definition level stores its defaults
+     */
+    config?: TConfig;
+}
+export interface ITag<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> extends ITagDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
+    /**
+     * A special validation property.
+     * It resolves to `true` if TConfig only has optional keys, otherwise `false`.
+     */
+    readonly __configHasOnlyOptionalKeys: RequiredKeys<TConfig> extends never ? true : false;
+    config?: TConfig;
+    /**
+     * Checks if the tag exists in a taggable or a list of tags.
+     */
+    exists(target: ITaggable | TagType[]): boolean;
+    /**
+     * Creates a configured instance of the tag.
+     */
+    with(config: TConfig): ITagConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract>;
+    /**
+     * Extracts the configuration of the tag from a taggable or a list of tags.
+     */
+    extract(target: ITaggable | TagType[]): TConfig | undefined;
+    [symbolFilePath]: string;
+    [symbolTag]: true;
+}
+type ITagWithOptionalConfig<TValue, TEnforceInputContract, TEnforceOutputContract> = ITag<any, TEnforceInputContract, TEnforceOutputContract> & {
+    readonly __configHasOnlyOptionalKeys: true;
+};
+export interface ITagConfigured<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> extends ITag<TConfig, TEnforceInputContract, TEnforceOutputContract> {
+    [symbolTagConfigured]: true;
+    config: TConfig;
+}
+export type TagType = ITag<void, any, any> | ITagWithOptionalConfig<any, any, any> | ITagConfigured<any, any, any>;
+export {};

package/dist/{resource.types.js → types/tag.js}

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=resource.types.js.map
+const utilities_1 = require("./utilities");
+//# sourceMappingURL=tag.js.map

package/dist/types/tag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.js","sourceRoot":"","sources":["../../src/types/tag.ts"],"names":[],"mappings":";;AAEA,2CAMqB"}

package/dist/types/task.d.ts

@@ -1,68 +1,44 @@
-import type { ITaskMeta } from './metadata';
-import type { DependencyMapType, DependencyValuesType } from './dependencies';
-import type { IEventDefinition, IEvent, IEventEmission } from './event';
-import type { MiddlewareAttachments } from './middleware';
-export type BeforeRunEventPayload<TInput> = {
-    input: TInput;
-};
-export type AfterRunEventPayload<TInput, TOutput> = {
-    input: TInput;
-    output: TOutput extends Promise<infer U> ? U : TOutput;
-    setOutput(newOutput: TOutput extends Promise<infer U> ? U : TOutput): void;
-};
-export type OnErrorEventPayload = {
-    error: any;
-    /**
-     * This function can be called to suppress the error from being thrown.
-     */
-    suppress(): void;
-};
-type ExtractEventParams<T> = T extends IEventDefinition<infer P> ? P : never;
-export interface ITaskDefinition<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined> {
-    /**
-     * Stable identifier. If omitted, an anonymous id is generated from file path
-     * (see README: Anonymous IDs).
-     */
-    id?: string | symbol;
+import { DependencyMapType, DependencyValuesType, IOptionalDependency, IValidationSchema, TaskMiddlewareAttachmentType } from "../defs";
+import { TagType } from "./tag";
+import { ITaskMeta } from "./meta";
+import { symbolFilePath, symbolTask } from "./symbols";
+import { EnsureInputSatisfiesContracts, EnsureOutputSatisfiesContracts, HasInputContracts, HasOutputContracts } from "./contracts";
+export interface ITaskDefinition<TInput = undefined, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
+    id: string;
     /**
      * Access other tasks/resources/events. Can be an object or a function when
      * you need late or config‑dependent resolution.
      */
     dependencies?: TDependencies | (() => TDependencies);
     /** Middleware applied around task execution. */
-    middleware?: MiddlewareAttachments[];
+    middleware?: TMiddleware;
+    /** Optional metadata used for docs, filtering and tooling. */
+    meta?: TMeta;
     /**
-     * Listen to events in a simple way
+     * Optional validation schema for runtime input validation.
+     * When provided, task input will be validated before execution.
      */
-    on?: TOn;
+    inputSchema?: IValidationSchema<TInput>;
     /**
-     * This makes sense only when `on` is specified to provide the order of the execution.
-     * The event with the lowest order will be executed first.
+     * Optional validation schema for the task result.
+     * When provided, the result will be validated immediately after the task's
+     * `run` resolves, without considering middleware.
      */
-    listenerOrder?: number;
-    /** Optional metadata used for docs, filtering and tooling. */
-    meta?: ITaskMeta;
+    resultSchema?: IValidationSchema<TOutput extends Promise<infer U> ? U : never>;
+    run: (input: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? EnsureInputSatisfiesContracts<[...TTags, ...TMiddleware], TInput> : TInput, dependencies: DependencyValuesType<TDependencies>) => HasOutputContracts<[...TTags, ...TMiddleware]> extends true ? EnsureOutputSatisfiesContracts<[...TTags, ...TMiddleware], TOutput> : TOutput;
     /**
-     * The task body. If `on` is set, the input is an `IEventEmission`. Otherwise,
-     * it's the declared input type.
+     * Tags applied to the task that might define its behvaiour or impact the systems.
      */
-    run: (input: TOn extends undefined ? TInput : IEventEmission<TOn extends "*" ? any : ExtractEventParams<TOn>>, dependencies: DependencyValuesType<TDependencies>) => TOutput;
+    tags?: TTags;
 }
-/**
- * This is the response after the definition has been prepared. TODO: better naming?
- */
-export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined> extends ITaskDefinition<TInput, TOutput, TDependencies, TOn> {
-    id: string | symbol;
+export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> extends ITaskDefinition<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware> {
+    [symbolFilePath]: string;
+    [symbolTask]: true;
+    id: string;
     dependencies: TDependencies | (() => TDependencies);
     computedDependencies?: DependencyValuesType<TDependencies>;
-    middleware: MiddlewareAttachments[];
-    /**
-     * These events are automatically populated after the task has been defined.
-     */
-    events: {
-        beforeRun: IEvent<BeforeRunEventPayload<TInput>>;
-        afterRun: IEvent<AfterRunEventPayload<TInput, TOutput>>;
-        onError: IEvent<OnErrorEventPayload>;
-    };
+    middleware: TMiddleware;
+    /** Return an optional dependency wrapper for this task. */
+    optional: () => IOptionalDependency<ITask<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware>>;
+    tags: TTags;
 }
-export {};

package/dist/types/task.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const symbols_1 = require("./symbols");
 //# sourceMappingURL=task.js.map

package/dist/types/task.js.map

@@ -1 +1 @@
-{"version":3,"file":"task.js","sourceRoot":"","sources":["../../src/types/task.ts"],"names":[],"mappings":""}
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../src/types/task.ts"],"names":[],"mappings":";;AAUA,uCAAuD"}

package/dist/types/taskMiddleware.d.ts

@@ -0,0 +1,48 @@
+import { DependencyMapType, DependencyValuesType, IValidationSchema, ITask } from "../defs";
+import { TagType } from "./tag";
+import { IMiddlewareMeta } from "./meta";
+import { symbolFilePath, symbolMiddlewareConfigured, symbolTaskMiddleware } from "./symbols";
+import { IContractable } from "./contracts";
+export interface ITaskMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
+    id: string;
+    /** Static or lazy dependency map. */
+    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
+    /**
+     * Optional validation schema for runtime config validation.
+     * When provided, middleware config will be validated when .with() is called.
+     */
+    configSchema?: IValidationSchema<TConfig>;
+    /**
+     * The middleware body, called with task execution input.
+     */
+    run: (input: ITaskMiddlewareExecutionInput<TEnforceInputContract extends void ? any : TEnforceInputContract, TEnforceOutputContract extends void ? any : TEnforceOutputContract>, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
+    meta?: IMiddlewareMeta;
+    tags?: TagType[];
+    everywhere?: boolean | ((task: ITask<any, any, any, any>) => boolean);
+}
+export interface ITaskMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends ITaskMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
+    [symbolTaskMiddleware]: true;
+    [symbolFilePath]: string;
+    id: string;
+    dependencies: TDependencies | (() => TDependencies);
+    /** Current configuration object (empty by default). */
+    config: TConfig;
+    /** Configure the middleware and return a marked, configured instance. */
+    with: (config: TConfig) => ITaskMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
+    tags: TagType[];
+}
+export interface ITaskMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends ITaskMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies> {
+    [symbolMiddlewareConfigured]: true;
+    config: TConfig;
+}
+export interface ITaskMiddlewareExecutionInput<TTaskInput = any, TTaskOutput = any> {
+    /** Task hook */
+    task: {
+        definition: ITask<TTaskInput, any, any, any>;
+        input: TTaskInput;
+    };
+    next: (taskInput?: TTaskInput) => Promise<TTaskOutput>;
+}
+export type TaskMiddlewareAttachmentType = ITaskMiddleware<void, any, any, any> | ITaskMiddleware<{
+    [K in any]?: any;
+}, any, any, any> | ITaskMiddlewareConfigured<any, any, any, any>;

package/dist/{event.types.js → types/taskMiddleware.js}

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const symbols_1 = require("./symbols");
-//# sourceMappingURL=event.types.js.map
+//# sourceMappingURL=taskMiddleware.js.map

package/dist/types/taskMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskMiddleware.js","sourceRoot":"","sources":["../../src/types/taskMiddleware.ts"],"names":[],"mappings":";;AAQA,uCAImB"}

package/dist/types/utilities.d.ts

@@ -1,7 +1,106 @@
-export type Optional<T> = {
-    [K in keyof T]?: T[K];
+import { IResource, IResourceWithConfig } from "./resource";
+import { ITask } from "./task";
+import { ITaskMiddleware } from "./taskMiddleware";
+import { IResourceMiddleware } from "./resourceMiddleware";
+import { IHook } from "./hook";
+import { IEvent, IEventDefinition } from "./event";
+import { ITag } from "./tag";
+import { symbolOptionalDependency } from "./symbols";
+export * from "./symbols";
+/**
+ * Generic validation schema interface that can be implemented by any validation library.
+ * Compatible with Zod, Yup, Joi, and other validation libraries.
+ */
+export interface IValidationSchema<T = any> {
+    /**
+     * Parse and validate the input data.
+     * Should throw an error if validation fails.
+     * Can transform the data if the schema supports transformations.
+     */
+    parse(input: unknown): T;
+}
+/**
+ * Core public TypeScript types for BlueLibs Runner.
+ *
+ * This file contains the strongly-typed contract for tasks, resources, events
+ * and middleware. It mirrors the mental model described in the README:
+ * - Tasks are functions
+ * - Resources are singletons (with init/dispose hooks)
+ * - Events are simple, strongly-typed emissions
+ * - Middleware can target both tasks and resources
+ *
+ * DX goals:
+ * - Crystal‑clear generics and helper types that infer dependency shapes
+ * - Friendly JSDoc you can hover in editors to understand usage instantly
+ * - Safe overrides and strong typing around config and register mechanics
+ */
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+/**
+ * The reason we accept null and undefined is because we want to be able to offer beautiful DX:
+ * overrides: [
+ *    process.env.NODE_ENV === 'production' ? prodEmailer : null,
+ * ]
+ */
+export type OverridableElements = IResource<any, any, any, any, any> | ITask<any, any, any, any> | ITaskMiddleware<any> | IResourceMiddleware<any, any> | IResourceWithConfig<any, any, any> | IHook<any, any> | undefined | null;
+/**
+ * A mapping of dependency keys to Runner definitions. Used in `dependencies`
+ * for tasks and resources. Values are later transformed into the actual
+ * callable/value shape by `DependencyValuesType`.
+ */
+export type DependencyMapType = Record<string, ITask<any, any, any, any, any, any> | IResource<any, any, any, any, any, any, any> | IEvent<any> | IOptionalDependency<ITask<any, any, any, any, any, any>> | IOptionalDependency<IResource<any, any, any, any, any, any, any>> | IOptionalDependency<IEvent<any>>>;
+/** Wrapper type marking a dependency as optional at wiring time */
+export interface IOptionalDependency<T> {
+    /** The wrapped dependency definition */
+    inner: T;
+    /** Brand symbol for optional dependency */
+    [symbolOptionalDependency]: true;
+}
+type ExtractTaskInput<T> = T extends ITask<infer I, any, infer D> ? I : never;
+type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer D> ? O : never;
+type ExtractResourceValue<T> = T extends IResource<any, infer V, infer D> ? V extends Promise<infer U> ? U : V : never;
+export type ExtractEventParams<T> = T extends IEvent<infer P> ? P : never;
+/**
+ * Task dependencies transform into callable functions: call with the task input
+ * and you receive the task output.
+ */
+type TaskDependency<I, O> = (...args: I extends null | void ? [] : [I]) => O;
+/**
+ * Resource dependencies resolve to the resource's value directly.
+ */
+type ResourceDependency<V> = V;
+/**
+ * Event dependencies resolve to an emitter function. If the payload type is
+ * `void`, the function can be called with zero args (or an empty object).
+ */
+type EventDependency<P> = P extends void ? (() => Promise<void>) & ((input?: Record<string, never>) => Promise<void>) : (input: P) => Promise<void>;
+/**
+ * Transforms a dependency definition into the usable shape inside `run`/`init`:
+ * - Task -> callable function
+ * - Resource -> resolved value
+ * - Event -> emit function
+ */
+export type DependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependency<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventParams<T>> : T extends IOptionalDependency<infer U> ? DependencyValueType<U> | undefined : never;
+export type DependencyValuesType<T extends DependencyMapType> = {
+    [K in keyof T]: DependencyValueType<T[K]>;
 };
-export type IsVoid<T> = [T] extends [void] ? true : false;
-export type IsOptional<T> = undefined extends T ? true : false;
-export type OptionalOrVoidOrAnything<T> = IsVoid<T> extends true ? void : IsOptional<T> extends true ? Optional<T> : T;
-export type OnlyOptionalFields<T> = {} extends T ? true : false;
+export type TaskLocalInterceptor<TInput, TOutput> = (next: (input: TInput) => TOutput, input: TInput) => TOutput;
+export type TaskDependencyWithIntercept<TInput, TOutput> = TaskDependency<TInput, TOutput> & {
+    intercept: (middleware: TaskLocalInterceptor<TInput, TOutput>) => void;
+};
+/** Resource-context dependency typing where tasks expose intercept() */
+export type ResourceDependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependencyWithIntercept<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventParams<T>> : T extends IOptionalDependency<infer U> ? ResourceDependencyValueType<U> | undefined : never;
+export type ResourceDependencyValuesType<T extends DependencyMapType> = {
+    [K in keyof T]: ResourceDependencyValueType<T[K]>;
+};
+/**
+ * Anything you can put inside a resource's `register: []`.
+ * - Resources (with or without `.with()`)
+ * - Tasks
+ * - Middleware
+ * - Events
+ */
+export type RegisterableItems<T = any> = IResourceWithConfig<any, any, any, any, any, any, any> | IResource<void, any, any, any, any, any, any> | IResource<{
+    [K in any]?: any;
+}, any, any, any, any, any, any> | ITask<any, any, any, any> | IHook<any, any> | ITaskMiddleware<any, any, any, any> | IResourceMiddleware<any, any, any, any> | IEvent<any> | ITag<any, any, any>;

package/dist/types/utilities.js

@@ -1,5 +1,19 @@
 "use strict";
-// Layer 1: Foundation - Utility Types
-// No dependencies
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const symbols_1 = require("./symbols");
+__exportStar(require("./symbols"), exports);
 //# sourceMappingURL=utilities.js.map

package/dist/types/utilities.js.map

@@ -1 +1 @@
-{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../src/types/utilities.ts"],"names":[],"mappings":";AAAA,sCAAsC;AACtC,kBAAkB"}
+{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../src/types/utilities.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAOA,uCAAqD;AAErD,4CAA0B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluelibs/runner",
-  "version": "3.4.2",
+  "version": "4.0.1",
   "description": "BlueLibs Runner",
   "main": "dist/index.js",
   "repository": {
@@ -8,7 +8,8 @@
     "url": "https://github.com/bluelibs/bluelibs"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
     "watch": "tsc -w",
     "test": "jest --verbose --runInBand",
     "test:dev": "jest --verbose --watch",
@@ -16,9 +17,9 @@
     "test:clean": "jest --clearCache",
     "testonly": "npm test",
     "test:ci": "jest --verbose --coverage --ci --maxWorkers=2 --reporters=default --reporters=jest-junit",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run clean && npm run build",
     "typedoc": "typedoc --options typedoc.json",
-    "benchmark": "jest --testMatch=\"**/__tests__/benchmark/benchmark.test.ts\" --testTimeout 10000"
+    "benchmark": "jest --config jest.bench.config.js --verbose"
   },
   "devDependencies": {
     "@types/benchmark": "^2.1.5",
@@ -41,12 +42,20 @@
     "ts-jest": "^29.0.0",
     "typedoc": "^0.26.7",
     "typedoc-material-theme": "^1.1.0",
-    "typescript": "^5.6.2"
+    "typedoc-plugin-pages": "^1.1.0",
+    "typescript": "^5.6.2",
+    "zod": "^4.0.17"
   },
   "typings": "dist/index.d.ts",
   "typescript": {
     "definition": "dist/index.d.ts"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "AI.md",
+    "LICENSE.md"
+  ],
   "license": "MIT",
   "dependencies": {
     "lru-cache": "^11.1.0"

package/dist/cli/extract-docs.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};