@bluelibs/runner 4.8.6 → 4.9.0

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@bluelibs/runner",
-  "version": "4.8.6",
+  "version": "4.9.0",
   "description": "BlueLibs Runner",
   "sideEffects": false,
   "main": "dist/universal/index.cjs",
   "module": "dist/universal/index.mjs",
-  "types": "dist/index.d.ts",
+  "types": "dist/universal/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/universal/index.d.ts",
       "browser": {
         "import": "./dist/browser/index.mjs",
         "require": "./dist/browser/index.cjs",
@@ -77,7 +77,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.declarations.json && tsup --config tsup.config.ts --sourcemap",
+    "build": "tsup --config tsup.config.ts --sourcemap",
     "clean": "rm -rf dist",
     "watch": "tsup --config tsup.config.ts --watch",
     "test": "jest --verbose --runInBand",
@@ -125,7 +125,7 @@
     "typescript": "^5.6.2",
     "zod": "^4.0.17"
   },
-  "typings": "dist/index.d.ts",
+  "typings": "dist/universal/index.d.ts",
   "typescript": {
     "definition": "dist/index.d.ts"
   },

package/dist/define.d.ts

@@ -1,9 +0,0 @@
-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/definers/builders/asyncContext.d.ts

@@ -1,13 +0,0 @@
-import type { IAsyncContext } from "../../types/asyncContext";
-import type { IValidationSchema } from "../../types/utilities";
-import type { IAsyncContextMeta } from "../../types/meta";
-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>;
-}
-export declare function asyncContextBuilder<T = unknown>(id: string): AsyncContextFluentBuilder<T>;
-export declare const asyncContext: typeof asyncContextBuilder;

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

@@ -1,30 +0,0 @@
-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/error.d.ts

@@ -1,15 +0,0 @@
-import type { DefaultErrorType } from "../../types/error";
-import { ErrorHelper } from "../defineError";
-import type { IValidationSchema } from "../../types/utilities";
-import type { IErrorMeta } from "../../types/meta";
-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(): ErrorHelper<TData>;
-    format(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
-    meta<TNewMeta extends IErrorMeta>(m: TNewMeta): ErrorFluentBuilder<TData>;
-}
-export declare function errorBuilder<TData extends DefaultErrorType = DefaultErrorType>(id: string): ErrorFluentBuilder<TData>;
-export declare const error: typeof errorBuilder;

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

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

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

@@ -1,39 +0,0 @@
-import type { DependencyMapType, ITaskMiddleware, ITaskMiddlewareDefinition, IResourceMiddleware, IResourceMiddlewareDefinition, IValidationSchema, IMiddlewareMeta, TagType, ITask, IResource } 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>;
-}
-export declare function taskMiddlewareBuilder<C = void, In = void, Out = void, D extends DependencyMapType = {}>(id: string): TaskMiddlewareFluentBuilder<C, In, Out, D>;
-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>;
-}
-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/definers/builders/resource.d.ts

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

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

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

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

@@ -1,4 +0,0 @@
-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/defineAsyncContext.d.ts

@@ -1,15 +0,0 @@
-import { contextError } from "../errors";
-import { IAsyncContext, IAsyncContextDefinition } from "../types/asyncContext";
-export { contextError as ContextError };
-export declare const storage: import("../platform").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>): 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/definers/defineError.d.ts

@@ -1,26 +0,0 @@
-import { DefaultErrorType, IErrorDefinition, IErrorHelper, IErrorDefinitionFinal } from "../types/error";
-import { symbolError, 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;
-    constructor(definition: IErrorDefinitionFinal<TData>);
-    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>): ErrorHelper<TData>;
-export {};

package/dist/definers/defineEvent.d.ts

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

package/dist/definers/defineHook.d.ts

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

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

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

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

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

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

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

@@ -1,53 +0,0 @@
-/**
- * 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/defs.d.ts

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

package/dist/errors.d.ts

@@ -1,62 +0,0 @@
-import type { DefaultErrorType } from "./types/error";
-export declare const duplicateRegistrationError: import("./definers/defineError").ErrorHelper<{
-    type: string;
-    id: string;
-} & DefaultErrorType>;
-export declare const dependencyNotFoundError: import("./definers/defineError").ErrorHelper<{
-    key: string;
-} & DefaultErrorType>;
-export declare const unknownItemTypeError: import("./definers/defineError").ErrorHelper<{
-    item: unknown;
-} & DefaultErrorType>;
-export declare const contextError: import("./definers/defineError").ErrorHelper<{
-    details?: string;
-} & DefaultErrorType>;
-export declare const circularDependenciesError: import("./definers/defineError").ErrorHelper<{
-    cycles: string[];
-} & DefaultErrorType>;
-export declare const eventNotFoundError: import("./definers/defineError").ErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-export declare const resourceNotFoundError: import("./definers/defineError").ErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-export declare const middlewareNotRegisteredError: import("./definers/defineError").ErrorHelper<{
-    type: "task" | "resource";
-    source: string;
-    middlewareId: string;
-} & DefaultErrorType>;
-export declare const tagNotFoundError: import("./definers/defineError").ErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-export declare const lockedError: import("./definers/defineError").ErrorHelper<{
-    what: string;
-} & DefaultErrorType>;
-export declare const storeAlreadyInitializedError: import("./definers/defineError").ErrorHelper<DefaultErrorType>;
-export declare const validationError: import("./definers/defineError").ErrorHelper<{
-    subject: string;
-    id: string;
-    originalError: string | Error;
-} & DefaultErrorType>;
-export declare const eventCycleError: import("./definers/defineError").ErrorHelper<{
-    path: Array<{
-        id: string;
-        source: string;
-    }>;
-} & DefaultErrorType>;
-export declare const eventEmissionCycleError: import("./definers/defineError").ErrorHelper<{
-    cycles: string[];
-} & DefaultErrorType>;
-export declare const platformUnsupportedFunctionError: import("./definers/defineError").ErrorHelper<{
-    functionName: string;
-} & DefaultErrorType>;
-export declare const cancellationError: import("./definers/defineError").ErrorHelper<{
-    reason?: string;
-} & DefaultErrorType>;
-export declare const tunnelOwnershipConflictError: import("./definers/defineError").ErrorHelper<{
-    taskId: string;
-    currentOwnerId: string;
-    attemptedOwnerId: string;
-} & DefaultErrorType>;
-export declare function isCancellationError(err: unknown): boolean;
-export type { IErrorHelper } from "./types/error";

package/dist/globals/debug.d.ts

@@ -1,10 +0,0 @@
-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/globals/globalEvents.d.ts

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