@pipedog/core 0.0.0 → 0.1.0

package/dist/pipeline/base_pipeline.d.ts

@@ -0,0 +1,49 @@
+/** Base pipeline implementation for frame processing. */
+import { type Task } from "@pipedog/asyncio";
+import { FrameProcessor, type FrameProcessorOptions, type FrameProcessorSetup } from "../processors/frame_processor.ts";
+export interface BasePipelineOptions extends FrameProcessorOptions {
+}
+/** Base class for all pipeline implementations. */
+export declare class BasePipeline extends FrameProcessor {
+    /** Initialize the base pipeline. */
+    constructor(options?: BasePipelineOptions);
+    /**
+     * Set up the given processors concurrently.
+     *
+     * A processor that fails to set up reports it as an error and leaves the
+     * rest of the pipeline to carry on, the same way a failure while handling a
+     * frame is reported. Every failure is reported, not just the first.
+     *
+     * The failure is permanent whatever caused it, since setting up is not
+     * attempted again: the processor is left half-built for the rest of the
+     * session, so it loses its usability and a switcher can move off it.
+     *
+     * Call it right after this pipeline's own setup, once it has released
+     * itself with `_setupFinished()`. Each processor holds the StartFrame until
+     * its own setup is done, so one slow processor doesn't block the ones ahead
+     * of it. The processors are held before anything else runs, so the
+     * StartFrame can't get past one whose setup() hasn't begun yet.
+     *
+     * @param processors The processors to set up.
+     * @param setup Configuration for frame processor setup.
+     */
+    protected _setupProcessors(processors: readonly FrameProcessor[], setup: FrameProcessorSetup): Promise<void>;
+    /** Hold the processor's StartFrame and set it up in a task of its own. */
+    protected _createSetupTask(processor: FrameProcessor, setup: FrameProcessorSetup): Task<unknown>;
+    /** Release the processor once it is set up, unless setting it up was cancelled. */
+    protected _setupTaskDone(processor: FrameProcessor, task: Task<unknown>): void;
+    /** Set the processor up, reporting a failure as a permanent error. */
+    protected _setupProcessor(processor: FrameProcessor, setup: FrameProcessorSetup): Promise<void>;
+    /**
+     * Clean up the given processors concurrently.
+     *
+     * Tearing down is best effort: a processor that throws is logged and the
+     * rest are still released. Cleaning up runs after a processor failed to set
+     * up, or was abandoned part-way through being set up, so some of them are
+     * released from a state they never finished reaching.
+     *
+     * @param processors The processors to clean up.
+     */
+    protected _cleanupProcessors(processors: readonly FrameProcessor[]): Promise<void>;
+}
+//# sourceMappingURL=base_pipeline.d.ts.map

package/dist/pipeline/base_pipeline.js

@@ -0,0 +1,101 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/pipeline/base_pipeline.py
+/** Base pipeline implementation for frame processing. */
+import { gather, monotonicNs, rethrowIfCancelled } from "@pipedog/asyncio";
+import { ProcessorSetUp } from "../observers/base_observer.js";
+import { FrameProcessor, } from "../processors/frame_processor.js";
+import { logger } from "../utils/logger.js";
+/** Base class for all pipeline implementations. */
+export class BasePipeline extends FrameProcessor {
+    /** Initialize the base pipeline. */
+    constructor(options = {}) {
+        super(options);
+    }
+    /**
+     * Set up the given processors concurrently.
+     *
+     * A processor that fails to set up reports it as an error and leaves the
+     * rest of the pipeline to carry on, the same way a failure while handling a
+     * frame is reported. Every failure is reported, not just the first.
+     *
+     * The failure is permanent whatever caused it, since setting up is not
+     * attempted again: the processor is left half-built for the rest of the
+     * session, so it loses its usability and a switcher can move off it.
+     *
+     * Call it right after this pipeline's own setup, once it has released
+     * itself with `_setupFinished()`. Each processor holds the StartFrame until
+     * its own setup is done, so one slow processor doesn't block the ones ahead
+     * of it. The processors are held before anything else runs, so the
+     * StartFrame can't get past one whose setup() hasn't begun yet.
+     *
+     * @param processors The processors to set up.
+     * @param setup Configuration for frame processor setup.
+     */
+    async _setupProcessors(processors, setup) {
+        const tasks = processors.map((p) => this._createSetupTask(p, setup));
+        await gather(...tasks);
+    }
+    /** Hold the processor's StartFrame and set it up in a task of its own. */
+    _createSetupTask(processor, setup) {
+        processor._setupStarted();
+        const task = this.createTask(() => this._setupProcessor(processor, setup), `${this}::setup::${processor}`);
+        task.addDoneCallback((task) => this._setupTaskDone(processor, task));
+        return task;
+    }
+    /** Release the processor once it is set up, unless setting it up was cancelled. */
+    _setupTaskDone(processor, task) {
+        if (!task.cancelled()) {
+            processor._setupFinished();
+        }
+    }
+    /** Set the processor up, reporting a failure as a permanent error. */
+    async _setupProcessor(processor, setup) {
+        const startedAtNs = monotonicNs();
+        try {
+            await processor.setup(setup);
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            await processor.pushError(`Error setting up processor: ${errorMessage(e)}`, {
+                exception: e,
+                forceTreatAsPermanent: true,
+            });
+        }
+        if (setup.observer) {
+            await setup.observer.onProcessorSetup(new ProcessorSetUp({
+                processor,
+                startedAtNs,
+                finishedAtNs: monotonicNs(),
+            }));
+        }
+    }
+    /**
+     * Clean up the given processors concurrently.
+     *
+     * Tearing down is best effort: a processor that throws is logged and the
+     * rest are still released. Cleaning up runs after a processor failed to set
+     * up, or was abandoned part-way through being set up, so some of them are
+     * released from a state they never finished reaching.
+     *
+     * @param processors The processors to clean up.
+     */
+    async _cleanupProcessors(processors) {
+        const cleanupProcessor = async (processor) => {
+            try {
+                await processor.cleanup();
+            }
+            catch (e) {
+                rethrowIfCancelled(e);
+                logger.error(`Error cleaning up ${processor}: ${errorMessage(e)}`);
+            }
+        };
+        await gather(...processors.map((p) => () => cleanupProcessor(p)));
+    }
+}
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+//# sourceMappingURL=base_pipeline.js.map

package/dist/pipeline/capabilities.d.ts

@@ -0,0 +1,76 @@
+/**
+ * What a bot does in a session, reported so clients can configure themselves.
+ *
+ * `PipelineWorker` derives a `BotCapabilities` from its pipeline's transports
+ * and parameters, and RTVI sends it to the client in the `bot-ready` message.
+ */
+export interface BotCapabilitiesOptions {
+    audioIn?: boolean | null;
+    audioOut?: boolean | null;
+    videoIn?: boolean | null;
+    screenIn?: boolean | null;
+    videoOut?: boolean | null;
+    metrics?: boolean | null;
+}
+/** Wire (JSON) form of `BotCapabilities`, with the upstream snake_case keys. */
+export interface BotCapabilitiesDump {
+    audio_in?: boolean | null;
+    audio_out?: boolean | null;
+    video_in?: boolean | null;
+    screen_in?: boolean | null;
+    video_out?: boolean | null;
+    metrics?: boolean | null;
+}
+/**
+ * What a bot does in a session.
+ *
+ * Every field is optional: `null` means unknown, and a client should keep its
+ * default behavior for it. `false` means the bot does not do it, so a client
+ * can hide the matching UI.
+ *
+ * - `audioIn`: whether the bot receives the user's audio.
+ * - `audioOut`: whether the bot sends audio to the user.
+ * - `videoIn`: whether the bot receives the user's video.
+ * - `screenIn`: whether the bot receives the user's screen share. Known when
+ *   the transport captures its video sources from `videoInSources`; unknown
+ *   when the application captures them itself.
+ * - `videoOut`: whether the bot sends video to the user.
+ * - `metrics`: whether the bot reports metrics.
+ */
+export declare class BotCapabilities {
+    audioIn: boolean | null;
+    audioOut: boolean | null;
+    videoIn: boolean | null;
+    screenIn: boolean | null;
+    videoOut: boolean | null;
+    metrics: boolean | null;
+    constructor(options?: BotCapabilitiesOptions);
+    /**
+     * Combine the capabilities of two parts of the same bot.
+     *
+     * A field is `true` if either side is `true`, `false` if either side is
+     * `false` and neither is `true`, and `null` if both are unknown.
+     *
+     * @param other The capabilities to combine with these.
+     * @returns The combined capabilities.
+     */
+    combine(other: BotCapabilities): BotCapabilities;
+    /**
+     * Apply the fields `other` knows on top of these capabilities.
+     *
+     * @param other The capabilities whose known (non-null) fields win.
+     * @returns These capabilities with `other`'s known fields applied.
+     */
+    override(other: BotCapabilities): BotCapabilities;
+    /**
+     * The wire form, with upstream's snake_case keys (pydantic `model_dump`).
+     *
+     * @param options.excludeNone Leave out unknown (null) fields.
+     */
+    modelDump(options?: {
+        excludeNone?: boolean;
+    }): BotCapabilitiesDump;
+    /** Serialize with the wire keys, as pydantic does. */
+    toJSON(): BotCapabilitiesDump;
+}
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/pipeline/capabilities.js

@@ -0,0 +1,97 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/pipeline/capabilities.py
+const FIELDS = ["audioIn", "audioOut", "videoIn", "screenIn", "videoOut", "metrics"];
+const WIRE_KEYS = {
+    audioIn: "audio_in",
+    audioOut: "audio_out",
+    videoIn: "video_in",
+    screenIn: "screen_in",
+    videoOut: "video_out",
+    metrics: "metrics",
+};
+/**
+ * What a bot does in a session.
+ *
+ * Every field is optional: `null` means unknown, and a client should keep its
+ * default behavior for it. `false` means the bot does not do it, so a client
+ * can hide the matching UI.
+ *
+ * - `audioIn`: whether the bot receives the user's audio.
+ * - `audioOut`: whether the bot sends audio to the user.
+ * - `videoIn`: whether the bot receives the user's video.
+ * - `screenIn`: whether the bot receives the user's screen share. Known when
+ *   the transport captures its video sources from `videoInSources`; unknown
+ *   when the application captures them itself.
+ * - `videoOut`: whether the bot sends video to the user.
+ * - `metrics`: whether the bot reports metrics.
+ */
+export class BotCapabilities {
+    audioIn;
+    audioOut;
+    videoIn;
+    screenIn;
+    videoOut;
+    metrics;
+    constructor(options = {}) {
+        this.audioIn = options.audioIn ?? null;
+        this.audioOut = options.audioOut ?? null;
+        this.videoIn = options.videoIn ?? null;
+        this.screenIn = options.screenIn ?? null;
+        this.videoOut = options.videoOut ?? null;
+        this.metrics = options.metrics ?? null;
+    }
+    /**
+     * Combine the capabilities of two parts of the same bot.
+     *
+     * A field is `true` if either side is `true`, `false` if either side is
+     * `false` and neither is `true`, and `null` if both are unknown.
+     *
+     * @param other The capabilities to combine with these.
+     * @returns The combined capabilities.
+     */
+    combine(other) {
+        const combined = {};
+        for (const field of FIELDS) {
+            const values = [this[field], other[field]].filter((v) => v !== null);
+            combined[field] = values.length > 0 ? values.some(Boolean) : null;
+        }
+        return new BotCapabilities(combined);
+    }
+    /**
+     * Apply the fields `other` knows on top of these capabilities.
+     *
+     * @param other The capabilities whose known (non-null) fields win.
+     * @returns These capabilities with `other`'s known fields applied.
+     */
+    override(other) {
+        const updated = new BotCapabilities(this);
+        for (const field of FIELDS) {
+            if (other[field] !== null)
+                updated[field] = other[field];
+        }
+        return updated;
+    }
+    /**
+     * The wire form, with upstream's snake_case keys (pydantic `model_dump`).
+     *
+     * @param options.excludeNone Leave out unknown (null) fields.
+     */
+    modelDump(options = {}) {
+        const dump = {};
+        for (const field of FIELDS) {
+            const value = this[field];
+            if (options.excludeNone && value === null)
+                continue;
+            dump[WIRE_KEYS[field]] = value;
+        }
+        return dump;
+    }
+    /** Serialize with the wire keys, as pydantic does. */
+    toJSON() {
+        return this.modelDump();
+    }
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/pipeline/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/pipeline/__init__.py
+// Upstream's `__init__.py` is empty: import the package's modules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/pipeline/job_context.d.ts

@@ -0,0 +1,317 @@
+/**
+ * Worker group types for structured concurrent worker execution.
+ *
+ * Porting notes:
+ * - `async with ctx:` becomes `await ctx.run(async (ctx) => { ... })`, or the
+ *   explicit `await ctx.enter()` / `await ctx.exit(error)` pair.
+ * - `async for event in ctx` is `for await (const event of ctx)`.
+ * - The deprecated `resolve_job_params()` (and the per-argument job spelling
+ *   it absorbs) is not ported.
+ */
+import { Event, Queue, type Task } from "@pipedog/asyncio";
+import type { BaseWorker } from "../workers/base_worker.ts";
+/** A job payload or response: structured JSON-like data. */
+export type JobPayload = Record<string, unknown>;
+export interface JobParamsOptions {
+    name?: string | null;
+    payload?: JobPayload | null;
+    timeout?: number | null;
+    label?: string | null;
+    cancellable?: boolean;
+}
+/**
+ * Configuration for a job sent to a single worker.
+ *
+ * - `name`: optional job name, routing the request to the matching
+ *   `job({ name })` handler on the worker.
+ * - `payload`: optional structured data describing the work.
+ * - `timeout`: optional timeout in seconds, covering both the wait for the
+ *   worker to become ready and the job itself.
+ * - `label`: optional human-readable description of the work, e.g.
+ *   `"Research: Radiohead"`. A `UIWorker` titles the client's progress card
+ *   with it.
+ * - `cancellable`: whether an external requester, such as the client UI, may
+ *   ask for the job to be cancelled. Cancellation the worker initiates itself
+ *   (shutdown, timeout, `cancelOnError`) proceeds either way.
+ */
+export declare class JobParams {
+    name: string | null;
+    payload: JobPayload | null;
+    timeout: number | null;
+    label: string | null;
+    cancellable: boolean;
+    constructor(options?: JobParamsOptions);
+}
+export interface JobGroupParamsOptions extends JobParamsOptions {
+    cancelOnError?: boolean;
+}
+/**
+ * Configuration for a job sent to several workers at once.
+ *
+ * Carries every `JobParams` field, which apply to the group as a whole, plus
+ * how the group reacts to one of its workers failing.
+ *
+ * - `cancelOnError`: whether a worker responding with an error status cancels
+ *   the rest of the group.
+ */
+export declare class JobGroupParams extends JobParams {
+    cancelOnError: boolean;
+    constructor(options?: JobGroupParamsOptions);
+}
+/**
+ * Status of a completed worker.
+ *
+ * String values, so they compare naturally with plain strings and serialize
+ * without extra handling.
+ *
+ * - `COMPLETED`: the worker finished successfully.
+ * - `CANCELLED`: the worker was cancelled by the requester.
+ * - `FAILED`: the worker failed due to a logical or business error.
+ * - `ERROR`: the worker encountered an unexpected runtime error.
+ */
+export declare const JobStatus: {
+    readonly COMPLETED: "completed";
+    readonly CANCELLED: "cancelled";
+    readonly FAILED: "failed";
+    readonly ERROR: "error";
+};
+export type JobStatus = (typeof JobStatus)[keyof typeof JobStatus];
+/** Raised when a worker is cancelled due to a worker error or timeout. */
+export declare class JobError extends Error {
+    name: string;
+}
+/** Raised when a worker group is cancelled due to a worker error or timeout. */
+export declare class JobGroupError extends Error {
+    name: string;
+}
+/**
+ * Collected results from a completed job group.
+ *
+ * - `jobId`: the shared job identifier.
+ * - `responses`: collected responses keyed by worker name.
+ */
+export declare class JobGroupResponse {
+    jobId: string;
+    responses: Record<string, JobPayload>;
+    constructor(options: {
+        jobId: string;
+        responses: Record<string, JobPayload>;
+    });
+}
+/**
+ * An event received from a worker during a single-worker job.
+ *
+ * - `type`: the event type.
+ * - `data`: optional event payload.
+ */
+export declare class JobEvent {
+    static readonly UPDATE = "update";
+    static readonly STREAM_START = "stream_start";
+    static readonly STREAM_DATA = "stream_data";
+    static readonly STREAM_END = "stream_end";
+    type: string;
+    data: JobPayload | null;
+    constructor(options: {
+        type: string;
+        data?: JobPayload | null;
+    });
+}
+/**
+ * An event received from a worker during job group execution.
+ *
+ * - `type`: the event type.
+ * - `workerName`: the name of the worker that sent the event.
+ * - `data`: optional event payload.
+ */
+export declare class JobGroupEvent {
+    static readonly UPDATE = "update";
+    static readonly STREAM_START = "stream_start";
+    static readonly STREAM_DATA = "stream_data";
+    static readonly STREAM_END = "stream_end";
+    type: string;
+    workerName: string;
+    data: JobPayload | null;
+    constructor(options: {
+        type: string;
+        workerName: string;
+        data?: JobPayload | null;
+    });
+}
+export interface JobGroupOptions {
+    jobId: string;
+    workerNames: string[];
+    responses?: Record<string, JobPayload>;
+    timeoutTask?: Task<unknown> | null;
+    cancelOnError?: boolean;
+    label?: string | null;
+    cancellable?: boolean;
+    terminated?: Set<string>;
+    eventQueue?: Queue<JobGroupEvent | null> | null;
+}
+/**
+ * Tracks a group of workers launched together.
+ *
+ * - `jobId`: shared identifier for all workers in this group.
+ * - `workerNames`: names of the workers in the group, in dispatch order.
+ * - `responses`: collected responses keyed by worker name.
+ * - `timeoutTask`: optional task that cancels the group on timeout.
+ * - `cancelOnError`: whether to cancel the group if a worker errors.
+ * - `label`: optional human-readable description of the work, from
+ *   `JobGroupParams.label`.
+ * - `cancellable`: whether an external requester may ask for the group to be
+ *   cancelled, from `JobGroupParams.cancellable`.
+ * - `terminated`: names of the workers that have reached a terminal state,
+ *   whether by responding or by ending their stream.
+ * - `eventQueue`: optional queue for streaming events to a `JobGroupContext`
+ *   async iterator.
+ */
+export declare class JobGroup {
+    jobId: string;
+    workerNames: string[];
+    responses: Record<string, JobPayload>;
+    timeoutTask: Task<unknown> | null;
+    cancelOnError: boolean;
+    label: string | null;
+    cancellable: boolean;
+    terminated: Set<string>;
+    eventQueue: Queue<JobGroupEvent | null> | null;
+    protected _done: Event;
+    protected _error: string | null;
+    constructor(options: JobGroupOptions);
+    /** Whether the group has completed or failed. */
+    get isDone(): boolean;
+    /**
+     * Wait for all workers in the group to respond.
+     *
+     * @throws JobGroupError If the group was cancelled due to error or timeout.
+     */
+    wait(): Promise<void>;
+    /** Signal that all workers have responded. */
+    complete(): void;
+    /**
+     * Signal that the group was cancelled.
+     *
+     * @param reason Human-readable reason for the failure.
+     */
+    fail(reason?: string | null): void;
+    toString(): string;
+}
+/**
+ * Async context manager and iterator for structured job group execution.
+ *
+ * Sends job requests on enter, waits for all responses on exit. Supports
+ * `for await` to receive intermediate events (updates and streaming data)
+ * from workers while waiting for completion.
+ *
+ * On normal completion, results are available via `responses`. On worker
+ * error (with `cancelOnError: true`) or timeout, throws `JobGroupError`. If
+ * the block throws, remaining jobs are cancelled.
+ *
+ * @example
+ * const tg = this.jobGroup(["w1", "w2"], { params: new JobGroupParams({ payload: data }) });
+ * await tg.run(async (tg) => {
+ *   for await (const event of tg) {
+ *     console.log(`${event.workerName} [${event.type}]:`, event.data);
+ *   }
+ * });
+ *
+ * for (const [name, result] of Object.entries(tg.responses)) {
+ *   console.log(name, result);
+ * }
+ */
+export declare class JobGroupContext implements AsyncIterable<JobGroupEvent> {
+    protected _worker: BaseWorker;
+    protected _workerNames: readonly string[];
+    protected _params: JobGroupParams;
+    protected _group: JobGroup | null;
+    /**
+     * Initialize the JobGroupContext.
+     *
+     * @param worker The parent `BaseWorker` that owns this job group.
+     * @param workerNames Names of the workers to send the job to.
+     * @param options.params How to run the group. Defaults to `JobGroupParams` defaults.
+     */
+    constructor(worker: BaseWorker, workerNames: readonly string[], options?: {
+        params?: JobGroupParams | null;
+    });
+    /** The shared job identifier for this group. */
+    get jobId(): string;
+    /** Collected responses keyed by worker name. */
+    get responses(): Record<string, JobPayload>;
+    [Symbol.asyncIterator](): AsyncIterator<JobGroupEvent>;
+    /** Send the job requests (`__aenter__`). */
+    enter(): Promise<this>;
+    /**
+     * Leave the block (`__aexit__`): cancel the remaining jobs if the block
+     * threw, otherwise wait for every response.
+     *
+     * @param error What the block threw, if anything (`undefined` when it
+     *   completed normally).
+     */
+    exit(error?: unknown): Promise<void>;
+    /**
+     * Run `fn` inside the context, as `async with` does: enter, run the block,
+     * then exit. An error thrown by the block cancels the group and is
+     * re-thrown.
+     */
+    run<R>(fn: (ctx: this) => Promise<R> | R): Promise<R>;
+}
+/**
+ * Async context manager and iterator for a single-worker job.
+ *
+ * Sends a job request on enter, waits for the response on exit. Supports
+ * `for await` to receive intermediate events (updates and streaming data)
+ * from the worker while waiting for completion.
+ *
+ * On normal completion, the result is available via `response`. On worker
+ * error or timeout, throws `JobError`. If the block throws, the job is
+ * cancelled.
+ *
+ * @example
+ * const t = this.job("worker", { params: new JobParams({ payload: data }) });
+ * await t.run(async (t) => {
+ *   for await (const event of t) {
+ *     console.log(`[${event.type}]:`, event.data);
+ *   }
+ * });
+ *
+ * console.log(t.response);
+ */
+export declare class JobContext implements AsyncIterable<JobEvent> {
+    protected _worker: BaseWorker;
+    protected _workerName: string;
+    protected _params: JobParams;
+    protected _group: JobGroup | null;
+    /**
+     * Initialize the JobContext.
+     *
+     * @param worker The parent `BaseWorker` that owns this job.
+     * @param workerName Name of the worker to send the job to.
+     * @param options.params How to run the job. Defaults to `JobParams` defaults.
+     */
+    constructor(worker: BaseWorker, workerName: string, options?: {
+        params?: JobParams | null;
+    });
+    /** The job identifier. */
+    get jobId(): string;
+    /** The worker's response payload. */
+    get response(): JobPayload;
+    [Symbol.asyncIterator](): AsyncIterator<JobEvent>;
+    /** Send the job request (`__aenter__`). */
+    enter(): Promise<this>;
+    /**
+     * Leave the block (`__aexit__`): cancel the job if the block threw,
+     * otherwise wait for the response.
+     *
+     * @param error What the block threw, if anything (`undefined` when it
+     *   completed normally).
+     * @throws JobError If the worker failed or timed out.
+     */
+    exit(error?: unknown): Promise<void>;
+    /**
+     * Run `fn` inside the context, as `async with` does: enter, run the block,
+     * then exit. An error thrown by the block cancels the job and is re-thrown.
+     */
+    run<R>(fn: (ctx: this) => Promise<R> | R): Promise<R>;
+}
+//# sourceMappingURL=job_context.d.ts.map