@hotmeshio/long-tail 0.25.4 → 0.27.0

package/build/services/machines/contracts.d.ts

@@ -0,0 +1,210 @@
+/**
+ * What the unit workflow and the machine gateway agree on: row types, roles,
+ * the metadata a handoff row carries, error codes and resolution shapes. A
+ * handoff row is the same for a machine resolver and a person; only the
+ * protocol that resolves it differs.
+ */
+export declare const ROW_TYPE: {
+    readonly HANDOFF: "handoff";
+    readonly HANDOFF_ERROR: "handoff-error";
+    readonly ALARM: "line-alarm";
+    readonly MACHINE_OFFLINE: "machine-offline";
+    readonly MACHINE_QUIET: "machine-quiet";
+    /** A host asks a machine to start, stop, pause, resume or change over. */
+    readonly MACHINE_COMMAND: "machine-command";
+    /** A message that broke the contract under a strict codec: held for a person, never acted on. */
+    readonly CONTRACT_VIOLATION: "contract-violation";
+    /** An address claims a station the line already knows by another address, or the reverse: a person approves or rejects. */
+    readonly MACHINE_REGISTRATION: "machine-registration";
+};
+export declare const LINE_ROLE: {
+    /** People who clear alarms, bring machines back and decide failed handoffs. */
+    readonly OPERATOR: "line-operator";
+    /** People who take finished units off the line: the final handoff. */
+    readonly EXIT: "line-exit";
+    /** The gateway's own identity. */
+    readonly CONTROLLER: "line-controller";
+};
+/** A file a machine fetches and verifies before it starts, by reference. */
+export interface ArtifactRef {
+    url: string;
+    sha256: string;
+    /** The host's id for the file. */
+    id?: string;
+    contentType?: string;
+    sizeBytes?: number;
+}
+export interface HandoffUnit {
+    unitId: string;
+    carrierId: string | null;
+    /** This unit's own file, when each unit has one (a per-unit model or toolpath). */
+    artifact?: ArtifactRef;
+    /** This unit's files, when it has several. */
+    artifacts?: ArtifactRef[];
+    /** Parameters for this unit alone, sent to the machine as given. */
+    parameters?: Record<string, unknown>;
+}
+/** Metadata on a handoff row. Everything a dispatch needs rides here. */
+export interface HandoffFacets {
+    /** The line the row belongs to; a gateway acts only on its own line's rows. */
+    siteId: string;
+    lineId: string;
+    /** The units that move together as one job. */
+    units: HandoffUnit[];
+    /** The receiver's job for these units. */
+    jobId: string;
+    /** The sender's job for these units; cancelled with the row. */
+    senderJobId: string | null;
+    orderRef: string;
+    fromMachine: string | null;
+    toMachine: string | null;
+    recipeId: string | null;
+    recipeVersion: string | null;
+    process: string | null;
+    artifactUrl: string | null;
+    artifactSha256: string | null;
+    attempt: number;
+    /** Parameters for the job, sent to the machine as given; what they mean is between the host and its codec. */
+    parameters?: Record<string, unknown>;
+}
+/**
+ * Items a handoff row accumulates, one per unit: the sender's finished-job
+ * record, and the receiver's arrival. When every unit's arrival is held, the
+ * receiver resolves the row.
+ */
+export declare const itemKeys: {
+    released: (unitId: string) => string;
+    arrived: (unitId: string) => string;
+    started: (unitId: string) => string;
+    progress: (unitId: string, step: number) => string;
+    stage: (unitId: string, stage: string) => string;
+    paused: (alarmId: string, raisedAt: string) => string;
+    resumed: (alarmId: string, raisedAt: string) => string;
+};
+/** The unit an arrival item names; null for any other item. */
+export declare function arrivedUnit(itemKey: string): string | null;
+/** Where a handoff's units stand, read from its items. */
+export interface HandoffProgress {
+    /** Units the sender reported finished and released. */
+    released: string[];
+    /** Units the receiver reported arrived. */
+    arrived: string[];
+    /** Units with no arrival, in the handoff's order. */
+    missing: string[];
+}
+/** A handoff's progress from its items (a row's items, or `$accumulated` on a finished wait), for the units it carries. */
+export declare function handoffProgress(units: readonly string[], items: readonly {
+    itemKey: string;
+}[]): HandoffProgress;
+export declare const HANDOFF_ERROR: {
+    readonly JAM: "jam";
+    readonly INCOMPLETE_HANDSHAKE: "incomplete-handshake";
+    readonly CARRIER_MISMATCH: "carrier-mismatch";
+    readonly UNREADABLE_ID: "unreadable-id";
+    readonly DISPATCH_REFUSED: "dispatch-refused";
+    /** Accepted, then the machine could not prepare the job (artifact, recipe). */
+    readonly DISPATCH_FAILED: "dispatch-failed";
+    readonly NO_REPLY: "no-reply";
+    readonly SENDER_REJECTED: "sender-rejected";
+    readonly HANDOFF_TIMEOUT: "handoff-timeout";
+    /** The handoff timed out after some of its units arrived; the units are split between two stations. */
+    readonly PARTIAL_ARRIVAL: "partial-arrival";
+    readonly SOFTWARE_UNSUPPORTED: "software-unsupported";
+    readonly WITHDRAWN: "withdrawn";
+    readonly CANCELLED: "cancelled";
+};
+export type HandoffErrorCode = typeof HANDOFF_ERROR[keyof typeof HANDOFF_ERROR];
+/** A material lot a machine consumed for a unit. */
+export interface TraceMaterial {
+    material: string;
+    lot: string;
+}
+/** One unit as a machine finished it, kept on the handoff row so a search by lot finds it. */
+export interface TraceEntry {
+    unitId: string;
+    machineId: string;
+    jobId: string | null;
+    result: string | null;
+    materials: TraceMaterial[];
+}
+/**
+ * Facets a handoff row gains as the sender finishes its units: `trace`, one
+ * entry per unit, and `lots`, every lot those units consumed. Both are
+ * containment-searchable, e.g. `{ lots: ['LOT-7'] }`.
+ */
+export declare const TRACE_FACET: {
+    readonly TRACE: "trace";
+    readonly LOTS: "lots";
+};
+/** The facet a row holding a job carries while it runs: its latest noted progress. */
+export declare const LIFECYCLE_FACET: {
+    readonly PROGRESS: "progress";
+};
+/** What resolves a handoff row, from a machine or from a person's form. */
+export interface HandoffResolution {
+    received: boolean;
+    receiver?: string;
+    /** Every unit received, on success. */
+    units?: string[];
+    /** The unit that failed, on an error. */
+    unitId?: string;
+    /** The machine that reported the error, when it is not the one resolving. */
+    reportedBy?: string;
+    errorCode?: HandoffErrorCode;
+    reason?: string | null;
+    detail?: string;
+}
+/** Decisions on line-operator rows: failed handoffs, alarms, dark machines, contested registrations. */
+export declare const DECISION: {
+    readonly RETRY: "retry";
+    readonly MANUAL: "manual";
+    readonly SCRAP: "scrap";
+    readonly ACKNOWLEDGE: "acknowledge";
+    readonly CLEARED: "cleared";
+    readonly RESTORED: "restored";
+    readonly APPROVE: "approve";
+    readonly REJECT: "reject";
+};
+export type Decision = typeof DECISION[keyof typeof DECISION];
+/** The decisions an operator may take on a failed handoff; retry only while every unit is still at the sender. */
+export declare function handoffDecisions(errorCode?: HandoffErrorCode): Decision[];
+export interface OperatorResolution {
+    decision: Decision;
+    note?: string;
+}
+/** Signal keys for the unit workflow; every attempt mints a fresh key. */
+export declare const signalKeys: {
+    handoff: (jobKey: string, step: number, attempt: number) => string;
+    handoffError: (jobKey: string, step: number, attempt: number, round?: number) => string;
+    jobStop: (jobKey: string, step: number, attempt: number) => string;
+};
+/** Metadata on a machine-command row. */
+export interface CommandFacets {
+    siteId: string;
+    lineId: string;
+    machineId: string;
+    op: string;
+    args: Record<string, unknown>;
+}
+export declare const COMMAND_STATUS: {
+    readonly NO_REPLY: "no-reply";
+    readonly UNSUPPORTED: "unsupported";
+    readonly ACCEPTED: "accepted";
+    readonly COMPLETED: "completed";
+    readonly REFUSED: "refused";
+    readonly FAILED: "failed";
+};
+export type CommandStatus = typeof COMMAND_STATUS[keyof typeof COMMAND_STATUS];
+/** What resolves a machine-command row: the machine's reply, as data. */
+export interface CommandResolution {
+    accepted: boolean;
+    machineId: string;
+    op: string;
+    status: CommandStatus;
+    reason?: string;
+}
+/** A row's dispatch command in its validity round; a later round is a new command (gateway/pacing.ts dispatchWindow). */
+export declare const dispatchCommandId: (escalationId: string, round?: number) => string;
+/** A command row's command in its validity round; a later round is a new command (gateway/pacing.ts dispatchWindow). */
+export declare const controlCommandId: (escalationId: string, round?: number) => string;
+export declare const cancelCommandId: (escalationId: string) => string;

package/build/services/machines/contracts.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * What the unit workflow and the machine gateway agree on: row types, roles,
+ * the metadata a handoff row carries, error codes and resolution shapes. A
+ * handoff row is the same for a machine resolver and a person; only the
+ * protocol that resolves it differs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelCommandId = exports.controlCommandId = exports.dispatchCommandId = exports.COMMAND_STATUS = exports.signalKeys = exports.DECISION = exports.LIFECYCLE_FACET = exports.TRACE_FACET = exports.HANDOFF_ERROR = exports.itemKeys = exports.LINE_ROLE = exports.ROW_TYPE = void 0;
+exports.arrivedUnit = arrivedUnit;
+exports.handoffProgress = handoffProgress;
+exports.handoffDecisions = handoffDecisions;
+const line_1 = require("../../lib/machines/line");
+const protocol_1 = require("../../lib/machines/protocol");
+exports.ROW_TYPE = {
+    HANDOFF: 'handoff',
+    HANDOFF_ERROR: 'handoff-error',
+    ALARM: 'line-alarm',
+    MACHINE_OFFLINE: 'machine-offline',
+    MACHINE_QUIET: 'machine-quiet',
+    /** A host asks a machine to start, stop, pause, resume or change over. */
+    MACHINE_COMMAND: 'machine-command',
+    /** A message that broke the contract under a strict codec: held for a person, never acted on. */
+    CONTRACT_VIOLATION: 'contract-violation',
+    /** An address claims a station the line already knows by another address, or the reverse: a person approves or rejects. */
+    MACHINE_REGISTRATION: 'machine-registration',
+};
+exports.LINE_ROLE = {
+    /** People who clear alarms, bring machines back and decide failed handoffs. */
+    OPERATOR: line_1.DEFAULT_OPERATOR_ROLE,
+    /** People who take finished units off the line: the final handoff. */
+    EXIT: line_1.DEFAULT_EXIT_ROLE,
+    /** The gateway's own identity. */
+    CONTROLLER: 'line-controller',
+};
+const RELEASED_PREFIX = 'released:';
+const ARRIVED_PREFIX = 'arrived:';
+/**
+ * Items a handoff row accumulates, one per unit: the sender's finished-job
+ * record, and the receiver's arrival. When every unit's arrival is held, the
+ * receiver resolves the row.
+ */
+exports.itemKeys = {
+    released: (unitId) => `${RELEASED_PREFIX}${unitId}`,
+    arrived: (unitId) => `${ARRIVED_PREFIX}${unitId}`,
+    started: (unitId) => `started:${unitId}`,
+    progress: (unitId, step) => `progress:${unitId}:${step}`,
+    stage: (unitId, stage) => `stage:${unitId}:${stage}`,
+    paused: (alarmId, raisedAt) => `paused:${alarmId}:${raisedAt}`,
+    resumed: (alarmId, raisedAt) => `resumed:${alarmId}:${raisedAt}`,
+};
+/** The unit an arrival item names; null for any other item. */
+function arrivedUnit(itemKey) {
+    return itemKey.startsWith(ARRIVED_PREFIX) ? itemKey.slice(ARRIVED_PREFIX.length) : null;
+}
+/** A handoff's progress from its items (a row's items, or `$accumulated` on a finished wait), for the units it carries. */
+function handoffProgress(units, items) {
+    const keys = new Set(items.map((i) => i.itemKey));
+    const arrived = units.filter((u) => keys.has(exports.itemKeys.arrived(u)));
+    return {
+        released: units.filter((u) => keys.has(exports.itemKeys.released(u))),
+        arrived,
+        missing: units.filter((u) => !arrived.includes(u)),
+    };
+}
+exports.HANDOFF_ERROR = {
+    DISPATCH_REFUSED: 'dispatch-refused',
+    /** Accepted, then the machine could not prepare the job (artifact, recipe). */
+    DISPATCH_FAILED: 'dispatch-failed',
+    NO_REPLY: 'no-reply',
+    SENDER_REJECTED: 'sender-rejected',
+    HANDOFF_TIMEOUT: 'handoff-timeout',
+    /** The handoff timed out after some of its units arrived; the units are split between two stations. */
+    PARTIAL_ARRIVAL: 'partial-arrival',
+    SOFTWARE_UNSUPPORTED: 'software-unsupported',
+    WITHDRAWN: 'withdrawn',
+    CANCELLED: 'cancelled',
+    ...protocol_1.TRANSFER_FAILURE,
+};
+/**
+ * Facets a handoff row gains as the sender finishes its units: `trace`, one
+ * entry per unit, and `lots`, every lot those units consumed. Both are
+ * containment-searchable, e.g. `{ lots: ['LOT-7'] }`.
+ */
+exports.TRACE_FACET = { TRACE: 'trace', LOTS: 'lots' };
+/** The facet a row holding a job carries while it runs: its latest noted progress. */
+exports.LIFECYCLE_FACET = { PROGRESS: 'progress' };
+/** Decisions on line-operator rows: failed handoffs, alarms, dark machines, contested registrations. */
+exports.DECISION = {
+    RETRY: 'retry',
+    MANUAL: 'manual',
+    SCRAP: 'scrap',
+    ACKNOWLEDGE: 'acknowledge',
+    CLEARED: 'cleared',
+    RESTORED: 'restored',
+    APPROVE: 'approve',
+    REJECT: 'reject',
+};
+/**
+ * Failures a retry cannot repair. Units a sender finished as not ok leave the
+ * automated line and never re-enter it; units split by a partial arrival are
+ * no longer all at the sender, so the same hop cannot move them again.
+ */
+const NO_RETRY = [exports.HANDOFF_ERROR.SENDER_REJECTED, exports.HANDOFF_ERROR.PARTIAL_ARRIVAL];
+/** The decisions an operator may take on a failed handoff; retry only while every unit is still at the sender. */
+function handoffDecisions(errorCode) {
+    const noRetry = !!errorCode && NO_RETRY.includes(errorCode);
+    return noRetry ? [exports.DECISION.MANUAL, exports.DECISION.SCRAP] : [exports.DECISION.RETRY, exports.DECISION.MANUAL, exports.DECISION.SCRAP];
+}
+/** Signal keys for the unit workflow; every attempt mints a fresh key. */
+exports.signalKeys = {
+    handoff: (jobKey, step, attempt) => `handoff-${jobKey}-s${step}-a${attempt}`,
+    handoffError: (jobKey, step, attempt, round = 1) => `handoff-error-${jobKey}-s${step}-a${attempt}${round > 1 ? `-r${round}` : ''}`,
+    jobStop: (jobKey, step, attempt) => `job-stop-${jobKey}-s${step}-a${attempt}`,
+};
+exports.COMMAND_STATUS = { ...protocol_1.REPLY_STATUS, NO_REPLY: 'no-reply', UNSUPPORTED: 'unsupported' };
+/** A row's dispatch command in its validity round; a later round is a new command (gateway/pacing.ts dispatchWindow). */
+const dispatchCommandId = (escalationId, round = 1) => (round > 1 ? `${escalationId}:dispatch:r${round}` : `${escalationId}:dispatch`);
+exports.dispatchCommandId = dispatchCommandId;
+/** A command row's command in its validity round; a later round is a new command (gateway/pacing.ts dispatchWindow). */
+const controlCommandId = (escalationId, round = 1) => (round > 1 ? `${escalationId}:command:r${round}` : `${escalationId}:command`);
+exports.controlCommandId = controlCommandId;
+const cancelCommandId = (escalationId) => `${escalationId}:cancel`;
+exports.cancelCommandId = cancelCommandId;

package/build/services/machines/forms.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The escalation surfaces each role owns. A handoff row looks the same to a
+ * machine and to a person: machines resolve it through the gateway, a person
+ * resolves the line-exit row with this form. Line operators decide failed
+ * handoffs and close alarm and machine-state rows.
+ */
+export declare const HANDOFF_FORM_SCHEMA: {
+    title: string;
+    description: string;
+    'x-lt-order': string[];
+    required: string[];
+    properties: {
+        received: {
+            type: string;
+            default: boolean;
+            description: string;
+        };
+        receiver: {
+            type: string;
+            default: string;
+            description: string;
+        };
+        note: {
+            type: string;
+            format: string;
+            default: string;
+            description: string;
+        };
+    };
+};
+export declare const OPERATOR_FORM_SCHEMA: {
+    title: string;
+    description: string;
+    'x-lt-order': string[];
+    required: string[];
+    properties: {
+        decision: {
+            type: string;
+            enum: ("reject" | "scrap" | "retry" | "manual" | "acknowledge" | "cleared" | "restored" | "approve")[];
+            default: "acknowledge";
+            description: string;
+        };
+        note: {
+            type: string;
+            format: string;
+            default: string;
+            description: string;
+        };
+        clearedBy: {
+            type: string;
+            default: string;
+            description: string;
+        };
+    };
+};

package/build/services/machines/forms.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * The escalation surfaces each role owns. A handoff row looks the same to a
+ * machine and to a person: machines resolve it through the gateway, a person
+ * resolves the line-exit row with this form. Line operators decide failed
+ * handoffs and close alarm and machine-state rows.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPERATOR_FORM_SCHEMA = exports.HANDOFF_FORM_SCHEMA = void 0;
+const contracts_1 = require("./contracts");
+exports.HANDOFF_FORM_SCHEMA = {
+    title: 'Receive units',
+    description: 'Confirm the units are in hand. A machine confirms its own receipts; this form is for a person receiving them.',
+    'x-lt-order': ['received', 'receiver', 'note'],
+    required: ['received'],
+    properties: {
+        received: { type: 'boolean', default: true, description: 'Every unit in this handoff is in hand' },
+        receiver: { type: 'string', default: '', description: 'Who or what received them' },
+        note: { type: 'string', format: 'textarea', default: '', description: 'Anything notable about the units' },
+    },
+};
+exports.OPERATOR_FORM_SCHEMA = {
+    title: 'Line decision',
+    description: 'A handoff that did not complete: retry it, finish the units by hand, or scrap them. Units a machine finished as not ok are off the line: finish them by hand or scrap them. An alarm or a machine that went dark: acknowledge it once handled.',
+    'x-lt-order': ['decision', 'note'],
+    required: ['decision'],
+    properties: {
+        decision: {
+            type: 'string',
+            enum: Object.values(contracts_1.DECISION),
+            default: contracts_1.DECISION.ACKNOWLEDGE,
+            description: 'One of the row\'s decisions for a failed handoff; acknowledge for an alarm or a machine',
+        },
+        note: { type: 'string', format: 'textarea', default: '', description: 'What was done' },
+        clearedBy: { type: 'string', default: '', description: 'Who cleared it at the machine, when the machine reports it' },
+    },
+};

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

@@ -0,0 +1,111 @@
+/**
+ * The gateway's side effects as data. The planner decides; the executor does.
+ * `as` names the identity a verb runs under: a machine id, or the controller.
+ */
+import type { Disposition } from '../../../lib/machines/transport';
+export declare const CONTROLLER = "controller";
+export type Actor = string;
+export interface CreateRowInput {
+    type: string;
+    subtype?: string;
+    role: string;
+    description: string;
+    priority: number;
+    metadata: Record<string, any>;
+    /** JSON envelope, e.g. `{ lookups: [...] }` naming the catalog edition a code comes from. */
+    envelope?: string;
+    /** What the row shows a person, serialized. */
+    escalation_payload?: string;
+}
+export type Action = 
+/** `receivedOnAccept`: the units are already at the machine, so its acceptance completes the handoff. */
+{
+    kind: 'dispatch';
+    rowId: string;
+    machineId: string;
+    cmdId: string;
+    args: Record<string, any>;
+    receivedOnAccept?: boolean;
+} | {
+    kind: 'command';
+    machineId: string;
+    op: string;
+    cmdId: string;
+    args: Record<string, any>;
+}
+/** A host's machine-command row: send the command, resolve the row with the reply. */
+ | {
+    kind: 'control';
+    rowId: string;
+    machineId: string;
+    op: string;
+    args: Record<string, any>;
+    createdAt?: number;
+} | {
+    kind: 'claim';
+    as: Actor;
+    rowId: string;
+}
+/** `metadata` is merged into the row's metadata in the same statement. */
+ | {
+    kind: 'accumulate';
+    as: Actor;
+    rowId: string;
+    itemKey: string;
+    payload: Record<string, any>;
+    metadata?: Record<string, any>;
+    complete?: Completion;
+} | {
+    kind: 'resolve';
+    as: Actor;
+    rowId: string;
+    payload: Record<string, any>;
+} | {
+    kind: 'createAlarmRow';
+    machineId: string;
+    alarmId: string;
+    row: CreateRowInput;
+}
+/** A row for a person, raised by the controller. */
+ | {
+    kind: 'createRow';
+    row: CreateRowInput;
+} | {
+    kind: 'watchOffline';
+    machineId: string;
+} | {
+    kind: 'settleReply';
+    cmdId: string;
+    status: string;
+    reason: string;
+}
+/** A machine reported the jobs it holds: answers a status query in flight. */
+ | {
+    kind: 'settleSnapshot';
+    machineId: string;
+    jobIds: string[];
+}
+/** Bind a station to the address that claims it, and keep the binding in the address book. `by`: who approved it, when someone did. */
+ | {
+    kind: 'bindAddress';
+    machineId: string;
+    address: string;
+    by?: string;
+}
+/** An approved registration the gateway will not bind, and why. */
+ | {
+    kind: 'refuseBinding';
+    machineId: string;
+    address: string;
+    reason: string;
+};
+/** Once the row holds every one of `keys`: resolve it with `payload`, or run `then` instead. */
+export interface Completion {
+    keys: string[];
+    payload?: Record<string, any>;
+    then?: Action[];
+}
+export interface Plan {
+    actions: Action[];
+    disposition: Disposition;
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * The gateway's side effects as data. The planner decides; the executor does.
+ * `as` names the identity a verb runs under: a machine id, or the controller.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTROLLER = void 0;
+exports.CONTROLLER = 'controller';

package/build/services/machines/gateway/address-book.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Where a line keeps the machine addresses it learned, so a gateway that
+ * takes the line over sends to the same machines. The memory book lasts as
+ * long as the process; Long Tail keeps each binding on the station's bot
+ * account (identities.ts).
+ */
+export interface AddressBook {
+    /** Station → address, for every station bound so far. */
+    load(): Promise<Map<string, string>>;
+    bind(machineId: string, address: string): Promise<void>;
+}
+export declare class MemoryAddressBook implements AddressBook {
+    private readonly bindings;
+    load(): Promise<Map<string, string>>;
+    bind(machineId: string, address: string): Promise<void>;
+}

package/build/services/machines/gateway/address-book.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Where a line keeps the machine addresses it learned, so a gateway that
+ * takes the line over sends to the same machines. The memory book lasts as
+ * long as the process; Long Tail keeps each binding on the station's bot
+ * account (identities.ts).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAddressBook = void 0;
+class MemoryAddressBook {
+    constructor() {
+        this.bindings = new Map();
+    }
+    async load() {
+        return new Map(this.bindings);
+    }
+    async bind(machineId, address) {
+        for (const [station, bound] of this.bindings)
+            if (bound === address)
+                this.bindings.delete(station);
+        this.bindings.set(machineId, address);
+    }
+}
+exports.MemoryAddressBook = MemoryAddressBook;

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

@@ -0,0 +1,35 @@
+/**
+ * What happens to a decoded machine message before the planner sees it: the
+ * sender is checked against the line's learned addresses (registration.ts),
+ * and under a strict codec a message that breaks the contract is held for a
+ * person instead of acted on.
+ */
+import { type LineDef } from '../../../lib/machines/line';
+import type { Inspection } from '../../../lib/machines/protocol';
+import { type Disposition, type InboundMessage } from '../../../lib/machines/transport';
+import type { Action } from './actions';
+import { type GatewayLog } from './log';
+import type { GatewayState } from './state';
+/** What handling one decoded message came to. */
+export interface Applied {
+    disposition: Disposition;
+    failed: boolean;
+}
+export interface AdmissionContext {
+    state: GatewayState;
+    line: LineDef;
+    executor: {
+        apply(actions: Action[]): Promise<void>;
+    };
+    log: GatewayLog;
+    /** Send waiting handoffs that may now go out. */
+    pace(): Promise<void>;
+}
+/**
+ * The station a message is from (registration.ts). A newly claimed station is
+ * bound and its waiting work goes out; a contested claim raises one row for a
+ * person; either of those, and an address no station claims, is not acted on.
+ */
+export declare function admitSender(ctx: AdmissionContext, topic: string, raw: Inspection): Promise<Inspection | Applied>;
+/** Under a strict codec a broken message is not acted on: a person sees it on a row, once. */
+export declare function holdViolation(ctx: AdmissionContext, msg: InboundMessage, seen: Inspection): Promise<Applied>;