@bluelibs/runner 4.6.0 → 4.7.0-alpha

package/dist/models/RunResult.d.ts

@@ -0,0 +1,35 @@
+import { DependencyMapType, IEvent, ITask } from "../defs";
+import { IResource } from "../defs";
+import { EventManager } from "./EventManager";
+import { Logger } from "./Logger";
+import { Store } from "./Store";
+import { TaskRunner } from "./TaskRunner";
+export declare class RunResult<V> {
+    readonly value: V;
+    readonly logger: Logger;
+    readonly store: Store;
+    private readonly eventManager;
+    private readonly taskRunner;
+    private readonly disposeFn;
+    constructor(value: V, logger: Logger, store: Store, eventManager: EventManager, taskRunner: TaskRunner, disposeFn: () => Promise<void>);
+    /**
+     * Run a task within the context of the run result.
+     * @param task - The task to run.
+     * @param args - The arguments to pass to the task.
+     * @returns The result of the task.
+     */
+    runTask: <I = undefined, O extends Promise<any> = any, D extends DependencyMapType = any>(task: ITask<I, O, D> | string, ...args: I extends undefined | void ? [] : [I]) => Promise<O | undefined>;
+    /**
+     * Emit an event within the context of the run result.
+     * @param event - The event to emit.
+     * @param payload - The payload to emit.
+     */
+    emitEvent: <P>(event: IEvent<P> | string, payload?: P extends undefined | void ? undefined : P) => Promise<void>;
+    /**
+     * Get the value of a resource from the run result.
+     * @param resource - The resource to get the value of.
+     * @returns The value of the resource.
+     */
+    getResourceValue: <Output extends Promise<any>>(resource: string | IResource<any, Output, any, any, any>) => Output extends Promise<infer U> ? U : Output;
+    dispose: () => Promise<void>;
+}

package/dist/models/Semaphore.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A semaphore that limits the number of concurrent operations.
+ * Used to prevent connection pool exhaustion by limiting concurrent
+ * database operations to the pool size.
+ */
+export declare class Semaphore {
+    private permits;
+    private readonly waitingQueue;
+    private disposed;
+    private readonly maxPermits;
+    constructor(maxPermits: number);
+    /**
+     * Acquire a permit. If no permits are available, waits until one becomes available.
+     */
+    acquire(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Release a permit, allowing waiting operations to proceed.
+     */
+    release(): void;
+    private removeFromQueue;
+    /**
+     * Execute a function with a permit, automatically releasing it afterwards.
+     */
+    withPermit<T>(fn: () => Promise<T>, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    /**
+     * Dispose the semaphore, rejecting all waiting operations and preventing new ones.
+     */
+    dispose(): void;
+    /**
+     * Get current number of available permits (for debugging)
+     */
+    getAvailablePermits(): number;
+    /**
+     * Get current number of waiting operations (for debugging)
+     */
+    getWaitingCount(): number;
+    /**
+     * Get maximum number of permits
+     */
+    getMaxPermits(): number;
+    /**
+     * Check if the semaphore has been disposed
+     */
+    isDisposed(): boolean;
+    /**
+     * Get metrics about the current state of the semaphore
+     */
+    getMetrics(): {
+        availablePermits: number;
+        waitingCount: number;
+        maxPermits: number;
+        utilization: number;
+        disposed: boolean;
+    };
+}

package/dist/models/Store.d.ts

@@ -0,0 +1,69 @@
+import { IResource, ITask, RegisterableItems, ITaskMiddleware, IResourceMiddleware, ITag } from "../defs";
+import { EventManager } from "./EventManager";
+import { Logger } from "./Logger";
+import { ResourceStoreElementType, TaskStoreElementType, TaskMiddlewareStoreElementType, ResourceMiddlewareStoreElementType, EventStoreElementType } from "../types/storeTypes";
+import { TaskRunner } from "./TaskRunner";
+import { OnUnhandledError } from "./UnhandledError";
+import { MiddlewareManager } from "./MiddlewareManager";
+export { ResourceStoreElementType, TaskStoreElementType, EventStoreElementType, };
+/**
+ * Store class which is used to store all the resources, tasks, middleware and events.
+ */
+export declare class Store {
+    #private;
+    protected readonly eventManager: EventManager;
+    protected readonly logger: Logger;
+    readonly onUnhandledError: OnUnhandledError;
+    root: ResourceStoreElementType;
+    private registry;
+    private overrideManager;
+    private validator;
+    private taskRunner?;
+    private middlewareManager;
+    constructor(eventManager: EventManager, logger: Logger, onUnhandledError: OnUnhandledError);
+    get tasks(): Map<string, TaskStoreElementType>;
+    get hooks(): Map<string, import("..").HookStoreElementType>;
+    get resources(): Map<string, ResourceStoreElementType>;
+    get events(): Map<string, EventStoreElementType>;
+    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 overrideRequests(): Set<{
+        source: string;
+        override: RegisterableItems;
+    }>;
+    getMiddlewareManager(): MiddlewareManager;
+    get isLocked(): boolean;
+    lock(): void;
+    checkLock(): void;
+    private registerGlobalComponents;
+    setTaskRunner(taskRunner: TaskRunner): void;
+    private setupRootResource;
+    validateDependencyGraph(): void;
+    validateEventEmissionGraph(): void;
+    initializeStore(root: IResource<any, any, any, any, any>, config: any): void;
+    dispose(): Promise<void>;
+    /**
+     * Internal, avoid using this method directly.
+     */
+    processOverrides(): void;
+    /**
+     * Internal, avoid using this method directly.
+     * @param item
+     * @returns
+     */
+    storeGenericItem<C>(item: RegisterableItems): void;
+    /**
+     * Returns all tasks with the given tag.
+     * @param tag - The tag to filter by.
+     * @returns The tasks with the given tag.
+     */
+    getTasksWithTag(tag: string | ITag<any, any, any>): ITask<any, any, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>[];
+    /**
+     * Returns all resources with the given tag.
+     * @param tag - The tag to filter by.
+     * @returns The resources with the given tag.
+     */
+    getResourcesWithTag(tag: string | ITag<any, any, any>): IResource<any, any, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>[];
+}

package/dist/models/StoreRegistry.d.ts

@@ -0,0 +1,43 @@
+import { IResource, ITask, IResourceWithConfig, RegisterableItems, ITaskMiddleware, IResourceMiddleware, IEvent, ITag, IHook } from "../defs";
+import { TaskStoreElementType, TaskMiddlewareStoreElementType, ResourceMiddlewareStoreElementType, ResourceStoreElementType, EventStoreElementType, HookStoreElementType } from "../defs";
+import { StoreValidator } from "./StoreValidator";
+import { Store } from "./Store";
+import { IDependentNode } from "./utils/findCircularDependencies";
+type StoringMode = "normal" | "override";
+export declare class StoreRegistry {
+    protected readonly store: Store;
+    tasks: Map<string, TaskStoreElementType>;
+    resources: Map<string, ResourceStoreElementType>;
+    events: Map<string, EventStoreElementType>;
+    taskMiddlewares: Map<string, TaskMiddlewareStoreElementType>;
+    resourceMiddlewares: Map<string, ResourceMiddlewareStoreElementType>;
+    hooks: Map<string, HookStoreElementType>;
+    tags: Map<string, ITag>;
+    private validator;
+    constructor(store: Store);
+    getValidator(): StoreValidator;
+    storeGenericItem<C>(item: RegisterableItems): 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;
+    storeResourceMiddleware<C>(item: IResourceMiddleware<any>, overrideMode?: StoringMode): void;
+    storeEvent<C>(item: IEvent<void>): void;
+    storeResourceWithConfig<C>(item: IResourceWithConfig<any, any, any>, storingMode?: StoringMode): IResource<any, any, any, any, any, import("..").TagType[], IResourceMiddleware<any, void, void, any>[]>;
+    computeRegistrationDeeply<C>(element: IResource<C>, config?: C): void;
+    storeResource<C>(item: IResource<any, any, any>, overrideMode?: StoringMode): IResource<any, any, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    storeTask<C>(item: ITask<any, any, {}>, storingMode?: StoringMode): void;
+    getDependentNodes(): IDependentNode[];
+    /**
+     * Builds a directed graph of event emissions based on hooks listening to events
+     * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
+     */
+    buildEventEmissionGraph(): IDependentNode[];
+    private setupBlankNodes;
+    getTasksWithTag(tag: string | ITag): ITask<any, any, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>[];
+    getResourcesWithTag(tag: string | ITag): IResource<any, any, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>[];
+    /**
+     * Used to fetch the value cloned, and if we're dealing with an override, we need to extend the previous value.
+     */
+    private getFreshValue;
+}
+export {};

package/dist/models/StoreValidator.d.ts

@@ -0,0 +1,8 @@
+import { StoreRegistry } from "./StoreRegistry";
+export declare class StoreValidator {
+    private registry;
+    constructor(registry: StoreRegistry);
+    checkIfIDExists(id: string): void | never;
+    runSanityChecks(): void;
+    ensureAllTagsUsedAreRegistered(): void;
+}

package/dist/models/TaskRunner.d.ts

@@ -0,0 +1,27 @@
+import { DependencyMapType, ITask } from "../defs";
+import { EventManager } from "./EventManager";
+import { Store } from "./Store";
+import { Logger } from "./Logger";
+export declare class TaskRunner {
+    protected readonly store: Store;
+    protected readonly eventManager: EventManager;
+    protected readonly logger: Logger;
+    protected readonly runnerStore: Map<string | symbol, (input: any) => Promise<any>>;
+    constructor(store: Store, eventManager: EventManager, logger: Logger);
+    private readonly middlewareManager;
+    /**
+     * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+     * This function can throw only if any of the event listeners or run function throws
+     * @param task the task to be run
+     * @param input the input to be passed to the task
+     */
+    run<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>, input?: TInput): Promise<TOutput | undefined>;
+    /**
+     * Creates the function with the chain of middleware.
+     * @param task
+     * @param input
+     * @param taskDependencies
+     * @returns
+     */
+    protected createRunnerWithMiddleware<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>): (input: any) => Promise<TOutput | (TOutput extends Promise<infer U> ? U : never)>;
+}

package/dist/models/UnhandledError.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from "./Logger";
+export type UnhandledErrorKind = "process" | "task" | "middleware" | "resourceInit" | "hook" | "run";
+export interface OnUnhandledErrorInfo {
+    error: unknown;
+    kind?: UnhandledErrorKind;
+    source?: string;
+}
+export type OnUnhandledError = (info: OnUnhandledErrorInfo) => void | Promise<void>;
+export declare function createDefaultUnhandledError(logger: Logger): OnUnhandledError;
+export declare function bindProcessErrorHandler(handler: OnUnhandledError): (error: unknown, source: "uncaughtException" | "unhandledRejection") => void | Promise<void>;
+export declare function safeReportUnhandledError(handler: OnUnhandledError, info: OnUnhandledErrorInfo): Promise<void>;

package/dist/models/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./DependencyProcessor";
+export * from "./EventManager";
+export * from "./Logger";
+export * from "./Store";
+export * from "./TaskRunner";
+export * from "./ResourceInitializer";
+export * from "./MiddlewareManager";
+export * from "./Semaphore";
+export * from "./Queue";
+export * from "./UnhandledError";
+export * from "./RunResult";

package/dist/models/utils/findCircularDependencies.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A node that has dependencies.
+ */
+export interface IDependentNode {
+    id: string;
+    dependencies: Record<string, IDependentNode>;
+}
+interface FindCircularDependenciesResult {
+    cycles: string[];
+    missingDependencies: Array<{
+        nodeId: string;
+        dependencyId: string;
+    }>;
+}
+export declare function findCircularDependencies(nodes: IDependentNode[]): FindCircularDependenciesResult;
+export {};

package/dist/models/utils/safeStringify.d.ts

@@ -0,0 +1,3 @@
+export declare function safeStringify(value: unknown, space?: number, options?: {
+    maxDepth?: number;
+}): string;

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

@@ -0,0 +1,3 @@
+import type { Store } from "../../models/Store";
+import type { AllowListGuard } from "./types";
+export declare function createAllowListGuard(store: Store): AllowListGuard;

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

@@ -0,0 +1,6 @@
+import type { Authenticator } from "./types";
+export interface NodeExposureHttpAuthConfig {
+    header?: string;
+    token: string;
+}
+export declare function createAuthenticator(authCfg?: NodeExposureHttpAuthConfig): Authenticator;

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

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { NodeExposureHttpCorsConfig } from "./resourceTypes";
+export declare function applyCorsActual(req: IncomingMessage, res: ServerResponse, cfg: NodeExposureHttpCorsConfig | undefined): void;
+export declare function handleCorsPreflight(req: IncomingMessage, res: ServerResponse, cfg: NodeExposureHttpCorsConfig | undefined): boolean;

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

@@ -0,0 +1,2 @@
+import type { NodeExposureConfig, NodeExposureDeps, NodeExposureHandlers } from "./resourceTypes";
+export declare function createNodeExposure(cfg: NodeExposureConfig | undefined, deps: NodeExposureDeps): Promise<NodeExposureHandlers>;

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

@@ -0,0 +1,18 @@
+import * as http from "http";
+import type { RequestHandler } from "./types";
+import type { NodeExposureDeps, NodeExposureHttpConfig } from "./resourceTypes";
+interface ExposureServerOptions {
+    httpConfig?: NodeExposureHttpConfig;
+    handler: RequestHandler;
+    logger: NodeExposureDeps["logger"];
+    basePath: string;
+}
+interface ExposureServerControls {
+    server: http.Server | null;
+    createRequestListener(): http.RequestListener;
+    createServer(): http.Server;
+    attachTo(server: http.Server): () => void;
+    close(): Promise<void>;
+}
+export declare function createExposureServer(options: ExposureServerOptions): Promise<ExposureServerControls>;
+export {};

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

@@ -0,0 +1,10 @@
+import type { ServerResponse } from "http";
+import type { Serializer } from "../../globals/resources/tunnel/serializer";
+import type { JsonResponse, StreamingResponse } from "./types";
+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 respondJson(res: ServerResponse, response: JsonResponse, serializer?: Serializer): void;
+export declare function respondStream(res: ServerResponse, value: StreamingResponse | NodeJS.ReadableStream): void;

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

@@ -0,0 +1,4 @@
+import type { Logger } from "../../models/Logger";
+export declare function safeLogError(logger: Logger, message: string, data: Record<string, unknown>): void;
+export declare function safeLogInfo(logger: Logger, message: string, data: Record<string, unknown>): void;
+export declare function errorMessage(error: unknown): string;

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

@@ -0,0 +1,27 @@
+import type { IncomingHttpHeaders } from "http";
+import type { Serializer } from "../../globals/resources/tunnel/serializer";
+import type { JsonResponse } from "./types";
+interface MultipartFinalizeOk {
+    ok: true;
+}
+interface MultipartFinalizeError {
+    ok: false;
+    response: JsonResponse;
+}
+export type MultipartFinalizeResult = MultipartFinalizeOk | MultipartFinalizeError;
+interface MultipartSuccess {
+    ok: true;
+    value: unknown;
+    finalize: Promise<MultipartFinalizeResult>;
+}
+type MultipartResult = MultipartSuccess | {
+    ok: false;
+    response: JsonResponse;
+};
+export interface MultipartRequest extends NodeJS.ReadableStream {
+    headers: IncomingHttpHeaders;
+    method?: string;
+}
+export declare function parseMultipartInput(req: MultipartRequest, signal?: AbortSignal, serializer?: Serializer): Promise<MultipartResult>;
+export declare function isMultipart(contentType: string): boolean;
+export {};

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

@@ -0,0 +1,11 @@
+import type { IncomingMessage } from "http";
+import type { Serializer } from "../../globals/resources/tunnel/serializer";
+import type { JsonResponse } from "./types";
+export declare function readRequestBody(req: IncomingMessage, signal?: AbortSignal): Promise<Buffer>;
+export declare function readJsonBody<T>(req: IncomingMessage, signal?: AbortSignal, serializer?: Serializer): Promise<{
+    ok: true;
+    value: T | undefined;
+} | {
+    ok: false;
+    response: JsonResponse;
+}>;

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

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from "http";
+export interface ExposureRequestContextValue {
+    req: IncomingMessage;
+    res: ServerResponse;
+    url: URL;
+    basePath: string;
+    headers: IncomingMessage["headers"];
+    method?: string;
+    signal: AbortSignal;
+}
+export declare const ExposureRequestContext: import("..").Context<ExposureRequestContextValue>;
+export declare function useExposureContext(): ExposureRequestContextValue;
+/**
+ * Checks if the exposure request context is currently available without throwing an error.
+ * Useful for conditional logic in tasks that may or may not be exposed.
+ */
+export declare function hasExposureContext(): boolean;

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

@@ -0,0 +1,24 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { Serializer } from "../../globals/resources/tunnel/serializer";
+import type { Authenticator, AllowListGuard, RequestHandler } from "./types";
+import type { ExposureRouter } from "./router";
+import type { NodeExposureDeps, NodeExposureHttpCorsConfig } from "./resourceTypes";
+interface RequestProcessingDeps {
+    store: NodeExposureDeps["store"];
+    taskRunner: NodeExposureDeps["taskRunner"];
+    eventManager: NodeExposureDeps["eventManager"];
+    logger: NodeExposureDeps["logger"];
+    authenticator: Authenticator;
+    allowList: AllowListGuard;
+    router: ExposureRouter;
+    cors?: NodeExposureHttpCorsConfig;
+    serializer: Serializer;
+}
+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;
+export {};

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

@@ -0,0 +1,60 @@
+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";
+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;
+}
+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/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/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/node/exposure/types.d.ts

@@ -0,0 +1,31 @@
+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) => {
+    ok: true;
+} | {
+    ok: false;
+    response: JsonResponse;
+};
+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/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/node/exposure.resource.d.ts

@@ -0,0 +1,12 @@
+import type { NodeExposureConfig, NodeExposureHandlers } from "./exposure/resourceTypes";
+export type { NodeExposureHttpAuthConfig } from "./exposure/authenticator";
+export declare const nodeExposure: import("..").IResource<NodeExposureConfig, Promise<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("../globals/resources/tunnel/serializer").Serializer>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+}, any, {
+    title: string;
+    description: string;
+}, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;

package/dist/node/files.d.ts

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

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

@@ -0,0 +1,22 @@
+import { Readable } from "stream";
+import type { Serializer } from "../globals/resources/tunnel/serializer";
+export interface HttpSmartClientAuthConfig {
+    header?: string;
+    token: string;
+}
+export interface HttpSmartClientConfig {
+    baseUrl: string;
+    auth?: HttpSmartClientAuthConfig;
+    timeoutMs?: number;
+    serializer: Serializer;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export interface HttpSmartClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+}
+export declare function createHttpSmartClient(cfg: HttpSmartClientConfig): HttpSmartClient;
+export type { Readable };

package/dist/node/index.d.ts

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