@bluelibs/runner 5.1.0 → 5.2.1

package/dist/types/node/exposure/requestHandlers.d.ts

@@ -0,0 +1,29 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { SerializerLike } from "../../serializer";
+import type { Authenticator, AllowListGuard, RequestHandler } from "./types";
+import type { ExposureRouter } from "./router";
+import type { NodeExposureDeps, NodeExposureHttpCorsConfig } from "./resourceTypes";
+export interface RequestProcessingDeps {
+    store: NodeExposureDeps["store"];
+    taskRunner: NodeExposureDeps["taskRunner"];
+    eventManager: NodeExposureDeps["eventManager"];
+    logger: NodeExposureDeps["logger"];
+    authenticator: Authenticator;
+    allowList: AllowListGuard;
+    router: ExposureRouter;
+    cors?: NodeExposureHttpCorsConfig;
+    serializer: SerializerLike;
+    limits?: {
+        json?: {
+            maxSize?: number;
+        };
+        multipart?: any;
+    };
+}
+export interface NodeExposureRequestHandlers {
+    handleTask: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleEvent: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleDiscovery: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleRequest: RequestHandler;
+}
+export declare function createRequestHandlers(deps: RequestProcessingDeps): NodeExposureRequestHandlers;

package/dist/types/node/exposure/resource.d.ts

@@ -0,0 +1,12 @@
+import type { NodeExposureConfig } from "./resourceTypes";
+export type { NodeExposureHttpAuthConfig } from "./authenticator";
+export declare const nodeExposure: import("..").IResource<NodeExposureConfig, Promise<import("./resourceTypes").NodeExposureHandlers>, {
+    store: import("..").IResource<void, Promise<import("..").Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("..").IResource<void, Promise<import("..").TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("..").IResource<void, Promise<import("..").EventManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    logger: import("..").IResource<void, Promise<import("..").Logger>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    serializer: import("..").IResource<void, Promise<import("..").SerializerLike>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+}, any, {
+    title: string;
+    description: string;
+}, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/node/exposure/resourceTypes.d.ts

@@ -0,0 +1,73 @@
+import type * as http from "http";
+import type { IncomingMessage, ServerResponse } from "http";
+import { globalResources } from "../../globals/globalResources";
+import type { ResourceDependencyValuesType } from "../../defs";
+import type { NodeExposureHttpAuthConfig } from "./authenticator";
+import type { MultipartLimits } from "./multipart";
+export interface JsonLimits {
+    maxSize?: number;
+}
+export type NodeExposureDependencyMap = {
+    store: typeof globalResources.store;
+    taskRunner: typeof globalResources.taskRunner;
+    eventManager: typeof globalResources.eventManager;
+    logger: typeof globalResources.logger;
+    serializer: typeof globalResources.serializer;
+};
+export type NodeExposureDeps = ResourceDependencyValuesType<NodeExposureDependencyMap>;
+export interface NodeExposureHttpConfig {
+    basePath?: string;
+    server?: http.Server;
+    listen?: {
+        port: number;
+        host?: string;
+    };
+    auth?: NodeExposureHttpAuthConfig;
+    cors?: NodeExposureHttpCorsConfig;
+    limits?: {
+        json?: JsonLimits;
+        multipart?: MultipartLimits;
+    };
+    /**
+     * Opt out of fail-closed exposure (not recommended).
+     * When true and no server-mode tunnel is registered, exposure is open.
+     */
+    dangerouslyAllowOpenExposure?: boolean;
+}
+export interface NodeExposureConfig {
+    http?: NodeExposureHttpConfig;
+}
+export interface NodeExposureHandlers {
+    handleRequest: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+    handleTask: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleEvent: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleDiscovery: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    createRequestListener: () => http.RequestListener;
+    createServer: () => http.Server;
+    attachTo: (server: http.Server) => () => void;
+    server?: http.Server | null;
+    basePath: string;
+    close: () => Promise<void>;
+}
+export interface NodeExposureHttpCorsConfig {
+    /**
+     * Allowed origin(s). When omitted, defaults to "*".
+     * - string: exact origin value to send
+     * - string[]: allow-list; request origin must match an item
+     * - RegExp: allow when test(origin) is true
+     * - function: returns the origin to send or null to disallow
+     */
+    origin?: string | string[] | RegExp | ((origin: string | undefined) => string | null | undefined);
+    /** Which methods are allowed on preflight; defaults to ["POST", "OPTIONS"]. */
+    methods?: string[];
+    /** Access-Control-Allow-Headers value. If omitted, echoes Access-Control-Request-Headers. */
+    allowedHeaders?: string[];
+    /** Expose response headers for actual requests. */
+    exposedHeaders?: string[];
+    /** Whether to include Access-Control-Allow-Credentials: true. */
+    credentials?: boolean;
+    /** Max age in seconds for preflight caching. */
+    maxAge?: number;
+    /** Whether to append Vary: Origin when a specific origin is returned. Default true. */
+    varyOrigin?: boolean;
+}

package/dist/types/node/exposure/router.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage } from "http";
+import type { JsonResponse, RequestKind, RequestTarget } from "./types";
+export interface ExposureRouter {
+    basePath: string;
+    isUnderBase(pathname: string): boolean;
+    extract(pathname: string): RequestTarget | null;
+}
+export declare function resolveBasePath(basePath?: string): string;
+export declare function createRouter(basePath: string): ExposureRouter;
+export declare function resolveTargetFromRequest(req: IncomingMessage, router: ExposureRouter, expected: RequestKind): {
+    ok: true;
+    id: string;
+} | {
+    ok: false;
+    response: JsonResponse;
+};
+export declare function requestUrl(req: IncomingMessage): URL;

package/dist/types/node/exposure/serverLifecycle.d.ts

@@ -0,0 +1,13 @@
+import * as http from "http";
+import type { RequestHandler } from "./types";
+import type { Logger } from "../../models/Logger";
+export declare function makeRequestListener(options: {
+    handler: RequestHandler;
+    respondOnMiss: boolean;
+    logger: Logger;
+}): http.RequestListener;
+export declare function startHttpServer(server: http.Server, listen: {
+    port: number;
+    host?: string;
+}): Promise<void>;
+export declare function stopHttpServer(server: http.Server): Promise<void>;

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

@@ -0,0 +1,45 @@
+import type { IncomingMessage, ServerResponse } from "http";
+export type RequestKind = "task" | "event" | "discovery";
+export interface RequestTarget {
+    kind: RequestKind;
+    id: string;
+}
+export type JsonBody = {
+    ok: boolean;
+    [key: string]: unknown;
+};
+export interface JsonResponse {
+    status: number;
+    body: JsonBody;
+}
+export type RequestHandler = (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export type Authenticator = (req: IncomingMessage) => Promise<{
+    ok: true;
+} | {
+    ok: false;
+    response: JsonResponse;
+}>;
+/** Input provided to auth validator tasks */
+export interface AuthValidatorInput {
+    headers: Record<string, string | string[] | undefined>;
+    method: string;
+    url: string;
+    path: string;
+}
+/** Result returned by auth validator tasks */
+export type AuthValidatorResult = {
+    ok: true;
+} | {
+    ok: false;
+    message?: string;
+};
+export interface AllowListGuard {
+    ensureTask(id: string): JsonResponse | null;
+    ensureEvent(id: string): JsonResponse | null;
+}
+export interface StreamingResponse {
+    stream: NodeJS.ReadableStream;
+    status?: number;
+    contentType?: string;
+    headers?: Record<string, string>;
+}

package/dist/types/node/exposure/utils.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from "http";
+/**
+ * Extract a normalized Content-Type header value from request headers.
+ * Returns an empty string if not present. If multiple values are present,
+ * the first one is used.
+ */
+export declare function getContentType(headers: IncomingHttpHeaders): string;
+/**
+ * Attach an event listener to a Node-style emitter that may expose either
+ * `once` or `on`. Returns true if attached, false otherwise.
+ */
+export declare function attachRequestListener(target: unknown, event: string, handler: (...args: unknown[]) => void): boolean;
+/**
+ * Wires an AbortController to abort when the client disconnects.
+ * Attaches to `req` aborted and `res` close events using robust listener attachment.
+ */
+export declare function createAbortControllerForRequest(req: IncomingMessage, res: ServerResponse): AbortController;

package/dist/types/node/files/createNodeFile.d.ts

@@ -0,0 +1,9 @@
+import type { Readable } from "stream";
+import type { InputFileMeta, RunnerFileSentinel } from "../../types/inputFile";
+export interface NodeFileSource {
+    stream?: Readable;
+    buffer?: Buffer;
+}
+export declare function createNodeFile(meta: InputFileMeta, source: NodeFileSource, id?: string): RunnerFileSentinel & {
+    _node: NodeFileSource;
+};

package/dist/types/node/files/index.d.ts

@@ -0,0 +1,4 @@
+export { createNodeFile } from "./createNodeFile";
+export { NodeInputFile, toPassThrough } from "./inputFile.model";
+export type { NodeReadable } from "./inputFile.model";
+export { readInputFileToBuffer, writeInputFileToPath } from "./inputFile.utils";

package/dist/types/node/files/inputFile.model.d.ts

@@ -0,0 +1,22 @@
+import type { InputFile } from "../../types/inputFile";
+import { Readable } from "stream";
+export type NodeReadable = Readable;
+export declare class NodeInputFile implements InputFile<NodeReadable> {
+    name: string;
+    type?: string | undefined;
+    size?: number | undefined;
+    lastModified?: number | undefined;
+    extra?: Record<string, unknown> | undefined;
+    private _stream;
+    private _consumed;
+    constructor(meta: Omit<InputFile<NodeReadable>, "resolve" | "stream" | "toTempFile">, stream: NodeReadable);
+    resolve(): Promise<{
+        stream: NodeReadable;
+    }>;
+    stream(): NodeReadable;
+    toTempFile(dir?: string): Promise<{
+        path: string;
+        bytesWritten: number;
+    }>;
+}
+export declare function toPassThrough(stream: NodeReadable): NodeReadable;

package/dist/types/node/files/inputFile.utils.d.ts

@@ -0,0 +1,14 @@
+import type { InputFile } from "../../types/inputFile";
+import type { Readable } from "stream";
+/**
+ * Read an InputFile's contents fully into memory as a Buffer.
+ * Note: InputFile streams are single-use; this will consume it.
+ */
+export declare function readInputFileToBuffer(file: InputFile<Readable>): Promise<Buffer>;
+/**
+ * Write an InputFile's contents to a specific path, returning bytesWritten.
+ * Note: InputFile streams are single-use; this will consume it.
+ */
+export declare function writeInputFileToPath(file: InputFile<Readable>, targetPath: string): Promise<{
+    bytesWritten: number;
+}>;

package/dist/types/node/http/http-mixed-client.d.ts

@@ -0,0 +1,45 @@
+import type { Readable } from "stream";
+import type { SerializerLike } from "../../serializer";
+import type { IAsyncContext } from "../../types/asyncContext";
+import type { IErrorHelper } from "../../types/error";
+export interface MixedHttpClientAuthConfig {
+    header?: string;
+    token: string;
+}
+export interface MixedHttpClientConfig {
+    baseUrl: string;
+    auth?: MixedHttpClientAuthConfig;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    /**
+     * Forces the Smart client path even for plain JSON inputs.
+     *
+     * Use this when a task may return a stream even when its input is not a stream
+     * and does not include Node File sentinels (ex: download endpoints).
+     *
+     * - `true`: always use Smart for tasks
+     * - predicate: use Smart for selected task ids/inputs
+     */
+    forceSmart?: boolean | ((ctx: {
+        id: string;
+        input: unknown;
+    }) => boolean | Promise<boolean>);
+    serializer: SerializerLike;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<unknown>>;
+    errorRegistry?: Map<string, IErrorHelper<any>>;
+}
+export interface MixedHttpClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable | ReadableStream<Uint8Array>>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+    eventWithResult?<P = unknown>(id: string, payload?: P): Promise<P>;
+}
+/**
+ * Unified Node client that mixes JSON fetch for standard calls and
+ * Smart client for streaming/multipart. Keeps transport details out of app code.
+ */
+export declare function createHttpMixedClient(cfg: MixedHttpClientConfig): MixedHttpClient;
+export type { Readable };

package/dist/types/node/http/http-mixed-client.factory.resource.d.ts

@@ -0,0 +1,17 @@
+import type { MixedHttpClient } from "./http-mixed-client";
+export interface HttpMixedClientFactoryConfig {
+    baseUrl: string;
+    auth?: {
+        header?: string;
+        token: string;
+    };
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export type HttpMixedClientFactory = (config: HttpMixedClientFactoryConfig) => MixedHttpClient;
+export declare const httpMixedClientFactory: import("..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export type { MixedHttpClient };

package/dist/types/node/http/http-smart-client.factory.resource.d.ts

@@ -0,0 +1,16 @@
+import type { HttpSmartClient } from "./http-smart-client.model";
+export interface HttpSmartClientFactoryConfig {
+    baseUrl: string;
+    auth?: {
+        header?: string;
+        token: string;
+    };
+    timeoutMs?: number;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export type HttpSmartClientFactory = (config: HttpSmartClientFactoryConfig) => HttpSmartClient;
+export declare const httpSmartClientFactory: import("..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export type { HttpSmartClient };

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

@@ -0,0 +1,27 @@
+import { Readable } from "stream";
+import type { SerializerLike } from "../../serializer";
+import type { IAsyncContext } from "../../types/asyncContext";
+import type { IErrorHelper } from "../../types/error";
+export interface HttpSmartClientAuthConfig {
+    header?: string;
+    token: string;
+}
+export interface HttpSmartClientConfig {
+    baseUrl: string;
+    auth?: HttpSmartClientAuthConfig;
+    timeoutMs?: number;
+    serializer: SerializerLike;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<unknown>>;
+    errorRegistry?: Map<string, IErrorHelper<any>>;
+}
+export interface HttpSmartClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+    eventWithResult?<P = unknown>(id: string, payload?: P): Promise<P>;
+}
+export declare function createHttpSmartClient(cfg: HttpSmartClientConfig): HttpSmartClient;
+export type { Readable };

package/dist/types/node/http/index.d.ts

@@ -0,0 +1,4 @@
+export { createHttpSmartClient, type HttpSmartClient, type HttpSmartClientAuthConfig, type HttpSmartClientConfig, type Readable, } from "./http-smart-client.model";
+export { createHttpMixedClient, type MixedHttpClient, type MixedHttpClientAuthConfig, type MixedHttpClientConfig, } from "./http-mixed-client";
+export { httpSmartClientFactory, type HttpSmartClientFactory, type HttpSmartClientFactoryConfig, } from "./http-smart-client.factory.resource";
+export { httpMixedClientFactory, type HttpMixedClientFactory, type HttpMixedClientFactoryConfig, } from "./http-mixed-client.factory.resource";

package/dist/types/node/index.d.ts

@@ -0,0 +1 @@
+export * from "./node";

package/dist/types/node/node.d.ts

@@ -0,0 +1,193 @@
+export * from "../index";
+import type { RunResult } from "../models/RunResult";
+import type { SerializerLike } from "../serializer";
+export { nodeExposure } from "./exposure";
+export { hasExposureContext, useExposureContext, } from "./exposure/requestContext";
+export type * from "./exposure/resourceTypes";
+export { createNodeFile, NodeInputFile } from "./files";
+export type { NodeReadable } from "./files";
+export { readInputFileToBuffer, writeInputFileToPath } from "./files";
+export { createHttpSmartClient, createHttpMixedClient } from "./http";
+export type { HttpSmartClient, HttpSmartClientAuthConfig, HttpSmartClientConfig, MixedHttpClient, MixedHttpClientAuthConfig, MixedHttpClientConfig, Readable, } from "./http";
+export * from "./durable";
+export declare const globals: {
+    resources: {
+        httpSmartClientFactory: import("./node").IResource<void, Promise<import("./http").HttpSmartClientFactory>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        httpMixedClientFactory: import("./node").IResource<void, Promise<import("./http").HttpMixedClientFactory>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        store: import("./node").IResource<void, Promise<import("./node").Store>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        middlewareManager: import("./node").IResource<void, Promise<import("./node").MiddlewareManager>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        eventManager: import("./node").IResource<void, Promise<import("./node").EventManager>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        taskRunner: import("./node").IResource<void, Promise<import("./node").TaskRunner>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        logger: import("./node").IResource<void, Promise<import("./node").Logger>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        serializer: import("./node").IResource<void, Promise<SerializerLike>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        cache: import("./node").IResource<import("./node").CacheResourceConfig, Promise<{
+            map: Map<string, import("./node").ICacheInstance>;
+            cacheFactoryTask: import("./node").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>>;
+            defaultOptions: any;
+        }>, {
+            cacheFactoryTask: import("./node").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>, any, any, import("./node").TagType[], import("./node").TaskMiddlewareAttachmentType[]>;
+        }, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        queue: import("./node").IResource<void, Promise<{
+            map: Map<string, import("./node").Queue>;
+            run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+        }>, {}, {
+            map: Map<string, import("./node").Queue>;
+        }, {
+            title: string;
+            description: string;
+        }, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        httpClientFactory: import("./node").IResource<void, Promise<import("./node").HttpClientFactory>, {
+            serializer: import("./node").IResource<void, Promise<SerializerLike>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            store: import("./node").IResource<void, Promise<import("./node").Store>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        }, any, {
+            title: string;
+            description: string;
+        }, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        rateLimit: import("./node").IResource<void, Promise<{
+            states: WeakMap<import("./node").RateLimitMiddlewareConfig, import("./node").RateLimitState>;
+        }>, {}, any, any, import("./node").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        circuitBreaker: import("./node").IResource<void, Promise<{
+            statusMap: Map<string, import("./node").CircuitBreakerStatus>;
+        }>, {}, any, any, import("./node").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        temporal: import("./node").IResource<void, Promise<{
+            debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
+            throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
+        }>, {}, any, any, import("./node").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+        concurrency: import("./node").IResource<void, Promise<{
+            semaphoresByConfig: WeakMap<import("./node").ConcurrencyMiddlewareConfig, import("./node").Semaphore>;
+            semaphoresByKey: Map<string, {
+                semaphore: import("./node").Semaphore;
+                limit: number;
+            }>;
+        }>, {}, any, any, import("./node").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+    };
+    events: {
+        readonly ready: import("./node").IEvent<void>;
+    };
+    middleware: {
+        requireContext: import("./node").ITaskMiddleware<import("./node").RequireContextMiddlewareConfig, void, void, any>;
+        task: {
+            requireContext: import("./node").ITaskMiddleware<import("./node").RequireContextMiddlewareConfig, void, void, any>;
+            cache: import("./node").ITaskMiddleware<any, void, void, {
+                cache: import("./node").IResource<import("./node").CacheResourceConfig, Promise<{
+                    map: Map<string, import("./node").ICacheInstance>;
+                    cacheFactoryTask: import("./node").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>>;
+                    defaultOptions: any;
+                }>, {
+                    cacheFactoryTask: import("./node").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>, any, any, import("./node").TagType[], import("./node").TaskMiddlewareAttachmentType[]>;
+                }, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly hit: import("./node").JournalKey<boolean>;
+                };
+            };
+            concurrency: import("./node").ITaskMiddleware<import("./node").ConcurrencyMiddlewareConfig, void, void, {
+                state: import("./node").IResource<void, Promise<{
+                    semaphoresByConfig: WeakMap<import("./node").ConcurrencyMiddlewareConfig, import("./node").Semaphore>;
+                    semaphoresByKey: Map<string, {
+                        semaphore: import("./node").Semaphore;
+                        limit: number;
+                    }>;
+                }>, {}, any, any, import("./node").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            }>;
+            debounce: import("./node").ITaskMiddleware<import("./node").TemporalMiddlewareConfig, void, void, {
+                state: import("./node").IResource<void, Promise<{
+                    debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
+                    throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
+                }>, {}, any, any, import("./node").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            }>;
+            throttle: import("./node").ITaskMiddleware<import("./node").TemporalMiddlewareConfig, void, void, {
+                state: import("./node").IResource<void, Promise<{
+                    debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
+                    throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
+                }>, {}, any, any, import("./node").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            }>;
+            fallback: import("./node").ITaskMiddleware<import("./node").FallbackMiddlewareConfig, void, void, {
+                taskRunner: import("./node").IResource<void, Promise<import("./node").TaskRunner>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly active: import("./node").JournalKey<boolean>;
+                    readonly error: import("./node").JournalKey<Error>;
+                };
+            };
+            rateLimit: import("./node").ITaskMiddleware<import("./node").RateLimitMiddlewareConfig, void, void, {
+                state: import("./node").IResource<void, Promise<{
+                    states: WeakMap<import("./node").RateLimitMiddlewareConfig, import("./node").RateLimitState>;
+                }>, {}, any, any, import("./node").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly remaining: import("./node").JournalKey<number>;
+                    readonly resetTime: import("./node").JournalKey<number>;
+                    readonly limit: import("./node").JournalKey<number>;
+                };
+            };
+            retry: import("./node").ITaskMiddleware<import("./node").RetryMiddlewareConfig, void, void, any> & {
+                journalKeys: {
+                    readonly attempt: import("./node").JournalKey<number>;
+                    readonly lastError: import("./node").JournalKey<Error>;
+                };
+            };
+            timeout: import("./node").ITaskMiddleware<import("./node").TimeoutMiddlewareConfig, void, void, any> & {
+                journalKeys: {
+                    readonly abortController: import("./node").JournalKey<AbortController>;
+                };
+            };
+            circuitBreaker: import("./node").ITaskMiddleware<import("./node").CircuitBreakerMiddlewareConfig, void, void, {
+                state: import("./node").IResource<void, Promise<{
+                    statusMap: Map<string, import("./node").CircuitBreakerStatus>;
+                }>, {}, any, any, import("./node").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly state: import("./node").JournalKey<import("./node").CircuitBreakerState>;
+                    readonly failures: import("./node").JournalKey<number>;
+                };
+            };
+        };
+        resource: {
+            retry: import("./node").IResourceMiddleware<import("./node").RetryMiddlewareConfig, void, void, any>;
+            timeout: import("./node").IResourceMiddleware<import("./node").TimeoutMiddlewareConfig, void, void, any>;
+        };
+    };
+    tags: {
+        system: import("./node").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>;
+        excludeFromGlobalHooks: import("./node").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>;
+        debug: import("./node").ITag<import("./node").DebugFriendlyConfig, void, void>;
+        tunnel: import("./node").ITag<void, void, import("./node").TunnelRunner>;
+        tunnelPolicy: import("./node").ITag<import("./node").TunnelTaskMiddlewarePolicyConfig, void, void>;
+        authValidator: import("./node").ITag<void, void, void>;
+    };
+    tunnels: Readonly<{
+        http: Readonly<{
+            createClient(cfg: import("./node").HttpCreateClientConfig): import("./node").ExposureFetchClient;
+        }>;
+    }>;
+    debug: {
+        levels: {
+            normal: import("./node").DebugConfig;
+            verbose: import("./node").DebugConfig;
+        };
+    };
+};
+export declare function run(root: any, config?: any): Promise<RunResult<any>>;

package/dist/types/node/platform/createFile.d.ts

@@ -0,0 +1,9 @@
+import type { Readable } from "stream";
+import type { InputFileMeta, RunnerFileSentinel } from "../../types/inputFile";
+export interface NodeFileSource {
+    stream?: Readable;
+    buffer?: Buffer;
+}
+export declare function createFile(meta: InputFileMeta, source: NodeFileSource, id?: string): RunnerFileSentinel & {
+    _node: NodeFileSource;
+};

package/dist/types/node/tunnel/allowlist.d.ts

@@ -0,0 +1,7 @@
+import type { Store } from "../../models/Store";
+export interface TunnelAllowList {
+    enabled: boolean;
+    taskIds: Set<string>;
+    eventIds: Set<string>;
+}
+export declare function computeAllowList(store: Store): TunnelAllowList;

package/dist/types/node/tunnel/index.d.ts

@@ -0,0 +1,2 @@
+export { computeAllowList } from "./allowlist";
+export type { TunnelAllowList } from "./allowlist";

package/dist/types/node/upload/manifest.d.ts

@@ -0,0 +1,23 @@
+import type { Readable } from "stream";
+import type { InputFileMeta } from "../../types/inputFile";
+export interface NodeFileSource {
+    id: string;
+    meta: InputFileMeta;
+    source: {
+        type: "buffer";
+        buffer: Buffer;
+    } | {
+        type: "stream";
+        stream: Readable;
+    };
+}
+export interface BuiltManifest<T = any> {
+    input: T;
+    files: NodeFileSource[];
+}
+export type AnyObj = Record<string, unknown>;
+/**
+ * Walk an input object and collect File sentinels having local Node sources.
+ * It returns a shallow-cloned structure where any internal _node fields are removed.
+ */
+export declare function buildNodeManifest<T>(input: T): BuiltManifest<T>;