@hotmeshio/long-tail 0.25.3 → 0.26.0

package/build/services/machines/gateway/api-escalations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * LineEscalations backed by the escalation API functions in process: the same
+ * calls the HTTP routes make, run as the user each actor maps to.
+ */
+import type { Actor, CreateRowInput } from './actions';
+import { type LineEscalations, type RowItem, type VerbResult } from './escalations';
+import type { OpenRowQuery } from '../rows';
+export declare class ApiLineEscalations implements LineEscalations {
+    private readonly userFor;
+    constructor(userFor: (as: Actor) => string);
+    private auth;
+    private verb;
+    claim(as: Actor, id: string): Promise<VerbResult>;
+    accumulate(as: Actor, id: string, itemKey: string, payload: Record<string, any>, metadata?: Record<string, any>): Promise<VerbResult>;
+    resolve(as: Actor, id: string, payload: Record<string, any>): Promise<VerbResult>;
+    create(as: Actor, input: CreateRowInput): Promise<{
+        id: string;
+    }>;
+    itemKeys(id: string): Promise<string[]>;
+    items(id: string): Promise<RowItem[]>;
+    get(id: string): Promise<Record<string, any> | null>;
+    listOpen(query: OpenRowQuery): Promise<Record<string, any>[]>;
+}

package/build/services/machines/gateway/api-escalations.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * LineEscalations backed by the escalation API functions in process: the same
+ * calls the HTTP routes make, run as the user each actor maps to.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiLineEscalations = void 0;
+const escalationApi = __importStar(require("../../../api/escalations"));
+const uuid_1 = require("../../../lib/uuid");
+const escalations_1 = require("./escalations");
+const actions_1 = require("./actions");
+class ApiLineEscalations {
+    constructor(userFor) {
+        this.userFor = userFor;
+    }
+    auth(as) {
+        return { userId: this.userFor(as) };
+    }
+    verb(result) {
+        const outcome = (0, escalations_1.verbOutcomeOf)(result.status);
+        if (!outcome)
+            throw new Error(`escalation verb failed ${result.status}: ${result.error}`);
+        return outcome === escalations_1.VERB_OUTCOME.DONE ? { outcome } : { outcome, detail: result.error, status: result.status };
+    }
+    async claim(as, id) {
+        return this.verb(await escalationApi.claimEscalation({ id, durationMinutes: 60 }, this.auth(as)));
+    }
+    async accumulate(as, id, itemKey, payload, metadata) {
+        return this.verb(await escalationApi.accumulateItem({ id, itemKey, payload, ...(metadata ? { metadata } : {}) }, this.auth(as)));
+    }
+    async resolve(as, id, payload) {
+        return this.verb(await escalationApi.resolveEscalation({ id, resolverPayload: payload }, this.auth(as)));
+    }
+    async create(as, input) {
+        const result = await escalationApi.createEscalation({ ...input }, this.auth(as));
+        if (result.status >= 300)
+            throw new Error(`create failed ${result.status}: ${result.error}`);
+        return { id: result.data.id };
+    }
+    async itemKeys(id) {
+        return (await this.items(id)).map((i) => i.itemKey);
+    }
+    async items(id) {
+        const result = await escalationApi.getEscalationItems({ id }, this.auth(actions_1.CONTROLLER));
+        if (result.status >= 300)
+            throw new Error(`items failed ${result.status}: ${result.error}`);
+        return result.data.items.map((i) => ({ itemKey: i.itemKey, payload: i.payload ?? {} }));
+    }
+    async get(id) {
+        if (!(0, uuid_1.isUuid)(id))
+            return null;
+        const result = await escalationApi.getEscalation({ id }, this.auth(actions_1.CONTROLLER));
+        if (result.status === 403 || result.status === 404)
+            return null;
+        if (result.status >= 300)
+            throw new Error(`get failed ${result.status}: ${result.error}`);
+        return result.data;
+    }
+    async listOpen(query) {
+        return (0, escalations_1.readAllPages)(async (offset) => {
+            const result = await escalationApi.listEscalations({ ...query, status: 'pending', limit: escalations_1.OPEN_PAGE, offset, sort_by: 'created_at', order: 'asc' }, this.auth(actions_1.CONTROLLER));
+            if (result.status >= 300)
+                throw new Error(`list failed ${result.status}: ${result.error}`);
+            return result.data.escalations;
+        });
+    }
+}
+exports.ApiLineEscalations = ApiLineEscalations;

package/build/services/machines/gateway/dispatcher.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Commands to machines and their replies. A dispatch becomes one command per
+ * job (gateway/jobs.ts); missing replies are asked for again with the same
+ * command ids, and the row is claimed once every job is accepted. Silence is
+ * not a refusal: the gateway asks the machine what it holds, and a job it
+ * holds counts as accepted. When a dispatch ends without that, the row is
+ * resolved with the error and every job is cancelled, so a dispatch still
+ * queued for a machine that was away never runs later. A machine-command row is resolved with its command's
+ * reply. Other commands are tracked for their reply and logged. A command the
+ * codec has no message for is unsupported: nothing is sent or awaited.
+ */
+import type { LineDef } from '../../../lib/machines/line';
+import { type LineCodec } from '../../../lib/machines/protocol';
+import type { MachineBus } from '../../../lib/machines/transport';
+import { type Action } from './actions';
+import { type LineEscalations } from './escalations';
+import { type GatewayLog } from './log';
+import type { CommandReply, ReplyWaiter } from './reply-waiter';
+import { type GatewayState } from './state';
+export interface DispatcherDeps {
+    bus: MachineBus;
+    codec: LineCodec;
+    line: LineDef;
+    lt: LineEscalations;
+    replies: ReplyWaiter;
+    state: GatewayState;
+    replyTimeoutMs: number;
+    dispatchAttempts: number;
+    log: GatewayLog;
+}
+type DispatchAction = Extract<Action, {
+    kind: 'dispatch';
+}>;
+type CommandAction = Extract<Action, {
+    kind: 'command';
+}>;
+type ControlAction = Extract<Action, {
+    kind: 'control';
+}>;
+export declare class Dispatcher {
+    private readonly d;
+    constructor(d: DispatcherDeps);
+    /** False when the codec has no message for the command. */
+    publish(machineId: string, op: string, cmdId: string, args: Record<string, any>): Promise<boolean>;
+    /** Publish and wait for the reply, asking again with the same id; null when none came. */
+    ask(machineId: string, op: string, cmdId: string, args: Record<string, any>): Promise<CommandReply | null>;
+    command(a: CommandAction): Promise<void>;
+    /**
+     * A machine-command row: send it, then resolve the row with the reply, as the
+     * machine that gave it. The command expires when the asking ends, so one that
+     * reaches a machine after its row resolved no-reply is refused, never run.
+     */
+    control(a: ControlAction): Promise<void>;
+    dispatch(a: DispatchAction): Promise<void>;
+    /** The units were already at the machine: its acceptance completes the handoff. */
+    private received;
+    /** Ask a silent machine what it holds; null when it cannot say or does not answer in time. */
+    private heldJobs;
+    private check;
+    /** Cancel jobs the machine accepted or may still receive; replies are only logged. */
+    private withdraw;
+}
+export {};

package/build/services/machines/gateway/dispatcher.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Commands to machines and their replies. A dispatch becomes one command per
+ * job (gateway/jobs.ts); missing replies are asked for again with the same
+ * command ids, and the row is claimed once every job is accepted. Silence is
+ * not a refusal: the gateway asks the machine what it holds, and a job it
+ * holds counts as accepted. When a dispatch ends without that, the row is
+ * resolved with the error and every job is cancelled, so a dispatch still
+ * queued for a machine that was away never runs later. A machine-command row is resolved with its command's
+ * reply. Other commands are tracked for their reply and logged. A command the
+ * codec has no message for is unsupported: nothing is sent or awaited.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatcher = void 0;
+const promises_1 = require("timers/promises");
+const contracts_1 = require("../contracts");
+const registration_1 = require("./registration");
+const protocol_1 = require("../../../lib/machines/protocol");
+const actions_1 = require("./actions");
+const escalations_1 = require("./escalations");
+const jobs_1 = require("./jobs");
+const log_1 = require("./log");
+const state_1 = require("./state");
+/** A reply the machine sent, as opposed to none or an unsupported command. */
+function fromMachine(reply) {
+    return !!reply && reply.status !== contracts_1.COMMAND_STATUS.UNSUPPORTED;
+}
+/** The machine took the work: recorded it, or already has it ready. */
+function took(reply) {
+    return reply?.status === protocol_1.REPLY_STATUS.ACCEPTED || reply?.status === protocol_1.REPLY_STATUS.COMPLETED;
+}
+class Dispatcher {
+    constructor(d) {
+        this.d = d;
+    }
+    /** False when the codec has no message for the command. */
+    async publish(machineId, op, cmdId, args) {
+        const wires = this.d.codec.encode((0, registration_1.identFor)(this.d.state, this.d.line, machineId), { cmdId, op, args });
+        for (const wire of wires)
+            await this.d.bus.publish(wire.topic, wire.payload);
+        return wires.length > 0;
+    }
+    /** Publish and wait for the reply, asking again with the same id; null when none came. */
+    async ask(machineId, op, cmdId, args) {
+        for (let attempt = 1; attempt <= this.d.dispatchAttempts; attempt++) {
+            const waiting = this.d.replies.wait(cmdId, this.d.replyTimeoutMs);
+            if (!await this.publish(machineId, op, cmdId, args)) {
+                this.d.replies.settle({ cmdId, status: contracts_1.COMMAND_STATUS.UNSUPPORTED, reason: `the line's codec has no ${op} command` });
+            }
+            const reply = await waiting;
+            if (reply)
+                return reply;
+        }
+        return null;
+    }
+    async command(a) {
+        const reply = await this.ask(a.machineId, a.op, a.cmdId, a.args);
+        if (!reply)
+            this.d.log.warn(log_1.GATEWAY_LOG.COMMAND_UNANSWERED, { machine: a.machineId, op: a.op, cmdId: a.cmdId });
+        else if (reply.status === contracts_1.COMMAND_STATUS.UNSUPPORTED)
+            this.d.log.info(log_1.GATEWAY_LOG.COMMAND_UNSUPPORTED, { machine: a.machineId, op: a.op });
+        else if (reply.status !== protocol_1.REPLY_STATUS.ACCEPTED) {
+            this.d.log.warn(log_1.GATEWAY_LOG.COMMAND_REFUSED, { machine: a.machineId, op: a.op, cmdId: a.cmdId, status: reply.status, reason: reply.reason });
+        }
+    }
+    /**
+     * A machine-command row: send it, then resolve the row with the reply, as the
+     * machine that gave it. The command expires when the asking ends, so one that
+     * reaches a machine after its row resolved no-reply is refused, never run.
+     */
+    async control(a) {
+        const expiresAt = Date.now() + this.d.replyTimeoutMs * this.d.dispatchAttempts;
+        const reply = await this.ask(a.machineId, a.op, a.cmdId, { ...a.args, expiresAt: (0, protocol_1.isoTs)(expiresAt) });
+        // Timers may fire a little early; the command must have expired before the row says no-reply.
+        if (!reply && Date.now() <= expiresAt)
+            await (0, promises_1.setTimeout)(expiresAt - Date.now() + 1);
+        const outcome = reply
+            ? { accepted: reply.status === protocol_1.REPLY_STATUS.ACCEPTED, machineId: a.machineId, op: a.op, status: reply.status, reason: reply.reason }
+            : { accepted: false, machineId: a.machineId, op: a.op, status: contracts_1.COMMAND_STATUS.NO_REPLY, reason: `no reply after ${this.d.dispatchAttempts} attempts` };
+        const context = { row: a.rowId, machine: a.machineId, op: a.op, status: outcome.status, reason: outcome.reason };
+        if (outcome.accepted)
+            this.d.log.info(log_1.GATEWAY_LOG.COMMANDED, context);
+        else
+            this.d.log.warn(!reply ? log_1.GATEWAY_LOG.COMMAND_UNANSWERED : fromMachine(reply) ? log_1.GATEWAY_LOG.COMMAND_REFUSED : log_1.GATEWAY_LOG.COMMAND_UNSUPPORTED, context);
+        this.check(a.rowId, 'resolve', await this.d.lt.resolve(fromMachine(reply) ? a.machineId : actions_1.CONTROLLER, a.rowId, outcome));
+    }
+    async dispatch(a) {
+        const { lt, state, log } = this.d;
+        if (a.receivedOnAccept) {
+            // An arrival may be delivered again after the job went out; send it once.
+            const row = state.get(a.rowId);
+            if (row?.dispatch !== state_1.DISPATCH_STATE.ARRIVING)
+                return;
+            row.dispatch = state_1.DISPATCH_STATE.PENDING;
+        }
+        const jobs = (0, jobs_1.dispatchJobs)(a.args.jobId, a.args.units, state.unitsPerDispatch);
+        // Known before any reply, so a failure that follows an acceptance finds its row.
+        for (const job of jobs)
+            state.rememberDispatch(`${a.cmdId}${job.suffix}`, a.rowId);
+        const replies = await Promise.all(jobs.map((job) => this.ask(a.machineId, protocol_1.OP.DISPATCH, `${a.cmdId}${job.suffix}`, { ...a.args, jobId: job.jobId, units: job.units })));
+        const refused = replies.find((r) => r && !took(r));
+        const silent = jobs.filter((_, i) => !replies[i]);
+        const held = !refused && silent.length ? await this.heldJobs(a.machineId, a.cmdId) : null;
+        const reconciled = !!held && silent.every((j) => held.has(j.jobId));
+        const row = state.get(a.rowId);
+        if (!refused && (!silent.length || reconciled)) {
+            if (row)
+                row.dispatch = state_1.DISPATCH_STATE.ACCEPTED;
+            if (reconciled)
+                log.info(log_1.GATEWAY_LOG.DISPATCH_RECONCILED, { row: a.rowId, machine: a.machineId, jobs: silent.map((j) => j.jobId) });
+            log.info(log_1.GATEWAY_LOG.DISPATCHED, { row: a.rowId, machine: a.machineId, reason: replies.map((r) => r?.reason ?? 'held').join('; ') });
+            this.check(a.rowId, 'claim', await lt.claim(a.machineId, a.rowId));
+            if (a.receivedOnAccept)
+                await this.received(a);
+            return;
+        }
+        // The handoff may have ended meanwhile: a machine that ran the job anyway reports the arrival.
+        if (!row)
+            return;
+        row.dispatch = state_1.DISPATCH_STATE.REFUSED;
+        const unanswered = `${a.machineId} sent no reply after ${this.d.dispatchAttempts} attempts`;
+        const resolution = refused
+            ? { received: false, errorCode: contracts_1.HANDOFF_ERROR.DISPATCH_REFUSED, detail: `${a.machineId} ${refused.status}: ${refused.reason}` }
+            : { received: false, errorCode: contracts_1.HANDOFF_ERROR.NO_REPLY, detail: held ? `${unanswered} and does not hold the job` : `${unanswered}; its state is unknown` };
+        log.warn(log_1.GATEWAY_LOG.DISPATCH_REFUSED, { row: a.rowId, machine: a.machineId, ...resolution });
+        const ended = await lt.resolve(fromMachine(refused ?? null) ? a.machineId : actions_1.CONTROLLER, a.rowId, resolution);
+        this.check(a.rowId, 'resolve', ended);
+        state.close(a.rowId);
+        if (ended.outcome !== escalations_1.VERB_OUTCOME.DONE)
+            return;
+        await this.withdraw(a, jobs.filter((_, i) => !replies[i] || took(replies[i])));
+    }
+    /** The units were already at the machine: its acceptance completes the handoff. */
+    async received(a) {
+        const units = a.args.units.map((u) => u.unitId);
+        this.check(a.rowId, 'resolve', await this.d.lt.resolve(a.machineId, a.rowId, { received: true, receiver: a.machineId, units }));
+        this.d.state.close(a.rowId);
+    }
+    /** Ask a silent machine what it holds; null when it cannot say or does not answer in time. */
+    async heldJobs(machineId, cmdId) {
+        const waiting = this.d.replies.waitSnapshot(machineId, this.d.replyTimeoutMs);
+        if (!await this.publish(machineId, protocol_1.OP.SNAPSHOT, `${cmdId}:status`, {}))
+            this.d.replies.settleSnapshot(machineId, null);
+        return waiting;
+    }
+    check(rowId, verb, result) {
+        if (result.outcome === escalations_1.VERB_OUTCOME.INVALID)
+            this.d.log.error(log_1.GATEWAY_LOG.VERB_INVALID, { action: verb, row: rowId, detail: result.detail });
+    }
+    /** Cancel jobs the machine accepted or may still receive; replies are only logged. */
+    async withdraw(a, jobs) {
+        await Promise.all(jobs.map((job) => this.command({
+            kind: 'command', machineId: a.machineId, op: protocol_1.OP.CANCEL, cmdId: `${(0, contracts_1.cancelCommandId)(a.rowId)}${job.suffix}`, args: { jobId: job.jobId },
+        })));
+    }
+}
+exports.Dispatcher = Dispatcher;

package/build/services/machines/gateway/escalations.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The escalation verbs the gateway performs, as an interface so the executor
+ * runs the same against Long Tail over HTTP or an in-memory fake. Outcomes
+ * the gateway treats as done (the row already ended, or the claim is already
+ * held) are not errors: replays and races land there.
+ */
+import type { OpenRowQuery } from '../rows';
+import type { Actor, CreateRowInput } from './actions';
+export declare const VERB_OUTCOME: {
+    readonly DONE: "done";
+    /** 404, or 409 because the row already ended: nothing left to do. */
+    readonly ALREADY: "already";
+    /** 422: the payload does not satisfy the role's form schema. */
+    readonly INVALID: "invalid";
+};
+export type VerbOutcome = typeof VERB_OUTCOME[keyof typeof VERB_OUTCOME];
+export interface VerbResult {
+    outcome: VerbOutcome;
+    detail?: string;
+    /** The HTTP status behind an `already` or `invalid` outcome. */
+    status?: number;
+    /** After an accumulate: the item keys the row now holds, when the response carries them. */
+    itemKeys?: string[];
+}
+export interface RowItem {
+    itemKey: string;
+    payload: Record<string, any>;
+}
+export interface LineEscalations {
+    claim(as: Actor, id: string): Promise<VerbResult>;
+    /** `metadata` is merged (shallow) into the row's metadata in the same statement as the item. */
+    accumulate(as: Actor, id: string, itemKey: string, payload: Record<string, any>, metadata?: Record<string, any>): Promise<VerbResult>;
+    resolve(as: Actor, id: string, payload: Record<string, any>): Promise<VerbResult>;
+    create(as: Actor, input: CreateRowInput): Promise<{
+        id: string;
+    }>;
+    /** The item keys an accumulator row holds. */
+    itemKeys(id: string): Promise<string[]>;
+    /** The items an accumulator row holds, with their payloads. */
+    items(id: string): Promise<RowItem[]>;
+    /** The stored row, as the controller sees it; null when it does not exist or the controller may not read it. */
+    get(id: string): Promise<Record<string, any> | null>;
+    /** Every pending row matching each given field, oldest first, in the projection escalation events carry. */
+    listOpen(query: OpenRowQuery): Promise<Record<string, any>[]>;
+}
+/** Rows per page when reading open rows back. */
+export declare const OPEN_PAGE = 500;
+/** Read every page of `page(offset)`, oldest first, until a short page. */
+export declare function readAllPages(page: (offset: number) => Promise<Record<string, any>[]>): Promise<Record<string, any>[]>;
+/** Map an HTTP status to a verb outcome; anything else is a real failure. */
+export declare function verbOutcomeOf(status: number): VerbOutcome | null;

package/build/services/machines/gateway/escalations.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * The escalation verbs the gateway performs, as an interface so the executor
+ * runs the same against Long Tail over HTTP or an in-memory fake. Outcomes
+ * the gateway treats as done (the row already ended, or the claim is already
+ * held) are not errors: replays and races land there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPEN_PAGE = exports.VERB_OUTCOME = void 0;
+exports.readAllPages = readAllPages;
+exports.verbOutcomeOf = verbOutcomeOf;
+exports.VERB_OUTCOME = {
+    DONE: 'done',
+    /** 404, or 409 because the row already ended: nothing left to do. */
+    ALREADY: 'already',
+    /** 422: the payload does not satisfy the role's form schema. */
+    INVALID: 'invalid',
+};
+/** Rows per page when reading open rows back. */
+exports.OPEN_PAGE = 500;
+/** Read every page of `page(offset)`, oldest first, until a short page. */
+async function readAllPages(page) {
+    const rows = [];
+    for (let offset = 0;; offset += exports.OPEN_PAGE) {
+        const batch = await page(offset);
+        rows.push(...batch);
+        if (batch.length < exports.OPEN_PAGE)
+            return rows;
+    }
+}
+/** Map an HTTP status to a verb outcome; anything else is a real failure. */
+function verbOutcomeOf(status) {
+    if (status >= 200 && status < 300)
+        return exports.VERB_OUTCOME.DONE;
+    if (status === 404 || status === 409)
+        return exports.VERB_OUTCOME.ALREADY;
+    if (status === 422)
+        return exports.VERB_OUTCOME.INVALID;
+    return null;
+}

package/build/services/machines/gateway/executor.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Runs the planner's actions: escalation verbs through LineEscalations,
+ * dispatches and commands through the Dispatcher, alarm and machine rows,
+ * and the offline debounce. A verb that fails for real throws, so the message that
+ * caused it is delivered again.
+ */
+import { type LineDef } from '../../../lib/machines/line';
+import { type LineCodec } from '../../../lib/machines/protocol';
+import type { MachineBus } from '../../../lib/machines/transport';
+import { type Action } from './actions';
+import type { AddressBook } from './address-book';
+import { type LineEscalations } from './escalations';
+import { type GatewayLog } from './log';
+import type { ReplyWaiter } from './reply-waiter';
+import type { GatewayState } from './state';
+export interface ExecutorDeps {
+    bus: MachineBus;
+    lt: LineEscalations;
+    replies: ReplyWaiter;
+    state: GatewayState;
+    line: LineDef;
+    codec: LineCodec;
+    replyTimeoutMs: number;
+    dispatchAttempts: number;
+    offlineDebounceMs: number;
+    log: GatewayLog;
+    /** Where learned addresses are kept (registration.ts). */
+    addresses: AddressBook;
+}
+export declare class Executor {
+    private readonly d;
+    private inflight;
+    private quietPending;
+    private timers;
+    private readonly dispatcher;
+    constructor(d: ExecutorDeps);
+    /** Dispatches and commands run detached so one slow reply never holds up the feed. */
+    apply(actions: Action[]): Promise<void>;
+    /** Resolves when every detached dispatch has finished. */
+    idle(): Promise<void>;
+    stop(): void;
+    private track;
+    private run;
+    /** A dispatch's second reply: ready, or a failure to prepare that ends the handoff. */
+    private lateReply;
+    /** Add the item; when the row then holds every key the action waits for, resolve it. */
+    private accumulate;
+    private check;
+    private createAlarmRow;
+    /** Raise a quiet row for each connected machine silent longer than `quietMs`. */
+    checkQuiet(machineIds: string[], quietMs: number): void;
+    private raiseQuiet;
+    private watchOffline;
+    private raiseOffline;
+}