@hotmeshio/long-tail 0.27.0 → 0.28.1

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

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * The line as its leader sees it, for the dashboard: each machine's link,
+ * held units, open rows and alarms from the gateway state, and the claims
+ * waiting for a person. Pure: reads the state and the line, changes nothing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectLine = projectLine;
+const line_1 = require("../../../lib/machines/line");
+const protocol_1 = require("../../../lib/machines/protocol");
+const at = (ms) => (ms ? (0, protocol_1.isoTs)(ms) : null);
+function addressOf(state, line, def) {
+    if ((0, line_1.learnsAddress)(line, def.machineId))
+        return state.learnedAddress(def.machineId) ?? null;
+    return def.address ?? def.machineId;
+}
+function alarmsOf(state, machineId) {
+    return [...state.alarms.values()]
+        .filter((track) => track.machineId === machineId)
+        .map((track) => ({ alarmId: track.alarmId, level: track.level ?? '', raisedAt: track.raisedAt ?? '', rowId: track.rowId ?? null }));
+}
+/** The handoff that brought a unit into a machine: open first, then the recently closed one. */
+function rowCarrying(state, machineId, unitId) {
+    const into = (r) => r.toMachine === machineId;
+    return state.openFor(unitId, into) ?? state.closedFor(unitId, into);
+}
+function machineView(state, line, def) {
+    const m = def.machineId;
+    const link = state.links.get(m);
+    const open = state.open();
+    return {
+        machineId: m, process: def.process, role: (0, line_1.machineRole)(def), address: addressOf(state, line, def),
+        online: link ? link.online : null, since: at(link?.since), lastSeen: at(link?.lastSeen),
+        software: link?.software ?? null, bootId: link?.bootId ?? null, sessionId: link?.sessionId ?? null,
+        heldUnits: state.heldUnitsAt(m).map(({ unitId }) => {
+            const row = rowCarrying(state, m, unitId);
+            return { unitId, carrierId: row?.units.find((u) => u.unitId === unitId)?.carrierId ?? null, rowId: row?.id ?? '' };
+        }),
+        rows: {
+            handoff: open.filter((r) => r.toMachine === m).length,
+            command: state.openCommandsFor(m),
+            alarm: [...state.alarms.values()].filter((t) => t.machineId === m && t.open && !!t.rowId).length,
+            offlineRowId: link?.rowId ?? null, quietRowId: link?.quietRowId ?? null,
+        },
+        alarms: alarmsOf(state, m),
+        jobs: link?.jobs ?? [],
+    };
+}
+function projectLine(state, line) {
+    return {
+        siteId: line.siteId, lineId: line.lineId, leading: true, takenAt: at(state.takenAt),
+        machines: line.machines.map((def) => machineView(state, line, def)),
+        contested: state.contested(),
+    };
+}

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

@@ -9,6 +9,7 @@
 import { type LineCodec, type MachineIdent } from '../../../lib/machines/protocol';
 import type { MachineBus } from '../../../lib/machines/transport';
 import { type GatewayLog } from './log';
+import type { WireRecorder } from './wire';
 /** Most message ids one receipt carries. */
 export declare const MAX_RECEIPT_IDS = 100;
 export interface ReceiptDeps {
@@ -17,6 +18,8 @@ export interface ReceiptDeps {
     /** How long ids gather before a receipt goes out. */
     delayMs: number;
     log: GatewayLog;
+    /** Records each receipt the gateway sends, for the line's wire view. */
+    wire?: Pick<WireRecorder, 'receipt'>;
 }
 export declare class ReceiptBatcher {
     private readonly d;

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

@@ -58,8 +58,10 @@ class ReceiptBatcher {
         this.sending.add(work);
     }
     async publish(ident, ids) {
-        for (const wire of this.d.codec.receipt(ident, ids))
+        for (const wire of this.d.codec.receipt(ident, ids)) {
             await this.d.bus.publish(wire.topic, wire.payload);
+            this.d.wire?.receipt(ident, ids, wire);
+        }
     }
 }
 exports.ReceiptBatcher = ReceiptBatcher;

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

@@ -22,8 +22,8 @@ async function restoreLineRows(state, lt, line) {
     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 });
+        const { machineId, alarmId, raisedAt, level } = row.metadata;
+        state.alarms.set(state.alarmKey(machineId, alarmId), { machineId, alarmId, raisedAt, level, rowId: row.id, open: true });
     }
     for (const row of offline) {
         const link = state.link(row.metadata.machineId);
@@ -33,7 +33,7 @@ async function restoreLineRows(state, lt, line) {
     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);
+        state.raiseClaim(row.metadata.address, row.metadata.machineId, row.id);
     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. */

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

@@ -106,7 +106,7 @@ function planRegistrationRow(state, line, event) {
     if (typeof md.machineId !== 'string' || typeof md.address !== 'string')
         return [];
     if (event.verb === 'created') {
-        state.raiseClaim(md.address, md.machineId);
+        state.raiseClaim(md.address, md.machineId, event.escalationId);
         return [];
     }
     state.settleClaim(md.address, md.machineId);

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

@@ -1,12 +1,17 @@
 /**
  * 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.
+ * deadline. Several waits on one key are all settled by the next answer, so
+ * two dispatches asking one machine what it holds share its next snapshot.
  */
 export interface CommandReply {
     cmdId: string;
     status: string;
     reason: string;
+    /** The machine's structured code for the outcome, when its reply carried one. */
+    code?: string;
+    /** An acceptance the machine will follow with `completed` or `failed` once the job is prepared. */
+    preparing?: boolean;
 }
 /** The jobs a machine reports holding, queued or in work. */
 export type HeldJobs = Set<string>;
@@ -16,9 +21,9 @@ export declare class ReplyWaiter {
     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. */
+    /** The next snapshot from `machineId`, or null at the deadline; every wait in flight for the machine gets it. */
     waitSnapshot(machineId: string, timeoutMs: number): Promise<HeldJobs | null>;
-    /** Answer a status query in flight; null when there is nothing to wait for. */
+    /** Answer the status queries 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

@@ -2,7 +2,8 @@
 /**
  * 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.
+ * deadline. Several waits on one key are all settled by the next answer, so
+ * two dispatches asking one machine what it holds share its next snapshot.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReplyWaiter = void 0;
@@ -11,31 +12,51 @@ class Waits {
         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 });
+            const waiter = {
+                resolve,
+                timer: setTimeout(() => {
+                    this.drop(key, waiter);
+                    resolve(null);
+                }, timeoutMs),
+            };
+            let waiters = this.waiting.get(key);
+            if (!waiters) {
+                waiters = new Set();
+                this.waiting.set(key, waiters);
+            }
+            waiters.add(waiter);
         });
     }
+    /** True when at least one waiter took the value. */
     settle(key, value) {
-        const w = this.waiting.get(key);
-        if (!w)
+        const waiters = this.waiting.get(key);
+        if (!waiters)
             return false;
-        clearTimeout(w.timer);
         this.waiting.delete(key);
-        w.resolve(value);
+        for (const w of waiters) {
+            clearTimeout(w.timer);
+            w.resolve(value);
+        }
         return true;
     }
     cancelAll() {
-        for (const [, w] of this.waiting) {
-            clearTimeout(w.timer);
-            w.resolve(null);
+        for (const waiters of this.waiting.values()) {
+            for (const w of waiters) {
+                clearTimeout(w.timer);
+                w.resolve(null);
+            }
         }
         this.waiting.clear();
     }
+    drop(key, waiter) {
+        const waiters = this.waiting.get(key);
+        if (!waiters)
+            return;
+        waiters.delete(waiter);
+        if (!waiters.size)
+            this.waiting.delete(key);
+    }
 }
 class ReplyWaiter {
     constructor() {
@@ -49,11 +70,11 @@ class ReplyWaiter {
     settle(reply) {
         return this.replies.settle(reply.cmdId, reply);
     }
-    /** The next snapshot from `machineId`, or null at the deadline. */
+    /** The next snapshot from `machineId`, or null at the deadline; every wait in flight for the machine gets it. */
     waitSnapshot(machineId, timeoutMs) {
         return this.snapshots.wait(machineId, timeoutMs);
     }
-    /** Answer a status query in flight; null when there is nothing to wait for. */
+    /** Answer the status queries in flight; null when there is nothing to wait for. */
     settleSnapshot(machineId, jobs) {
         this.snapshots.settle(machineId, jobs);
     }

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

@@ -5,6 +5,8 @@
  * machine's link: presence, last message, software and boot id.
  */
 import type { HandoffFacets, TraceEntry } from '../contracts';
+import type { LineDef } from '../../../lib/machines/line';
+import type { ContestedClaimView, LineView } from '../../../types/machines-view';
 /**
  * WAITING: the machine has no room yet (pacing.ts); the row waits in its role queue.
  * ARRIVING: the job goes out once its units arrive at the receiver (codec `dispatchOn: arrival`).
@@ -33,6 +35,8 @@ export interface HandoffRow extends HandoffFacets {
     trace?: TraceEntry[];
     /** Each unit's arrival event, as its receiver reported it (dispatch on arrival). */
     arrivals?: Record<string, Record<string, any>>;
+    /** Dispatch commands accepted as preparing; on arrival dispatch the row is received once each is ready. */
+    awaitingReady?: Set<string>;
     /** Lifecycle item keys already on the row (lifecycle.ts). */
     noted?: string[];
     /** Parked with a limit on its items, which lifecycle notes must never use up. */
@@ -47,6 +51,7 @@ export interface AlarmTrack {
     alarmId: string;
     /** When the machine raised it; a reused alarm id with a new time is a new alarm. */
     raisedAt?: string;
+    level?: string;
     rowId?: string;
     /** Created and not yet resolved by anyone. */
     open: boolean;
@@ -62,12 +67,25 @@ export interface LinkTrack {
     watching?: boolean;
     software?: string;
     bootId?: string;
+    /** The machine's connection, when its presence names one; a new one while online is a reconnect to resync. */
+    sessionId?: string;
+    /** Why the machine went offline, when its presence said. */
+    reason?: string;
+    /** The jobs its last snapshot listed, as the codec reported them. */
+    jobs?: unknown[];
+}
+/** One unit a machine holds: the job it arrived under. */
+export interface HeldUnit {
+    unitId: string;
+    jobId: string;
 }
 export declare class GatewayState {
     /** Units one dispatch may carry, from the codec; null when any number may. */
     unitsPerDispatch: number | null;
     /** Jobs go to a receiver once its units arrive there, from the codec. */
     dispatchOnArrival: boolean;
+    /** Commands of the machines' own that a machine-command row may ask for, from the codec. */
+    rowOps: readonly string[];
     /** Note each job's start, progress steps and pauses on the row that holds it (lifecycle.ts). */
     lifecycle: boolean;
     /** Active alarms are retained on the broker; otherwise snapshots list them (codec.ts retainedAlarms). */
@@ -82,11 +100,16 @@ export declare class GatewayState {
     holdDispatch: boolean;
     /** Units at each machine that arrived and have not left: machine → unit → job. */
     private held;
+    /** Jobs sent and taken, by machine: job → the row that sent it, kept while the machine holds the job's units. */
+    private sentJobs;
+    /** Jobs whose units left each machine since its last snapshot: they ended, a snapshot without them lost nothing. */
+    private endedJobs;
     private openRows;
     private closedRows;
     readonly alarms: Map<string, AlarmTrack>;
     /** Finished records that came before their row: machine/unit → job body. */
     private earlyFinishes;
+    /** Open machine-command rows → the machine each commands. */
     private openCommands;
     /** Accepted dispatch command ids → their row, so a later failure finds the row. */
     private dispatches;
@@ -97,7 +120,7 @@ export declare class GatewayState {
     /** Learned addresses, both ways: station → address and address → station. */
     private addressOfStation;
     private stationOfAddress;
-    /** Contested claims already raised as registration rows, `${address}>${station}`. */
+    /** Contested claims already raised as registration rows, `${address}>${station}` → the row. */
     private claims;
     /** Contested claims heard from the machines themselves, `${address}>${station}`. */
     private heard;
@@ -105,6 +128,8 @@ export declare class GatewayState {
     private strangers;
     index(row: HandoffRow): void;
     get(id: string): HandoffRow | undefined;
+    /** A row that ended, while the gateway still remembers it. */
+    closedRow(id: string): HandoffRow | undefined;
     close(id: string, ended?: RowEnd): HandoffRow | undefined;
     isClosed(id: string): boolean;
     open(): HandoffRow[];
@@ -113,10 +138,26 @@ export declare class GatewayState {
     closedFor(unitId: string, pred: (r: HandoffRow) => boolean): HandoffRow | undefined;
     hold(machineId: string, unitId: string, jobId: string): void;
     letGo(machineId: string, unitId: string): void;
+    /** A job the machine took, remembered by its row while the machine holds the job's units. */
+    rememberSent(machineId: string, jobId: string, rowId: string): void;
+    /**
+     * After a restart, the jobs the machine lost: those its units are held under
+     * or its last snapshot listed, that the new snapshot lacks and no open row
+     * will send again. `resend` names the rows remembered for them; `unknown`
+     * the jobs nothing is remembered for.
+     */
+    lostAfterReboot(machineId: string, listed: Set<string>): {
+        resend: {
+            jobId: string;
+            row: HandoffRow;
+        }[];
+        unknown: string[];
+    };
     /** The job a unit arrived under at `machineId`, while it is still there. */
     heldJob(machineId: string, unitId: string): string | undefined;
     heldAt(machineId: string): string[];
-    /** Keep only units whose job the machine still lists (its snapshot). */
+    heldUnitsAt(machineId: string): HeldUnit[];
+    /** Keep only units whose job the machine still lists (its snapshot); a job it no longer lists is over. */
     keepHeld(machineId: string, jobIds: Set<string>): void;
     /** Keep a sender's finished record until its row is known, so an arrival cannot close the row without it. */
     rememberFinish(machineId: string, unitId: string, body: Record<string, any>): void;
@@ -125,14 +166,18 @@ export declare class GatewayState {
     /** The row a dispatch command belongs to, open or recently closed. */
     rowForDispatch(cmdId: string): HandoffRow | undefined;
     /** Track a machine-command row; false when it is already tracked or has ended. */
-    trackCommand(id: string): boolean;
+    trackCommand(id: string, machineId?: string): boolean;
+    /** Open machine-command rows for one machine. */
+    openCommandsFor(machineId: string): number;
     endCommand(id: string): void;
     /** Bind a station to an address, replacing whatever either was bound to before. */
     bindAddress(machineId: string, address: string): void;
     learnedAddress(machineId: string): string | undefined;
     stationAt(address: string): string | undefined;
     claimRaised(address: string, machineId: string): boolean;
-    raiseClaim(address: string, machineId: string): void;
+    raiseClaim(address: string, machineId: string, rowId?: string): void;
+    /** The contested claims waiting for a person, with the rows that ask. */
+    contested(): ContestedClaimView[];
     settleClaim(address: string, machineId: string): void;
     hearClaim(address: string, machineId: string): void;
     claimHeard(address: string, machineId: string): boolean;
@@ -142,4 +187,8 @@ export declare class GatewayState {
     raiseViolation(key: string): void;
     link(machineId: string, now?: number): LinkTrack;
     alarmKey(machineId: string, alarmId: string): string;
+    /** The line as this gateway sees it (project.ts). */
+    project(line: LineDef): LineView;
+    /** A copy a dry run may change without touching the line. */
+    clone(): GatewayState;
 }

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

@@ -7,6 +7,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayState = exports.ROW_END = exports.DISPATCH_STATE = void 0;
+const jobs_1 = require("./jobs");
+const project_1 = require("./project");
 const trace_1 = require("./trace");
 /**
  * WAITING: the machine has no room yet (pacing.ts); the row waits in its role queue.
@@ -16,6 +18,10 @@ exports.DISPATCH_STATE = {
     NONE: 'none', WAITING: 'waiting', ARRIVING: 'arriving', PENDING: 'pending', ACCEPTED: 'accepted', REFUSED: 'refused',
 };
 exports.ROW_END = { RESOLVED: 'resolved', CANCELLED: 'cancelled', EXPIRED: 'expired' };
+function copyInto(from, into, clone = (v) => v) {
+    for (const [k, v] of from)
+        into.set(k, clone(v));
+}
 const CLOSED_LIMIT = 2_000;
 class GatewayState {
     constructor() {
@@ -23,6 +29,8 @@ class GatewayState {
         this.unitsPerDispatch = null;
         /** Jobs go to a receiver once its units arrive there, from the codec. */
         this.dispatchOnArrival = false;
+        /** Commands of the machines' own that a machine-command row may ask for, from the codec. */
+        this.rowOps = [];
         /** Note each job's start, progress steps and pauses on the row that holds it (lifecycle.ts). */
         this.lifecycle = false;
         /** Active alarms are retained on the broker; otherwise snapshots list them (codec.ts retainedAlarms). */
@@ -37,12 +45,17 @@ class GatewayState {
         this.holdDispatch = false;
         /** Units at each machine that arrived and have not left: machine → unit → job. */
         this.held = new Map();
+        /** Jobs sent and taken, by machine: job → the row that sent it, kept while the machine holds the job's units. */
+        this.sentJobs = new Map();
+        /** Jobs whose units left each machine since its last snapshot: they ended, a snapshot without them lost nothing. */
+        this.endedJobs = new Map();
         this.openRows = new Map();
         this.closedRows = new Map();
         this.alarms = new Map();
         /** Finished records that came before their row: machine/unit → job body. */
         this.earlyFinishes = new Map();
-        this.openCommands = new Set();
+        /** Open machine-command rows → the machine each commands. */
+        this.openCommands = new Map();
         /** Accepted dispatch command ids → their row, so a later failure finds the row. */
         this.dispatches = new Map();
         this.endedCommands = new Set();
@@ -52,8 +65,8 @@ class GatewayState {
         /** Learned addresses, both ways: station → address and address → station. */
         this.addressOfStation = new Map();
         this.stationOfAddress = new Map();
-        /** Contested claims already raised as registration rows, `${address}>${station}`. */
-        this.claims = new Set();
+        /** Contested claims already raised as registration rows, `${address}>${station}` → the row. */
+        this.claims = new Map();
         /** Contested claims heard from the machines themselves, `${address}>${station}`. */
         this.heard = new Set();
         /** Addresses heard that claim no station, logged once each. */
@@ -67,13 +80,17 @@ class GatewayState {
         this.openRows.set(row.id, existing
             ? {
                 ...row, dispatch: existing.dispatch, trace: (0, trace_1.mergeTrace)(row.trace, existing.trace), arrivals: existing.arrivals,
-                dueAt: existing.dueAt, noted: existing.noted ?? row.noted,
+                dueAt: existing.dueAt, noted: existing.noted ?? row.noted, awaitingReady: existing.awaitingReady,
             }
             : row);
     }
     get(id) {
         return this.openRows.get(id);
     }
+    /** A row that ended, while the gateway still remembers it. */
+    closedRow(id) {
+        return this.closedRows.get(id);
+    }
     close(id, ended = exports.ROW_END.RESOLVED) {
         const row = this.openRows.get(id);
         if (!row)
@@ -107,7 +124,53 @@ class GatewayState {
         this.held.get(machineId).set(unitId, jobId);
     }
     letGo(machineId, unitId) {
-        this.held.get(machineId)?.delete(unitId);
+        const units = this.held.get(machineId);
+        const jobId = units?.get(unitId);
+        units?.delete(unitId);
+        if (jobId === undefined || [...units.values()].includes(jobId))
+            return;
+        this.sentJobs.get(machineId)?.delete(jobId);
+        if (!this.endedJobs.has(machineId))
+            this.endedJobs.set(machineId, new Set());
+        this.endedJobs.get(machineId).add(jobId);
+    }
+    /** A job the machine took, remembered by its row while the machine holds the job's units. */
+    rememberSent(machineId, jobId, rowId) {
+        if (!this.sentJobs.has(machineId))
+            this.sentJobs.set(machineId, new Map());
+        this.sentJobs.get(machineId).set(jobId, rowId);
+    }
+    /**
+     * After a restart, the jobs the machine lost: those its units are held under
+     * or its last snapshot listed, that the new snapshot lacks and no open row
+     * will send again. `resend` names the rows remembered for them; `unknown`
+     * the jobs nothing is remembered for.
+     */
+    lostAfterReboot(machineId, listed) {
+        const link = this.links.get(machineId);
+        const before = new Set(this.heldAt(machineId));
+        for (const job of link?.jobs ?? [])
+            if (typeof job?.jobId === 'string')
+                before.add(job.jobId);
+        const ended = this.endedJobs.get(machineId) ?? new Set();
+        const sendsAgain = new Set();
+        for (const row of this.openRows.values()) {
+            if (row.toMachine === machineId)
+                for (const job of (0, jobs_1.dispatchJobs)(row.jobId, row.units, this.unitsPerDispatch))
+                    sendsAgain.add(job.jobId);
+        }
+        const resend = [];
+        const unknown = [];
+        for (const jobId of before) {
+            if (listed.has(jobId) || ended.has(jobId) || sendsAgain.has(jobId))
+                continue;
+            const row = this.closedRows.get(this.sentJobs.get(machineId)?.get(jobId) ?? '');
+            if (row)
+                resend.push({ jobId, row });
+            else
+                unknown.push(jobId);
+        }
+        return { resend, unknown };
     }
     /** The job a unit arrived under at `machineId`, while it is still there. */
     heldJob(machineId, unitId) {
@@ -116,14 +179,21 @@ class GatewayState {
     heldAt(machineId) {
         return [...(this.held.get(machineId)?.values() ?? [])];
     }
-    /** Keep only units whose job the machine still lists (its snapshot). */
+    heldUnitsAt(machineId) {
+        return [...(this.held.get(machineId)?.entries() ?? [])].map(([unitId, jobId]) => ({ unitId, jobId }));
+    }
+    /** Keep only units whose job the machine still lists (its snapshot); a job it no longer lists is over. */
     keepHeld(machineId, jobIds) {
+        this.endedJobs.delete(machineId);
         const units = this.held.get(machineId);
         if (!units)
             return;
-        for (const [unitId, jobId] of units)
-            if (!jobIds.has(jobId))
-                units.delete(unitId);
+        for (const [unitId, jobId] of units) {
+            if (jobIds.has(jobId))
+                continue;
+            units.delete(unitId);
+            this.sentJobs.get(machineId)?.delete(jobId);
+        }
     }
     /** Keep a sender's finished record until its row is known, so an arrival cannot close the row without it. */
     rememberFinish(machineId, unitId, body) {
@@ -154,12 +224,16 @@ class GatewayState {
         return rowId ? this.openRows.get(rowId) ?? this.closedRows.get(rowId) : undefined;
     }
     /** Track a machine-command row; false when it is already tracked or has ended. */
-    trackCommand(id) {
+    trackCommand(id, machineId = '') {
         if (this.openCommands.has(id) || this.endedCommands.has(id))
             return false;
-        this.openCommands.add(id);
+        this.openCommands.set(id, machineId);
         return true;
     }
+    /** Open machine-command rows for one machine. */
+    openCommandsFor(machineId) {
+        return [...this.openCommands.values()].filter((m) => m === machineId).length;
+    }
     endCommand(id) {
         this.openCommands.delete(id);
         this.endedCommands.add(id);
@@ -189,8 +263,15 @@ class GatewayState {
     claimRaised(address, machineId) {
         return this.claims.has(`${address}>${machineId}`);
     }
-    raiseClaim(address, machineId) {
-        this.claims.add(`${address}>${machineId}`);
+    raiseClaim(address, machineId, rowId) {
+        this.claims.set(`${address}>${machineId}`, rowId ?? this.claims.get(`${address}>${machineId}`) ?? null);
+    }
+    /** The contested claims waiting for a person, with the rows that ask. */
+    contested() {
+        return [...this.claims.entries()].map(([key, rowId]) => {
+            const [address, station] = key.split('>');
+            return { address, station, rowId: rowId ?? '' };
+        });
     }
     settleClaim(address, machineId) {
         this.claims.delete(`${address}>${machineId}`);
@@ -234,6 +315,40 @@ class GatewayState {
     alarmKey(machineId, alarmId) {
         return `${machineId}/${alarmId}`;
     }
+    /** The line as this gateway sees it (project.ts). */
+    project(line) {
+        return (0, project_1.projectLine)(this, line);
+    }
+    /** A copy a dry run may change without touching the line. */
+    clone() {
+        const copy = new GatewayState();
+        Object.assign(copy, {
+            unitsPerDispatch: this.unitsPerDispatch, dispatchOnArrival: this.dispatchOnArrival, rowOps: this.rowOps, lifecycle: this.lifecycle,
+            retainedAlarms: this.retainedAlarms, readingRetained: this.readingRetained, takenAt: this.takenAt, progressStep: this.progressStep, holdDispatch: this.holdDispatch,
+        });
+        copyInto(this.held, copy.held, (units) => new Map(units));
+        copyInto(this.sentJobs, copy.sentJobs, (jobs) => new Map(jobs));
+        copyInto(this.endedJobs, copy.endedJobs, (jobs) => new Set(jobs));
+        copyInto(this.openRows, copy.openRows, (row) => ({ ...row, units: [...row.units], ...(row.noted ? { noted: [...row.noted] } : {}) }));
+        copyInto(this.closedRows, copy.closedRows, (row) => ({ ...row }));
+        copyInto(this.alarms, copy.alarms, (track) => ({ ...track, ...(track.noted ? { noted: [...track.noted] } : {}) }));
+        copyInto(this.earlyFinishes, copy.earlyFinishes);
+        copyInto(this.openCommands, copy.openCommands);
+        copyInto(this.dispatches, copy.dispatches);
+        copyInto(this.links, copy.links, (link) => ({ ...link }));
+        copyInto(this.addressOfStation, copy.addressOfStation);
+        copyInto(this.stationOfAddress, copy.stationOfAddress);
+        copyInto(this.claims, copy.claims);
+        for (const id of this.endedCommands)
+            copy.endedCommands.add(id);
+        for (const key of this.violations)
+            copy.violations.add(key);
+        for (const key of this.heard)
+            copy.heard.add(key);
+        for (const key of this.strangers)
+            copy.strangers.add(key);
+        return copy;
+    }
 }
 exports.GatewayState = GatewayState;
 function carries(row, unitId) {

package/build/services/machines/gateway/wire-window.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The last wire events of a line, kept by its leader so a client reads the
+ * tape over HTTP instead of the event stream. A ring of a fixed size; reads
+ * are newest first and may narrow by machine, direction, kind and time.
+ */
+import type { WireDirection, WireEvent, WireKind, WireWindowQuery } from '../../../types/machines-view';
+export declare const DEFAULT_WIRE_WINDOW = 500;
+export declare const MAX_WIRE_PAGE = 500;
+export declare class WireWindow {
+    readonly size: number;
+    private readonly events;
+    private head;
+    private count;
+    constructor(size?: number);
+    push(event: WireEvent): void;
+    /** Newest first, narrowed by the query, at most `limit` (the window's size when absent). */
+    read(query?: WireWindowQuery): WireEvent[];
+    get length(): number;
+}
+export declare function isWireDirection(v: unknown): v is WireDirection;
+export declare function isWireKind(v: unknown): v is WireKind;