@bluelibs/runner 4.7.0-alpha → 4.8.0

package/dist/errors.d.ts

@@ -1,104 +1,62 @@
-/**
- * Base error class for all BlueLibs Runner errors
- */
-export declare class RuntimeError extends Error {
-    constructor(message: string);
-}
-/**
- * Error thrown when attempting to register a component with a duplicate ID
- */
-export declare class DuplicateRegistrationError extends RuntimeError {
-    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);
-}
-/**
- * Error thrown when an unknown item type is encountered
- */
-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
- */
-export declare class CircularDependenciesError extends RuntimeError {
-    constructor(cycles: string[]);
-}
-/**
- * Error thrown when an event is not found in the registry
- */
-export declare class EventNotFoundError extends RuntimeError {
-    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 a tag is not found in the registry
- */
-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);
-}
-/**
- * Error thrown when attempting to initialize a store that's already initialized
- */
-export declare class StoreAlreadyInitializedError extends RuntimeError {
-    constructor();
-}
-/**
- * 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, originalError: Error | string);
-}
-/**
- * Error thrown when an event emission cycle is detected
- */
-export declare class EventCycleError extends RuntimeError {
-    constructor(path: Array<{
+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;
-    }>);
-}
-/**
- * Error thrown when a compile-time event emission cycle is detected
- */
-export declare class EventEmissionCycleError extends RuntimeError {
-    constructor(cycles: string[]);
-}
-/**
- * Error thrown when a platform function is not supported in the current environment.
- */
-export declare class PlatformUnsupportedFunction extends RuntimeError {
-    constructor(functionName: string);
-}
-/**
- * CancellationError: used to signal client-initiated aborts (e.g., HTTP request aborted).
- * Handlers can catch and map to 499 Client Closed Request without noisy logs.
- */
-export declare class CancellationError extends RuntimeError {
-    constructor(message?: string);
-}
-export declare function isCancellationError(err: unknown): err is CancellationError;
+    }>;
+} & 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

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

package/dist/globals/globalMiddleware.d.ts

@@ -1,14 +1,14 @@
-import { Context } from "../context";
+import { IAsyncContext } from "../definers/defineAsyncContext";
 /**
  * Global middlewares
  */
 export declare const globalMiddlewares: {
     requireContext: import("..").ITaskMiddleware<{
-        context: Context<any>;
+        context: IAsyncContext<any>;
     }, void, void, any>;
     task: {
         requireContext: import("..").ITaskMiddleware<{
-            context: Context<any>;
+            context: IAsyncContext<any>;
         }, void, void, any>;
         cache: import("..").ITaskMiddleware<any, void, void, {
             cache: import("..").IResource<{

package/dist/globals/middleware/requireContext.middleware.d.ts

@@ -1,6 +1,6 @@
-import { Context } from "../../context";
+import { IAsyncContext } from "../../definers/defineAsyncContext";
 type RequireContextMiddlewareConfig = {
-    context: Context<any>;
+    context: IAsyncContext<any>;
 };
 export declare const requireContextTaskMiddleware: import("../..").ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>;
 export {};

package/dist/globals/resources/tunnel/protocol.d.ts

@@ -3,6 +3,8 @@ export interface ProtocolErrorShape {
     code: string;
     message: string;
     details?: unknown;
+    id?: string;
+    data?: unknown;
 }
 export interface ProtocolEnvelope<T = unknown> {
     ok: boolean;
@@ -30,7 +32,12 @@ export interface EventRequest {
 export declare class TunnelError extends Error {
     readonly code: string;
     readonly details?: unknown;
-    constructor(code: string, message: string, details?: unknown);
+    readonly id?: string;
+    readonly data?: unknown;
+    constructor(code: string, message: string, details?: unknown, extras?: {
+        id?: string;
+        data?: unknown;
+    });
 }
 export declare function toTunnelError(input: unknown, fallbackMessage?: string): TunnelError;
 export declare function assertOkEnvelope<T>(envelope: ProtocolEnvelope<T> | undefined, opts?: {

package/dist/globals/resources/tunnel/serializer.d.ts

@@ -2,7 +2,7 @@ import { EJSON } from "@bluelibs/ejson";
 export interface Serializer {
     stringify(value: unknown): string;
     parse<T = unknown>(text: string): T;
-    addType<TJson = unknown, T = unknown>(name: string, factory: (json: TJson) => T): void;
+    addType?<TJson = unknown, T = unknown>(name: string, factory: (json: TJson) => T): void;
 }
 export declare const EjsonSerializer: Serializer;
 export declare function getDefaultSerializer(): Serializer;

package/dist/globals/types.d.ts

@@ -1 +1,2 @@
 export * from "./resources/debug/types";
+export * from "./debug";

package/dist/http-client.d.ts

@@ -1,5 +1,7 @@
 import type { Readable } from "stream";
 import type { Serializer } from "./globals/resources/tunnel/serializer";
+import type { IAsyncContext } from "./types/asyncContext";
+import type { IErrorHelper } from "./types/error";
 export interface HttpClientAuth {
     header?: string;
     token: string;
@@ -14,6 +16,8 @@ export interface HttpClientConfig {
         url: string;
         headers: Record<string, string>;
     }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<any>>;
+    errorRegistry?: Map<string, IErrorHelper<any>>;
 }
 export interface HttpClient {
     task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable | ReadableStream<Uint8Array>>;

package/dist/http-fetch-tunnel.resource.d.ts

@@ -1,4 +1,6 @@
 import { Serializer } from "./globals/resources/tunnel/serializer";
+import type { IAsyncContext } from "./types/asyncContext";
+import type { IErrorHelper } from "./types/error";
 export { normalizeError } from "./globals/resources/tunnel/error-utils";
 export interface ExposureFetchAuthConfig {
     header?: string;
@@ -14,9 +16,18 @@ export interface ExposureFetchConfig {
         url: string;
         headers: Record<string, string>;
     }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<any>>;
+    errorRegistry?: Map<string, IErrorHelper<any>>;
 }
 export interface ExposureFetchClient {
     task<I = unknown, O = unknown>(id: string, input?: I): Promise<O>;
     event<P = unknown>(id: string, payload?: P): Promise<void>;
 }
+/**
+ * This functions communicates with the exposure server over HTTP.
+ * It uses the @readmes/TUNNEL_HTTP_POLICY.md strategy.
+ *
+ * @param cfg
+ * @returns
+ */
 export declare function createExposureFetch(cfg: ExposureFetchConfig): ExposureFetchClient;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { defineTask, defineResource, defineEvent, defineTaskMiddleware, defineResourceMiddleware, defineTag, defineOverride, defineHook } from "./define";
-import { createContext } from "./context";
+import { defineAsyncContext, createContext as oldCreateContext } from "./definers/defineAsyncContext";
 import { run } from "./run";
 import { createTestResource } from "./testing";
 declare const globals: {
@@ -34,11 +34,11 @@ declare const globals: {
     };
     middleware: {
         requireContext: import(".").ITaskMiddleware<{
-            context: import("./context").Context<any>;
+            context: import("./types/asyncContext").IAsyncContext<any>;
         }, void, void, any>;
         task: {
             requireContext: import(".").ITaskMiddleware<{
-                context: import("./context").Context<any>;
+                context: import("./types/asyncContext").IAsyncContext<any>;
             }, void, void, any>;
             cache: import(".").ITaskMiddleware<any, void, void, {
                 cache: import(".").IResource<{
@@ -75,15 +75,25 @@ declare const globals: {
             createClient(cfg: import("./globals/tunnels").HttpCreateClientConfig): import("./http-fetch-tunnel.resource").ExposureFetchClient;
         }>;
     }>;
+    debug: {
+        levels: {
+            normal: import(".").DebugConfig;
+            verbose: import(".").DebugConfig;
+        };
+    };
 };
 export { globals };
-export { defineTask as task, defineResource as resource, defineEvent as event, defineTaskMiddleware as taskMiddleware, defineResourceMiddleware as resourceMiddleware, defineTag as tag, defineOverride as override, defineHook as hook, run, createContext, createTestResource, };
+export { defineTask as task, defineResource as resource, defineEvent as event, defineTaskMiddleware as taskMiddleware, defineResourceMiddleware as resourceMiddleware, defineAsyncContext as asyncContext, defineTag as tag, defineOverride as override, defineHook as hook, run, createTestResource, };
+declare const createContext: typeof oldCreateContext;
+export { createContext };
 export declare const r: Readonly<{
     resource: typeof import("./definers/builders/resource").resourceBuilder;
     task: import("./definers/builders/task").TaskBuilderWithPhantom;
     event: typeof import("./definers/builders/event").eventBuilder;
     hook: typeof import("./definers/builders/hook").hookBuilder;
     tag: typeof import("./definers/builders/tag").tagBuilder;
+    asyncContext: typeof import("./definers/builders/asyncContext").asyncContextBuilder;
+    error: typeof import("./definers/builders/error").errorBuilder;
     middleware: Readonly<{
         task: typeof import("./definers/builders/middleware").taskMiddlewareBuilder;
         resource: typeof import("./definers/builders/middleware").resourceMiddlewareBuilder;
@@ -93,7 +103,6 @@ export * as definitions from "./defs";
 export * from "./models";
 export * from "./globals/types";
 export * as Errors from "./errors";
-export { Context } from "./context";
 export { PlatformAdapter, setPlatform } from "./platform";
 export { EJSON } from "@bluelibs/ejson";
 export type * from "./defs";

package/dist/models/Store.d.ts

@@ -5,6 +5,7 @@ import { ResourceStoreElementType, TaskStoreElementType, TaskMiddlewareStoreElem
 import { TaskRunner } from "./TaskRunner";
 import { OnUnhandledError } from "./UnhandledError";
 import { MiddlewareManager } from "./MiddlewareManager";
+import { RunnerMode } from "../types/runner";
 export { ResourceStoreElementType, TaskStoreElementType, EventStoreElementType, };
 /**
  * Store class which is used to store all the resources, tasks, middleware and events.
@@ -20,15 +21,18 @@ export declare class Store {
     private validator;
     private taskRunner?;
     private middlewareManager;
-    constructor(eventManager: EventManager, logger: Logger, onUnhandledError: OnUnhandledError);
+    mode: RunnerMode;
+    constructor(eventManager: EventManager, logger: Logger, onUnhandledError: OnUnhandledError, mode?: RunnerMode);
     get tasks(): Map<string, TaskStoreElementType>;
     get hooks(): Map<string, import("..").HookStoreElementType>;
     get resources(): Map<string, ResourceStoreElementType>;
     get events(): Map<string, EventStoreElementType>;
+    get errors(): Map<string, import("../errors").IErrorHelper<any>>;
+    get asyncContexts(): Map<string, import("../types/asyncContext").IAsyncContext<any>>;
     get taskMiddlewares(): Map<string, TaskMiddlewareStoreElementType>;
     get resourceMiddlewares(): Map<string, ResourceMiddlewareStoreElementType>;
     get tags(): Map<string, ITag<void, void, void>>;
-    get overrides(): Map<string, IResourceMiddleware<any, void, void, any> | ITask<any, any, {}, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]> | IResource<void, Promise<any>, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]> | import("..").IResourceWithConfig<any, Promise<any>, any, any, any, import("..").TagType[], IResourceMiddleware<any, void, void, any>[]> | import("..").IHook<{}, any, any> | ITaskMiddleware<any, void, void, any>>;
+    get overrides(): Map<string, IResourceMiddleware<any, void, void, any> | ITaskMiddleware<any, void, void, any> | ITask<any, any, {}, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]> | IResource<void, Promise<any>, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]> | import("..").IResourceWithConfig<any, Promise<any>, any, any, any, import("..").TagType[], IResourceMiddleware<any, void, void, any>[]> | import("..").IHook<{}, any, any>>;
     get overrideRequests(): Set<{
         source: string;
         override: RegisterableItems;

package/dist/models/StoreRegistry.d.ts

@@ -3,6 +3,8 @@ import { TaskStoreElementType, TaskMiddlewareStoreElementType, ResourceMiddlewar
 import { StoreValidator } from "./StoreValidator";
 import { Store } from "./Store";
 import { IDependentNode } from "./utils/findCircularDependencies";
+import { IErrorHelper } from "../types/error";
+import type { IAsyncContext } from "../types/asyncContext";
 type StoringMode = "normal" | "override";
 export declare class StoreRegistry {
     protected readonly store: Store;
@@ -13,10 +15,14 @@ export declare class StoreRegistry {
     resourceMiddlewares: Map<string, ResourceMiddlewareStoreElementType>;
     hooks: Map<string, HookStoreElementType>;
     tags: Map<string, ITag>;
+    asyncContexts: Map<string, IAsyncContext<any>>;
+    errors: Map<string, IErrorHelper<any>>;
     private validator;
     constructor(store: Store);
     getValidator(): StoreValidator;
     storeGenericItem<C>(item: RegisterableItems): void;
+    storeError<C>(item: IErrorHelper<any>): void;
+    storeAsyncContext<C>(item: IAsyncContext<any>): void;
     storeTag(item: ITag<any, any, any>): void;
     storeHook<C>(item: IHook<any, any>, overrideMode?: StoringMode): void;
     storeTaskMiddleware<C>(item: ITaskMiddleware<any>, storingMode?: StoringMode): void;

package/dist/node/exposure/httpResponse.d.ts

@@ -5,6 +5,6 @@ export declare const EJSON_CONTENT_TYPE = "application/json; charset=utf-8";
 export declare const NOT_FOUND_RESPONSE: JsonResponse;
 export declare const METHOD_NOT_ALLOWED_RESPONSE: JsonResponse;
 export declare function jsonOkResponse(data?: Record<string, unknown>): JsonResponse;
-export declare function jsonErrorResponse(status: number, message: string, code?: string): JsonResponse;
+export declare function jsonErrorResponse(status: number, message: string, code?: string, extra?: Record<string, unknown>): JsonResponse;
 export declare function respondJson(res: ServerResponse, response: JsonResponse, serializer?: Serializer): void;
 export declare function respondStream(res: ServerResponse, value: StreamingResponse | NodeJS.ReadableStream): void;

package/dist/node/exposure/requestContext.d.ts

@@ -8,7 +8,7 @@ export interface ExposureRequestContextValue {
     method?: string;
     signal: AbortSignal;
 }
-export declare const ExposureRequestContext: import("..").Context<ExposureRequestContextValue>;
+export declare const ExposureRequestContext: import("../../types/asyncContext").IAsyncContext<ExposureRequestContextValue>;
 export declare function useExposureContext(): ExposureRequestContextValue;
 /**
  * Checks if the exposure request context is currently available without throwing an error.

package/dist/node/{mixed-http-client.node.d.ts → http-mixed-client.d.ts}

@@ -23,5 +23,5 @@ export interface MixedHttpClient {
  * Unified Node client that mixes JSON/EJSON fetch for standard calls and
  * Smart client for streaming/multipart. Keeps transport details out of app code.
  */
-export declare function createMixedHttpClient(cfg: MixedHttpClientConfig): MixedHttpClient;
+export declare function createHttpMixedClient(cfg: MixedHttpClientConfig): MixedHttpClient;
 export type { Readable };

package/dist/node/http-smart-client.model.d.ts

@@ -1,5 +1,6 @@
 import { Readable } from "stream";
 import type { Serializer } from "../globals/resources/tunnel/serializer";
+import type { IAsyncContext } from "../types/asyncContext";
 export interface HttpSmartClientAuthConfig {
     header?: string;
     token: string;
@@ -13,6 +14,7 @@ export interface HttpSmartClientConfig {
         url: string;
         headers: Record<string, string>;
     }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<any>>;
 }
 export interface HttpSmartClient {
     task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable>;