@hotmeshio/long-tail 0.25.4 → 0.27.0

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

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Identities. Each machine acts in Long Tail as its own bot account, so the
+ * rows it claims and resolves name the machine beside the people who worked
+ * the unit; the gateway's own bot (the controller) raises operator rows. At
+ * boot the gateway logs in, makes sure every bot exists with its roles, and
+ * mints a fresh session key per bot, revoking the previous one.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_KEY_NAME = void 0;
+exports.lineIdentities = lineIdentities;
+exports.adminToken = adminToken;
+exports.provisionIdentities = provisionIdentities;
+const protocol_1 = require("../../../lib/machines/protocol");
+const line_1 = require("../../../lib/machines/line");
+const actions_1 = require("./actions");
+exports.SESSION_KEY_NAME = 'machine-gateway-session';
+/** The bots a line needs: one per machine, plus the controller. */
+function lineIdentities(line) {
+    const stations = (0, line_1.stationRoles)(line);
+    const machines = line.machines.map((m) => ({
+        actor: m.machineId,
+        botName: `machine-${(0, protocol_1.clientIdOf)((0, line_1.identOf)(line, m.machineId))}`,
+        roles: [...stations, ...(0, line_1.receiverRoles)(line)],
+    }));
+    const controller = {
+        actor: actions_1.CONTROLLER,
+        botName: (0, line_1.controllerId)(line),
+        roles: [...stations, ...(0, line_1.receiverRoles)(line), (0, line_1.operatorRole)(line)],
+    };
+    return [controller, ...machines];
+}
+/** A builder token: LT_GATEWAY_TOKEN when set, otherwise a username/password login. */
+async function adminToken(http, env) {
+    if (env.LT_GATEWAY_TOKEN)
+        return env.LT_GATEWAY_TOKEN;
+    const username = env.LT_GATEWAY_USERNAME;
+    const password = env.LT_GATEWAY_PASSWORD;
+    if (!username || !password)
+        throw new Error('the gateway needs LT_GATEWAY_TOKEN, or LT_GATEWAY_USERNAME and LT_GATEWAY_PASSWORD');
+    const { token } = await http.request('POST', '/auth/login', null, { username, password });
+    return token;
+}
+async function ensureBot(http, admin, identity) {
+    const page = await http.request('GET', `/bot-accounts?search=${encodeURIComponent(identity.botName)}&limit=50`, admin);
+    const found = page.bots.find((b) => b.external_id === identity.botName);
+    if (found) {
+        const { roles } = await http.request('GET', `/bot-accounts/${found.id}/roles`, admin);
+        const held = new Set(roles.map((r) => r.role));
+        for (const role of identity.roles.filter((r) => !held.has(r))) {
+            await http.request('POST', `/bot-accounts/${found.id}/roles`, admin, { role, type: 'member' });
+        }
+        return found.id;
+    }
+    const bot = await http.request('POST', '/bot-accounts', admin, {
+        name: identity.botName,
+        display_name: identity.actor === actions_1.CONTROLLER ? 'Line controller' : identity.actor,
+        description: identity.actor === actions_1.CONTROLLER ? 'Machine gateway: raises line-operator rows' : `Machine ${identity.actor} on the line`,
+        roles: identity.roles.map((role) => ({ role, type: 'member' })),
+    });
+    return bot.id;
+}
+async function mintSessionKey(http, admin, botId) {
+    const { keys } = await http.request('GET', `/bot-accounts/${botId}/api-keys`, admin);
+    for (const key of keys.filter((k) => k.name === exports.SESSION_KEY_NAME)) {
+        await http.request('DELETE', `/bot-accounts/${botId}/api-keys/${key.id}`, admin);
+    }
+    const { rawKey } = await http.request('POST', `/bot-accounts/${botId}/api-keys`, admin, { name: exports.SESSION_KEY_NAME });
+    return rawKey;
+}
+/** Ensure every bot and mint its session key; returns actor → bearer token. */
+async function provisionIdentities(http, admin, line) {
+    const tokens = new Map();
+    for (const identity of lineIdentities(line)) {
+        const botId = await ensureBot(http, admin, identity);
+        tokens.set(identity.actor, await mintSessionKey(http, admin, botId));
+    }
+    return tokens;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Application receipts. A machine that keeps an outbox until the line
+ * controller confirms each event gets that confirmation here: once the
+ * gateway is done with a message, its id joins a batch for that machine, and
+ * the batch goes out through the codec after a short delay or when full. A
+ * replayed event is confirmed again, so a machine that missed a receipt stops
+ * resending.
+ */
+import { type LineCodec, type MachineIdent } from '../../../lib/machines/protocol';
+import type { MachineBus } from '../../../lib/machines/transport';
+import { type GatewayLog } from './log';
+/** Most message ids one receipt carries. */
+export declare const MAX_RECEIPT_IDS = 100;
+export interface ReceiptDeps {
+    bus: MachineBus;
+    codec: Pick<LineCodec, 'receipt'>;
+    /** How long ids gather before a receipt goes out. */
+    delayMs: number;
+    log: GatewayLog;
+}
+export declare class ReceiptBatcher {
+    private readonly d;
+    private batches;
+    private sending;
+    constructor(d: ReceiptDeps);
+    /** Whether the codec sends receipts at all. */
+    get enabled(): boolean;
+    add(ident: MachineIdent, messageId: string): void;
+    /** Send every batch now and wait for the sends. */
+    flush(): Promise<void>;
+    private send;
+    private publish;
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Application receipts. A machine that keeps an outbox until the line
+ * controller confirms each event gets that confirmation here: once the
+ * gateway is done with a message, its id joins a batch for that machine, and
+ * the batch goes out through the codec after a short delay or when full. A
+ * replayed event is confirmed again, so a machine that missed a receipt stops
+ * resending.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiptBatcher = exports.MAX_RECEIPT_IDS = void 0;
+const protocol_1 = require("../../../lib/machines/protocol");
+const log_1 = require("./log");
+/** Most message ids one receipt carries. */
+exports.MAX_RECEIPT_IDS = 100;
+class ReceiptBatcher {
+    constructor(d) {
+        this.d = d;
+        this.batches = new Map();
+        this.sending = new Set();
+    }
+    /** Whether the codec sends receipts at all. */
+    get enabled() {
+        return !!this.d.codec.receipt;
+    }
+    add(ident, messageId) {
+        if (!this.enabled)
+            return;
+        const key = (0, protocol_1.addressOf)(ident);
+        let batch = this.batches.get(key);
+        if (!batch) {
+            batch = { ident, ids: new Set() };
+            this.batches.set(key, batch);
+        }
+        batch.ids.add(messageId);
+        if (batch.ids.size >= exports.MAX_RECEIPT_IDS)
+            this.send(key);
+        else
+            batch.timer ??= setTimeout(() => this.send(key), this.d.delayMs);
+    }
+    /** Send every batch now and wait for the sends. */
+    async flush() {
+        for (const key of [...this.batches.keys()])
+            this.send(key);
+        await Promise.all([...this.sending]);
+    }
+    send(key) {
+        const batch = this.batches.get(key);
+        if (!batch)
+            return;
+        this.batches.delete(key);
+        if (batch.timer)
+            clearTimeout(batch.timer);
+        const ids = [...batch.ids];
+        const work = this.publish(batch.ident, ids)
+            .catch((err) => this.d.log.warn(log_1.GATEWAY_LOG.RECEIPT_FAILED, { machine: batch.ident.machineId, ids: ids.length, error: String(err?.message ?? err) }))
+            .finally(() => this.sending.delete(work));
+        this.sending.add(work);
+    }
+    async publish(ident, ids) {
+        for (const wire of this.d.codec.receipt(ident, ids))
+            await this.d.bus.publish(wire.topic, wire.payload);
+    }
+}
+exports.ReceiptBatcher = ReceiptBatcher;

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

@@ -0,0 +1,35 @@
+/**
+ * What a gateway restores when it starts leading a line, read back from Long
+ * Tail: the alarm, offline and quiet rows it raised before, so a clear or a
+ * return that comes later still resolves them; and the units each open
+ * handoff saw arrive, so the receiver holds them again.
+ */
+import { type LineDef } from '../../../lib/machines/line';
+import type { AddressBook } from './address-book';
+import type { Action } from './actions';
+import type { LineEscalations } from './escalations';
+import { type GatewayState } from './state';
+export interface RestoredRows {
+    alarms: number;
+    offline: number;
+    quiet: number;
+    registrations: number;
+}
+export declare function restoreLineRows(state: GatewayState, lt: LineEscalations, line: LineDef): Promise<RestoredRows>;
+/** The addresses the line learned before, for the stations that still learn theirs. */
+export declare function restoreAddresses(state: GatewayState, book: AddressBook, line: LineDef): Promise<number>;
+/** Alarm rows whose alarm the machine no longer holds: it cleared while no gateway was listening. */
+export declare function alarmsClearedMeanwhile(state: GatewayState, active: Set<string>): {
+    key: string;
+    rowId: string;
+    machineId: string;
+}[];
+/**
+ * Units that arrived at an open handoff's receiver, read from the row's items:
+ * the receiver holds them again, so a timeout leaves their job alone. A row
+ * whose units all arrived completes; one dispatched on arrival is sent with the
+ * arrivals it holds.
+ */
+export declare function arrivalsOnRows(state: GatewayState, lt: LineEscalations, dispatchTtlMs: number): Promise<Action[]>;
+/** With lifecycle notes on, the items each handoff out of a machine already holds, so a restart notes nothing twice. */
+export declare function notesOnRows(state: GatewayState, lt: LineEscalations): Promise<void>;

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

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * What a gateway restores when it starts leading a line, read back from Long
+ * Tail: the alarm, offline and quiet rows it raised before, so a clear or a
+ * return that comes later still resolves them; and the units each open
+ * handoff saw arrive, so the receiver holds them again.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreLineRows = restoreLineRows;
+exports.restoreAddresses = restoreAddresses;
+exports.alarmsClearedMeanwhile = alarmsClearedMeanwhile;
+exports.arrivalsOnRows = arrivalsOnRows;
+exports.notesOnRows = notesOnRows;
+const contracts_1 = require("../contracts");
+const line_1 = require("../../../lib/machines/line");
+const jobs_1 = require("./jobs");
+const pacing_1 = require("./pacing");
+const state_1 = require("./state");
+async function restoreLineRows(state, lt, line) {
+    const role = (0, line_1.operatorRole)(line);
+    const mine = (row) => row.metadata?.siteId === line.siteId && row.metadata?.lineId === line.lineId && row.metadata?.machineId;
+    const [alarms, offline, quiet, registrations] = await Promise.all([contracts_1.ROW_TYPE.ALARM, contracts_1.ROW_TYPE.MACHINE_OFFLINE, contracts_1.ROW_TYPE.MACHINE_QUIET, contracts_1.ROW_TYPE.MACHINE_REGISTRATION]
+        .map(async (type) => (await lt.listOpen({ type, role })).filter(mine)));
+    for (const row of alarms) {
+        const { machineId, alarmId, raisedAt } = row.metadata;
+        state.alarms.set(state.alarmKey(machineId, alarmId), { machineId, alarmId, raisedAt, rowId: row.id, open: true });
+    }
+    for (const row of offline) {
+        const link = state.link(row.metadata.machineId);
+        link.online = false;
+        link.rowId = row.id;
+    }
+    for (const row of quiet)
+        state.link(row.metadata.machineId).quietRowId = row.id;
+    for (const row of registrations)
+        state.raiseClaim(row.metadata.address, row.metadata.machineId);
+    return { alarms: alarms.length, offline: offline.length, quiet: quiet.length, registrations: registrations.length };
+}
+/** The addresses the line learned before, for the stations that still learn theirs. */
+async function restoreAddresses(state, book, line) {
+    let restored = 0;
+    for (const [machineId, address] of await book.load()) {
+        if (!(0, line_1.learnsAddress)(line, machineId))
+            continue;
+        state.bindAddress(machineId, address);
+        restored++;
+    }
+    return restored;
+}
+/** Alarm rows whose alarm the machine no longer holds: it cleared while no gateway was listening. */
+function alarmsClearedMeanwhile(state, active) {
+    return [...state.alarms.entries()]
+        .filter(([key, t]) => t.open && t.rowId && !active.has(key))
+        .map(([key, t]) => ({ key, rowId: t.rowId, machineId: t.machineId }));
+}
+/**
+ * Units that arrived at an open handoff's receiver, read from the row's items:
+ * the receiver holds them again, so a timeout leaves their job alone. A row
+ * whose units all arrived completes; one dispatched on arrival is sent with the
+ * arrivals it holds.
+ */
+async function arrivalsOnRows(state, lt, dispatchTtlMs) {
+    const actions = [];
+    for (const row of state.open()) {
+        const to = row.toMachine;
+        if (!to || (row.dispatch !== state_1.DISPATCH_STATE.ARRIVING && row.dispatch !== state_1.DISPATCH_STATE.ACCEPTED))
+            continue;
+        const items = await lt.items(row.id);
+        row.noted = items.map((i) => i.itemKey);
+        const units = row.units.map((u) => u.unitId);
+        const { arrived, missing } = (0, contracts_1.handoffProgress)(units, items);
+        for (const job of (0, jobs_1.dispatchJobs)(row.jobId, row.units, state.unitsPerDispatch)) {
+            for (const u of job.units)
+                if (arrived.includes(u.unitId))
+                    state.hold(to, u.unitId, job.jobId);
+        }
+        if (missing.length)
+            continue;
+        if (row.dispatch === state_1.DISPATCH_STATE.ACCEPTED) {
+            actions.push({ kind: 'resolve', as: to, rowId: row.id, payload: { received: true, receiver: to, units } });
+            continue;
+        }
+        const byUnit = new Map(items.filter((i) => (0, contracts_1.arrivedUnit)(i.itemKey)).map((i) => [i.payload.unitId, i.payload]));
+        row.arrivals = Object.fromEntries(units.map((u) => [u, byUnit.get(u)?.arrival ?? { unitId: u, carrierId: byUnit.get(u)?.carrierId ?? null }]));
+        for (const arrival of byUnit.values())
+            row.dueAt = (0, pacing_1.latestArrival)(row.dueAt, arrival.at);
+        actions.push((0, pacing_1.dispatchAction)(row, to, dispatchTtlMs));
+    }
+    return actions;
+}
+/** With lifecycle notes on, the items each handoff out of a machine already holds, so a restart notes nothing twice. */
+async function notesOnRows(state, lt) {
+    if (!state.lifecycle)
+        return;
+    for (const row of state.open()) {
+        if (row.fromMachine && !row.noted)
+            row.noted = (await lt.items(row.id)).map((i) => i.itemKey);
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Learned addresses. On a line that learns them, a station is bound to the
+ * address that first claims it. A claim that disagrees with a binding (a
+ * station already bound to another address, or an address bound to another
+ * station) is a person's decision: one registration row per claim, and the
+ * claimant's messages have no effect until it is approved. Lines that declare
+ * their addresses pass through unchanged.
+ */
+import { type LineDef } from '../../../lib/machines/line';
+import { type Inspection, type MachineIdent } from '../../../lib/machines/protocol';
+import type { EscalationEvent } from '../../../lib/machines/transport';
+import type { Action, CreateRowInput } from './actions';
+import type { GatewayState } from './state';
+export declare const SENDER: {
+    readonly KNOWN: "known";
+    readonly BOUND: "bound";
+    readonly CONTESTED: "contested";
+    readonly UNKNOWN: "unknown";
+};
+export type SenderStatus = typeof SENDER[keyof typeof SENDER];
+export interface Sender {
+    status: SenderStatus;
+    address: string;
+    /** The station the message is from (known, bound) or claims to be (contested). */
+    machineId?: string;
+    /** The inspection with the station as its machine id; set when the message may be acted on. */
+    seen?: Inspection;
+}
+/** Who sent a message: a known station, one bound just now, a contested claim, or no station at all. */
+export declare function resolveSender(state: GatewayState, line: LineDef, seen: Inspection): Sender;
+/** A station's identity on the wire, with the address the line learned for it. */
+export declare function identFor(state: GatewayState, line: LineDef, machineId: string): MachineIdent;
+/** Whether the gateway knows where to send to a station: a declared address, or one it learned. */
+export declare function reachable(state: GatewayState, line: LineDef, machineId: string): boolean;
+/** The row asking a person whether `address` is `machineId`. */
+export declare function registrationRow(state: GatewayState, line: LineDef, address: string, machineId: string): CreateRowInput;
+/** A person decided a registration row: approval binds the station to the claimant; anything else leaves the binding. */
+export declare function planRegistrationRow(state: GatewayState, line: LineDef, event: EscalationEvent): Action[];

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

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Learned addresses. On a line that learns them, a station is bound to the
+ * address that first claims it. A claim that disagrees with a binding (a
+ * station already bound to another address, or an address bound to another
+ * station) is a person's decision: one registration row per claim, and the
+ * claimant's messages have no effect until it is approved. Lines that declare
+ * their addresses pass through unchanged.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SENDER = void 0;
+exports.resolveSender = resolveSender;
+exports.identFor = identFor;
+exports.reachable = reachable;
+exports.registrationRow = registrationRow;
+exports.planRegistrationRow = planRegistrationRow;
+const contracts_1 = require("../contracts");
+const line_1 = require("../../../lib/machines/line");
+const protocol_1 = require("../../../lib/machines/protocol");
+exports.SENDER = { KNOWN: 'known', BOUND: 'bound', CONTESTED: 'contested', UNKNOWN: 'unknown' };
+const onLine = (line, machineId) => !!machineId && line.machines.some((m) => m.machineId === machineId);
+function declaredAt(line, machineId, address) {
+    return onLine(line, machineId) && !(0, line_1.learnsAddress)(line, machineId) && (0, protocol_1.addressOf)((0, line_1.identOf)(line, machineId)) === address;
+}
+function asStation(seen, machineId, address) {
+    return { ...seen, parsed: { ...seen.parsed, ident: { ...seen.parsed.ident, machineId, address } } };
+}
+/** Who sent a message: a known station, one bound just now, a contested claim, or no station at all. */
+function resolveSender(state, line, seen) {
+    const ident = seen.parsed.ident;
+    const address = ident.address ?? ident.machineId;
+    if (line.addressing !== line_1.ADDRESSING.LEARNED)
+        return { status: exports.SENDER.KNOWN, address, machineId: ident.machineId, seen };
+    // A station whose address the line declares is known only on that address.
+    if (declaredAt(line, ident.machineId, address))
+        return { status: exports.SENDER.KNOWN, address, machineId: ident.machineId, seen };
+    const claim = seen.claim ?? (ident.address ? ident.machineId : undefined);
+    const bound = state.stationAt(address);
+    if (bound) {
+        if (claim && claim !== bound)
+            return { status: exports.SENDER.CONTESTED, address, machineId: claim };
+        return { status: exports.SENDER.KNOWN, address, machineId: bound, seen: asStation(seen, bound, address) };
+    }
+    if (!onLine(line, claim) || !(0, line_1.learnsAddress)(line, claim))
+        return { status: exports.SENDER.UNKNOWN, address };
+    if (state.learnedAddress(claim))
+        return { status: exports.SENDER.CONTESTED, address, machineId: claim };
+    return { status: exports.SENDER.BOUND, address, machineId: claim, seen: asStation(seen, claim, address) };
+}
+/** A station's identity on the wire, with the address the line learned for it. */
+function identFor(state, line, machineId) {
+    const learned = (0, line_1.learnsAddress)(line, machineId) ? state.learnedAddress(machineId) : undefined;
+    return { ...(0, line_1.identOf)(line, machineId), ...(learned ? { address: learned } : {}) };
+}
+/** Whether the gateway knows where to send to a station: a declared address, or one it learned. */
+function reachable(state, line, machineId) {
+    return !(0, line_1.learnsAddress)(line, machineId) || !!state.learnedAddress(machineId);
+}
+/** The row asking a person whether `address` is `machineId`. */
+function registrationRow(state, line, address, machineId) {
+    const boundAddress = state.learnedAddress(machineId) ?? null;
+    const boundStation = state.stationAt(address) ?? null;
+    const now = [
+        boundAddress ? `${machineId} is bound to ${boundAddress}` : null,
+        boundStation ? `${address} is bound to ${boundStation}` : null,
+    ].filter(Boolean).join('; ');
+    return {
+        type: contracts_1.ROW_TYPE.MACHINE_REGISTRATION, role: (0, line_1.operatorRole)(line), priority: 2,
+        description: `${address} says it is ${machineId}. ${now}. Approve to bind ${machineId} to ${address}.`,
+        metadata: { siteId: line.siteId, lineId: line.lineId, machineId, address, boundAddress, boundStation },
+    };
+}
+/** A row's resolver payload, which Long Tail stores serialized. */
+function resolutionOf(raw) {
+    if (raw && typeof raw === 'object')
+        return raw;
+    if (typeof raw !== 'string')
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Why an approved registration may not bind; null when it may. The row is only a request:
+ * the station must learn its address, the address must be one a machine could send from,
+ * and a machine at that address must have claimed the station on the wire.
+ */
+function bindingRefusal(state, line, machineId, address) {
+    if (!onLine(line, machineId) || !(0, line_1.learnsAddress)(line, machineId))
+        return `${machineId} is not a station on this line that learns its address`;
+    if (!(0, protocol_1.isTopicLevel)(address))
+        return `"${address}" is not an address a machine can send from`;
+    if (line.machines.some((m) => declaredAt(line, m.machineId, address)))
+        return `${address} is the declared address of another station`;
+    if (!state.claimHeard(address, machineId))
+        return `no machine at ${address} has claimed ${machineId} since this gateway took the line`;
+    return null;
+}
+/** A person decided a registration row: approval binds the station to the claimant; anything else leaves the binding. */
+function planRegistrationRow(state, line, event) {
+    const md = event.data?.metadata ?? {};
+    if (typeof md.machineId !== 'string' || typeof md.address !== 'string')
+        return [];
+    if (event.verb === 'created') {
+        state.raiseClaim(md.address, md.machineId);
+        return [];
+    }
+    state.settleClaim(md.address, md.machineId);
+    const approved = event.verb === 'resolved' && resolutionOf(event.data?.resolver_payload)?.decision === contracts_1.DECISION.APPROVE;
+    const by = event.data?.resolved_by ?? event.data?.metadata?.resolved_by ?? undefined;
+    if (!approved)
+        return [];
+    const reason = bindingRefusal(state, line, md.machineId, md.address);
+    return reason
+        ? [{ kind: 'refuseBinding', machineId: md.machineId, address: md.address, reason }]
+        : [{ kind: 'bindAddress', machineId: md.machineId, address: md.address, by }];
+}

package/build/services/machines/gateway/reply-waiter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Command replies by cmdId, and machine snapshots by machine. A wait registers
+ * before the command is published and resolves with the reply, or null at the
+ * deadline.
+ */
+export interface CommandReply {
+    cmdId: string;
+    status: string;
+    reason: string;
+}
+/** The jobs a machine reports holding, queued or in work. */
+export type HeldJobs = Set<string>;
+export declare class ReplyWaiter {
+    private replies;
+    private snapshots;
+    wait(cmdId: string, timeoutMs: number): Promise<CommandReply | null>;
+    /** True when a waiter took the reply. */
+    settle(reply: CommandReply): boolean;
+    /** The next snapshot from `machineId`, or null at the deadline. */
+    waitSnapshot(machineId: string, timeoutMs: number): Promise<HeldJobs | null>;
+    /** Answer a status query in flight; null when there is nothing to wait for. */
+    settleSnapshot(machineId: string, jobs: HeldJobs | null): void;
+    cancelAll(): void;
+}

package/build/services/machines/gateway/reply-waiter.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Command replies by cmdId, and machine snapshots by machine. A wait registers
+ * before the command is published and resolves with the reply, or null at the
+ * deadline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplyWaiter = void 0;
+class Waits {
+    constructor() {
+        this.waiting = new Map();
+    }
+    wait(key, timeoutMs) {
+        this.waiting.get(key)?.resolve(null);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.waiting.delete(key);
+                resolve(null);
+            }, timeoutMs);
+            this.waiting.set(key, { resolve, timer });
+        });
+    }
+    settle(key, value) {
+        const w = this.waiting.get(key);
+        if (!w)
+            return false;
+        clearTimeout(w.timer);
+        this.waiting.delete(key);
+        w.resolve(value);
+        return true;
+    }
+    cancelAll() {
+        for (const [, w] of this.waiting) {
+            clearTimeout(w.timer);
+            w.resolve(null);
+        }
+        this.waiting.clear();
+    }
+}
+class ReplyWaiter {
+    constructor() {
+        this.replies = new Waits();
+        this.snapshots = new Waits();
+    }
+    wait(cmdId, timeoutMs) {
+        return this.replies.wait(cmdId, timeoutMs);
+    }
+    /** True when a waiter took the reply. */
+    settle(reply) {
+        return this.replies.settle(reply.cmdId, reply);
+    }
+    /** The next snapshot from `machineId`, or null at the deadline. */
+    waitSnapshot(machineId, timeoutMs) {
+        return this.snapshots.wait(machineId, timeoutMs);
+    }
+    /** Answer a status query in flight; null when there is nothing to wait for. */
+    settleSnapshot(machineId, jobs) {
+        this.snapshots.settle(machineId, jobs);
+    }
+    cancelAll() {
+        this.replies.cancelAll();
+        this.snapshots.cancelAll();
+    }
+}
+exports.ReplyWaiter = ReplyWaiter;