@bluelibs/runner 4.8.6 → 4.9.0

package/dist/types/contracts.d.ts

@@ -1,63 +0,0 @@
-import { TagType } from "./tag";
-export declare const CONTRACT: unique symbol;
-export type CONTRACT = typeof CONTRACT;
-export interface IContractable<TConfig = any, TInput = void, TOutput = void> {
-    readonly __containsContract: true;
-    readonly [CONTRACT]: {
-        config: TConfig;
-        input: TInput;
-        output: TOutput;
-    };
-}
-type NonVoid<T> = [T] extends [void] ? never : T;
-type IsTuple<T extends readonly unknown[]> = number extends T["length"] ? false : true;
-type UnionToIntersection<U> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type IsUnknown<T> = unknown extends T ? [T] extends [unknown] ? true : false : false;
-type UnknownToNever<T> = IsUnknown<T> extends true ? never : T;
-type ExtractContractOf<T, Kind extends "input" | "output"> = T extends IContractable<any, infer I, infer O> ? UnknownToNever<Kind extends "input" ? NonVoid<I> : NonVoid<O>> : never;
-type FilterContractsKind<TItems extends readonly unknown[], Kind extends "input" | "output", Acc extends readonly unknown[] = []> = TItems extends readonly [infer H, ...infer R] ? ExtractContractOf<H, Kind> extends never ? FilterContractsKind<R, Kind, Acc> : FilterContractsKind<R, Kind, [...Acc, ExtractContractOf<H, Kind>]> : Acc;
-type ExtractContractsFromCollection<TItems extends readonly unknown[], Kind extends "input" | "output"> = IsTuple<TItems> extends true ? FilterContractsKind<TItems, Kind> : Array<ExtractContractOf<TItems[number], Kind>>;
-export type ExtractInputTypeFromContracts<TItems extends readonly unknown[]> = ExtractContractsFromCollection<TItems, "input">;
-export type ExtractOutputTypeFromContracts<TItems extends readonly unknown[]> = ExtractContractsFromCollection<TItems, "output">;
-type ContractsUnionInputs<TItems extends readonly unknown[]> = ExtractInputTypeFromContracts<TItems> extends readonly (infer U)[] ? U : never;
-type ContractsUnionOutputs<TItems extends readonly unknown[]> = ExtractOutputTypeFromContracts<TItems> extends readonly (infer U)[] ? U : never;
-type ContractsIntersectionInputs<TItems extends readonly unknown[]> = UnionToIntersection<ContractsUnionInputs<TItems>>;
-type ContractsIntersectionOutputs<TItems extends readonly unknown[]> = UnionToIntersection<ContractsUnionOutputs<TItems>>;
-export type HasInputContracts<TItems extends readonly unknown[]> = [
-    ContractsUnionInputs<TItems>
-] extends [never] ? false : true;
-export type HasOutputContracts<TItems extends readonly unknown[]> = [
-    ContractsUnionOutputs<TItems>
-] extends [never] ? false : true;
-type IsNever<T> = [T] extends [never] ? true : false;
-type KeysWithNever<T> = T extends object ? {
-    [K in keyof T]-?: [T[K]] extends [never] ? K : never;
-}[keyof T] : never;
-type HasNeverProperty<T> = KeysWithNever<T> extends never ? false : true;
-type IsImpossibleIntersection<T> = IsNever<T> extends true ? true : HasNeverProperty<T> extends true ? true : false;
-export type InputContractViolationError<TItems extends readonly unknown[], TActual> = {
-    message: "Value does not satisfy all input contracts";
-    expected: Simplify<ContractsIntersectionInputs<TItems>>;
-    received: TActual;
-};
-export type OutputContractViolationError<TItems extends readonly unknown[], TActual> = {
-    message: "Value does not satisfy all output contracts";
-    expected: Simplify<ContractsIntersectionOutputs<TItems>>;
-    received: TActual;
-};
-export type EnsureInputSatisfiesContracts<TItems extends readonly unknown[], TValue> = [ContractsUnionInputs<TItems>] extends [never] ? TValue : TValue extends Promise<infer U> ? Promise<U extends ContractsIntersectionInputs<TItems> ? U : InputContractViolationError<TItems, U>> : TValue extends ContractsIntersectionInputs<TItems> ? TValue : InputContractViolationError<TItems, TValue>;
-export type EnsureOutputSatisfiesContracts<TItems extends readonly unknown[], TResponse> = [ContractsUnionOutputs<TItems>] extends [never] ? TResponse : TResponse extends Promise<infer U> ? Promise<U extends ContractsIntersectionOutputs<TItems> ? U : OutputContractViolationError<TItems, U>> : TResponse extends ContractsIntersectionOutputs<TItems> ? TResponse : OutputContractViolationError<TItems, TResponse>;
-export type InferInputOrViolationFromContracts<TItems extends readonly unknown[]> = HasInputContracts<TItems> extends false ? void : ContractsIntersectionInputs<TItems> extends infer I ? IsImpossibleIntersection<I> extends true ? InputContractViolationError<TItems, Simplify<I extends never ? never : I>> : Simplify<I> : never;
-export type InputArg<TItems extends readonly unknown[]> = [
-    InferInputOrViolationFromContracts<TItems>
-] extends [void] ? [] : [InferInputOrViolationFromContracts<TItems>];
-export type InputCollisionGuard<TItems extends readonly unknown[]> = IsImpossibleIntersection<ContractsIntersectionInputs<TItems>> extends true ? InputContractViolationError<TItems, Simplify<ContractsIntersectionInputs<TItems>>> : unknown;
-export type InferOutputOrViolationFromContracts<TItems extends readonly unknown[]> = HasOutputContracts<TItems> extends false ? unknown : ContractsIntersectionOutputs<TItems> extends infer O ? IsImpossibleIntersection<O> extends true ? OutputContractViolationError<TItems, Simplify<O extends never ? never : O>> : Simplify<O> : never;
-/** @deprecated Use ExtractOutputTypeFromContracts instead */
-export type ExtractTagsWithNonVoidReturnTypeFromTags<TTags extends TagType[]> = ExtractOutputTypeFromContracts<TTags>;
-/** @deprecated Use EnsureOutputSatisfiesContracts instead */
-export type EnsureResponseSatisfiesContracts<TTags extends TagType[], TResponse> = EnsureOutputSatisfiesContracts<TTags, TResponse>;
-export {};

package/dist/types/error.d.ts

@@ -1,36 +0,0 @@
-import { symbolError } from "./symbols";
-import type { IOptionalDependency } from "./utilities";
-import type { IValidationSchema } from "./utilities";
-import type { IErrorMeta } from "./meta";
-export declare const ERROR_TYPES_LOADED: true;
-export interface IErrorDefinition<TData extends DefaultErrorType = DefaultErrorType> {
-    id: string;
-    serialize?: (data: TData) => string;
-    parse?: (data: string) => TData;
-    format?: (data: TData) => string;
-    /**
-     * Validate error data on throw(). If provided, data is parsed first.
-     */
-    dataSchema?: IValidationSchema<TData>;
-    meta?: IErrorMeta;
-}
-export interface IErrorDefinitionFinal<TData extends DefaultErrorType> extends IErrorDefinition<TData> {
-    format: (data: TData) => string;
-}
-export type DefaultErrorType = Record<string, unknown>;
-/**
- * Runtime helper returned by defineError()/r.error().
- * Contains helpers to throw typed errors and perform type-safe checks.
- */
-export interface IErrorHelper<TData extends DefaultErrorType = DefaultErrorType> {
-    /** Unique id for registration and DI */
-    id: string;
-    /** Throw a typed error with the given data */
-    throw(data: TData): never;
-    /** Type guard for checking if an unknown error is this error */
-    is(error: unknown): boolean;
-    /** Brand symbol for runtime detection */
-    [symbolError]: true;
-    /** Return an optional dependency wrapper for this error */
-    optional(): IOptionalDependency<IErrorHelper<TData>>;
-}

package/dist/types/event.d.ts

@@ -1,74 +0,0 @@
-import { IOptionalDependency, IValidationSchema } from "../defs";
-import { TagType } from "./tag";
-import { IEventMeta } from "./meta";
-import { CommonPayload, symbolEvent, symbolFilePath } from "./utilities";
-export type EventHandlerType<T = any> = (event: IEventEmission<T>) => any | Promise<any>;
-export declare function onAnyOf<T extends readonly IEventDefinition<any>[]>(...defs: T): T;
-/**
- * Runtime guard that checks if an emission belongs to one of the given event defs.
- * Narrows payload type to the intersection of the provided events' payloads.
- */
-export declare function isOneOf<TDefs extends readonly IEventDefinition<any>[]>(emission: IEventEmission<any>, defs: TDefs): emission is IEventEmission<CommonPayload<TDefs>>;
-export interface IEventDefinition<TPayload = void> {
-    id: string;
-    meta?: IEventMeta;
-    /**
-     * Optional validation schema for runtime payload validation.
-     * When provided, event payload will be validated when emitted.
-     */
-    payloadSchema?: IValidationSchema<TPayload>;
-    tags?: TagType[];
-}
-/**
- * The definioten of the event.
- * This is different from the event emission.
- */
-export interface IEvent<TPayload = any> extends IEventDefinition<TPayload> {
-    id: string;
-    /**
-     * We use this event to discriminate between resources with just 'id' and 'events' as they collide. This is a workaround, should be redone using classes and instanceof.
-     */
-    [symbolEvent]: true;
-    [symbolFilePath]: string;
-    /** Return an optional dependency wrapper for this event. */
-    optional: () => IOptionalDependency<IEvent<TPayload>>;
-    tags: TagType[];
-}
-/**
- * This represents the object that is passed to event handlers
- */
-export interface IEventEmission<TPayload = any> {
-    /**
-     * The ID of the event. This is the same as the event's ID.
-     * This is useful for global event listeners.
-     */
-    id: string;
-    /**
-     * The data that the event carries. It can be anything.
-     */
-    data: TPayload;
-    /**
-     * The timestamp when the event was created.
-     */
-    timestamp: Date;
-    /**
-     * The source of the event. This can be useful for debugging.
-     */
-    source: string;
-    /**
-     * Metadata associated with the event definition.
-     */
-    meta: IEventMeta;
-    /**
-     * Stops propagation to remaining event listeners.
-     */
-    stopPropagation(): void;
-    /**
-     * Returns true if propagation has been stopped.
-     */
-    isPropagationStopped(): boolean;
-    /**
-     * The tags that the event carries.
-     */
-    tags: TagType[];
-}

package/dist/types/hook.d.ts

@@ -1,23 +0,0 @@
-import { DependencyMapType, DependencyValuesType, IEventDefinition, IEventEmission, ExtractEventPayload } from "../defs";
-import { TagType } from "./tag";
-import { ITaskMeta } from "./meta";
-import { CommonPayload, symbolFilePath, symbolHook } from "./utilities";
-type OnType = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
-export interface IHookDefinition<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> {
-    id: string;
-    dependencies?: TDependencies | (() => TDependencies);
-    on: TOn;
-    /** Listener execution order. Lower numbers run first. */
-    order?: number;
-    meta?: TMeta;
-    run: (event: IEventEmission<TOn extends "*" ? any : TOn extends readonly IEventDefinition<any>[] ? CommonPayload<TOn> : ExtractEventPayload<TOn>>, dependencies: DependencyValuesType<TDependencies>) => Promise<any>;
-    tags?: TagType[];
-}
-export interface IHook<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> extends IHookDefinition<TDependencies, TOn, TMeta> {
-    id: string;
-    dependencies: TDependencies | (() => TDependencies);
-    [symbolFilePath]: string;
-    [symbolHook]: true;
-    tags: TagType[];
-}
-export {};

package/dist/types/inputFile.d.ts

@@ -1,34 +0,0 @@
-export interface InputFileMeta {
-    name: string;
-    type?: string;
-    size?: number;
-    lastModified?: number;
-    extra?: Record<string, unknown>;
-}
-/** Universal interface exposed to tasks for streamed files. */
-export interface InputFile<TStream = unknown> extends InputFileMeta {
-    /**
-     * Resolve the underlying stream for one-time consumption.
-     * Implementations must enforce single-use semantics.
-     */
-    resolve(): Promise<{
-        stream: TStream;
-    }>;
-    /**
-     * Return the underlying stream (single-use). Should throw if already consumed.
-     */
-    stream(): TStream;
-    /**
-     * Persist the stream to a temporary file on disk and return its path and number of bytes written.
-     */
-    toTempFile(dir?: string): Promise<{
-        path: string;
-        bytesWritten: number;
-    }>;
-}
-/** Client-side sentinel to declare file presence in an input structure. */
-export interface EjsonFileSentinel {
-    $ejson: "File";
-    id: string;
-    meta: InputFileMeta;
-}

package/dist/types/meta.d.ts

@@ -1,22 +0,0 @@
-/**
- * Common metadata you can attach to tasks/resources/events/middleware.
- * Useful for docs, filtering and middleware decisions.
- */
-export interface IMeta {
-    title?: string;
-    description?: string;
-}
-export interface ITaskMeta extends IMeta {
-}
-export interface IResourceMeta extends IMeta {
-}
-export interface IEventMeta extends IMeta {
-}
-export interface IMiddlewareMeta extends IMeta {
-}
-export interface ITagMeta extends IMeta {
-}
-export interface IErrorMeta extends IMeta {
-}
-export interface IAsyncContextMeta extends IMeta {
-}

package/dist/types/resource.d.ts

@@ -1,87 +0,0 @@
-import { DependencyMapType, IOptionalDependency, IResourceMiddleware, IValidationSchema, OverridableElements, RegisterableItems, ResourceDependencyValuesType, ResourceMiddlewareAttachmentType } from "../defs";
-import { TagType } from "./tag";
-import { IResourceMeta } from "./meta";
-import { symbolFilePath, symbolResource, symbolResourceWithConfig } from "./symbols";
-import { EnsureInputSatisfiesContracts, EnsureOutputSatisfiesContracts, HasInputContracts, HasOutputContracts, InferInputOrViolationFromContracts } from "./contracts";
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type IsUnspecified<T> = [T] extends [undefined] ? true : [T] extends [void] ? true : IsAny<T> extends true ? true : false;
-export interface IResourceDefinition<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = {}, TContext = any, THooks = any, TRegisterableItems = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> {
-    /** Stable identifier. */
-    id: string;
-    /** Static or lazy dependency map. Receives `config` when provided. */
-    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
-    /**
-     * Register other registerables (resources/tasks/middleware/events). Accepts a
-     * static array or a function of `config` to support dynamic wiring.
-     */
-    register?: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
-    /**
-     * Initialize and return the resource value. Called once during boot.
-     */
-    init?: (config: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? IsUnspecified<TConfig> extends true ? InferInputOrViolationFromContracts<[...TTags, ...TMiddleware]> : EnsureInputSatisfiesContracts<[...TTags, ...TMiddleware], TConfig> : TConfig, dependencies: ResourceDependencyValuesType<TDependencies>, context: TContext) => HasOutputContracts<[...TTags, ...TMiddleware]> extends true ? EnsureOutputSatisfiesContracts<[...TTags, ...TMiddleware], TValue> : TValue;
-    /**
-     * Optional validation schema for the resource's resolved value.
-     * When provided, the value will be validated immediately after `init` resolves,
-     * without considering middleware.
-     */
-    resultSchema?: IValidationSchema<TValue extends Promise<infer U> ? U : TValue>;
-    /**
-     * Clean-up function for the resource. This is called when the resource is no longer needed.
-     *
-     * @param value The value of the resource (undefined if no init method)
-     * @param config The configuration it received
-     * @param dependencies The dependencies it needed
-     * @returns Promise<void>
-     */
-    dispose?: (this: any, value: TValue extends Promise<infer U> ? U : TValue, config: TConfig, dependencies: ResourceDependencyValuesType<TDependencies>, context: TContext) => Promise<void>;
-    meta?: TMeta;
-    /**
-     * Optional validation schema for runtime config validation.
-     * When provided, resource config will be validated when .with() is called.
-     */
-    configSchema?: IValidationSchema<TConfig>;
-    /**
-     * Safe overrides to swap behavior while preserving identities. See
-     * README: Overrides.
-     */
-    overrides?: Array<OverridableElements>;
-    /** Middleware applied around init/dispose. */
-    middleware?: TMiddleware;
-    /**
-     * Create a private, mutable context shared between `init` and `dispose`.
-     */
-    context?: () => TContext;
-    /**
-     * This is optional and used from an index resource to get the correct caller.
-     * This is the reason we allow it here as well.
-     */
-    [symbolFilePath]?: string;
-    tags?: TTags;
-}
-/**
- * Helper alias describing the canonical resource init call signature.
- * Shared with fluent builders to keep init typing consistent.
- */
-export type ResourceInitFn<TConfig, TValue extends Promise<any>, TDependencies extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[]> = NonNullable<IResourceDefinition<TConfig, TValue, TDependencies, TContext, any, any, TMeta, TTags, TMiddleware>["init"]>;
-export interface IResource<TConfig = void, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = any, TContext = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> extends IResourceDefinition<TConfig, TValue, TDependencies, TContext, any, any, TMeta, TTags, TMiddleware> {
-    id: string;
-    with(config: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? IsUnspecified<TConfig> extends true ? InferInputOrViolationFromContracts<[...TTags, ...TMiddleware]> : TConfig : TConfig): IResourceWithConfig<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
-    register: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
-    overrides: Array<OverridableElements>;
-    middleware: TMiddleware;
-    [symbolFilePath]: string;
-    [symbolResource]: true;
-    /** Return an optional dependency wrapper for this resource. */
-    optional: () => IOptionalDependency<IResource<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>>;
-    tags: TTags;
-}
-export interface IResourceWithConfig<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = any, TContext = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends IResourceMiddleware<any, any, any, any>[] = IResourceMiddleware[]> {
-    [symbolResourceWithConfig]: true;
-    /** The id of the underlying resource. */
-    id: string;
-    /** The underlying resource definition. */
-    resource: IResource<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
-    /** The configuration captured by `.with(config)`. */
-    config: TConfig;
-}
-export {};

package/dist/types/resourceMiddleware.d.ts

@@ -1,47 +0,0 @@
-import { DependencyMapType, DependencyValuesType, IValidationSchema, IResource } from "../defs";
-import { TagType } from "./tag";
-import { IMiddlewareMeta } from "./meta";
-import { symbolFilePath, symbolMiddlewareConfigured, symbolResourceMiddleware } from "./symbols";
-import { IContractable } from "./contracts";
-export interface IResourceMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
-    id: string;
-    /** Static or lazy dependency map. */
-    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
-    /**
-     * Optional validation schema for runtime config validation.
-     * When provided, middleware config will be validated when .with() is called.
-     */
-    configSchema?: IValidationSchema<TConfig>;
-    /**
-     * The middleware body, called with resource execution input.
-     */
-    run: (input: IResourceMiddlewareExecutionInput<TEnforceInputContract extends void ? any : TEnforceInputContract, TEnforceOutputContract extends void ? any : TEnforceOutputContract>, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
-    meta?: IMiddlewareMeta;
-    tags?: TagType[];
-    everywhere?: boolean | ((resource: IResource<any, any, any, any, any>) => boolean);
-}
-export interface IResourceMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends IResourceMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
-    [symbolResourceMiddleware]: true;
-    id: string;
-    dependencies: TDependencies | (() => TDependencies);
-    /** Current configuration object (empty by default). */
-    config: TConfig;
-    /** Configure the middleware and return a marked, configured instance. */
-    with: (config: TConfig) => IResourceMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-    [symbolFilePath]: string;
-    tags: TagType[];
-}
-export interface IResourceMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends IResourceMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies> {
-    [symbolMiddlewareConfigured]: true;
-}
-export interface IResourceMiddlewareExecutionInput<TResourceConfig = any, TResourceOutput = any> {
-    /** Resource hook */
-    resource: {
-        definition: IResource<TResourceConfig, any, any, any, any>;
-        config: TResourceConfig;
-    };
-    next: (resourceConfig?: TResourceConfig) => Promise<TResourceOutput>;
-}
-export type ResourceMiddlewareAttachmentType = IResourceMiddleware<void, any, any, any> | IResourceMiddleware<{
-    [K in any]?: any;
-}, any, any, any> | IResourceMiddlewareConfigured<any, any, any, any>;

package/dist/types/runner.d.ts

@@ -1,68 +0,0 @@
-import { DebugFriendlyConfig } from "../globals/resources/debug";
-import { LogLevels, PrintStrategy } from "../models/Logger";
-import { OnUnhandledError } from "../models/UnhandledError";
-export type RunOptions = {
-    /**
-     * Defaults to undefined. If true, we introduce logging to the console.
-     */
-    debug?: DebugFriendlyConfig;
-    /**
-     * Configure logging settings.
-     */
-    logs?: {
-        /**
-         * Defaults to info. Use null to disable logging.
-         */
-        printThreshold?: null | LogLevels;
-        /**
-         * Defaults to PRETTY. How to print the logs.
-         */
-        printStrategy?: PrintStrategy;
-        /**
-         * Defaults to false. If true, we buffer logs until the root resource is ready.
-         * This provides you with the chance to see the logs before the root resource is ready.
-         */
-        bufferLogs?: boolean;
-    };
-    /**
-     * When true (default), installs a central error boundary that catches uncaught errors
-     * from process-level events and routes them to `onUnhandledError`.
-     */
-    errorBoundary?: boolean;
-    /**
-     * When true (default), installs SIGINT/SIGTERM handlers that call dispose() on the root allowing for graceful shutdown.
-     */
-    shutdownHooks?: boolean;
-    /**
-     * Custom handler for any unhandled error caught by Runner. Defaults to logging via the created logger.
-     */
-    onUnhandledError?: OnUnhandledError;
-    /**
-     * Defaults to false.
-     *
-     * Dry run mode. When true, the runner will setup the system, ensure there are no errors, but will not start the system.
-     * Your resources will not be initialized, and no events will be emitted. This is useful for testing and debugging.
-     *
-     * Note: this cannot catch init() errors that happen within resources.
-     */
-    dryRun?: boolean;
-    /**
-     * Defaults to true.
-     * When set, forces runtime cycle detection for event emissions. Disable if you're sure
-     * you don't have event deadlocks to improve event emission performance.
-     */
-    runtimeCycleDetection?: boolean;
-    /**
-     * Specify in which mode to run "dev", "prod" or "test".
-     * If inside Node this is automatically detected from the NODE_ENV environment variable if not provided.
-     */
-    mode?: RunnerMode;
-};
-/**
- * The mode in which the runner is operating
- */
-export declare enum RunnerMode {
-    TEST = "test",
-    DEV = "dev",
-    PROD = "prod"
-}

package/dist/types/storeTypes.d.ts

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

package/dist/types/symbols.d.ts

@@ -1,32 +0,0 @@
-/**
- * Internal brand symbols used to tag created objects at runtime and help with
- * type‑narrowing. Prefer the `isTask`/`isResource`/`isEvent`/`isMiddleware`
- * helpers instead of touching these directly.
- * @internal
- */
-export declare const symbolTask: unique symbol;
-/** Marks a task as a phantom task (no-op run; meant to be tunneled/routed). */
-export declare const symbolPhantomTask: unique symbol;
-export declare const symbolResource: unique symbol;
-export declare const symbolResourceWithConfig: unique symbol;
-export declare const symbolEvent: unique symbol;
-/** @internal Marks an error helper definition */
-export declare const symbolError: unique symbol;
-export declare const symbolMiddleware: unique symbol;
-/** New brands for separated middleware kinds */
-export declare const symbolTaskMiddleware: unique symbol;
-export declare const symbolResourceMiddleware: unique symbol;
-export declare const symbolMiddlewareConfigured: unique symbol;
-/** Records which tunnel resource owns the task patching (exclusivity). */
-export declare const symbolTunneledBy: unique symbol;
-/** @internal Marks hook definitions (event listeners without middleware) */
-export declare const symbolHook: unique symbol;
-/** @internal Marks a tag definition */
-export declare const symbolTag: unique symbol;
-export declare const symbolTagConfigured: unique symbol;
-/** @internal Marks an optional dependency wrapper */
-export declare const symbolOptionalDependency: unique symbol;
-/** @internal Path to aid anonymous id generation and error messages */
-export declare const symbolFilePath: unique symbol;
-/** @internal Marks an async context definition */
-export declare const symbolAsyncContext: unique symbol;

package/dist/types/tag.d.ts

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

package/dist/types/task.d.ts

@@ -1,54 +0,0 @@
-import { DependencyMapType, DependencyValuesType, IOptionalDependency, IValidationSchema, TaskMiddlewareAttachmentType } from "../defs";
-import { TagType } from "./tag";
-import { ITaskMeta } from "./meta";
-import { symbolFilePath, symbolTask, symbolPhantomTask, symbolTunneledBy } from "./symbols";
-import { EnsureInputSatisfiesContracts, EnsureOutputSatisfiesContracts, HasInputContracts, HasOutputContracts, InferInputOrViolationFromContracts } from "./contracts";
-export interface ITaskDefinition<TInput = undefined, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
-    id: string;
-    /**
-     * Access other tasks/resources/events. Can be an object or a function when
-     * you need late or config‑dependent resolution.
-     */
-    dependencies?: TDependencies | (() => TDependencies);
-    /** Middleware applied around task execution. */
-    middleware?: TMiddleware;
-    /** Optional metadata used for docs, filtering and tooling. */
-    meta?: TMeta;
-    /**
-     * Optional validation schema for runtime input validation.
-     * When provided, task input will be validated before execution.
-     */
-    inputSchema?: IValidationSchema<TInput>;
-    /**
-     * Optional validation schema for the task result.
-     * When provided, the result will be validated immediately after the task's
-     * `run` resolves, without considering middleware.
-     */
-    resultSchema?: IValidationSchema<TOutput extends Promise<infer U> ? U : never>;
-    run: (input: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? [TInput] extends [undefined] ? InferInputOrViolationFromContracts<[...TTags, ...TMiddleware]> : EnsureInputSatisfiesContracts<[...TTags, ...TMiddleware], TInput> : TInput, dependencies: DependencyValuesType<TDependencies>) => HasOutputContracts<[...TTags, ...TMiddleware]> extends true ? EnsureOutputSatisfiesContracts<[...TTags, ...TMiddleware], TOutput> : TOutput;
-    /**
-     * Tags applied to the task that might define its behvaiour or impact the systems.
-     */
-    tags?: TTags;
-}
-export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> extends ITaskDefinition<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware> {
-    [symbolFilePath]: string;
-    [symbolTask]: true;
-    /** Present only for phantom tasks. */
-    [symbolPhantomTask]?: true;
-    /** Indicates if the task is tunneled through a tunnel client. */
-    isTunneled?: boolean;
-    /** Records which tunnel resource owns the task (exclusivity). */
-    [symbolTunneledBy]?: string;
-    id: string;
-    dependencies: TDependencies | (() => TDependencies);
-    computedDependencies?: DependencyValuesType<TDependencies>;
-    middleware: TMiddleware;
-    /** Return an optional dependency wrapper for this task. */
-    optional: () => IOptionalDependency<ITask<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware>>;
-    tags: TTags;
-}
-/** Narrowed type for phantom tasks (no-op run by default). */
-export type IPhantomTask<TInput = any, TResolved = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> = ITask<TInput, Promise<TResolved>, TDependencies, TMeta, TTags, TMiddleware> & {
-    [symbolPhantomTask]: true;
-};