@hotmeshio/long-tail 0.26.0 → 0.28.0

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.d.ts

@@ -31,3 +31,5 @@ export declare function alarmsClearedMeanwhile(state: GatewayState, active: Set<
  * 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

@@ -10,6 +10,7 @@ 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");
@@ -21,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);
@@ -32,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. */
@@ -65,6 +66,7 @@ async function arrivalsOnRows(state, lt, dispatchTtlMs) {
         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)) {
@@ -80,7 +82,18 @@ async function arrivalsOnRows(state, lt, dispatchTtlMs) {
         }
         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.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,15 @@
 /**
  * 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;
 }
 /** The jobs a machine reports holding, queued or in work. */
 export type HeldJobs = Set<string>;
@@ -16,9 +19,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,15 +35,26 @@ 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>>;
+    /** 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. */
+    capped?: boolean;
+    /** When the row was created (epoch ms). */
+    createdAt?: number;
+    /** When its last unit arrived (epoch ms, dispatch on arrival); its dispatch windows count from here, else from createdAt. */
+    dueAt?: number;
 }
 export interface AlarmTrack {
     machineId: string;
     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;
+    /** Rows the alarm paused, noted again when it clears. */
+    noted?: string[];
 }
 export interface LinkTrack {
     online: boolean;
@@ -52,12 +65,35 @@ 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). */
+    retainedAlarms: boolean;
+    /** Reading the broker's retained messages on taking the line; a snapshot read back may be older than its alarms. */
+    readingRetained: boolean;
+    /** When this gateway took the line (epoch ms); a command for an older row may have been sent by an earlier one. */
+    takenAt: number;
+    /** With lifecycle notes, progress is noted each time it crosses this many percent; 0 notes none. */
+    progressStep: number;
     /** While reconciling, new handoffs wait so pacing sees the whole line before anything is sent. */
     holdDispatch: boolean;
     /** Units at each machine that arrived and have not left: machine → unit → job. */
@@ -67,6 +103,7 @@ export declare class GatewayState {
     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;
@@ -77,7 +114,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;
@@ -96,23 +133,28 @@ export declare class GatewayState {
     /** The job a unit arrived under at `machineId`, while it is still there. */
     heldJob(machineId: string, unitId: string): string | undefined;
     heldAt(machineId: string): string[];
+    heldUnitsAt(machineId: string): HeldUnit[];
     /** Keep only units whose job the machine still lists (its snapshot). */
     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;
     takeFinish(machineId: string, unitId: string): Record<string, any> | undefined;
     rememberDispatch(cmdId: string, rowId: string): void;
-    /** The open row an accepted dispatch command belongs to. */
+    /** 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;
@@ -122,4 +164,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,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayState = exports.ROW_END = exports.DISPATCH_STATE = void 0;
+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 +17,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 +28,18 @@ 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). */
+        this.retainedAlarms = false;
+        /** Reading the broker's retained messages on taking the line; a snapshot read back may be older than its alarms. */
+        this.readingRetained = false;
+        /** When this gateway took the line (epoch ms); a command for an older row may have been sent by an earlier one. */
+        this.takenAt = 0;
+        /** With lifecycle notes, progress is noted each time it crosses this many percent; 0 notes none. */
+        this.progressStep = 25;
         /** While reconciling, new handoffs wait so pacing sees the whole line before anything is sent. */
         this.holdDispatch = false;
         /** Units at each machine that arrived and have not left: machine → unit → job. */
@@ -32,7 +49,8 @@ class GatewayState {
         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();
@@ -42,8 +60,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. */
@@ -55,7 +73,10 @@ class GatewayState {
         const existing = this.openRows.get(row.id);
         // An event may carry metadata older than what the gateway already wrote: keep both traces.
         this.openRows.set(row.id, existing
-            ? { ...row, dispatch: existing.dispatch, trace: (0, trace_1.mergeTrace)(row.trace, existing.trace), arrivals: existing.arrivals }
+            ? {
+                ...row, dispatch: existing.dispatch, trace: (0, trace_1.mergeTrace)(row.trace, existing.trace), arrivals: existing.arrivals,
+                dueAt: existing.dueAt, noted: existing.noted ?? row.noted,
+            }
             : row);
     }
     get(id) {
@@ -103,6 +124,9 @@ class GatewayState {
     heldAt(machineId) {
         return [...(this.held.get(machineId)?.values() ?? [])];
     }
+    heldUnitsAt(machineId) {
+        return [...(this.held.get(machineId)?.entries() ?? [])].map(([unitId, jobId]) => ({ unitId, jobId }));
+    }
     /** Keep only units whose job the machine still lists (its snapshot). */
     keepHeld(machineId, jobIds) {
         const units = this.held.get(machineId);
@@ -135,18 +159,22 @@ class GatewayState {
                 this.dispatches.delete(oldest);
         }
     }
-    /** The open row an accepted dispatch command belongs to. */
+    /** The row a dispatch command belongs to, open or recently closed. */
     rowForDispatch(cmdId) {
         const rowId = this.dispatches.get(cmdId);
-        return rowId ? this.openRows.get(rowId) : undefined;
+        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);
@@ -176,8 +204,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}`);
@@ -221,6 +256,38 @@ 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.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.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The wire record. Every message a gateway reads, and every command,
+ * snapshot request and receipt it sends, becomes one WireEvent for the
+ * line's view: what was on the wire, how the codec read it, and what the
+ * gateway did about it. Telemetry is left out unless the line asks for it.
+ */
+import { type Inspection, type MachineCommand, type MachineIdent, type WireMessage } from '../../../lib/machines/protocol';
+import { type InboundMessage } from '../../../lib/machines/transport';
+import type { WireAction, WireEvent } from '../../../types/machines-view';
+import type { Action } from './actions';
+import type { Applied } from './admission';
+export type WireSink = (event: WireEvent) => void;
+export declare const WIRE_EVENT_TYPE = "machine.wire";
+export declare const WIRE_DIRECTION: {
+    readonly IN: "in";
+    readonly OUT: "out";
+};
+export interface WireOptions {
+    /** Publish telemetry messages too. */
+    telemetry?: boolean;
+}
+interface WireLine {
+    siteId: string;
+    lineId: string;
+}
+/** The sender a message was read as, when it differs from the topic's. */
+export interface WireSender {
+    machineId: string | null;
+    address: string | null;
+}
+export declare class WireRecorder {
+    private readonly line;
+    private readonly sink;
+    private readonly opts;
+    constructor(line: WireLine, sink: WireSink, opts?: WireOptions);
+    /** A decoded inbound message and what the gateway did with it. */
+    inbound(msg: InboundMessage, seen: Inspection, applied: Applied, deliveries: number, sender?: WireSender): void;
+    /** A message the codec could not read, or one that is not a machine's. */
+    unreadable(msg: InboundMessage, detail: string, verb?: WireAction['verb']): void;
+    /** A command the gateway sent, as the codec put it on the wire. */
+    command(ident: MachineIdent, command: MachineCommand, wire: WireMessage): void;
+    /** A receipt confirming the messages the gateway is done with. */
+    receipt(ident: MachineIdent, ids: string[], wire: WireMessage): void;
+    private outbound;
+}
+/** The event name within the kind: job event, alarm action, command op, reply status. */
+export declare function eventOf(seen: Inspection): string | null;
+/** One line from the kind, the event and the ids the body names. */
+export declare function summarize(seen: Inspection): string;
+/** The record of an inbound message before the gateway's actions are known. */
+export declare function describeInbound(line: WireLine, msg: InboundMessage, seen: Inspection, sender?: WireSender): Omit<WireEvent, 'actions'>;
+/** What handling a message came to, as actions; a message with none is acknowledged, or waits for its row. */
+export declare function appliedActions(applied: Applied, deliveries: number, maxDeliveries?: number): WireAction[];
+/** A message no row has claimed after this many deliveries is not racing its row. */
+export declare const MAX_DELIVERIES = 30;
+/** A planner action as the wire would record it, before it runs; a dry run shows these. */
+export declare function plannedAction(a: Action): WireAction;
+export {};