@bluelibs/runner 4.6.0 → 4.7.0-alpha

package/dist/errors.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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<{
+        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;

package/dist/globals/globalEvents.d.ts

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

package/dist/globals/globalMiddleware.d.ts

@@ -0,0 +1,31 @@
+import { Context } from "../context";
+/**
+ * Global middlewares
+ */
+export declare const globalMiddlewares: {
+    requireContext: import("..").ITaskMiddleware<{
+        context: Context<any>;
+    }, void, void, any>;
+    task: {
+        requireContext: import("..").ITaskMiddleware<{
+            context: Context<any>;
+        }, void, void, any>;
+        cache: import("..").ITaskMiddleware<any, void, void, {
+            cache: import("..").IResource<{
+                defaultOptions?: any;
+            }, Promise<{
+                map: Map<string, import("..").ICacheInstance>;
+                cacheFactoryTask: import("..").TaskDependencyWithIntercept<any, Promise<import("..").ICacheInstance>>;
+                defaultOptions: any;
+            }>, {
+                cacheFactoryTask: import("..").ITask<any, Promise<import("..").ICacheInstance>, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>;
+            }, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }>;
+        retry: import("..").ITaskMiddleware<import("./middleware/retry.middleware").RetryMiddlewareConfig, void, void, any>;
+        timeout: import("..").ITaskMiddleware<import("./middleware/timeout.middleware").TimeoutMiddlewareConfig, void, void, any>;
+    };
+    resource: {
+        retry: import("..").IResourceMiddleware<import("./middleware/retry.middleware").RetryMiddlewareConfig, void, void, any>;
+        timeout: import("..").IResourceMiddleware<import("./middleware/timeout.middleware").TimeoutMiddlewareConfig, void, void, any>;
+    };
+};

package/dist/globals/globalResources.d.ts

@@ -0,0 +1,32 @@
+import { EventManager } from "../models/EventManager";
+import { Logger } from "../models/Logger";
+import { Store } from "../models/Store";
+import { TaskRunner } from "../models/TaskRunner";
+import { MiddlewareManager } from "../models/MiddlewareManager";
+import type { Serializer } from "./resources/tunnel/serializer";
+export declare const globalResources: {
+    store: import("..").IResource<void, Promise<Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    middlewareManager: import("..").IResource<void, Promise<MiddlewareManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("..").IResource<void, Promise<EventManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("..").IResource<void, Promise<TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    logger: import("..").IResource<void, Promise<Logger>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    serializer: import("..").IResource<void, Promise<Serializer>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    cache: import("..").IResource<{
+        defaultOptions?: any;
+    }, Promise<{
+        map: Map<string, import("..").ICacheInstance>;
+        cacheFactoryTask: import("..").TaskDependencyWithIntercept<any, Promise<import("..").ICacheInstance>>;
+        defaultOptions: any;
+    }>, {
+        cacheFactoryTask: import("..").ITask<any, Promise<import("..").ICacheInstance>, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>;
+    }, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    queue: import("..").IResource<void, Promise<{
+        map: Map<string, import("..").Queue>;
+        run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+    }>, {}, {
+        map: Map<string, import("..").Queue>;
+    }, {
+        title: string;
+        description: string;
+    }, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+};

package/dist/globals/globalTags.d.ts

@@ -0,0 +1,11 @@
+export declare const globalTags: {
+    system: import("..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>;
+    excludeFromGlobalHooks: import("..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>;
+    debug: import("..").ITag<import("./types").DebugFriendlyConfig, void, void>;
+    tunnel: import("..").ITag<void, void, import("./resources/tunnel/types").TunnelRunner>;
+    tunnelPolicy: import("..").ITag<import("./resources/tunnel/tunnel.policy.tag").TunnelTaskMiddlewarePolicyConfig, void, void>;
+};

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

@@ -0,0 +1,27 @@
+import { IResource, ITask } from "../../defs";
+export interface ICacheInstance {
+    set(key: string, value: any): void;
+    get(key: string): any;
+    clear(): void;
+}
+export declare const cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+type CacheResourceConfig = {
+    defaultOptions?: any;
+};
+export declare const cacheResource: IResource<CacheResourceConfig, Promise<{
+    map: Map<string, ICacheInstance>;
+    cacheFactoryTask: import("../..").TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
+    defaultOptions: any;
+}>, {
+    cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const cacheMiddleware: import("../..").ITaskMiddleware<any, void, void, {
+    cache: IResource<CacheResourceConfig, Promise<{
+        map: Map<string, ICacheInstance>;
+        cacheFactoryTask: import("../..").TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
+        defaultOptions: any;
+    }>, {
+        cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+    }, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;
+export {};

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Configuration options for the retry middleware
+ */
+export interface RetryMiddlewareConfig {
+    /**
+     * Maximum number of retry attempts (default: 3)
+     */
+    retries?: number;
+    /**
+     * Callback to determine if retry should stop based on error
+     * @default () => false (retry all errors)
+     */
+    stopRetryIf?: (error: Error) => boolean;
+    /**
+     * Custom delay strategy function
+     * @default Exponential backoff starting at 100ms
+     */
+    delayStrategy?: (attempt: number, error: Error) => number;
+}
+export declare const retryTaskMiddleware: import("../..").ITaskMiddleware<RetryMiddlewareConfig, void, void, any>;
+export declare const retryResourceMiddleware: import("../..").IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;

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

@@ -0,0 +1,9 @@
+export interface TimeoutMiddlewareConfig {
+    /**
+     * Maximum time in milliseconds before the wrapped operation is aborted
+     * and a timeout error is thrown. Defaults to 5000ms.
+     */
+    ttl: number;
+}
+export declare const timeoutTaskMiddleware: import("../..").ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any>;
+export declare const timeoutResourceMiddleware: import("../..").IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;

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

@@ -0,0 +1,2 @@
+import type { TunnelRunner } from "../resources/tunnel/types";
+export declare const tunnelResourceMiddleware: import("../..").IResourceMiddleware<void, any, TunnelRunner, any>;

package/dist/globals/resources/debug/debug.resource.d.ts

@@ -0,0 +1,7 @@
+import { DebugFriendlyConfig } from "./types";
+export declare const debugResource: import("../../..").IResource<DebugFriendlyConfig, Promise<any>, {}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/debug/debug.tag.d.ts

@@ -0,0 +1,2 @@
+import { DebugFriendlyConfig } from "./types";
+export declare const debugTag: import("../../..").ITag<DebugFriendlyConfig, void, void>;

package/dist/globals/resources/debug/debugConfig.resource.d.ts

@@ -0,0 +1,22 @@
+import { DebugFriendlyConfig } from "./types";
+export declare const debugConfig: import("../../..").IResource<DebugFriendlyConfig, Promise<{
+    logResourceConfig: boolean;
+    logResourceValue: boolean;
+    logResourceBeforeRun: boolean;
+    logResourceAfterRun: boolean;
+    logTaskBeforeRun: boolean;
+    logTaskInput: boolean;
+    logTaskOutput: boolean;
+    logTaskAfterRun: boolean;
+    logMiddlewareBeforeRun: boolean;
+    logMiddlewareAfterRun: boolean;
+    logEventEmissionOnRun: boolean;
+    logEventEmissionInput: boolean;
+    logHookTriggered: boolean;
+    logHookCompleted: boolean;
+}>, {}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/debug/executionTracker.middleware.d.ts

@@ -0,0 +1,50 @@
+export declare const tasksTrackerMiddleware: import("../../..").ITaskMiddleware<any, void, void, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    store: import("../../..").IResource<void, Promise<import("../../..").Store>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}>;
+export declare const resourcesTrackerMiddleware: import("../../..").IResourceMiddleware<any, void, void, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    store: import("../../..").IResource<void, Promise<import("../../..").Store>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}>;

package/dist/globals/resources/debug/globalEvent.hook.d.ts

@@ -0,0 +1,27 @@
+export declare const globalEventListener: import("../../..").IHook<{
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}, "*", {
+    title: string;
+    description: string;
+}>;

package/dist/globals/resources/debug/hook.hook.d.ts

@@ -0,0 +1,30 @@
+export declare const hookInterceptorResource: import("../../..").IResource<void, Promise<void>, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../..").IResource<void, Promise<import("../../..").EventManager>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/debug/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./debug.resource";
+export * from "./debugConfig.resource";
+export * from "./types";
+export * from "./globalEvent.hook";
+export * from "./executionTracker.middleware";
+export * from "./debug.tag";

package/dist/globals/resources/debug/middleware.hook.d.ts

@@ -0,0 +1,30 @@
+export declare const middlewareInterceptorResource: import("../../..").IResource<void, Promise<void>, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    middlewareManager: import("../../..").IResource<void, Promise<import("../../..").MiddlewareManager>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/debug/types.d.ts

@@ -0,0 +1,25 @@
+import { ITaggable } from "../../../defs";
+export type DebugConfig = {
+    logResourceConfig: boolean;
+    logResourceValue: boolean;
+    logResourceBeforeRun: boolean;
+    logResourceAfterRun: boolean;
+    logTaskBeforeRun: boolean;
+    logTaskInput: boolean;
+    logTaskOutput: boolean;
+    logTaskAfterRun: boolean;
+    logMiddlewareBeforeRun: boolean;
+    logMiddlewareAfterRun: boolean;
+    logEventEmissionOnRun: boolean;
+    logEventEmissionInput: boolean;
+    logHookTriggered: boolean;
+    logHookCompleted: boolean;
+};
+export declare const allFalse: DebugConfig;
+export declare const levelNormal: DebugConfig;
+export declare const levelVerbose: DebugConfig;
+/**
+ * If you choose to specify your own config, all values will be set to false by default and extended by your config.
+ */
+export type DebugFriendlyConfig = "normal" | "verbose" | Partial<DebugConfig>;
+export declare const getConfig: (config: DebugFriendlyConfig, taggable?: ITaggable) => DebugConfig;

package/dist/globals/resources/debug/utils.d.ts

@@ -0,0 +1,2 @@
+import { ITaggable } from "../../../defs";
+export declare const hasSystemTag: (definition: ITaggable) => boolean;

package/dist/globals/resources/queue.resource.d.ts

@@ -0,0 +1,10 @@
+import { Queue } from "../../models/Queue";
+export declare const queueResource: import("../..").IResource<void, Promise<{
+    map: Map<string, Queue>;
+    run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+}>, {}, {
+    map: Map<string, Queue>;
+}, {
+    title: string;
+    description: string;
+}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/tunnel/ejson-extensions.d.ts

@@ -0,0 +1 @@
+export declare const EJSON: import("@bluelibs/ejson").EJSONModule;

package/dist/globals/resources/tunnel/error-utils.d.ts

@@ -0,0 +1 @@
+export declare function normalizeError(input: unknown): Error;

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

@@ -0,0 +1,19 @@
+import type { ITaskMiddleware } from "../../../defs";
+export type ValidationSide = "client" | "server" | "both";
+export interface ExecutionPlan {
+    clientMiddleware: string[];
+    serverMiddleware: string[];
+    validation: ValidationSide;
+}
+export interface PlanMeta {
+    plan?: ExecutionPlan;
+    headers?: Record<string, string>;
+    traceId?: string;
+    context?: unknown;
+}
+export declare function computeExecutionPlanFromWhitelist(whitelist: {
+    client?: Array<string | ITaskMiddleware<any, any, any, any>>;
+    server?: Array<string | ITaskMiddleware<any, any, any, any>>;
+}, opts?: {
+    defaultValidation?: ValidationSide;
+}): ExecutionPlan;

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

@@ -0,0 +1,40 @@
+import type { ITask, IEventEmission } from "../../../defs";
+export interface ProtocolErrorShape {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export interface ProtocolEnvelope<T = unknown> {
+    ok: boolean;
+    result?: T;
+    error?: ProtocolErrorShape;
+    meta?: {
+        protocolVersion?: string;
+        traceId?: string;
+        taskVersion?: string;
+    };
+}
+export interface TaskRequest {
+    id: string;
+    input?: unknown;
+    plan?: unknown;
+    context?: Record<string, unknown>;
+    traceId?: string;
+}
+export interface EventRequest {
+    id: string;
+    payload?: unknown;
+    context?: Record<string, unknown>;
+    traceId?: string;
+}
+export declare class TunnelError extends Error {
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(code: string, message: string, details?: unknown);
+}
+export declare function toTunnelError(input: unknown, fallbackMessage?: string): TunnelError;
+export declare function assertOkEnvelope<T>(envelope: ProtocolEnvelope<T> | undefined, opts?: {
+    fallbackMessage?: string;
+}): T;
+export declare function runViaTunnel(runner: (task: ITask<any, any, any, any, any, any>, input?: unknown) => Promise<unknown>, task: ITask<any, any, any, any, any, any>, input?: unknown): Promise<unknown>;
+export declare function emitViaTunnel(runner: (emission: IEventEmission<any>) => Promise<unknown>, emission: IEventEmission<any>): Promise<void>;

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

@@ -0,0 +1,9 @@
+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;
+}
+export declare const EjsonSerializer: Serializer;
+export declare function getDefaultSerializer(): Serializer;
+export { EJSON };

package/dist/globals/resources/tunnel/tunnel.policy.tag.d.ts

@@ -0,0 +1,18 @@
+import type { ITaskMiddleware } from "../../../defs";
+export type TunnelPolicySide = "client" | "server";
+export type TunnelMiddlewareId = string | ITaskMiddleware<any, any, any, any>;
+export interface TunnelTaskMiddlewarePolicyConfig {
+    /**
+     * Whitelist of middleware ids/definitions allowed to run on the caller side
+     * when the task is tunneled (mode: "client"). If omitted, defaults to
+     * allowing all (the framework default remains "both").
+     */
+    client?: TunnelMiddlewareId[];
+    /**
+     * Whitelist of middleware ids/definitions intended to run on the executor side.
+     * Note: The local runner cannot enforce server-side policy; this is a declarative
+     * contract that a Runner-based executor can consume to apply a symmetric filter.
+     */
+    server?: TunnelMiddlewareId[];
+}
+export declare const tunnelPolicyTag: import("../../..").ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;

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

@@ -0,0 +1,2 @@
+import type { TunnelRunner } from "./types";
+export declare const tunnelTag: import("../../..").ITag<void, void, TunnelRunner>;

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

@@ -0,0 +1,17 @@
+import type { ITask, IEvent, IEventEmission } from "../../../defs";
+export type TunnelMode = "client" | "server" | "both" | "none";
+export type TunnelTaskSelector = Array<string | ITask<any, any, any, any, any, any>> | ((task: ITask<any, any, any, any, any, any>) => boolean);
+export type TunnelEventSelector = Array<string | IEvent<any>> | ((event: IEvent<any>) => boolean);
+export type EventDeliveryMode = "mirror" | "remote-only" | "local-only" | "remote-first";
+export interface TunnelTagConfig {
+}
+export type TunnelTaskRunner = (task: ITask<any, any, any, any, any, any>, input?: any) => Promise<any>;
+export interface TunnelRunner {
+    transport?: "http" | string;
+    mode?: TunnelMode;
+    tasks?: TunnelTaskSelector;
+    events?: TunnelEventSelector;
+    eventDeliveryMode?: EventDeliveryMode;
+    run?: TunnelTaskRunner;
+    emit?: (event: IEventEmission<any>) => Promise<any>;
+}

package/dist/globals/tunnels/index.d.ts

@@ -0,0 +1,23 @@
+import type { Serializer } from "../resources/tunnel/serializer";
+import type { ExposureFetchClient } from "../../http-fetch-tunnel.resource";
+export interface HttpClientAuthConfig {
+    header?: string;
+    token: string;
+}
+export interface HttpCreateClientConfig {
+    url: string;
+    auth?: HttpClientAuthConfig;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    serializer: Serializer;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export declare const tunnels: Readonly<{
+    http: Readonly<{
+        createClient(cfg: HttpCreateClientConfig): ExposureFetchClient;
+    }>;
+}>;
+export type { ExposureFetchClient };

package/dist/globals/types.d.ts

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