@bluelibs/runner 4.6.1 → 4.7.0-alpha

package/dist/context.d.ts

@@ -0,0 +1,31 @@
+import { ITaskMiddlewareConfigured } from "./defs";
+import { ContextError } from "./errors";
+export { ContextError };
+/**
+ * The generic Context object returned by `createContext`.
+ */
+export interface Context<T> {
+    /** unique symbol used as key in the AsyncLocalStorage map */
+    readonly id: symbol;
+    /** Retrieve the current context value or throw */
+    use(): T;
+    /**
+     * Provide a value for this context during the lifetime of `fn()`
+     */
+    provide<R>(value: T, fn: () => Promise<R> | R): Promise<R> | R;
+    /**
+     * Generates a middleware that guarantees the context exists (and optionally
+     * enforces that certain keys are present on the context object).
+     */
+    require<K extends keyof T = never>(keys?: K[]): ITaskMiddlewareConfigured<{
+        context: Context<T>;
+    }>;
+}
+export declare const storage: import("./platform").IAsyncLocalStorage<Map<symbol, unknown>>;
+/** Returns the currently active store or undefined. */
+export declare function getCurrentStore(): Map<symbol, 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 createContext<T>(name?: string): Context<T>;

package/dist/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, } from "./definers/tools";

package/dist/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/definers/builders/event.d.ts

@@ -0,0 +1,12 @@
+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>;
+    build(): IEvent<TPayload>;
+}
+export declare function eventBuilder(id: string): EventFluentBuilder<void>;
+export declare const event: typeof eventBuilder;

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

@@ -0,0 +1,20 @@
+import type { DependencyMapType, IEventDefinition, IHook, IHookDefinition, ITaskMeta, TagType } from "../../defs";
+export interface HookFluentBuilder<TDeps extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] = any, TMeta extends ITaskMeta = ITaskMeta> {
+    id: string;
+    on<TNewOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[]>(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>;
+    run(fn: IHookDefinition<TDeps, TOn, TMeta>["run"]): HookFluentBuilder<TDeps, TOn, TMeta>;
+    build(): IHook<TDeps, TOn, TMeta>;
+}
+export declare function hookBuilder(id: string): HookFluentBuilder<{}, any, ITaskMeta>;
+export declare const hook: typeof hookBuilder;

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

@@ -0,0 +1,39 @@
+import type { DependencyMapType, ITaskMiddleware, ITaskMiddlewareDefinition, IResourceMiddleware, IResourceMiddlewareDefinition, 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: any) => boolean)): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+    build(): ITaskMiddleware<C, In, Out, D>;
+}
+export declare function taskMiddlewareBuilder(id: string): TaskMiddlewareFluentBuilder<any, void, void, {}>;
+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: any) => boolean)): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+    build(): IResourceMiddleware<C, In, Out, D>;
+}
+export declare function resourceMiddlewareBuilder(id: string): ResourceMiddlewareFluentBuilder<any, void, void, {}>;
+export declare const taskMiddleware: typeof taskMiddlewareBuilder;
+export declare const resourceMiddleware: typeof resourceMiddlewareBuilder;

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

@@ -0,0 +1,40 @@
+import type { DependencyMapType, IResource, IResourceDefinition, IResourceMeta, IValidationSchema, OverridableElements, RegisterableItems, ResourceInitFn, ResourceMiddlewareAttachmentType, TagType } from "../../defs";
+type ShouldReplaceConfig<T> = [T] extends [void] ? true : [T] extends [undefined] ? true : false;
+type ResolveConfig<TExisting, TProposed> = ShouldReplaceConfig<TExisting> extends true ? TProposed : TExisting;
+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>;
+    overrides(o: Array<OverridableElements>, options?: {
+        override?: boolean;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+    build(): IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+}
+export declare function resourceBuilder<TConfig = void>(id: string): ResourceFluentBuilder<TConfig, Promise<any>, {}, any, IResourceMeta, TagType[], ResourceMiddlewareAttachmentType[]>;
+export declare const resource: typeof resourceBuilder;
+export {};

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

@@ -0,0 +1,10 @@
+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>;
+}
+export declare function tagBuilder<TConfig = void, TEnforceIn = void, TEnforceOut = void>(id: string): TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;
+export declare const tag: typeof tagBuilder;

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

@@ -0,0 +1,37 @@
+import type { DependencyMapType, ITask, ITaskDefinition, ITaskMeta, IValidationSchema, TagType, TaskMiddlewareAttachmentType } from "../../defs";
+import { type PhantomTaskFluentBuilder } from "./task.phantom";
+type ShouldReplaceInput<T> = [T] extends [undefined] ? true : [T] extends [void] ? true : (0 extends 1 & T ? true : false);
+type ResolveInput<TExisting, TProposed> = ShouldReplaceInput<TExisting> extends true ? TProposed : TExisting;
+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>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): TaskFluentBuilder<TInput, TOutput, TDeps, TNewMeta, TTags, TMiddleware>;
+    build(): ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
+}
+export declare function taskBuilder(id: string): TaskFluentBuilder<undefined, Promise<any>, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
+export interface TaskBuilderWithPhantom {
+    (id: string): TaskFluentBuilder<undefined, Promise<any>, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
+    phantom: <TInput = undefined, TResolved = any>(id: string) => PhantomTaskFluentBuilder<TInput, TResolved, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
+}
+export declare const task: TaskBuilderWithPhantom;
+export {};

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

@@ -0,0 +1,27 @@
+import type { DependencyMapType, ITaskMeta, IValidationSchema, TagType, TaskMiddlewareAttachmentType, IPhantomTask } from "../../defs";
+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>;
+    build(): IPhantomTask<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
+}
+export declare function phantomTaskBuilder<TInput = undefined, TResolved = any>(id: string): PhantomTaskFluentBuilder<TInput, TResolved, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;

package/dist/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/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/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/definers/defineOverride.d.ts

@@ -0,0 +1,17 @@
+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 AnyTask = ITask<any, any, any, any, any, any>;
+type AnyResource = IResource<any, any, any, any, any, any, any>;
+type AnyTaskMiddleware = ITaskMiddleware<any, any, any, any>;
+type AnyResourceMiddleware = IResourceMiddleware<any, any, any, any>;
+type AnyHook = IHook<any, any, any>;
+type OverridePatch<T> = T extends AnyTask ? Omit<Partial<T>, "id"> & Pick<T, "run"> : T extends AnyResource ? Omit<Partial<T>, "id"> & Pick<T, "init"> : T extends AnyTaskMiddleware ? Omit<Partial<T>, "id"> : T extends AnyResourceMiddleware ? Omit<Partial<T>, "id"> & Pick<T, "run"> : T extends AnyHook ? Omit<Partial<T>, "id" | "on"> & Pick<T, "run"> : never;
+export declare function defineOverride<T extends AnyTask | AnyResource | AnyTaskMiddleware | AnyResourceMiddleware | AnyHook>(base: T, patch: OverridePatch<T>): T;
+export {};

package/dist/definers/defineResource.d.ts

@@ -0,0 +1,2 @@
+import { IResource, IResourceDefinition, DependencyMapType, IResourceMeta, TagType, ResourceMiddlewareAttachmentType } from "../defs";
+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/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/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/definers/defineTask.d.ts

@@ -0,0 +1,18 @@
+import { ITask, ITaskDefinition, DependencyMapType, ITaskMeta, TagType, TaskMiddlewareAttachmentType, IPhantomTask } from "../defs";
+/**
+ * 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/definers/defineTaskMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { ITaskMiddleware, ITaskMiddlewareDefinition, DependencyMapType } from "../defs";
+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/definers/tools.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Type guard and utility functions for checking definition types.
+ */
+import { ITask, IResource, IResourceWithConfig, ITaskMiddleware, IResourceMiddleware, IEvent, IHook, IOptionalDependency, ITag, IPhantomTask } from "../defs";
+/**
+ * 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>;

package/dist/defs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { ICacheInstance } from "./globals/middleware/cache.middleware";
+export * from "./types/storeTypes";