@bluelibs/runner 3.4.2 → 4.0.1

package/dist/defs.d.ts

@@ -3,435 +3,27 @@
  *
  * 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 (with lifecycle events)
- * - Resources are singletons (with init/dispose hooks and lifecycle events)
+ * - 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
+ * - 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
  */
-import { MiddlewareEverywhereOptions } from "./define";
-import { EnsureResponseSatisfiesContracts, HasContracts } from "./defs.returnTag";
-/**
- * Generic validation schema interface that can be implemented by any validation library.
- * Compatible with Zod, Yup, Joi, and other validation libraries.
- */
-export interface IValidationSchema<T = any> {
-    /**
-     * Parse and validate the input data.
-     * Should throw an error if validation fails.
-     * Can transform the data if the schema supports transformations.
-     */
-    parse(input: unknown): T;
-}
+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 "./models/StoreTypes";
-/**
- * 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;
-export declare const symbolResource: unique symbol;
-export declare const symbolResourceWithConfig: unique symbol;
-export declare const symbolEvent: unique symbol;
-export declare const symbolMiddleware: unique symbol;
-export declare const symbolMiddlewareConfigured: unique symbol;
-export declare const symbolMiddlewareGlobal: unique symbol;
-export declare const symbolMiddlewareEverywhereTasks: unique symbol;
-export declare const symbolMiddlewareEverywhereResources: unique symbol;
-/** @internal Path to aid anonymous id generation and error messages */
-export declare const symbolFilePath: unique symbol;
-/** @internal Marks disposable instances */
-export declare const symbolDispose: unique symbol;
-/** @internal Link to internal Store */
-export declare const symbolStore: unique symbol;
-/** @internal Brand used by index() resources */
-export declare const symbolIndexResource: unique symbol;
-export interface ITagDefinition<TConfig = void, TEnforceContract = void> {
-    id: string | symbol;
-}
-/**
- * A configured instance of a tag as produced by `ITag.with()`.
- */
-export interface ITagWithConfig<TConfig = void, TEnforceContract = void> {
-    id: string | symbol;
-    /** The tag definition used to produce this configured instance. */
-    tag: ITag<TConfig, TEnforceContract>;
-    /** The configuration captured for this tag instance. */
-    config: TConfig;
-}
-/**
- * A tag definition (builder). Use `.with(config)` to obtain configured instances,
- * and `.extract(tags)` to find either a configured instance or the bare tag in a list.
- */
-export interface ITag<TConfig = void, TEnforceContract = void> extends ITagDefinition<TConfig, TEnforceContract> {
-    /**
-     * Creates a configured instance of the tag.
-     */
-    with(config: TConfig): ITagWithConfig<TConfig, TEnforceContract>;
-    /**
-     * Extracts either a configured instance or the bare tag from a list of tags
-     * or from a taggable object (`{ meta: { tags?: [] } }`).
-     */
-    extract(target: TagType[] | ITaggable): ExtractedTagResult<TConfig, TEnforceContract> | null;
-    [symbolFilePath]: string;
-}
-/**
- * Restrict bare tags to those whose config can be omitted (void or optional object),
- * mirroring the same principle used for resources in `RegisterableItems`.
- * Required-config tags must appear as configured instances.
- */
-export type TagType = string | ITag<void, any> | ITag<{
-    [K in any]?: any;
-}, any> | ITagWithConfig<any, any>;
-/**
- * Conditional result type for `ITag.extract`:
- * - For void config → just the identifier
- * - For optional object config → identifier with optional config
- * - For required config → identifier with required config
- */
-export type ExtractedTagResult<TConfig, TEnforceContract> = {} extends TConfig ? {
-    id: string | symbol;
-    config?: TConfig;
-} : {
-    id: string | symbol;
-    config: TConfig;
-};
-/**
- * Any object that can carry tags via metadata. This mirrors how tasks,
- * resources, events, and middleware expose `meta.tags`.
- */
-export interface ITaggable {
-    meta?: {
-        tags?: TagType[];
-    };
-}
-/**
- * Common metadata you can attach to tasks/resources/events/middleware.
- * Useful for docs, filtering and middleware decisions.
- */
-export interface IMeta {
-    title?: string;
-    description?: string;
-    tags?: TagType[];
-}
-export interface ITaskMeta extends IMeta {
-}
-export interface IResourceMeta extends IMeta {
-}
-export interface IEventMeta extends IMeta {
-}
-export interface IMiddlewareMeta extends IMeta {
-}
-/**
- * A mapping of dependency keys to Runner definitions. Used in `dependencies`
- * for tasks and resources. Values are later transformed into the actual
- * callable/value shape by `DependencyValuesType`.
- */
-export type DependencyMapType = Record<string, ITask<any, any, any, any> | IResource<any, any, any> | IEventDefinition<any>>;
-type ExtractTaskInput<T> = T extends ITask<infer I, any, infer D> ? I : never;
-type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer D> ? O : never;
-type ExtractResourceValue<T> = T extends IResource<any, infer V, infer D> ? V extends Promise<infer U> ? U : V : never;
-type ExtractEventParams<T> = T extends IEvent<infer P> ? P : never;
-/**
- * Task dependencies transform into callable functions: call with the task input
- * and you receive the task output.
- */
-type TaskDependency<I, O> = (...args: I extends null | void ? [] : [I]) => O;
-/**
- * Resource dependencies resolve to the resource's value directly.
- */
-type ResourceDependency<V> = V;
-/**
- * Event dependencies resolve to an emitter function. If the payload type is
- * `void`, the function can be called with zero args (or an empty object).
- */
-type EventDependency<P> = P extends void ? (() => Promise<void>) & ((input?: Record<string, never>) => Promise<void>) : (input: P) => Promise<void>;
-/**
- * Transforms a dependency definition into the usable shape inside `run`/`init`:
- * - Task -> callable function
- * - Resource -> resolved value
- * - Event -> emit function
- */
-export type DependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependency<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventParams<T>> : never;
-export type DependencyValuesType<T extends DependencyMapType> = {
-    [K in keyof T]: DependencyValueType<T[K]>;
-};
-/**
- * Anything you can put inside a resource's `register: []`.
- * - Resources (with or without `.with()`)
- * - Tasks
- * - Middleware
- * - Events
- */
-export type RegisterableItems<T = any> = IResourceWithConfig<any> | IResource<void, any, any, any> | IResource<{
-    [K in any]?: any;
-}, any, any, any> | ITask<any, any, any, any> | IMiddleware<any> | IEvent<any>;
-export type MiddlewareAttachments = IMiddleware<void> | IMiddleware<{
-    [K in any]?: any;
-}> | IMiddlewareConfigured<any>;
-export interface ITaskDefinition<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined, // Adding a generic to track 'on' type,
-TMeta extends ITaskMeta = any> {
-    /**
-     * Stable identifier. If omitted, an anonymous id is generated from file path
-     * (see README: Anonymous IDs).
-     */
-    id?: string | symbol;
-    /**
-     * 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?: MiddlewareAttachments[];
-    /**
-     * Listen to events in a simple way
-     */
-    on?: TOn;
-    /**
-     * This makes sense only when `on` is specified to provide the order of the execution.
-     * The event with the lowest order will be executed first.
-     */
-    listenerOrder?: number;
-    /** 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>;
-    /**
-     * The task body. If `on` is set, the input is an `IEventEmission`. Otherwise,
-     * it's the declared input type.
-     */
-    run: (input: TOn extends undefined ? TInput : IEventEmission<TOn extends "*" ? any : ExtractEventParams<TOn>>, dependencies: DependencyValuesType<TDependencies>) => HasContracts<TMeta> extends true ? EnsureResponseSatisfiesContracts<TMeta, TOutput> : TOutput;
-}
-export type BeforeRunEventPayload<TInput> = {
-    input: TInput;
-};
-export type AfterRunEventPayload<TInput, TOutput> = {
-    input: TInput;
-    output: TOutput extends Promise<infer U> ? U : TOutput;
-    setOutput(newOutput: TOutput extends Promise<infer U> ? U : TOutput): void;
-};
-export type OnErrorEventPayload = {
-    error: any;
-    /**
-     * This function can be called to suppress the error from being thrown.
-     */
-    suppress(): void;
-};
-export type BeforeInitEventPayload<TConfig> = {
-    config: TConfig;
-};
-export type AfterInitEventPayload<TConfig, TValue> = {
-    config: TConfig;
-    value: TValue;
-};
-/**
- * This is the response after the definition has been prepared. TODO: better naming?
- */
-export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined, TMeta extends ITaskMeta = any> extends ITaskDefinition<TInput, TOutput, TDependencies, TOn, TMeta> {
-    id: string | symbol;
-    dependencies: TDependencies | (() => TDependencies);
-    computedDependencies?: DependencyValuesType<TDependencies>;
-    middleware: MiddlewareAttachments[];
-    /**
-     * These events are automatically populated after the task has been defined.
-     */
-    events: {
-        beforeRun: IEvent<BeforeRunEventPayload<TInput>>;
-        afterRun: IEvent<AfterRunEventPayload<TInput, TOutput>>;
-        onError: IEvent<OnErrorEventPayload>;
-    };
-    [symbolFilePath]: string;
-    [symbolTask]: true;
-}
-export interface IResourceDefinition<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = {}, TContext = any, THooks = any, TRegisterableItems = any, TMeta extends IResourceMeta = any> {
-    /** Stable identifier. Omit to get an anonymous id. */
-    id?: string | symbol;
-    /** 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?: (this: any, config: TConfig, dependencies: DependencyValuesType<TDependencies>, context: TContext) => HasContracts<TMeta> extends true ? EnsureResponseSatisfiesContracts<TMeta, TValue> : 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: DependencyValuesType<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<IResource | ITask | IMiddleware | IResourceWithConfig>;
-    /** Middleware applied around init/dispose. */
-    middleware?: MiddlewareAttachments[];
-    /**
-     * 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;
-    /**
-     * This is used internally when creating index resources.
-     */
-    [symbolIndexResource]?: boolean;
-}
-export interface IResource<TConfig = void, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = any, TContext = any, TMeta extends IResourceMeta = any> extends IResourceDefinition<TConfig, TValue, TDependencies, TContext, any, any, TMeta> {
-    id: string | symbol;
-    with(config: TConfig): IResourceWithConfig<TConfig, TValue, TDependencies>;
-    register: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
-    /**
-     * These events are automatically populated after the task has been defined.
-     */
-    events: {
-        beforeInit: IEvent<BeforeInitEventPayload<TConfig>>;
-        afterInit: IEvent<AfterInitEventPayload<TConfig, TValue>>;
-        onError: IEvent<OnErrorEventPayload>;
-    };
-    overrides: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
-    middleware: MiddlewareAttachments[];
-    [symbolFilePath]: string;
-    [symbolIndexResource]: boolean;
-    [symbolResource]: true;
-}
-export interface IResourceWithConfig<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = any> {
-    /** The id of the underlying resource. */
-    id: string;
-    /** The underlying resource definition. */
-    resource: IResource<TConfig, TValue, TDependencies>;
-    /** The configuration captured by `.with(config)`. */
-    config: TConfig;
-}
-export type EventHandlerType<T = any> = (event: IEventEmission<T>) => any | Promise<any>;
-export interface IEventDefinition<TPayload = void> {
-    /** Stable identifier. Omit to get an anonymous id. */
-    id?: string | symbol;
-    meta?: IEventMeta;
-    /**
-     * Optional validation schema for runtime payload validation.
-     * When provided, event payload will be validated when emitted.
-     */
-    payloadSchema?: IValidationSchema<TPayload>;
-}
-export interface IEvent<TPayload = any> extends IEventDefinition<TPayload> {
-    id: string | symbol;
-    /**
-     * 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;
-}
-/**
- * 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 | symbol;
-    /**
-     * 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 | symbol;
-    /**
-     * 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;
-}
-export interface IMiddlewareDefinition<TConfig = any, TDependencies extends DependencyMapType = any> {
-    /** Stable identifier. Omit to get an anonymous id. */
-    id?: string | symbol;
-    /** 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 task/resource execution input.
-     */
-    run: (input: IMiddlewareExecutionInput, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
-    meta?: IMiddlewareMeta;
-}
-export interface IMiddleware<TConfig = any, TDependencies extends DependencyMapType = any> extends IMiddlewareDefinition<TConfig, TDependencies> {
-    [symbolMiddleware]: true;
-    [symbolMiddlewareConfigured]?: boolean;
-    [symbolMiddlewareEverywhereTasks]?: boolean;
-    [symbolMiddlewareEverywhereResources]?: boolean;
-    id: string | symbol;
-    dependencies: TDependencies | (() => TDependencies);
-    /**
-     * Attach this middleware globally. Use options to scope to tasks/resources.
-     */
-    everywhere(config?: MiddlewareEverywhereOptions): IMiddleware<TConfig, TDependencies>;
-    /** Current configuration object (empty by default). */
-    config: TConfig;
-    /** Configure the middleware and return a marked, configured instance. */
-    with: (config: TConfig) => IMiddlewareConfigured<TConfig, TDependencies>;
-    [symbolFilePath]: string;
-    [symbolMiddleware]: true;
-}
-export interface IMiddlewareConfigured<TConfig = any, TDependencies extends DependencyMapType = any> extends IMiddleware<TConfig, TDependencies> {
-    [symbolMiddlewareConfigured]: true;
-}
-export interface IMiddlewareDefinitionConfigured<C extends Record<string, any> = {}> {
-    middleware: IMiddleware<C>;
-    config?: C;
-}
-export interface IMiddlewareExecutionInput<TTaskInput = any, TResourceConfig = any> {
-    /** Task hook: present when wrapping a task run. */
-    task?: {
-        definition: ITask<TTaskInput>;
-        input: TTaskInput;
-    };
-    /** Resource hook: present when wrapping init/dispose. */
-    resource?: {
-        definition: IResource<TResourceConfig, any, any, any, any>;
-        config: TResourceConfig;
-    };
-    next: (taskInputOrResourceConfig?: TTaskInput | TResourceConfig) => Promise<any>;
-}
+export * from "./types/storeTypes";

package/dist/defs.js

@@ -1,19 +1,4 @@
 "use strict";
-/**
- * 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 (with lifecycle events)
- * - Resources are singletons (with init/dispose hooks and lifecycle events)
- * - Events are simple, strongly-typed emissions
- * - Middleware can target both tasks and resources
- *
- * 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
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -29,29 +14,32 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.symbolIndexResource = exports.symbolStore = exports.symbolDispose = exports.symbolFilePath = exports.symbolMiddlewareEverywhereResources = exports.symbolMiddlewareEverywhereTasks = exports.symbolMiddlewareGlobal = exports.symbolMiddlewareConfigured = exports.symbolMiddleware = exports.symbolEvent = exports.symbolResourceWithConfig = exports.symbolResource = exports.symbolTask = void 0;
-__exportStar(require("./models/StoreTypes"), exports);
 /**
- * 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
+ * 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
  */
-exports.symbolTask = Symbol("runner.task");
-exports.symbolResource = Symbol("runner.resource");
-exports.symbolResourceWithConfig = Symbol("runner.resourceWithConfig");
-exports.symbolEvent = Symbol("runner.event");
-exports.symbolMiddleware = Symbol("runner.middleware");
-exports.symbolMiddlewareConfigured = Symbol("runner.middlewareConfigured");
-exports.symbolMiddlewareGlobal = Symbol("runner.middlewareGlobal");
-exports.symbolMiddlewareEverywhereTasks = Symbol("runner.middlewareGlobalTasks");
-exports.symbolMiddlewareEverywhereResources = Symbol("runner.middlewareGlobalResources");
-/** @internal Path to aid anonymous id generation and error messages */
-exports.symbolFilePath = Symbol("runner.filePath");
-/** @internal Marks disposable instances */
-exports.symbolDispose = Symbol("runner.dispose");
-/** @internal Link to internal Store */
-exports.symbolStore = Symbol("runner.store");
-/** @internal Brand used by index() resources */
-exports.symbolIndexResource = Symbol("runner.indexResource");
+__exportStar(require("./types/utilities"), exports);
+__exportStar(require("./types/symbols"), exports);
+__exportStar(require("./types/tag"), exports);
+__exportStar(require("./types/hook"), exports);
+__exportStar(require("./types/resource"), exports);
+__exportStar(require("./types/event"), exports);
+__exportStar(require("./types/task"), exports);
+__exportStar(require("./types/taskMiddleware"), exports);
+__exportStar(require("./types/resourceMiddleware"), exports);
+__exportStar(require("./types/meta"), exports);
+__exportStar(require("./types/runner"), exports);
+__exportStar(require("./types/storeTypes"), exports);
 //# sourceMappingURL=defs.js.map

package/dist/defs.js.map

@@ -1 +1 @@
-{"version":3,"file":"defs.js","sourceRoot":"","sources":["../src/defs.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;AAuBH,sDAAoC;AACpC;;;;;GAKG;AACU,QAAA,UAAU,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AAClD,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AACW,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AACpD,QAAA,gBAAgB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC9D,QAAA,0BAA0B,GAAkB,MAAM,CAC7D,6BAA6B,CAC9B,CAAC;AACW,QAAA,sBAAsB,GAAkB,MAAM,CACzD,yBAAyB,CAC1B,CAAC;AACW,QAAA,+BAA+B,GAAkB,MAAM,CAClE,8BAA8B,CAC/B,CAAC;AACW,QAAA,mCAAmC,GAAkB,MAAM,CACtE,kCAAkC,CACnC,CAAC;AAEF,uEAAuE;AAC1D,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AACvE,2CAA2C;AAC9B,QAAA,aAAa,GAAkB,MAAM,CAAC,gBAAgB,CAAC,CAAC;AACrE,uCAAuC;AAC1B,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AAEjE,gDAAgD;AACnC,QAAA,mBAAmB,GAAkB,MAAM,CACtD,sBAAsB,CACvB,CAAC"}
+{"version":3,"file":"defs.js","sourceRoot":"","sources":["../src/defs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;GAeG;AACH,oDAAkC;AAClC,kDAAgC;AAChC,8CAA4B;AAC5B,+CAA6B;AAC7B,mDAAiC;AACjC,gDAA8B;AAC9B,+CAA6B;AAC7B,yDAAuC;AACvC,6DAA2C;AAC3C,+CAA6B;AAC7B,iDAA+B;AAI/B,qDAAmC"}

package/dist/errors.d.ts

@@ -8,13 +8,13 @@ export declare class RuntimeError extends Error {
  * Error thrown when attempting to register a component with a duplicate ID
  */
 export declare class DuplicateRegistrationError extends RuntimeError {
-    constructor(type: string, id: string | symbol);
+    constructor(type: string, id: string);
 }
 /**
  * Error thrown when a dependency is not found in the registry
  */
 export declare class DependencyNotFoundError extends RuntimeError {
-    constructor(key: string | symbol);
+    constructor(key: string);
 }
 /**
  * Error thrown when an unknown item type is encountered
@@ -22,6 +22,12 @@ export declare class DependencyNotFoundError extends RuntimeError {
 export declare class UnknownItemTypeError extends RuntimeError {
     constructor(item: any);
 }
+/**
+ * Error thrown whenever a requested context is not available.
+ */
+export declare class ContextError extends Error {
+    constructor(message: string);
+}
 /**
  * Error thrown when circular dependencies are detected
  */
@@ -32,19 +38,28 @@ export declare class CircularDependenciesError extends RuntimeError {
  * Error thrown when an event is not found in the registry
  */
 export declare class EventNotFoundError extends RuntimeError {
-    constructor(id: string | symbol);
+    constructor(id: string);
+}
+/**
+ * Error thrown when a resource is not found in the store
+ */
+export declare class ResourceNotFoundError extends RuntimeError {
+    constructor(id: string);
+}
+export declare class MiddlewareNotRegisteredError extends RuntimeError {
+    constructor(type: "task" | "resource", source: string, middlewareId: string);
 }
 /**
- * Error thrown when attempting to make a middleware global when it's already global
+ * Error thrown when a tag is not found in the registry
  */
-export declare class MiddlewareAlreadyGlobalError extends RuntimeError {
-    constructor(id: string | symbol);
+export declare class TagNotFoundError extends RuntimeError {
+    constructor(id: string);
 }
 /**
  * Error thrown when attempting to modify a locked component
  */
 export declare class LockedError extends RuntimeError {
-    constructor(what: string | symbol);
+    constructor(what: string);
 }
 /**
  * Error thrown when attempting to initialize a store that's already initialized
@@ -56,5 +71,5 @@ export declare class StoreAlreadyInitializedError extends RuntimeError {
  * Error thrown when validation fails for task input, resource config, middleware config, or event payload
  */
 export declare class ValidationError extends RuntimeError {
-    constructor(type: string, id: string | symbol, originalError: Error | string);
+    constructor(type: string, id: string, originalError: Error | string);
 }