@nanobpm/workflow 0.4.0 → 0.6.0

package/README.md

@@ -183,7 +183,25 @@ once.
 | `externalJobTypes(flow)` | The job types of a flow's external `task` steps (each overridable per-step via `w.task(name, { jobType })`). |
 | `WorkflowClient` | `deploy`, `start`, `signal`, `getInstance` over REST v2. |
 | `Worker` | Generic job runtime; routes job types → handlers, hosts the replay loop. |
-| `toBpmn(workflow)` | The derived BPMN XML (for inspection / deployment). |
+| `toBpmn(workflow)` | The DI-less semantic BPMN the engine runs (for inspection / deployment). |
+| `toDeployableBpmn(workflow, { layout? })` | The deployable BPMN **with an auto-generated diagram (DI)** so the deployed model is inspectable; what `deploy` sends by default. |
+| `layoutBpmn(xml)` / `declarativeToLayoutedBpmn(flow)` | Add DI to a model with `bpmn-auto-layout`. |
+
+### Inspectable deployments (diagram layout)
+
+`client.deploy(flow)` deploys the model **with an auto-generated diagram
+interchange (DI)** so it opens rendered and inspectable in a modeller/Operate
+rather than as a blank canvas. DI is generated with the optional peer dependency
+[`bpmn-auto-layout`](https://www.npmjs.com/package/bpmn-auto-layout):
+
+```sh
+npm i bpmn-auto-layout
+```
+
+If it is not installed, `deploy` degrades gracefully — it warns once and deploys
+the DI-less model. Pass `deploy(flow, { layout: false })` to skip layout
+deliberately. The semantic model stays authoritative; DI is derived and
+regenerable.
 
 See [ADR 0044](../docs/adr/0044-code-first-durable-orchestration.md) for the design
 rationale and [ADR 0047](../docs/adr/0047-declarative-flow-control-and-typed-envelopes.md)

package/dist/client.d.ts

@@ -1,36 +1,126 @@
 import type { DeclarativeFlow, DeployResult, Job, JsonObject, StartResult, Workflow } from "./types.js";
 /** Render a workflow (either surface) to its executable BPMN model. */
 export declare function toBpmn(wf: Workflow): string;
-type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
-export interface WorkflowClientOptions {
-    /** Base URL of the nanobpmn gateway, e.g. `http://localhost:8080`. */
-    baseUrl: string;
-    /** Injectable fetch (defaults to the global). Useful for tests/proxies. */
-    fetch?: FetchLike;
+/**
+ * Render a workflow to *deployable* BPMN — the executable model plus diagram
+ * interchange (DI), auto-generated with `bpmn-auto-layout` — so the deployed
+ * process opens rendered and inspectable in a modeller/Operate rather than as a
+ * blank canvas. The semantic model stays authoritative; DI is derived.
+ *
+ * DI generation needs the optional peer dependency `bpmn-auto-layout`. When it is
+ * absent, this degrades gracefully: it warns once and returns the DI-less model
+ * so `deploy` still works everywhere. Pass `{ layout: false }` to skip layout
+ * deliberately. A genuine layout failure (the dep is installed but errors) is
+ * surfaced, not swallowed.
+ */
+export declare function toDeployableBpmn(wf: Workflow, opts?: {
+    layout?: boolean;
+}): Promise<string>;
+/**
+ * The subset of the `@nanobpm/nano-sdk` (Camunda orchestration-cluster) client
+ * that the workflow surface uses. `createCamundaClient` returns a superset of
+ * this, so a test — or an author bringing their own transport (e.g. the embedded
+ * engine) — can inject any object satisfying it.
+ */
+export interface NanoSdkClient {
+    createDeployment(input: {
+        resources: File[];
+        [k: string]: unknown;
+    }, options?: unknown): Promise<Record<string, unknown>>;
+    createProcessInstance(input: {
+        processDefinitionId: string;
+        variables?: JsonObject;
+    }, options?: unknown): Promise<Record<string, unknown>>;
+    correlateMessage(input: {
+        name: string;
+        correlationKey: string;
+        variables?: JsonObject;
+    }, options?: unknown): Promise<Record<string, unknown>>;
+    getProcessInstance(input: {
+        processInstanceKey: string;
+    }, consistency: {
+        consistency: {
+            waitUpToMs: number;
+        };
+    }, options?: unknown): Promise<Record<string, unknown>>;
+    createJobWorker(cfg: JobWorkerConfig): NanoJobWorker;
+}
+/** Config for a nano-sdk job worker (the subset the Worker runtime sets). */
+export interface JobWorkerConfig {
+    jobType: string;
+    jobHandler: (job: ActivatedJob) => Promise<unknown> | unknown;
+    workerName?: string;
+    maxParallelJobs?: number;
+    /** Job lock timeout in ms. */
+    jobTimeoutMs?: number;
+    /** Long-poll timeout in ms. */
+    pollTimeoutMs?: number;
+    /** Start polling immediately. The Worker runtime sets this false and starts explicitly. */
+    autoStart?: boolean;
+}
+/** The handle returned by `createJobWorker`. */
+export interface NanoJobWorker {
+    start(): void;
+    stop(): void | Promise<void>;
+    stopGracefully?(opts?: {
+        waitUpToMs?: number;
+    }): Promise<void>;
 }
-export interface ActivateOptions {
-    worker: string;
-    maxJobsToActivate?: number;
-    /** Job timeout in ms (how long the worker holds the job). Default 30000. */
-    timeout?: number;
-    /** Long-poll timeout in ms; `< 0` disables long-poll. Default 15000. */
-    requestTimeout?: number;
+/** An activated job as delivered to a nano-sdk job handler: the workflow `Job`
+ *  fields plus the acknowledgement actions. */
+export type ActivatedJob = Job & {
+    complete(variables?: JsonObject): Promise<unknown>;
+    fail(body: {
+        errorMessage: string;
+        retries?: number;
+    }): Promise<unknown>;
+};
+/** Options common to both ways of building a `WorkflowClient`. */
+interface WorkflowClientCommon {
+    /** Auth token for the gateway (CAMUNDA_TOKEN). */
+    token?: string;
+    /** Transport mode passed to `createCamundaClient`: "auto" | "falcon" | "rest".
+     *  Default "auto" (Falcon on a Nano server, REST elsewhere). */
+    transport?: "auto" | "falcon" | "rest";
 }
+/** Construct a `WorkflowClient` from **either** a `baseUrl` (a nano-sdk client is
+ *  built for you) **or** a pre-built `client`. The union makes TypeScript enforce
+ *  that exactly one is supplied, matching the constructor's runtime requirement. */
+export type WorkflowClientOptions = (WorkflowClientCommon & {
+    /** Base URL of the nanobpmn gateway, e.g. `http://localhost:8080`. The
+     *  nano-sdk client normalises this to the `/v2` REST address. */
+    baseUrl: string;
+    client?: never;
+}) | (WorkflowClientCommon & {
+    /** Inject a pre-built nano-sdk client (or a compatible fake) instead of
+     *  constructing one from `baseUrl`. Useful for tests, the embedded
+     *  transport, and advanced authors who build the client themselves. */
+    client: NanoSdkClient;
+    baseUrl?: never;
+});
 export declare class WorkflowError extends Error {
     readonly status?: number | undefined;
     readonly body?: string | undefined;
     constructor(message: string, status?: number | undefined, body?: string | undefined);
 }
 export declare class WorkflowClient {
-    private readonly baseUrl;
-    private readonly fetchImpl;
+    /** The underlying nano-sdk client, exposed so the Worker runtime and app
+     *  authors can reach the engine through the same transport (ADR 0055). The
+     *  exported `NanoSdkClient` type intentionally models only the subset of
+     *  methods this package uses (deploy, create, correlate, get, job workers);
+     *  the runtime value is the full nano-sdk client. */
+    readonly sdk: NanoSdkClient;
     constructor(opts: WorkflowClientOptions);
-    private json;
-    /** Perform a request, throwing WorkflowError on transport error or !ok, and
-     *  return the raw Response (for endpoints with an empty/no-content body). */
-    private send;
-    /** Deploy a workflow's derived BPMN model. */
-    deploy(wf: Workflow): Promise<DeployResult>;
+    /**
+     * Deploy a workflow's derived BPMN model. The deployed model includes
+     * auto-generated diagram interchange (DI) so it is inspectable in a
+     * modeller/Operate; pass `{ layout: false }` to deploy the DI-less semantic
+     * model. DI needs the optional `bpmn-auto-layout` dependency — see
+     * `toDeployableBpmn` for the graceful-degradation behaviour when it is absent.
+     */
+    deploy(wf: Workflow, opts?: {
+        layout?: boolean;
+    }): Promise<DeployResult>;
     /**
      * Start a workflow instance. For imperative workflows the engine variables are
      * seeded with `{ input, journal: {}, wfDone: false }` (the replay state); for
@@ -41,10 +131,8 @@ export declare class WorkflowClient {
      *  unknown signal name (a typo would otherwise send an uncorrelatable message
      *  that the gateway silently drops). */
     signal(flow: DeclarativeFlow, signalName: string, correlationKey: string, variables?: JsonObject): Promise<JsonObject>;
-    /** Fetch an instance (used by demos/tests to observe completion). */
+    /** Fetch an instance (used by demos/tests to observe completion). Reads with
+     *  zero-wait consistency; returns null when the instance is not (yet) visible. */
     getInstance(processInstanceKey: string): Promise<JsonObject | null>;
-    activateJobs(type: string, opts: ActivateOptions): Promise<Job[]>;
-    completeJob(jobKey: string, variables?: JsonObject): Promise<void>;
-    failJob(jobKey: string, errorMessage: string, retries?: number): Promise<void>;
 }
 export {};

package/dist/client.js

@@ -1,14 +1,55 @@
-// A thin, dependency-free client for a running nanobpmn gateway (REST v2):
-// deploy a workflow's derived model, start instances, correlate signals, and the
-// low-level job activate/complete/fail used by the Worker runtime.
+// A client for a running nanobpmn gateway, built on `@nanobpm/nano-sdk` (the
+// single engine-transport spine — ADR 0055). It derives a workflow's model,
+// deploys it (with diagram interchange), starts instances, and correlates
+// signals; the low-level job protocol used by the Worker runtime is the SDK's
+// own job worker, reached through the exposed `sdk` client.
+import { createCamundaClient } from "@nanobpm/nano-sdk";
 import { declarativeToBpmn, walkNodes } from "./declarative.js";
 import { imperativeToBpmn } from "./imperative.js";
+import { layoutBpmn } from "./layout.js";
 import { assertWorkflowIds, messageName } from "./xml.js";
 /** Render a workflow (either surface) to its executable BPMN model. */
 export function toBpmn(wf) {
     assertWorkflowIds(wf);
     return wf.kind === "imperative" ? imperativeToBpmn(wf) : declarativeToBpmn(wf);
 }
+let warnedNoLayout = false;
+/**
+ * Render a workflow to *deployable* BPMN — the executable model plus diagram
+ * interchange (DI), auto-generated with `bpmn-auto-layout` — so the deployed
+ * process opens rendered and inspectable in a modeller/Operate rather than as a
+ * blank canvas. The semantic model stays authoritative; DI is derived.
+ *
+ * DI generation needs the optional peer dependency `bpmn-auto-layout`. When it is
+ * absent, this degrades gracefully: it warns once and returns the DI-less model
+ * so `deploy` still works everywhere. Pass `{ layout: false }` to skip layout
+ * deliberately. A genuine layout failure (the dep is installed but errors) is
+ * surfaced, not swallowed.
+ */
+export async function toDeployableBpmn(wf, opts = {}) {
+    const semantic = toBpmn(wf);
+    if (opts.layout === false)
+        return semantic;
+    try {
+        return await layoutBpmn(semantic);
+    }
+    catch (e) {
+        // Only fall back for the "optional dep not installed" case (layoutBpmn wraps
+        // it with an ERR_MODULE_NOT_FOUND cause). Any other failure is a real layout
+        // problem and must surface rather than silently deploy an uninspectable model.
+        const cause = e?.cause;
+        if (cause?.code !== "ERR_MODULE_NOT_FOUND")
+            throw e;
+        if (!warnedNoLayout) {
+            warnedNoLayout = true;
+            console.warn(`[@nanobpm/workflow] Deploying "${wf.id}" without a diagram: the optional ` +
+                '"bpmn-auto-layout" dependency is not installed, so the model will be ' +
+                "uninspectable in a modeller/Operate. Install it for diagram layout: " +
+                "npm i bpmn-auto-layout");
+        }
+        return semantic;
+    }
+}
 export class WorkflowError extends Error {
     status;
     body;
@@ -19,44 +60,53 @@ export class WorkflowError extends Error {
         this.name = "WorkflowError";
     }
 }
+/** Normalise a thrown SDK/transport error into a WorkflowError, preserving an
+ *  HTTP status when the SDK attached one. */
+function asWorkflowError(e, what) {
+    if (e instanceof WorkflowError)
+        return e;
+    const err = e;
+    const status = err?.status ?? err?.response?.status;
+    return new WorkflowError(`${what} failed: ${err?.message ?? String(e)}`, status);
+}
 export class WorkflowClient {
-    baseUrl;
-    fetchImpl;
+    /** The underlying nano-sdk client, exposed so the Worker runtime and app
+     *  authors can reach the engine through the same transport (ADR 0055). The
+     *  exported `NanoSdkClient` type intentionally models only the subset of
+     *  methods this package uses (deploy, create, correlate, get, job workers);
+     *  the runtime value is the full nano-sdk client. */
+    sdk;
     constructor(opts) {
+        if (opts?.client) {
+            this.sdk = opts.client;
+            return;
+        }
         if (!opts?.baseUrl)
-            throw new Error("WorkflowClient needs a baseUrl");
-        this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
-        const f = opts.fetch ?? globalThis.fetch;
-        if (!f)
-            throw new Error("no fetch available; pass options.fetch (Node < 18)");
-        this.fetchImpl = f;
-    }
-    async json(path, init, what) {
-        const res = await this.send(path, init, what);
-        return (await res.json());
+            throw new Error("WorkflowClient needs a baseUrl or a client");
+        this.sdk = createCamundaClient({
+            config: {
+                CAMUNDA_REST_ADDRESS: opts.baseUrl.replace(/\/+$/, ""),
+                ...(opts.token ? { CAMUNDA_TOKEN: opts.token } : {}),
+                CAMUNDA_TRANSPORT: opts.transport ?? "auto",
+            },
+        });
     }
-    /** Perform a request, throwing WorkflowError on transport error or !ok, and
-     *  return the raw Response (for endpoints with an empty/no-content body). */
-    async send(path, init, what) {
-        let res;
+    /**
+     * Deploy a workflow's derived BPMN model. The deployed model includes
+     * auto-generated diagram interchange (DI) so it is inspectable in a
+     * modeller/Operate; pass `{ layout: false }` to deploy the DI-less semantic
+     * model. DI needs the optional `bpmn-auto-layout` dependency — see
+     * `toDeployableBpmn` for the graceful-degradation behaviour when it is absent.
+     */
+    async deploy(wf, opts = {}) {
+        const xml = await toDeployableBpmn(wf, opts);
+        const file = new File([xml], `${wf.id}.bpmn`, { type: "text/xml" });
         try {
-            res = await this.fetchImpl(`${this.baseUrl}${path}`, init);
+            return (await this.sdk.createDeployment({ resources: [file] }));
         }
         catch (e) {
-            throw new WorkflowError(`${what} transport error: ${e.message}`);
-        }
-        if (!res.ok) {
-            const body = await res.text().catch(() => "");
-            throw new WorkflowError(`${what} failed: ${res.status}`, res.status, body);
+            throw asWorkflowError(e, "deploy");
         }
-        return res;
-    }
-    /** Deploy a workflow's derived BPMN model. */
-    async deploy(wf) {
-        const xml = toBpmn(wf);
-        const form = new FormData();
-        form.append("resources", new Blob([xml], { type: "text/xml" }), `${wf.id}.bpmn`);
-        return this.json(`/v2/deployments`, { method: "POST", body: form }, "deploy");
     }
     /**
      * Start a workflow instance. For imperative workflows the engine variables are
@@ -65,11 +115,15 @@ export class WorkflowClient {
      */
     async start(wf, input = {}) {
         const variables = wf.kind === "imperative" ? { input, journal: {}, wfDone: false } : input;
-        return this.json(`/v2/process-instances`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ processDefinitionId: wf.id, variables }),
-        }, "start");
+        try {
+            return (await this.sdk.createProcessInstance({
+                processDefinitionId: wf.id,
+                variables,
+            }));
+        }
+        catch (e) {
+            throw asWorkflowError(e, "start");
+        }
     }
     /** Correlate a signal to a parked declarative `signal` step. Fails fast on an
      *  unknown signal name (a typo would otherwise send an uncorrelatable message
@@ -85,40 +139,25 @@ export class WorkflowClient {
         if (!signals.includes(signalName)) {
             throw new WorkflowError(`unknown signal "${signalName}" on flow "${flow.id}" — declared signals: ${signals.length ? signals.map((s) => `"${s}"`).join(", ") : "(none)"}`);
         }
-        return this.json(`/v2/messages/correlation`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ name: messageName(flow.id, signalName), correlationKey, variables }),
-        }, `signal "${signalName}"`);
+        try {
+            return (await this.sdk.correlateMessage({
+                name: messageName(flow.id, signalName),
+                correlationKey,
+                variables,
+            }));
+        }
+        catch (e) {
+            throw asWorkflowError(e, `signal "${signalName}"`);
+        }
     }
-    /** Fetch an instance (used by demos/tests to observe completion). */
+    /** Fetch an instance (used by demos/tests to observe completion). Reads with
+     *  zero-wait consistency; returns null when the instance is not (yet) visible. */
     async getInstance(processInstanceKey) {
         try {
-            const res = await this.fetchImpl(`${this.baseUrl}/v2/process-instances/${processInstanceKey}`);
-            if (!res.ok)
-                return null;
-            return (await res.json());
+            return (await this.sdk.getProcessInstance({ processInstanceKey }, { consistency: { waitUpToMs: 0 } }));
         }
         catch {
             return null;
         }
     }
-    // --- low-level job protocol (used by the Worker runtime) -------------------
-    async activateJobs(type, opts) {
-        const body = {
-            type,
-            worker: opts.worker,
-            maxJobsToActivate: opts.maxJobsToActivate ?? 1,
-            timeout: opts.timeout ?? 30000,
-            requestTimeout: opts.requestTimeout ?? 15000,
-        };
-        const res = await this.json(`/v2/jobs/activation`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) }, `activate ${type}`);
-        return res.jobs ?? [];
-    }
-    async completeJob(jobKey, variables = {}) {
-        await this.send(`/v2/jobs/${jobKey}/completion`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ variables }) }, "complete job");
-    }
-    async failJob(jobKey, errorMessage, retries = 0) {
-        await this.send(`/v2/jobs/${jobKey}/failure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ errorMessage, retries }) }, "fail job");
-    }
 }

package/dist/index.d.ts

@@ -5,8 +5,8 @@ export type { FlowBuilder } from "./declarative.js";
 export { layoutBpmn, declarativeToLayoutedBpmn } from "./layout.js";
 export { envelope } from "./envelope.js";
 export type { Envelope, EnvelopeType, EnvelopeField, FieldSpec, ScalarType, ScalarTs, FieldTs, } from "./envelope.js";
-export { WorkflowClient, WorkflowError, toBpmn } from "./client.js";
-export type { WorkflowClientOptions, ActivateOptions } from "./client.js";
+export { WorkflowClient, WorkflowError, toBpmn, toDeployableBpmn } from "./client.js";
+export type { WorkflowClientOptions, NanoSdkClient, NanoJobWorker, JobWorkerConfig, ActivatedJob, } from "./client.js";
 export { Worker } from "./worker.js";
 export type { WorkerOptions, ActivityEvent } from "./worker.js";
 export type { Json, JsonObject, Job, StepHandler, DeclarativeFlow, DeclarativeStep, FlowNode, SwitchCase, NodeEnvelopes, StepContract, FlowContracts, ImperativeWorkflow, Orchestration, WorkflowContext, Workflow, DeployResult, StartResult, } from "./types.js";

package/dist/index.js

@@ -42,5 +42,5 @@ export { defineWorkflow, imperativeToBpmn, replayOnce } from "./imperative.js";
 export { defineFlow, declarativeToBpmn, externalJobTypes, walkNodes } from "./declarative.js";
 export { layoutBpmn, declarativeToLayoutedBpmn } from "./layout.js";
 export { envelope } from "./envelope.js";
-export { WorkflowClient, WorkflowError, toBpmn } from "./client.js";
+export { WorkflowClient, WorkflowError, toBpmn, toDeployableBpmn } from "./client.js";
 export { Worker } from "./worker.js";

package/dist/worker.d.ts

@@ -9,36 +9,53 @@ export interface ActivityEvent {
     /** For an imperative orchestrator turn: the journalled step key, or "__done". */
     step?: string;
 }
-export interface WorkerOptions {
-    /** Provide a baseUrl (a client is created) or an existing client. */
-    baseUrl?: string;
-    client?: WorkflowClient;
+/** Options common to both ways of building a `Worker`. */
+interface WorkerCommon {
     workflows: Workflow[];
     /** Worker name reported to the gateway. Default "nanobpm-workflow". */
     name?: string;
+    /** Transport for the worker's own client (used only when `client` is not
+     *  supplied): "auto" | "falcon" | "rest". Defaults to "rest" — job serving is
+     *  resilience-critical, and REST long-poll reconnects with backoff after an
+     *  engine restart (the ADR 0044 property), whereas the Falcon push transport
+     *  does not recover a mid-stream disconnect. Instance creation, by contrast,
+     *  defaults to Falcon on its own `WorkflowClient` for throughput. */
+    transport?: "auto" | "falcon" | "rest";
     /** Long-poll timeout per activation, ms. Also bounds stop() latency. Default 10000. */
     pollTimeoutMs?: number;
     /** Job lock timeout, ms. Default 30000. */
     jobTimeoutMs?: number;
-    /** Backoff after a transport error, ms. Default 500. */
-    backoffMs?: number;
+    /** Max jobs handled in parallel per derived job type. Default 1. */
+    maxParallelJobs?: number;
     onActivity?: (e: ActivityEvent) => void | Promise<void>;
     onError?: (err: Error, context: {
         type: string;
     }) => void;
 }
+/** Build a `Worker` from **either** a `baseUrl` (a `WorkflowClient` is created)
+ *  **or** an existing `client`. The union makes TypeScript enforce that exactly
+ *  one is supplied, matching the constructor's runtime requirement. */
+export type WorkerOptions = (WorkerCommon & {
+    /** Base URL of the nanobpmn gateway; a `WorkflowClient` is created for you. */
+    baseUrl: string;
+    client?: never;
+}) | (WorkerCommon & {
+    /** An existing `WorkflowClient` to serve jobs through. */
+    client: WorkflowClient;
+    baseUrl?: never;
+});
 export declare class Worker {
     private readonly client;
     private readonly name;
     private readonly pollTimeoutMs;
     private readonly jobTimeoutMs;
-    private readonly backoffMs;
+    private readonly maxParallelJobs;
     private readonly onActivity?;
     private readonly onError?;
     /** job type → { workflowId, handle } */
     private readonly routes;
     private running;
-    private loops;
+    private workers;
     constructor(opts: WorkerOptions);
     private register;
     /** Register a derived job type, failing fast on a collision. Two workflows can
@@ -55,9 +72,18 @@ export declare class Worker {
     private emitActivity;
     /** The derived job types this worker serves. */
     get servedTypes(): string[];
-    /** Begin polling. Resolves once the loops are running (they run until stop()). */
+    /** Begin serving. Creates one nano-sdk job worker per derived job type with
+     *  `autoStart: false`, then starts each explicitly, so the poll lifecycle is
+     *  deterministic and owned here rather than left to the SDK's auto-start
+     *  default (matching the `JobWorkerConfig.autoStart` contract). Nothing polls
+     *  before `start()` is called. */
     start(): void;
-    /** Stop polling and wait for in-flight loops to unwind (≤ pollTimeoutMs). */
+    /** Stop serving and wait for in-flight jobs to drain. Stopping is best-effort
+     *  per worker: the Falcon worker's `stop` throws if it never bound a transport
+     *  (detection still pending), which must not fail the whole shutdown. */
     stop(): Promise<void>;
-    private pollLoop;
+    /** Dispatch one activated job to its route handler and acknowledge it. Returns
+     *  the nano-sdk action receipt (its `complete`/`fail` result). */
+    private handleJob;
 }
+export {};