@bluelibs/runner 5.1.0 → 5.2.1

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

@@ -0,0 +1,26 @@
+import type { DependencyMapType, IResourceMeta, RegisterableItems, ResourceMiddlewareAttachmentType, TagType } from "../../../defs";
+import type { BuilderState, RegisterInput, RegisterState } from "./types";
+/**
+ * Clones and patches the builder state immutably.
+ */
+export declare function clone<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[], TNextConfig = TConfig, TNextValue extends Promise<any> = TValue, TNextDeps extends DependencyMapType = TDeps, TNextContext = TContext, TNextMeta extends IResourceMeta = TMeta, TNextTags extends TagType[] = TTags, TNextMiddleware extends ResourceMiddlewareAttachmentType[] = TMiddleware>(s: BuilderState<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>, patch: Partial<BuilderState<TNextConfig, TNextValue, TNextDeps, TNextContext, TNextMeta, TNextTags, TNextMiddleware>>): BuilderState<TNextConfig, TNextValue, TNextDeps, TNextContext, TNextMeta, TNextTags, TNextMiddleware>;
+/**
+ * Normalizes register items to an array.
+ */
+export declare function toRegisterArray(items: RegisterableItems | Array<RegisterableItems>): RegisterableItems[];
+/**
+ * Wraps a register function to always return an array.
+ */
+export declare function normalizeRegisterFunction<TConfig>(fn: (config: TConfig) => RegisterableItems | Array<RegisterableItems>): (config: TConfig) => RegisterableItems[];
+/**
+ * Merges register state handling all combinations of arrays and functions.
+ */
+export declare function mergeRegister<TConfig>(existing: RegisterState<TConfig>, addition: RegisterInput<TConfig>, override: boolean): RegisterState<TConfig>;
+/**
+ * Generic array merge with override support.
+ */
+export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+/**
+ * Merges dependencies handling all combinations of objects and functions.
+ */
+export declare function mergeDependencies<TConfig, TExisting extends DependencyMapType, TNew extends DependencyMapType>(existing: TExisting | ((config: TConfig) => TExisting) | undefined, addition: TNew | ((config: TConfig) => TNew), override: boolean): (TExisting & TNew) | ((config: TConfig) => TExisting & TNew);

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

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

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

@@ -0,0 +1,6 @@
+import type { TagFluentBuilder } from "./fluent-builder.interface";
+import type { BuilderState } from "./types";
+/**
+ * Creates a TagFluentBuilder from the given state.
+ */
+export declare function makeTagBuilder<TConfig, TEnforceIn, TEnforceOut>(state: BuilderState<TConfig, TEnforceIn, TEnforceOut>): TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;

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

@@ -0,0 +1,8 @@
+import type { ITag, ITagMeta, IValidationSchema } from "../../../defs";
+export interface TagFluentBuilder<TConfig = void, TEnforceIn = void, TEnforceOut = void> {
+    id: string;
+    meta<TNewMeta extends ITagMeta>(m: TNewMeta): TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;
+    configSchema<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/index.d.ts

@@ -0,0 +1,10 @@
+import type { TagFluentBuilder } from "./fluent-builder.interface";
+export * from "./fluent-builder.interface";
+export * from "./fluent-builder";
+export * from "./types";
+export * from "./utils";
+/**
+ * Entry point for creating a tag builder.
+ */
+export declare function tagBuilder<TConfig = void, TEnforceIn = void, TEnforceOut = void>(id: string): TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;
+export declare const tag: typeof tagBuilder;

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

@@ -0,0 +1,12 @@
+import type { ITagMeta, IValidationSchema } from "../../../defs";
+/**
+ * Internal state for the TagFluentBuilder.
+ * Kept immutable and frozen.
+ */
+export type BuilderState<TConfig, _TEnforceIn, _TEnforceOut> = Readonly<{
+    id: string;
+    filePath: string;
+    meta?: ITagMeta;
+    configSchema?: IValidationSchema<any>;
+    config?: TConfig;
+}>;

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

@@ -0,0 +1,5 @@
+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>;

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

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

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

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

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

@@ -0,0 +1,33 @@
+import type { DependencyMapType, ITask, ITaskDefinition, ITaskMeta, IValidationSchema, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
+import type { ResolveInput } from "./types";
+/**
+ * Fluent builder interface for constructing tasks.
+ */
+export interface TaskFluentBuilder<TInput = undefined, TOutput extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TMeta extends ITaskMeta = ITaskMeta, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
+    id: string;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options?: {
+        override?: false;
+    }): TaskFluentBuilder<TInput, TOutput, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
+        override: true;
+    }): TaskFluentBuilder<TInput, TOutput, TNewDeps, TMeta, TTags, TMiddleware>;
+    middleware<TNewMw extends TaskMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
+        override?: boolean;
+    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TTags, TNewMw>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: false;
+    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, [
+        ...TTags,
+        ...TNewTags
+    ], TMiddleware>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options: {
+        override: true;
+    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TNewTags, TMiddleware>;
+    inputSchema<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>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): TaskFluentBuilder<TInput, TOutput, TDeps, TNewMeta, TTags, TMiddleware>;
+    build(): ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
+}

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

@@ -0,0 +1,21 @@
+import type { ITaskMeta, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { TaskFluentBuilder } from "./fluent-builder.interface";
+import type { PhantomTaskFluentBuilder } from "./phantom-builder.interface";
+export * from "./fluent-builder.interface";
+export * from "./fluent-builder";
+export * from "./phantom-builder.interface";
+export * from "./phantom-builder";
+export * from "./types";
+/**
+ * Entry point for creating a task builder.
+ */
+export declare function taskBuilder(id: string): TaskFluentBuilder<undefined, 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[]>;
+    phantom: typeof phantomTaskBuilder;
+}
+export declare const task: TaskBuilderWithPhantom;

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

@@ -0,0 +1,8 @@
+import type { DependencyMapType, ITaskMeta, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { PhantomTaskFluentBuilder } from "./phantom-builder.interface";
+import type { PhantomBuilderState } from "./types";
+/**
+ * Creates a PhantomTaskFluentBuilder from the given state.
+ * Each builder method returns a new builder with updated state.
+ */
+export declare function makePhantomTaskBuilder<TInput, TResolved, TDeps extends DependencyMapType, TMeta extends ITaskMeta, TTags extends TagType[], TMiddleware extends TaskMiddlewareAttachmentType[]>(state: PhantomBuilderState<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;

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

@@ -0,0 +1,31 @@
+import type { DependencyMapType, IPhantomTask, ITaskMeta, IValidationSchema, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
+/**
+ * Fluent builder interface for constructing phantom tasks.
+ */
+export interface PhantomTaskFluentBuilder<TInput = undefined, TResolved = any, TDeps extends DependencyMapType = {}, TMeta extends ITaskMeta = ITaskMeta, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
+    id: string;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options?: {
+        override?: false;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
+    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
+        override: true;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TNewDeps, TMeta, TTags, TMiddleware>;
+    middleware<TNewMw extends TaskMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
+        override?: boolean;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TTags, TNewMw>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: false;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, [
+        ...TTags,
+        ...TNewTags
+    ], TMiddleware>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options: {
+        override: true;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TNewTags, TMiddleware>;
+    inputSchema<TNewInput>(schema: IValidationSchema<TNewInput>): PhantomTaskFluentBuilder<TNewInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
+    resultSchema<TNewResolved>(schema: IValidationSchema<TNewResolved>): PhantomTaskFluentBuilder<TInput, TNewResolved, TDeps, TMeta, TTags, TMiddleware>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TNewMeta, TTags, TMiddleware>;
+    throws(list: ThrowsList): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
+    build(): IPhantomTask<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
+}

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

@@ -0,0 +1,34 @@
+import type { DependencyMapType, ITaskMeta, IValidationSchema, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
+export type ShouldReplaceInput<T> = [T] extends [undefined] ? true : [T] extends [void] ? true : 0 extends 1 & T ? true : false;
+export type ResolveInput<TExisting, TProposed> = ShouldReplaceInput<TExisting> extends true ? TProposed : TExisting;
+/**
+ * Internal state for the TaskFluentBuilder.
+ * Kept immutable and frozen.
+ */
+export type BuilderState<_TInput, _TOutput, TDeps extends DependencyMapType, TMeta extends ITaskMeta, TTags extends TagType[], TMiddleware extends TaskMiddlewareAttachmentType[]> = Readonly<{
+    id: string;
+    filePath: string;
+    dependencies?: TDeps | (() => TDeps);
+    middleware?: TMiddleware;
+    meta?: TMeta;
+    inputSchema?: IValidationSchema<any>;
+    resultSchema?: IValidationSchema<any>;
+    throws?: ThrowsList;
+    run?: (input: unknown, dependencies: unknown) => unknown;
+    tags?: TTags;
+}>;
+/**
+ * Internal state for the PhantomTaskFluentBuilder.
+ */
+export type PhantomBuilderState<_TInput, _TResolved, TDeps extends DependencyMapType, TMeta extends ITaskMeta, TTags extends TagType[], TMiddleware extends TaskMiddlewareAttachmentType[]> = Readonly<{
+    id: string;
+    filePath: string;
+    dependencies?: TDeps | (() => TDeps);
+    middleware?: TMiddleware;
+    meta?: TMeta;
+    inputSchema?: IValidationSchema<any>;
+    resultSchema?: IValidationSchema<any>;
+    throws?: ThrowsList;
+    tags?: TTags;
+}>;

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

@@ -0,0 +1,14 @@
+import type { DependencyMapType, ITaskMeta, TagType, TaskMiddlewareAttachmentType } from "../../../defs";
+import type { BuilderState } from "./types";
+/**
+ * Clones and patches the builder state immutably.
+ */
+export declare function clone<TInput, TOutput, TDeps extends DependencyMapType, TMeta extends ITaskMeta, TTags extends TagType[], TMiddleware extends TaskMiddlewareAttachmentType[], TNextInput = TInput, TNextOutput = TOutput, TNextDeps extends DependencyMapType = TDeps, TNextMeta extends ITaskMeta = TMeta, TNextTags extends TagType[] = TTags, TNextMiddleware extends TaskMiddlewareAttachmentType[] = TMiddleware>(s: BuilderState<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>, patch: Partial<BuilderState<TNextInput, TNextOutput, TNextDeps, TNextMeta, TNextTags, TNextMiddleware>>): BuilderState<TNextInput, TNextOutput, TNextDeps, TNextMeta, TNextTags, TNextMiddleware>;
+/**
+ * Generic array merge with override support.
+ */
+export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+/**
+ * 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/task.d.ts

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

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

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

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

@@ -0,0 +1,4 @@
+import type { DependencyMapType } from "../../defs";
+export declare function cloneState<S, NS>(s: S, patch: Partial<NS>): NS;
+export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+export 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/defineAsyncContext.d.ts

@@ -0,0 +1,15 @@
+import { contextError } from "../errors";
+import { IAsyncContext, IAsyncContextDefinition } from "../types/asyncContext";
+export { contextError as ContextError };
+export declare const storage: import("..").IAsyncLocalStorage<Map<string, unknown>>;
+/** Returns the currently active store or undefined. */
+export declare function getCurrentStore(): Map<string, unknown> | undefined;
+/**
+ * Create a new typed Context. The result contains helpers similar to React's
+ * Context API but adapted for async usage in Runner.
+ */
+export declare function defineAsyncContext<T>(def: IAsyncContextDefinition<T>, filePath?: string): IAsyncContext<T>;
+export type { IAsyncContext } from "../types/asyncContext";
+/** Convenience creator allowing optional name. Used by tests and legacy API. */
+/** @deprecated Use defineAsyncContext instead */
+export declare function createContext<T>(name?: string): IAsyncContext<T>;

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

@@ -0,0 +1,27 @@
+import { DefaultErrorType, IErrorDefinition, IErrorHelper, IErrorDefinitionFinal } from "../types/error";
+import { symbolError, symbolFilePath, symbolOptionalDependency } from "../types/symbols";
+declare class RunnerError<TData extends DefaultErrorType = DefaultErrorType> extends Error {
+    readonly id: string;
+    readonly data: TData;
+    constructor(id: string, message: string, data: TData);
+}
+export declare class ErrorHelper<TData extends DefaultErrorType = DefaultErrorType> implements IErrorHelper<TData> {
+    private readonly definition;
+    [symbolError]: true;
+    [symbolFilePath]: string;
+    constructor(definition: IErrorDefinitionFinal<TData>, filePath: string);
+    get id(): string;
+    throw(data: TData): never;
+    is(error: unknown): error is RunnerError<TData>;
+    optional(): {
+        readonly inner: IErrorHelper<TData>;
+        readonly [symbolOptionalDependency]: true;
+    };
+}
+/**
+ * Create a new error that is going to be used
+ * @param definition
+ * @returns
+ */
+export declare function defineError<TData extends DefaultErrorType = DefaultErrorType>(definition: IErrorDefinition<TData>, filePath?: string): ErrorHelper<TData>;
+export {};

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

@@ -0,0 +1,2 @@
+import { IEvent, IEventDefinition } from "../defs";
+export declare function defineEvent<TPayload = void>(config: IEventDefinition<TPayload>): IEvent<TPayload>;

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

@@ -0,0 +1,6 @@
+import { DependencyMapType, IEventDefinition, ITaskMeta, IHook, IHookDefinition } from "../defs";
+/**
+ * Define a hook (event listeners).
+ * Same shape as task with mandatory `on` and without `middleware`.
+ */
+export declare function defineHook<D extends DependencyMapType = any, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] = any, TMeta extends ITaskMeta = any>(hookDef: IHookDefinition<D, TOn, TMeta>): IHook<D, TOn, TMeta>;

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

@@ -0,0 +1,12 @@
+import { ITask, IResource, ITaskMiddleware, IResourceMiddleware, IHook } from "../defs";
+/**
+ * Override helper that preserves the original `id` and returns the same type.
+ * You can override any property except `id`. The override is shallow-merged over the base.
+ *
+ * @param base - The base definition to override.
+ * @param patch - Properties to override (except `id`).
+ * @returns A definition of the same kind with overrides applied.
+ */
+type OverridePatch<TBase> = Readonly<TBase extends IHook<any, any, any> ? Omit<Partial<TBase>, "id" | "on"> : Omit<Partial<TBase>, "id">>;
+export declare function defineOverride<TBase extends ITask<any, any, any, any, any, any> | IResource<any, any, any, any, any, any, any> | ITaskMiddleware<any, any, any, any> | IResourceMiddleware<any, any, any, any> | IHook<any, any, any>>(base: TBase, patch: OverridePatch<TBase>): TBase;
+export {};

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

@@ -0,0 +1,2 @@
+import type { IResource, IResourceDefinition, DependencyMapType, IResourceMeta, TagType, ResourceMiddlewareAttachmentType } from "../types/resource";
+export declare function defineResource<TConfig = void, TValue extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TPrivate = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]>(constConfig: IResourceDefinition<TConfig, TValue, TDeps, TPrivate, any, any, TMeta, TTags, TMiddleware>): IResource<TConfig, TValue, TDeps, TPrivate, TMeta, TTags, TMiddleware>;

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

@@ -0,0 +1,2 @@
+import { IResourceMiddleware, IResourceMiddlewareDefinition, DependencyMapType } from "../defs";
+export declare function defineResourceMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any>(middlewareDef: IResourceMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>): IResourceMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;

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

@@ -0,0 +1,12 @@
+import { ITag, ITagDefinition } from "../defs";
+/**
+ * Create a tag definition.
+ * - `.with(config)` to create configured instances
+ * - `.extract(tags)` to extract this tag from a list of tags or a taggable's meta
+ *
+ * @typeParam TConfig - Configuration type carried by configured tags.
+ * @typeParam TEnforceContract - Optional helper type to enforce a contract when tags are used.
+ * @param definition - The tag definition (id).
+ * @returns A tag object with helpers to configure and extract.
+ */
+export declare function defineTag<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void>(definition: ITagDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract>): ITag<TConfig, TEnforceInputContract, TEnforceOutputContract>;

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

@@ -0,0 +1,18 @@
+import type { ITask, ITaskDefinition, DependencyMapType, ITaskMeta, TagType, TaskMiddlewareAttachmentType, IPhantomTask } from "../types/task";
+/**
+ * Define a task.
+ * Generates a strongly-typed task object with id, dependencies,
+ * middleware, and metadata.
+ *
+ * @typeParam Input - Input type accepted by the task's `run` function.
+ * @typeParam Output - Promise type returned by the `run` function.
+ * @typeParam Deps - Dependency map type this task requires.
+ * @typeParam TOn - Event type or "*" this task listens to.
+ * @typeParam TMeta - Arbitrary metadata type carried by the task.
+ * @param taskConfig - The task definition config.
+ * @returns A branded task definition usable by the runner.
+ */
+export declare function defineTask<Input = undefined, Output extends Promise<any> = any, Deps extends DependencyMapType = any, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]>(taskConfig: ITaskDefinition<Input, Output, Deps, TMeta, TTags, TMiddleware>): ITask<Input, Output, Deps, TMeta, TTags, TMiddleware>;
+export declare namespace defineTask {
+    var phantom: <Input = undefined, Output extends Promise<any> = any>(taskConfig: Omit<ITaskDefinition<Input, Output, any, any, any, any>, "run">) => IPhantomTask<Input, Output, any, any, any, any>;
+}

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

@@ -0,0 +1,2 @@
+import type { ITaskMiddleware, ITaskMiddlewareDefinition, DependencyMapType } from "../types/taskMiddleware";
+export declare function defineTaskMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any>(middlewareDef: ITaskMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>): ITaskMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;

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

@@ -0,0 +1 @@
+export declare function mergeMiddlewareConfig<TConfig>(base: TConfig, next: TConfig): TConfig;

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

@@ -0,0 +1,13 @@
+import type { DependencyMapType, RegisterableItems, ResourceForkOptions } from "../types/resource";
+export type ResourceRegisterList = Array<RegisterableItems> | ((config: any) => Array<RegisterableItems>) | undefined;
+type DependenciesList<TConfig, TDeps extends DependencyMapType> = TDeps | ((config: TConfig) => TDeps) | undefined;
+export declare function resolveForkedRegisterAndDependencies<TConfig, TDeps extends DependencyMapType>(params: {
+    register: ResourceRegisterList;
+    dependencies: DependenciesList<TConfig, TDeps>;
+    forkId: string;
+    options: ResourceForkOptions | undefined;
+}): {
+    register: ResourceRegisterList;
+    dependencies: DependenciesList<TConfig, TDeps>;
+};
+export {};

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

@@ -0,0 +1,53 @@
+/**
+ * Type guard and utility functions for checking definition types.
+ */
+import { ITask, IResource, IResourceWithConfig, ITaskMiddleware, IResourceMiddleware, IEvent, IHook, IOptionalDependency, ITag, IPhantomTask } from "../defs";
+import { IErrorHelper } from "../types/error";
+import type { IAsyncContext } from "../types/asyncContext";
+/**
+ * Type guard: checks if a definition is a Task.
+ * @param definition - Any value to test.
+ * @returns True when `definition` is a branded Task.
+ */
+export declare function isTask(definition: any): definition is ITask;
+/** Type guard: checks if a definition is a Phantom Task. */
+export declare function isPhantomTask(definition: any): 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;
+/**
+ * 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;
+/**
+ * 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;
+/** Type guard: checks if a definition is a Hook. */
+export declare function isHook(definition: any): 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;
+/**
+ * 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;
+/** Type guard: checks if a definition is an Optional Dependency wrapper. */
+export declare function isOptional(definition: any): definition is IOptionalDependency<any>;
+/** Type guard: checks if a definition is an Error helper. */
+export declare function isError(definition: any): definition is IErrorHelper<any>;
+/** Type guard: checks if a definition is an Async Context. */
+export declare function isAsyncContext(definition: any): definition is IAsyncContext<any>;

package/dist/types/defs.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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)
+ * - Hooks are event listeners without middleware
+ * - Events are simple, strongly-typed emissions
+ * - Middleware can target both tasks and resources (taskMiddleware, resourceMiddleware)
+ *
+ * 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 * from "./types/utilities";
+export * from "./types/symbols";
+export * from "./types/tag";
+export * from "./types/hook";
+export * from "./types/resource";
+export * from "./types/event";
+export * from "./types/task";
+export * from "./types/taskMiddleware";
+export * from "./types/resourceMiddleware";
+export * from "./types/meta";
+export * from "./types/runner";
+export * from "./types/asyncContext";
+export * from "./types/error";
+export * from "./types/contracts";
+export * from "./types/inputFile";
+export type { ICacheInstance } from "./globals/middleware/cache.middleware";
+export * from "./types/storeTypes";

package/dist/types/errors.d.ts

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

package/dist/types/globals/debug.d.ts

@@ -0,0 +1,10 @@
+export declare const debugLevels: {
+    normal: import("./types").DebugConfig;
+    verbose: import("./types").DebugConfig;
+};
+export declare const debug: {
+    levels: {
+        normal: import("./types").DebugConfig;
+        verbose: import("./types").DebugConfig;
+    };
+};

package/dist/types/globals/globalEvents.d.ts

@@ -0,0 +1,8 @@
+import { IEvent } from "../defs";
+export declare const globalEvents: {
+    /**
+     * Emitted when the system is fully initialized and ready for work.
+     */
+    readonly ready: IEvent<void>;
+};
+export declare const globalEventsArray: IEvent<any>[];