@bluelibs/runner 5.1.0 → 5.2.1

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

@@ -0,0 +1,76 @@
+import type { IEvent } from "../../defs";
+import { DurableAuditEntryKind, type DurableAuditEntry } from "./core/audit";
+export declare const durableEvents: {
+    readonly audit: {
+        readonly appended: IEvent<{
+            entry: DurableAuditEntry;
+        }>;
+    };
+    readonly execution: {
+        readonly statusChanged: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.ExecutionStatusChanged;
+            from: import(".").ExecutionStatus | null;
+            to: import(".").ExecutionStatus;
+            reason?: string;
+        }>;
+    };
+    readonly step: {
+        readonly completed: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.StepCompleted;
+            stepId: string;
+            durationMs: number;
+            isInternal: boolean;
+        }>;
+    };
+    readonly sleep: {
+        readonly scheduled: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SleepScheduled;
+            stepId: string;
+            timerId: string;
+            durationMs: number;
+            fireAt: Date;
+        }>;
+        readonly completed: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SleepCompleted;
+            stepId: string;
+            timerId: string;
+        }>;
+    };
+    readonly signal: {
+        readonly waiting: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SignalWaiting;
+            stepId: string;
+            signalId: string;
+            timeoutMs?: number;
+            timeoutAtMs?: number;
+            timerId?: string;
+            reason?: "initial" | "timeout_armed";
+        }>;
+        readonly delivered: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SignalDelivered;
+            stepId: string;
+            signalId: string;
+        }>;
+        readonly timedOut: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SignalTimedOut;
+            stepId: string;
+            signalId: string;
+            timerId: string;
+        }>;
+    };
+    readonly emit: {
+        readonly published: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.EmitPublished;
+            stepId: string;
+            eventId: string;
+        }>;
+    };
+    readonly note: {
+        readonly created: IEvent<import(".").DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.Note;
+            message: string;
+            meta?: Record<string, unknown>;
+        }>;
+    };
+};
+export declare const durableEventsArray: IEvent<any>[];

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

@@ -0,0 +1,34 @@
+export * from "./core/types";
+export * from "./core/ids";
+export * from "./core/audit";
+export * from "./core/interfaces/service";
+export * from "./core/interfaces/store";
+export * from "./core/interfaces/context";
+export * from "./core/interfaces/bus";
+export * from "./core/DurableResource";
+export { durableEvents, durableEventsArray } from "./events";
+export { createDurableRunnerAuditEmitter } from "./emitters/runnerAuditEmitter";
+export { DurableService, initDurableService, disposeDurableService, DurableExecutionError, } from "./core/DurableService";
+export { durableResource } from "./core/resource";
+export type { DurableResourceRuntimeConfig } from "./core/resource";
+export { createRunnerDurableRuntime } from "./core/createRunnerDurableRuntime";
+export type { RunnerDurableDeps, RunnerDurableRuntimeConfig, } from "./core/createRunnerDurableRuntime";
+export { DurableContext } from "./core/DurableContext";
+export { StepBuilder } from "./core/StepBuilder";
+export { DurableOperator } from "./core/DurableOperator";
+export { DurableWorker, initDurableWorker } from "./core/DurableWorker";
+export type { DurableFlowShape, FlowNode, FlowStepNode, FlowSleepNode, FlowSignalNode, FlowEmitNode, FlowSwitchNode, FlowNoteNode, } from "./core/flowShape";
+export { createDashboardMiddleware } from "./dashboard/server";
+export { MemoryStore } from "./store/MemoryStore";
+export { RedisStore } from "./store/RedisStore";
+export { MemoryQueue } from "./queue/MemoryQueue";
+export { RabbitMQQueue } from "./queue/RabbitMQQueue";
+export { MemoryEventBus } from "./bus/MemoryEventBus";
+export { NoopEventBus } from "./bus/NoopEventBus";
+export { RedisEventBus } from "./bus/RedisEventBus";
+export { createDurableTestSetup, waitUntil } from "./test-utils";
+export type { DurableTestSetup, DurableTestSetupOptions } from "./test-utils";
+export { memoryDurableResource } from "./resources/memoryDurableResource";
+export type { MemoryDurableResourceConfig } from "./resources/memoryDurableResource";
+export { redisDurableResource } from "./resources/redisDurableResource";
+export type { RedisDurableResourceConfig } from "./resources/redisDurableResource";

package/dist/types/node/durable/optionalDeps/amqplib.d.ts

@@ -0,0 +1 @@
+export declare function connectAmqplib(url: string): Promise<unknown>;

package/dist/types/node/durable/optionalDeps/ioredis.d.ts

@@ -0,0 +1 @@
+export declare function createIORedisClient(url?: string): unknown;

package/dist/types/node/durable/queue/MemoryQueue.d.ts

@@ -0,0 +1,12 @@
+import type { IDurableQueue, MessageHandler, QueueMessage } from "../core/interfaces/queue";
+export declare class MemoryQueue implements IDurableQueue {
+    private queue;
+    private handler;
+    private isProcessing;
+    private readonly inFlight;
+    enqueue<T>(message: Omit<QueueMessage<T>, "id" | "createdAt" | "attempts">): Promise<string>;
+    consume<T>(handler: MessageHandler<T>): Promise<void>;
+    ack(_messageId: string): Promise<void>;
+    nack(_messageId: string, _requeue?: boolean): Promise<void>;
+    private processNext;
+}

package/dist/types/node/durable/queue/RabbitMQQueue.d.ts

@@ -0,0 +1,30 @@
+import type { IDurableQueue, MessageHandler, QueueMessage } from "../core/interfaces/queue";
+export interface RabbitMQQueueConfig {
+    url?: string;
+    queueName?: string;
+    queue?: {
+        name?: string;
+        quorum?: boolean;
+        deadLetter?: string;
+        messageTtl?: number;
+    };
+    prefetch?: number;
+}
+export declare class RabbitMQQueue implements IDurableQueue {
+    private connection;
+    private channel;
+    private url;
+    private queueName;
+    private prefetch;
+    private readonly isQuorum;
+    private readonly deadLetterQueue?;
+    private readonly messageTtl?;
+    private messageMap;
+    constructor(config: RabbitMQQueueConfig);
+    init(): Promise<void>;
+    enqueue<T>(message: Omit<QueueMessage<T>, "id" | "createdAt" | "attempts">): Promise<string>;
+    consume<T>(handler: MessageHandler<T>): Promise<void>;
+    ack(messageId: string): Promise<void>;
+    nack(messageId: string, requeue?: boolean): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/types/node/durable/resources/isolation.d.ts

@@ -0,0 +1,15 @@
+export interface DurableIsolation {
+    namespace: string;
+    encodedNamespace: string;
+    storePrefix: string;
+    busPrefix: string;
+    queueName: string;
+    deadLetterQueueName: string;
+}
+export declare function deriveDurableIsolation(params: {
+    namespace: string;
+    storePrefix?: string;
+    busPrefix?: string;
+    queueName?: string;
+    deadLetterQueueName?: string;
+}): DurableIsolation;

package/dist/types/node/durable/resources/memoryDurableResource.d.ts

@@ -0,0 +1,21 @@
+import type { RunnerDurableRuntimeConfig } from "../core/createRunnerDurableRuntime";
+import type { DurableResource } from "../core/DurableResource";
+export type MemoryDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "store" | "queue" | "eventBus"> & {
+    /**
+     * Isolation namespace (used for defaults and docs).
+     * Defaults to the resource id (ie. the value passed to `.fork(id)`).
+     */
+    namespace?: string;
+    queue?: {
+        enabled?: boolean;
+    };
+};
+interface MemoryDurableResourceContext {
+    runtimeConfig: RunnerDurableRuntimeConfig | null;
+}
+export declare const memoryDurableResource: import("../..").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
+    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[]>;
+    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}, MemoryDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export {};

package/dist/types/node/durable/resources/redisDurableResource.d.ts

@@ -0,0 +1,35 @@
+import type { RunnerDurableRuntimeConfig } from "../core/createRunnerDurableRuntime";
+import type { DurableResource } from "../core/DurableResource";
+export type RedisDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "store" | "queue" | "eventBus"> & {
+    /**
+     * Isolation namespace (used for key prefixes and queue names).
+     * Defaults to the resource id (ie. the value passed to `.fork(id)`).
+     */
+    namespace?: string;
+    redis: {
+        url: string;
+    };
+    store?: {
+        prefix?: string;
+    };
+    eventBus?: {
+        prefix?: string;
+    };
+    queue?: {
+        url: string;
+        name?: string;
+        deadLetter?: string;
+        quorum?: boolean;
+        messageTtl?: number;
+        prefetch?: number;
+    };
+};
+interface RedisDurableResourceContext {
+    runtimeConfig: RunnerDurableRuntimeConfig | null;
+}
+export declare const redisDurableResource: import("../..").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
+    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[]>;
+    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}, RedisDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export {};

package/dist/types/node/durable/store/MemoryStore.d.ts

@@ -0,0 +1,56 @@
+import { type Execution, type Schedule, type StepResult, type Timer } from "../core/types";
+import type { IDurableStore, ListExecutionsOptions } from "../core/interfaces/store";
+import type { DurableAuditEntry } from "../core/audit";
+export declare class MemoryStore implements IDurableStore {
+    private executions;
+    private executionIdByIdempotencyKey;
+    private stepResults;
+    private auditEntries;
+    private timers;
+    private schedules;
+    private locks;
+    private getIdempotencyMapKey;
+    getExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+    }): Promise<string | null>;
+    setExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+        executionId: string;
+    }): Promise<boolean>;
+    saveExecution(execution: Execution): Promise<void>;
+    getExecution(id: string): Promise<Execution | null>;
+    updateExecution(id: string, updates: Partial<Execution>): Promise<void>;
+    listIncompleteExecutions(): Promise<Execution[]>;
+    listStuckExecutions(): Promise<Execution[]>;
+    listExecutions(options?: ListExecutionsOptions): Promise<Execution[]>;
+    listStepResults(executionId: string): Promise<StepResult[]>;
+    appendAuditEntry(entry: DurableAuditEntry): Promise<void>;
+    listAuditEntries(executionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<DurableAuditEntry[]>;
+    retryRollback(executionId: string): Promise<void>;
+    skipStep(executionId: string, stepId: string): Promise<void>;
+    forceFail(executionId: string, error: {
+        message: string;
+        stack?: string;
+    }): Promise<void>;
+    editStepResult(executionId: string, stepId: string, newResult: unknown): Promise<void>;
+    getStepResult(executionId: string, stepId: string): Promise<StepResult | null>;
+    saveStepResult(result: StepResult): Promise<void>;
+    createTimer(timer: Timer): Promise<void>;
+    getReadyTimers(now?: Date): Promise<Timer[]>;
+    markTimerFired(timerId: string): Promise<void>;
+    deleteTimer(timerId: string): Promise<void>;
+    claimTimer(timerId: string, workerId: string, ttlMs: number): Promise<boolean>;
+    createSchedule(schedule: Schedule): Promise<void>;
+    getSchedule(id: string): Promise<Schedule | null>;
+    updateSchedule(id: string, updates: Partial<Schedule>): Promise<void>;
+    deleteSchedule(id: string): Promise<void>;
+    listSchedules(): Promise<Schedule[]>;
+    listActiveSchedules(): Promise<Schedule[]>;
+    acquireLock(resource: string, ttlMs: number): Promise<string | null>;
+    releaseLock(resource: string, lockId: string): Promise<void>;
+}

package/dist/types/node/durable/store/RedisStore.d.ts

@@ -0,0 +1,89 @@
+import { type Execution, type Schedule, type StepResult, type Timer } from "../core/types";
+import type { IDurableStore, ListExecutionsOptions } from "../core/interfaces/store";
+import { type DurableAuditEntry } from "../core/audit";
+export interface RedisPipeline {
+    get(key: string): RedisPipeline;
+    hget(hash: string, key: string): RedisPipeline;
+    exec(): Promise<Array<[unknown, unknown]> | null>;
+}
+export interface RedisClient {
+    set(...args: unknown[]): Promise<unknown>;
+    get(...args: unknown[]): Promise<unknown>;
+    scan(...args: unknown[]): Promise<unknown>;
+    sscan(...args: unknown[]): Promise<unknown>;
+    sadd(...args: unknown[]): Promise<unknown>;
+    srem(...args: unknown[]): Promise<unknown>;
+    keys?(...args: unknown[]): Promise<unknown>;
+    pipeline(): RedisPipeline;
+    hset(...args: unknown[]): Promise<unknown>;
+    hget(...args: unknown[]): Promise<unknown>;
+    hdel(...args: unknown[]): Promise<unknown>;
+    hgetall(...args: unknown[]): Promise<unknown>;
+    zadd(...args: unknown[]): Promise<unknown>;
+    zrangebyscore(...args: unknown[]): Promise<unknown>;
+    zrem(...args: unknown[]): Promise<unknown>;
+    eval(...args: unknown[]): Promise<unknown>;
+    quit(...args: unknown[]): Promise<unknown>;
+}
+export interface RedisStoreConfig {
+    prefix?: string;
+    redis?: RedisClient | string;
+}
+export declare class RedisStore implements IDurableStore {
+    private redis;
+    private prefix;
+    constructor(config: RedisStoreConfig);
+    private k;
+    private encodeKeyPart;
+    getExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+    }): Promise<string | null>;
+    setExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+        executionId: string;
+    }): Promise<boolean>;
+    private parseRedisString;
+    private parseScanResponse;
+    private scanKeys;
+    private scanSetMembers;
+    private activeExecutionsKey;
+    private isActiveExecutionStatus;
+    private updateActiveExecutionMembership;
+    saveExecution(execution: Execution): Promise<void>;
+    getExecution(id: string): Promise<Execution | null>;
+    updateExecution(id: string, updates: Partial<Execution>): Promise<void>;
+    listIncompleteExecutions(): Promise<Execution[]>;
+    listStuckExecutions(): Promise<Execution[]>;
+    retryRollback(executionId: string): Promise<void>;
+    skipStep(executionId: string, stepId: string): Promise<void>;
+    forceFail(executionId: string, error: {
+        message: string;
+        stack?: string;
+    }): Promise<void>;
+    editStepResult(executionId: string, stepId: string, newResult: unknown): Promise<void>;
+    listExecutions(options?: ListExecutionsOptions): Promise<Execution[]>;
+    listStepResults(executionId: string): Promise<StepResult[]>;
+    appendAuditEntry(entry: DurableAuditEntry): Promise<void>;
+    listAuditEntries(executionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<DurableAuditEntry[]>;
+    getStepResult(executionId: string, stepId: string): Promise<StepResult | null>;
+    saveStepResult(result: StepResult): Promise<void>;
+    createTimer(timer: Timer): Promise<void>;
+    getReadyTimers(now?: Date): Promise<Timer[]>;
+    markTimerFired(timerId: string): Promise<void>;
+    deleteTimer(timerId: string): Promise<void>;
+    claimTimer(timerId: string, workerId: string, ttlMs: number): Promise<boolean>;
+    createSchedule(schedule: Schedule): Promise<void>;
+    getSchedule(id: string): Promise<Schedule | null>;
+    updateSchedule(id: string, updates: Partial<Schedule>): Promise<void>;
+    deleteSchedule(id: string): Promise<void>;
+    listSchedules(): Promise<Schedule[]>;
+    listActiveSchedules(): Promise<Schedule[]>;
+    acquireLock(resource: string, ttlMs: number): Promise<string | null>;
+    releaseLock(resource: string, lockId: string): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/types/node/durable/test-utils.d.ts

@@ -0,0 +1,29 @@
+import type { DurableResourceRuntimeConfig } from "./core/resource";
+import { durableResource } from "./core/resource";
+import { MemoryEventBus } from "./bus/MemoryEventBus";
+import { MemoryQueue } from "./queue/MemoryQueue";
+import { MemoryStore } from "./store/MemoryStore";
+type DurableResource = ReturnType<typeof durableResource.fork>;
+type DurableResourceRegistration = ReturnType<DurableResource["with"]>;
+export interface DurableTestSetup {
+    durable: DurableResource;
+    durableRegistration: DurableResourceRegistration;
+    store: MemoryStore;
+    eventBus: MemoryEventBus;
+    queue?: MemoryQueue;
+}
+export interface DurableTestSetupOptions {
+    durableId?: string;
+    store?: MemoryStore;
+    eventBus?: MemoryEventBus;
+    queue?: MemoryQueue;
+    worker?: boolean;
+    pollingIntervalMs?: number;
+    durableConfig?: Partial<DurableResourceRuntimeConfig>;
+}
+export declare function createDurableTestSetup(options?: DurableTestSetupOptions): DurableTestSetup;
+export declare function waitUntil(predicate: () => boolean | Promise<boolean>, options: {
+    timeoutMs: number;
+    intervalMs: number;
+}): Promise<void>;
+export {};

package/dist/types/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, allowOpen?: boolean): AllowListGuard;

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

@@ -0,0 +1,16 @@
+import type { Authenticator, AuthValidatorInput, AuthValidatorResult } from "./types";
+import type { ITask } from "../../defs";
+import type { TaskRunner } from "../../models/TaskRunner";
+export interface NodeExposureHttpAuthConfig {
+    header?: string;
+    token?: string | string[];
+    /**
+     * When true, allows unauthenticated access if no token or validators are configured.
+     * Defaults to false (secure by default - requires explicit auth configuration).
+     *
+     * WARNING: Setting this to true without proper network isolation exposes
+     * all tasks and events to unauthenticated access.
+     */
+    allowAnonymous?: boolean;
+}
+export declare function createAuthenticator(authCfg: NodeExposureHttpAuthConfig | undefined, taskRunner: TaskRunner, validatorTasks: ITask<AuthValidatorInput, Promise<AuthValidatorResult>, any>[]): Authenticator;

package/dist/types/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/types/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/types/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/types/node/exposure/handlers/contextWrapper.d.ts

@@ -0,0 +1,18 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { NodeExposureDeps } from "../resourceTypes";
+import type { SerializerLike } from "../../../serializer";
+export interface ExposureContextDeps {
+    store: NodeExposureDeps["store"];
+    router: {
+        basePath: string;
+    };
+    serializer: SerializerLike;
+}
+/**
+ * Builds a composed provider: first user async contexts (if any), then exposure context
+ */
+export declare const withExposureContext: <T>(req: IncomingMessage, res: ServerResponse, controller: AbortController, deps: ExposureContextDeps, fn: () => Promise<T>) => Promise<T>;
+/**
+ * Builds user async contexts (if any), without exposure context (for events)
+ */
+export declare const withUserContexts: <T>(req: IncomingMessage, deps: Pick<ExposureContextDeps, "store" | "serializer">, fn: () => Promise<T>) => Promise<T>;

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

@@ -0,0 +1,23 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { SerializerLike } from "../../../serializer";
+import type { Logger } from "../../../models/Logger";
+import type { Store } from "../../../models/Store";
+import type { NodeExposureHttpCorsConfig } from "../resourceTypes";
+import type { JsonResponse } from "../types";
+export declare enum ExposureErrorLogKey {
+    TaskError = "exposure.task.error",
+    EventError = "exposure.event.error"
+}
+/** Sanitizes 500 errors if they are not application-defined */
+export declare const sanitizeErrorResponse: (response: unknown) => JsonResponse;
+export interface HandleRequestErrorOptions {
+    error: unknown;
+    req: IncomingMessage;
+    res: ServerResponse;
+    store: Store;
+    logger: Logger;
+    cors?: NodeExposureHttpCorsConfig;
+    serializer: SerializerLike;
+    logKey: ExposureErrorLogKey;
+}
+export declare const handleRequestError: (options: HandleRequestErrorOptions) => void;

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

@@ -0,0 +1,20 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { SerializerLike } from "../../../serializer";
+import type { Authenticator, AllowListGuard } from "../types";
+import type { NodeExposureDeps, NodeExposureHttpCorsConfig } from "../resourceTypes";
+interface EventHandlerDeps {
+    store: NodeExposureDeps["store"];
+    eventManager: NodeExposureDeps["eventManager"];
+    logger: NodeExposureDeps["logger"];
+    authenticator: Authenticator;
+    allowList: AllowListGuard;
+    cors?: NodeExposureHttpCorsConfig;
+    serializer: SerializerLike;
+    limits?: {
+        json?: {
+            maxSize?: number;
+        };
+    };
+}
+export declare const createEventHandler: (deps: EventHandlerDeps) => (req: IncomingMessage, res: ServerResponse, eventId: string) => Promise<void>;
+export {};

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

@@ -0,0 +1,24 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { SerializerLike } from "../../../serializer";
+import type { Authenticator, AllowListGuard } from "../types";
+import type { NodeExposureDeps, NodeExposureHttpCorsConfig } from "../resourceTypes";
+interface TaskHandlerDeps {
+    store: NodeExposureDeps["store"];
+    taskRunner: NodeExposureDeps["taskRunner"];
+    logger: NodeExposureDeps["logger"];
+    authenticator: Authenticator;
+    allowList: AllowListGuard;
+    router: {
+        basePath: string;
+    };
+    cors?: NodeExposureHttpCorsConfig;
+    serializer: SerializerLike;
+    limits?: {
+        json?: {
+            maxSize?: number;
+        };
+        multipart?: any;
+    };
+}
+export declare const createTaskHandler: (deps: TaskHandlerDeps) => (req: IncomingMessage, res: ServerResponse, taskId: string) => Promise<void>;
+export {};

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

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

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

@@ -0,0 +1,3 @@
+export { nodeExposure } from "./resource";
+export type { NodeExposureHttpAuthConfig } from "./authenticator";
+export type * from "./resourceTypes";

package/dist/types/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/types/node/exposure/multipart.d.ts

@@ -0,0 +1,36 @@
+import type { IncomingHttpHeaders } from "http";
+import type { SerializerLike } from "../../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 interface MultipartLimits {
+    fieldNameSize?: number;
+    fieldSize?: number;
+    fields?: number;
+    fileSize?: number;
+    files?: number;
+    parts?: number;
+    headerPairs?: number;
+}
+export declare function parseMultipartInput(req: MultipartRequest, signal: AbortSignal | undefined, serializer: SerializerLike, limits?: MultipartLimits): Promise<MultipartResult>;
+export declare function isMultipart(contentType: string): boolean;
+export {};

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

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

package/dist/types/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("..").IAsyncContext<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;