@bluelibs/runner 5.1.0 → 5.2.1

package/dist/types/define.d.ts

@@ -0,0 +1,9 @@
+export { defineTask } from "./definers/defineTask";
+export { defineHook } from "./definers/defineHook";
+export { defineResource } from "./definers/defineResource";
+export { defineEvent } from "./definers/defineEvent";
+export { defineTaskMiddleware } from "./definers/defineTaskMiddleware";
+export { defineResourceMiddleware } from "./definers/defineResourceMiddleware";
+export { defineOverride } from "./definers/defineOverride";
+export { defineTag } from "./definers/defineTag";
+export { isTask, isPhantomTask, isResource, isResourceWithConfig, isEvent, isHook, isTaskMiddleware, isResourceMiddleware, isTag, isOptional, isError, isAsyncContext, } from "./definers/tools";

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

@@ -0,0 +1,6 @@
+import type { AsyncContextFluentBuilder } from "./fluent-builder.interface";
+import type { BuilderState } from "./types";
+/**
+ * Creates an AsyncContextFluentBuilder from the given state.
+ */
+export declare function makeAsyncContextBuilder<T>(state: BuilderState<T>): AsyncContextFluentBuilder<T>;

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

@@ -0,0 +1,9 @@
+import type { IAsyncContext, IAsyncContextMeta, IValidationSchema } from "../../../defs";
+export interface AsyncContextFluentBuilder<T = unknown> {
+    id: string;
+    serialize(fn: (data: T) => string): AsyncContextFluentBuilder<T>;
+    parse(fn: (raw: string) => T): AsyncContextFluentBuilder<T>;
+    configSchema(schema: IValidationSchema<T>): AsyncContextFluentBuilder<T>;
+    meta<TNewMeta extends IAsyncContextMeta>(m: TNewMeta): AsyncContextFluentBuilder<T>;
+    build(): IAsyncContext<T>;
+}

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

@@ -0,0 +1,10 @@
+import type { AsyncContextFluentBuilder } from "./fluent-builder.interface";
+export * from "./fluent-builder.interface";
+export * from "./fluent-builder";
+export * from "./types";
+export * from "./utils";
+/**
+ * Entry point for creating an async context builder.
+ */
+export declare function asyncContextBuilder<T = unknown>(id: string): AsyncContextFluentBuilder<T>;
+export declare const asyncContext: typeof asyncContextBuilder;

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

@@ -0,0 +1,13 @@
+import type { IAsyncContextMeta, IValidationSchema } from "../../../defs";
+/**
+ * Internal state for the AsyncContextFluentBuilder.
+ * Kept immutable and frozen.
+ */
+export type BuilderState<T> = Readonly<{
+    id: string;
+    filePath: string;
+    serialize?: (data: T) => string;
+    parse?: (raw: string) => T;
+    configSchema?: IValidationSchema<T>;
+    meta?: IAsyncContextMeta;
+}>;

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

@@ -0,0 +1,5 @@
+import type { BuilderState } from "./types";
+/**
+ * Clones and patches the builder state immutably.
+ */
+export declare function clone<T>(s: BuilderState<T>, patch: Partial<BuilderState<T>>): BuilderState<T>;

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

@@ -0,0 +1 @@
+export * from "./asyncContext/index";

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

@@ -0,0 +1,30 @@
+import type { DependencyMapType, IEventDefinition, IResourceDefinition, ITaskDefinition, IHookDefinition, ITaskMiddlewareDefinition, IResourceMiddlewareDefinition, TagType, ResourceMiddlewareAttachmentType, TaskMiddlewareAttachmentType } from "../../defs";
+import type { IResourceMeta, ITaskMeta } from "../../defs";
+export type Immutable<T> = {
+    readonly [K in keyof T]: Immutable<T[K]>;
+};
+export type ReadonlyDeep<T> = Immutable<T>;
+export interface ResourceBuilder<TConfig = void, TValue extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TContext = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> {
+    id: string;
+    definition: ReadonlyDeep<IResourceDefinition<TConfig, TValue, TDeps, TContext, any, any, TMeta, TTags, TMiddleware>>;
+}
+export interface TaskBuilder<TInput = undefined, TOutput extends Promise<any> = any, TDeps extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
+    id: string;
+    definition: ReadonlyDeep<ITaskDefinition<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>>;
+}
+export interface EventBuilder<TPayload = void> {
+    id: string;
+    definition: ReadonlyDeep<IEventDefinition<TPayload>>;
+}
+export interface HookBuilder<TDeps extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] = any, TMeta extends ITaskMeta = any> {
+    id: string;
+    definition: ReadonlyDeep<IHookDefinition<TDeps, TOn, TMeta>>;
+}
+export interface TaskMiddlewareBuilder<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
+    id: string;
+    definition: ReadonlyDeep<ITaskMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>>;
+}
+export interface ResourceMiddlewareBuilder<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
+    id: string;
+    definition: ReadonlyDeep<IResourceMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>>;
+}

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

@@ -0,0 +1,7 @@
+import type { DefaultErrorType } from "../../../defs";
+import type { ErrorFluentBuilder } from "./fluent-builder.interface";
+import type { BuilderState } from "./types";
+/**
+ * Creates an ErrorFluentBuilder from the given state.
+ */
+export declare function makeErrorBuilder<TData extends DefaultErrorType>(state: BuilderState<TData>): ErrorFluentBuilder<TData>;

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

@@ -0,0 +1,10 @@
+import type { DefaultErrorType, IErrorMeta, IValidationSchema, IErrorHelper } from "../../../defs";
+export interface ErrorFluentBuilder<TData extends DefaultErrorType = DefaultErrorType> {
+    id: string;
+    serialize(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
+    parse(fn: (raw: string) => TData): ErrorFluentBuilder<TData>;
+    dataSchema(schema: IValidationSchema<TData>): ErrorFluentBuilder<TData>;
+    build(): IErrorHelper<TData>;
+    format(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
+    meta<TNewMeta extends IErrorMeta>(m: TNewMeta): ErrorFluentBuilder<TData>;
+}

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

@@ -0,0 +1,11 @@
+import type { DefaultErrorType } from "../../../defs";
+import type { ErrorFluentBuilder } from "./fluent-builder.interface";
+export * from "./fluent-builder.interface";
+export * from "./fluent-builder";
+export * from "./types";
+export * from "./utils";
+/**
+ * Entry point for creating an error builder.
+ */
+export declare function errorBuilder<TData extends DefaultErrorType = DefaultErrorType>(id: string): ErrorFluentBuilder<TData>;
+export declare const error: typeof errorBuilder;

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

@@ -0,0 +1,14 @@
+import type { DefaultErrorType, IErrorMeta, IValidationSchema } from "../../../defs";
+/**
+ * Internal state for the ErrorFluentBuilder.
+ * Kept immutable and frozen.
+ */
+export type BuilderState<TData extends DefaultErrorType> = Readonly<{
+    id: string;
+    filePath: string;
+    format?: (data: TData) => string;
+    serialize?: (data: TData) => string;
+    parse?: (raw: string) => TData;
+    dataSchema?: IValidationSchema<TData>;
+    meta?: IErrorMeta;
+}>;

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

@@ -0,0 +1,6 @@
+import type { DefaultErrorType } from "../../../defs";
+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>;

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

@@ -0,0 +1 @@
+export * from "./error/index";

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

@@ -0,0 +1,7 @@
+import type { EventFluentBuilder } from "./fluent-builder.interface";
+import type { BuilderState } from "./types";
+/**
+ * Creates an EventFluentBuilder from the given state.
+ * Each builder method returns a new builder with updated state.
+ */
+export declare function makeEventBuilder<TPayload>(state: BuilderState<TPayload>): EventFluentBuilder<TPayload>;

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

@@ -0,0 +1,18 @@
+import type { IEvent, IEventMeta, IValidationSchema, TagType } from "../../../defs";
+export interface EventFluentBuilder<TPayload = void> {
+    id: string;
+    payloadSchema<TNew>(schema: IValidationSchema<TNew>): EventFluentBuilder<TNew>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: boolean;
+    }): EventFluentBuilder<TPayload>;
+    meta<TNewMeta extends IEventMeta>(m: TNewMeta): EventFluentBuilder<TPayload>;
+    /**
+     * Enable parallel execution for this event's listeners.
+     * When enabled, listeners with the same `order` run concurrently within a batch.
+     * Batches execute sequentially in ascending order priority.
+     *
+     * @param enabled - Whether to enable parallel execution (default: true)
+     */
+    parallel(enabled?: boolean): EventFluentBuilder<TPayload>;
+    build(): IEvent<TPayload>;
+}

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

@@ -0,0 +1,10 @@
+import type { EventFluentBuilder } from "./fluent-builder.interface";
+export * from "./fluent-builder.interface";
+export * from "./fluent-builder";
+export * from "./types";
+export * from "./utils";
+/**
+ * Entry point for creating an event builder.
+ */
+export declare function eventBuilder<TPayload = void>(id: string): EventFluentBuilder<TPayload>;
+export declare const event: typeof eventBuilder;

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

@@ -0,0 +1,8 @@
+import type { IEventDefinition } from "../../../defs";
+/**
+ * Internal state for the EventFluentBuilder.
+ * Kept immutable and frozen.
+ */
+export type BuilderState<TPayload> = Readonly<Required<Pick<IEventDefinition<TPayload>, "id" | "meta" | "tags">> & Pick<IEventDefinition<TPayload>, "parallel" | "payloadSchema"> & {
+    filePath: string;
+}>;

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

@@ -0,0 +1,9 @@
+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[];

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

@@ -0,0 +1 @@
+export * from "./event/index";

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

@@ -0,0 +1,8 @@
+import type { DependencyMapType, IEventDefinition, ITaskMeta } from "../../../defs";
+import type { HookFluentBuilder } from "./fluent-builder.interface";
+import type { BuilderState } from "./types";
+/**
+ * Creates a HookFluentBuilder from the given state.
+ * Each builder method returns a new builder with updated state.
+ */
+export declare function makeHookBuilder<TDeps extends DependencyMapType, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] | undefined, TMeta extends ITaskMeta>(state: BuilderState<TDeps, TOn, TMeta>): HookFluentBuilder<TDeps, TOn, TMeta>;

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

@@ -0,0 +1,27 @@
+import type { DependencyMapType, IEventDefinition, IHook, IHookDefinition, ITaskMeta, TagType } from "../../../defs";
+/** 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) */
+export type ResolvedOn<TOn> = TOn extends ValidOnTarget ? TOn : any;
+export interface HookFluentBuilder<TDeps extends DependencyMapType = {}, TOn extends ValidOnTarget | undefined = undefined, TMeta extends ITaskMeta = ITaskMeta> {
+    id: string;
+    on<TNewOn extends ValidOnTarget>(on: TNewOn): HookFluentBuilder<TDeps, TNewOn, TMeta>;
+    order(order: number): HookFluentBuilder<TDeps, TOn, TMeta>;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options?: {
+        override?: false;
+    }): HookFluentBuilder<TDeps & TNewDeps, TOn, TMeta>;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
+        override: true;
+    }): HookFluentBuilder<TNewDeps, TOn, TMeta>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: boolean;
+    }): HookFluentBuilder<TDeps, TOn, TMeta>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): HookFluentBuilder<TDeps, TOn, TNewMeta>;
+    /** Set the hook's run handler. Required before build(). */
+    run(fn: IHookDefinition<TDeps, ResolvedOn<TOn>, TMeta>["run"]): HookFluentBuilder<TDeps, TOn, TMeta>;
+    /**
+     * Build the hook definition. Requires .on() and .run() to be called first.
+     * @throws {Error} if on or run are not set
+     */
+    build(): IHook<TDeps, ResolvedOn<TOn>, TMeta>;
+}

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

@@ -0,0 +1,12 @@
+import type { ITaskMeta } from "../../../defs";
+import type { HookFluentBuilder } from "./fluent-builder.interface";
+export * from "./fluent-builder.interface";
+export * from "./fluent-builder";
+export * from "./types";
+export * from "./utils";
+/**
+ * Entry point for creating a hook builder.
+ * Requires calling .on() and .run() before .build().
+ */
+export declare function hookBuilder(id: string): HookFluentBuilder<{}, undefined, ITaskMeta>;
+export declare const hook: typeof hookBuilder;

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

@@ -0,0 +1,14 @@
+import type { DependencyMapType, IEventDefinition, IHookDefinition, ITaskMeta } from "../../../defs";
+/**
+ * Internal state for the HookFluentBuilder.
+ * Kept immutable and frozen.
+ * Note: `on` and `run` can be undefined during building,
+ * but are validated as required in build().
+ */
+export type BuilderState<TDeps extends DependencyMapType, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] | undefined, TMeta extends ITaskMeta> = Readonly<Omit<Required<Pick<IHookDefinition<TDeps, NonNullable<TOn>, TMeta>, "id" | "dependencies" | "order" | "meta" | "tags">>, never> & {
+    filePath: string;
+    /** Event(s) to listen to. Required before build(). */
+    on: TOn;
+    /** Hook handler function. Required before build(). */
+    run: IHookDefinition<TDeps, NonNullable<TOn>, TMeta>["run"] | undefined;
+}>;

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

@@ -0,0 +1,14 @@
+import type { DependencyMapType, IEventDefinition, ITaskMeta } from "../../../defs";
+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[];
+/**
+ * Merges dependencies handling all combinations of objects and functions.
+ */
+export declare function mergeDependencies<TExisting extends DependencyMapType, TNew extends DependencyMapType>(existing: TExisting | (() => TExisting) | undefined, addition: TNew | (() => TNew), override: boolean): (TExisting & TNew) | (() => TExisting & TNew);

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

@@ -0,0 +1 @@
+export * from "./hook/index";

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

@@ -0,0 +1,19 @@
+import type { DependencyMapType } from "../../../defs";
+import type { TaskMiddlewareFluentBuilder } from "./task.interface";
+import type { ResourceMiddlewareFluentBuilder } from "./resource.interface";
+export * from "./task.interface";
+export * from "./resource.interface";
+export * from "./task";
+export * from "./resource";
+export * from "./types";
+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>;
+/**
+ * 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 const taskMiddleware: typeof taskMiddlewareBuilder;
+export declare const resourceMiddleware: typeof resourceMiddlewareBuilder;

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

@@ -0,0 +1,7 @@
+import type { DependencyMapType } from "../../../defs";
+import type { ResourceMiddlewareFluentBuilder } from "./resource.interface";
+import type { ResMwState } from "./types";
+/**
+ * Creates a ResourceMiddlewareFluentBuilder from the given state.
+ */
+export declare function makeResourceMiddlewareBuilder<C, In, Out, D extends DependencyMapType>(state: ResMwState<C, In, Out, D>): ResourceMiddlewareFluentBuilder<C, In, Out, D>;

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

@@ -0,0 +1,18 @@
+import type { DependencyMapType, IResource, IResourceMiddleware, IResourceMiddlewareDefinition, IValidationSchema, IMiddlewareMeta, TagType } from "../../../defs";
+export interface ResourceMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
+    id: string;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options?: {
+        override?: false;
+    }): ResourceMiddlewareFluentBuilder<C, In, Out, D & TNewDeps>;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options: {
+        override: true;
+    }): ResourceMiddlewareFluentBuilder<C, In, Out, TNewDeps>;
+    configSchema<TNew>(schema: IValidationSchema<TNew>): ResourceMiddlewareFluentBuilder<TNew, In, Out, D>;
+    run(fn: IResourceMiddlewareDefinition<C, In, Out, D>["run"]): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+    meta<TNewMeta extends IMiddlewareMeta>(m: TNewMeta): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: boolean;
+    }): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+    everywhere(flag: boolean | ((resource: IResource<any, any, any, any, any>) => boolean)): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+    build(): IResourceMiddleware<C, In, Out, D>;
+}

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

@@ -0,0 +1,7 @@
+import type { DependencyMapType } from "../../../defs";
+import type { TaskMiddlewareFluentBuilder } from "./task.interface";
+import type { TaskMwState } from "./types";
+/**
+ * Creates a TaskMiddlewareFluentBuilder from the given state.
+ */
+export declare function makeTaskMiddlewareBuilder<C, In, Out, D extends DependencyMapType>(state: TaskMwState<C, In, Out, D>): TaskMiddlewareFluentBuilder<C, In, Out, D>;

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

@@ -0,0 +1,18 @@
+import type { DependencyMapType, ITask, ITaskMiddleware, ITaskMiddlewareDefinition, IValidationSchema, IMiddlewareMeta, TagType } from "../../../defs";
+export interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
+    id: string;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options?: {
+        override?: false;
+    }): TaskMiddlewareFluentBuilder<C, In, Out, D & TNewDeps>;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options: {
+        override: true;
+    }): TaskMiddlewareFluentBuilder<C, In, Out, TNewDeps>;
+    configSchema<TNew>(schema: IValidationSchema<TNew>): TaskMiddlewareFluentBuilder<TNew, In, Out, D>;
+    run(fn: ITaskMiddlewareDefinition<C, In, Out, D>["run"]): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+    meta<TNewMeta extends IMiddlewareMeta>(m: TNewMeta): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: boolean;
+    }): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+    everywhere(flag: boolean | ((task: ITask<any, any, any, any>) => boolean)): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+    build(): ITaskMiddleware<C, In, Out, D>;
+}

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

@@ -0,0 +1,13 @@
+import type { DependencyMapType, ITaskMiddlewareDefinition, IResourceMiddlewareDefinition } from "../../../defs";
+/**
+ * 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">> & {
+    filePath: string;
+}>;
+/**
+ * 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">> & {
+    filePath: string;
+}>;

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

@@ -0,0 +1,18 @@
+import type { DependencyMapType } from "../../../defs";
+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>;
+/**
+ * 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[];
+/**
+ * Merges dependencies handling all combinations of objects and functions.
+ */
+export declare function mergeDependencies<C, TExisting extends DependencyMapType, TNew extends DependencyMapType>(existing: TExisting | ((config: C) => TExisting) | undefined, addition: TNew | ((config: C) => TNew), override: boolean): (TExisting & TNew) | ((config: C) => TExisting & TNew);

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

@@ -0,0 +1 @@
+export * from "./middleware/index";

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

@@ -0,0 +1,16 @@
+import type { DependencyMapType, IEventDefinition, IHook, IHookDefinition, ITaskMeta, TagType } from "../../../defs";
+export type HookOn = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
+export interface HookOverrideBuilder<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta> {
+    id: string;
+    order(order: number): HookOverrideBuilder<TDeps, TOn, TMeta>;
+    dependencies<TNewDeps extends DependencyMapType, TIsOverride extends boolean = false>(deps: TNewDeps | (() => TNewDeps), options?: {
+        override?: TIsOverride;
+    }): HookOverrideBuilder<TIsOverride extends true ? TNewDeps : TDeps & TNewDeps, TOn, TMeta>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: boolean;
+    }): HookOverrideBuilder<TDeps, TOn, TMeta>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): HookOverrideBuilder<TDeps, TOn, TNewMeta>;
+    run(fn: IHookDefinition<TDeps, TOn, TMeta>["run"]): HookOverrideBuilder<TDeps, TOn, TMeta>;
+    build(): IHook<TDeps, TOn, TMeta>;
+}
+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

@@ -0,0 +1,11 @@
+import type { DependencyMapType, IHook, IResource, IResourceMeta, IResourceMiddleware, ITask, ITaskMeta, ITaskMiddleware, ResourceMiddlewareAttachmentType, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { ResourceFluentBuilder } from "../resource/fluent-builder.interface";
+import type { TaskFluentBuilder } from "../task/fluent-builder.interface";
+import type { ResourceMiddlewareFluentBuilder } from "../middleware/resource.interface";
+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<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<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta>(base: IHook<TDeps, TOn, TMeta>): HookOverrideBuilder<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: IResourceMiddleware<C, In, Out, D>): ResourceMiddlewareFluentBuilder<C, In, Out, D>;

package/dist/types/definers/builders/override/resource-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyMapType, IResourceMiddleware } from "../../../defs";
+import type { ResourceMiddlewareFluentBuilder } from "../middleware/resource.interface";
+export declare function resourceMiddlewareOverrideBuilder<C, In, Out, D extends DependencyMapType>(base: IResourceMiddleware<C, In, Out, D>): ResourceMiddlewareFluentBuilder<C, In, Out, D>;

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

@@ -0,0 +1,3 @@
+import type { DependencyMapType, IResource, IResourceMeta, ResourceMiddlewareAttachmentType, TagType } from "../../../defs";
+import type { ResourceFluentBuilder } from "../resource/fluent-builder.interface";
+export declare function resourceOverrideBuilder<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>;

package/dist/types/definers/builders/override/task-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyMapType, ITaskMiddleware } from "../../../defs";
+import type { TaskMiddlewareFluentBuilder } from "../middleware/task.interface";
+export declare function taskMiddlewareOverrideBuilder<C, In, Out, D extends DependencyMapType>(base: ITaskMiddleware<C, In, Out, D>): TaskMiddlewareFluentBuilder<C, In, Out, D>;

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

@@ -0,0 +1,3 @@
+import type { DependencyMapType, ITask, ITaskMeta, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { TaskFluentBuilder } from "../task/fluent-builder.interface";
+export declare function taskOverrideBuilder<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>;

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

@@ -0,0 +1,8 @@
+import type { DependencyMapType, IResourceMeta, ResourceMiddlewareAttachmentType, TagType } from "../../../defs";
+import type { ResourceFluentBuilder } from "./fluent-builder.interface";
+import type { BuilderState } from "./types";
+/**
+ * Creates a ResourceFluentBuilder from the given state.
+ * Each builder method returns a new builder with updated state.
+ */
+export declare function makeResourceBuilder<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[]>(state: BuilderState<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;

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

@@ -0,0 +1,42 @@
+import type { DependencyMapType, IResource, IResourceDefinition, IResourceMeta, IValidationSchema, OverridableElements, RegisterableItems, ResourceInitFn, ResourceMiddlewareAttachmentType, TagType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
+import type { ResolveConfig } from "./types";
+/**
+ * Fluent builder interface for constructing resources.
+ * Each method returns a new builder with updated type parameters.
+ */
+export interface ResourceFluentBuilder<TConfig = void, TValue extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TContext = any, TMeta extends IResourceMeta = IResourceMeta, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> {
+    id: string;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: TConfig) => TNewDeps), options?: {
+        override?: false;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps & TNewDeps, TContext, TMeta, TTags, TMiddleware>;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: TConfig) => TNewDeps), options: {
+        override: true;
+    }): ResourceFluentBuilder<TConfig, TValue, TNewDeps, TContext, TMeta, TTags, TMiddleware>;
+    register(items: RegisterableItems | Array<RegisterableItems> | ((config: TConfig) => RegisterableItems | Array<RegisterableItems>), options?: {
+        override?: boolean;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    middleware<TNewMw extends ResourceMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
+        override?: boolean;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TNewMw>;
+    tags<TNewTags extends TagType[]>(tags: TNewTags, options?: {
+        override?: false;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, [
+        ...TTags,
+        ...TNewTags
+    ], TMiddleware>;
+    tags<TNewTags extends TagType[]>(tags: TNewTags, options: {
+        override: true;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TNewTags, TMiddleware>;
+    context<TNewCtx>(factory: () => TNewCtx): ResourceFluentBuilder<TConfig, TValue, TDeps, TNewCtx, TMeta, TTags, TMiddleware>;
+    configSchema<TNewConfig>(schema: IValidationSchema<TNewConfig>): ResourceFluentBuilder<TNewConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    resultSchema<TResolved>(schema: IValidationSchema<TResolved>): ResourceFluentBuilder<TConfig, Promise<TResolved>, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    init<TNewConfig = TConfig, TNewValue extends Promise<any> = TValue>(fn: ResourceInitFn<ResolveConfig<TConfig, TNewConfig>, TNewValue, TDeps, TContext, TMeta, TTags, TMiddleware>): ResourceFluentBuilder<ResolveConfig<TConfig, TNewConfig>, TNewValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    dispose(fn: NonNullable<IResourceDefinition<TConfig, TValue, TDeps, TContext, any, any, TMeta, TTags, TMiddleware>["dispose"]>): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    meta<TNewMeta extends IResourceMeta>(m: TNewMeta): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TNewMeta, TTags, TMiddleware>;
+    throws(list: ThrowsList): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    overrides(o: Array<OverridableElements>, options?: {
+        override?: boolean;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    build(): IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+}

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

@@ -0,0 +1,13 @@
+import type { IResourceMeta, ResourceMiddlewareAttachmentType, TagType } from "../../../defs";
+import type { ResourceFluentBuilder } from "./fluent-builder.interface";
+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[]>;
+/**
+ * Alias for resourceBuilder - common shorthand.
+ */
+export declare const resource: typeof resourceBuilder;

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

@@ -0,0 +1,37 @@
+import type { DependencyMapType, IResourceDefinition, IResourceMeta, IValidationSchema, RegisterableItems, ResourceInitFn, ResourceMiddlewareAttachmentType, TagType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
+/**
+ * Internal builder state - immutable snapshot of all builder configuration.
+ */
+export type BuilderState<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[]> = Readonly<{
+    id: string;
+    filePath: string;
+    dependencies?: TDeps | ((config: TConfig) => TDeps);
+    register?: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
+    middleware?: TMiddleware;
+    tags?: TTags;
+    context?: () => TContext;
+    init?: ResourceInitFn<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    dispose?: NonNullable<IResourceDefinition<TConfig, TValue, TDeps, TContext, any, any, TMeta, TTags, TMiddleware>["dispose"]>;
+    configSchema?: IValidationSchema<any>;
+    resultSchema?: IValidationSchema<any>;
+    meta?: TMeta;
+    overrides?: Array<any>;
+    throws?: ThrowsList;
+}>;
+/**
+ * Helper type to determine if config should be replaced.
+ */
+export type ShouldReplaceConfig<T> = [T] extends [void] ? true : [T] extends [undefined] ? true : false;
+/**
+ * Resolves the config type - uses proposed if existing is void/undefined.
+ */
+export type ResolveConfig<TExisting, TProposed> = ShouldReplaceConfig<TExisting> extends true ? TProposed : TExisting;
+/**
+ * Input types accepted by the register() method.
+ */
+export type RegisterInput<TConfig> = RegisterableItems | Array<RegisterableItems> | ((config: TConfig) => RegisterableItems | Array<RegisterableItems>);
+/**
+ * Internal state representation for register.
+ */
+export type RegisterState<TConfig> = Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>) | undefined;