@hotmeshio/long-tail 0.25.4 → 0.27.0

package/build/scripts/machine-line.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * machine-line: drive the machine line example end to end.
+ *
+ * Starts unit routes on the factory line and plays the people: at every
+ * station people work (and at the inspector, where every route ends) a
+ * person takes the units off the station before and receives them; a
+ * technician clears alarms; an operator decides each failed handoff. The
+ * machines and the gateway do the rest over MQTT. MIX sets the share of
+ * routes minted from the automated manifest; the rest run the manual one,
+ * through the same workflow. Rows are watched on Long Tail's NATS.
+ *
+ * Usage (after `docker compose -f docker-compose.yml -f docker-compose.nats.yml -f docker-compose.machines.yml up -d --build`):
+ *   npm run machine:line
+ *   MIX=50 UNITS=8 npm run machine:line          # half automated, half manual, same factory
+ *   UNITS=8 BATCH=2 npm run machine:line
+ *   FAULT=jam npm run machine:line               # first route jams leaving FAULT_AT; operator retries
+ *   FAULT=reject DECIDE=scrap npm run machine:line
+ *
+ * Env vars:
+ *   BASE_URL      Long Tail API (default http://localhost:3000)
+ *   SIM_URL       mock line drill server (default http://localhost:8090)
+ *   NATS_URL      Long Tail NATS (default nats://localhost:4222), NATS_TOKEN (default dev_api_secret)
+ *   UNITS         units to run (default 6); BATCH units per route (default 2)
+ *   MIX           percent of routes on the automated manifest (default 100); the rest run manual
+ *   MACHINE_LINE_CONFIG, MACHINE_MANIFESTS   line and manifests (default the factory line and route-manifests.json)
+ *   FAULT         jam | incomplete | carrier_mismatch | unreadable | stall | reject | hold | estop | offline
+ *   FAULT_AT      machine the fault happens at (default the first machine)
+ *   DECIDE        operator decision on a failed handoff: retry | manual | scrap (default retry;
+ *                 manual where the row does not offer retry)
+ *   OFFLINE_S     how long FAULT=offline keeps the machine away (default 25)
+ *   HANDOFF_TIMEOUT  per-handoff timeout (default 5m); TIMEOUT_S whole run (default 300)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+try {
+    require('dotenv/config');
+}
+catch { /* dotenv optional */ }
+const nats_1 = require("nats");
+const contracts_1 = require("../services/machines/contracts");
+const line_1 = require("../lib/machines/line");
+const manifests_1 = require("../examples/workflows/machine-line/manifests");
+const line_2 = require("../examples/workflows/machine-line/line");
+const protocol_1 = require("../lib/machines/protocol");
+const route_1 = require("../examples/workflows/machine-line/workflows/route");
+const env = process.env;
+const BASE_URL = env.BASE_URL || 'http://localhost:3000';
+const SIM_URL = env.SIM_URL || 'http://localhost:8090';
+const NATS_URL = env.NATS_URL || 'nats://localhost:4222';
+const NATS_TOKEN = env.NATS_TOKEN ?? 'dev_api_secret';
+const UNITS = parseInt(env.UNITS || '6', 10);
+const BATCH = Math.max(1, parseInt(env.BATCH || '2', 10));
+const MIX = parseInt(env.MIX || '100', 10);
+const FAULT = env.FAULT || '';
+const DECIDE = env.DECIDE || contracts_1.DECISION.RETRY;
+const OFFLINE_S = parseInt(env.OFFLINE_S || '25', 10);
+const HANDOFF_TIMEOUT = env.HANDOFF_TIMEOUT || '5m';
+const TIMEOUT_S = parseInt(env.TIMEOUT_S || '300', 10);
+const TECH = 'line-tech';
+const TRANSFER_FAULTS = ['jam', 'incomplete', 'carrier_mismatch', 'unreadable', 'stall'];
+const RESULT_FAULTS = ['reject', 'hold'];
+const STOPPED = new Set([protocol_1.MODE.FAULTED, protocol_1.MODE.EMERGENCY_STOP]);
+const line = (0, line_2.loadLine)(env.MACHINE_LINE_CONFIG || manifests_1.FACTORY_LINE_PATH);
+const manifests = (0, manifests_1.loadManifests)(env.MACHINE_MANIFESTS || undefined);
+const MANIFEST = { AUTOMATED: 'automated', MANUAL: 'manual' };
+const machineRoles = new Set((0, line_1.stationRoles)(line));
+const firstMachine = manifests[MANIFEST.AUTOMATED].steps.find((s) => typeof s === 'string');
+const FAULT_AT = env.FAULT_AT || firstMachine;
+const manifestOf = new Map();
+const RUN = `L${Date.now().toString(36).slice(-5)}`;
+const counts = {};
+let token = '';
+const ts = () => new Date().toISOString().slice(11, 19);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const say = (msg) => console.log(`[${ts()}] ${msg}`);
+async function call(base, method, path, body, auth = true) {
+    const res = await fetch(`${base}${path}`, {
+        method,
+        headers: { 'content-type': 'application/json', ...(auth && token ? { authorization: `Bearer ${token}` } : {}) },
+        body: body === undefined ? undefined : typeof body === 'string' ? body : JSON.stringify(body),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok)
+        throw new Error(`${method} ${path} -> ${res.status}: ${JSON.stringify(data)}`);
+    return data;
+}
+const api = (method, path, body) => call(BASE_URL, method, `/api${path}`, body);
+const sim = (method, path, body) => call(SIM_URL, method, path, body, false);
+// ── The physical world ───────────────────────────────────────────────────────
+/** A technician clears every alarm at a machine and resets it if it stopped. */
+async function fixMachine(machineId) {
+    const state = await sim('GET', `/sim/${machineId}`);
+    for (const alarm of state.alarms ?? []) {
+        if (alarm.active)
+            await sim('POST', `/sim/${machineId}/clear-alarm`, { alarmId: alarm.alarmId, by: TECH });
+    }
+    if (STOPPED.has(state.mode))
+        await sim('POST', `/sim/${machineId}/reset`, { by: TECH });
+    if (!state.link?.connected)
+        await sim('POST', `/sim/${machineId}/network`, { mode: 'restore' });
+}
+async function injectFault() {
+    if (!FAULT)
+        return;
+    if (TRANSFER_FAULTS.includes(FAULT))
+        await sim('POST', `/sim/${FAULT_AT}/transfer`, { fault: FAULT });
+    else if (RESULT_FAULTS.includes(FAULT))
+        await sim('POST', `/sim/${FAULT_AT}/arm`, { result: FAULT, reason: `driver-${FAULT}` });
+    else if (FAULT === 'estop')
+        await sim('POST', `/sim/${FAULT_AT}/emergency-stop`);
+    else if (FAULT === 'offline') {
+        await sim('POST', `/sim/${FAULT_AT}/network`, { mode: 'drop' });
+        setTimeout(() => void sim('POST', `/sim/${FAULT_AT}/network`, { mode: 'restore' }).then(() => say(`[floor] ${FAULT_AT} back online`)), OFFLINE_S * 1000);
+    }
+    else
+        throw new Error(`unknown FAULT=${FAULT}`);
+    say(`[floor] fault armed: ${FAULT} at ${FAULT_AT}`);
+}
+// ── The people ───────────────────────────────────────────────────────────────
+/** A person takes units off a machine; false when a unit was not there to take. */
+async function takeUnits(machineId, units, tries = 40) {
+    if (!machineId)
+        return true;
+    let all = true;
+    for (const unit of units) {
+        let taken = false;
+        for (let i = 0; i < tries && !(taken = (await sim('POST', `/sim/${machineId}/unload`, { unitId: unit.unitId })).result); i++)
+            await sleep(250);
+        all &&= taken;
+    }
+    return all;
+}
+/** Wait until the row holds the sender's release of every unit: the machine has finished them. */
+async function released(rowId, units, ms = 180_000) {
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) {
+        const { items = [] } = await api('GET', `/escalations/${rowId}/items`);
+        const keys = new Set(items.map((i) => i.itemKey));
+        if (units.every((u) => keys.has(`released:${u.unitId}`)))
+            return true;
+        await sleep(500);
+    }
+    return false;
+}
+/** Units the operator sent off the line by hand: the sender already finished them, so no release is coming. */
+const takenOver = new Set();
+/**
+ * A person at a station: take each unit off the machine it came from (if any),
+ * or collect it where a split left it (a pickup row), then receive the set.
+ */
+async function receive(row) {
+    const md = row.metadata ?? {};
+    const units = md.units ?? [];
+    const at = md.pickupAt ?? md.fromMachine ?? null;
+    const finished = async () => !!md.pickupAt || units.every((u) => takenOver.has(u.unitId)) || released(row.id, units);
+    if (at && !(await finished() && await takeUnits(at, units))) {
+        say(`[${row.role}]`.padEnd(11) + ` ${units.map((u) => u.unitId).join(', ')} never left ${at}; leaving the row open`);
+        return;
+    }
+    await api('POST', `/escalations/${row.id}/resolve`, { resolverPayload: { received: true, receiver: `${row.role}-person` } });
+    say(`[${row.role}]`.padEnd(11) + ` received ${units.map((u) => u.unitId).join(', ')} ${md.pickupAt ? `collected at ${at}` : `from ${at ?? 'a person'}`}`);
+}
+/** Set once a route left the line on purpose (manual or scrap), so an incomplete run is expected. */
+let offLine = false;
+/** Operator: make the machines healthy, then decide the failed handoff; retry falls back to manual where the row does not offer it. */
+async function decideFailure(row) {
+    const md = row.metadata ?? {};
+    for (const m of line.machines)
+        await fixMachine(m.machineId);
+    const allowed = md.decisions ?? [DECIDE];
+    const decision = allowed.includes(DECIDE) ? DECIDE : allowed[0];
+    if (decision !== contracts_1.DECISION.RETRY)
+        offLine = true;
+    if (decision === contracts_1.DECISION.MANUAL)
+        for (const u of md.units ?? [])
+            takenOver.add(u.unitId);
+    if (decision === contracts_1.DECISION.SCRAP)
+        await takeUnits(md.fromMachine ?? null, md.units ?? [], 4);
+    await api('POST', `/escalations/${row.id}/resolve`, { resolverPayload: { decision, note: `driver: ${md.errorCode}` } });
+    // Scrapped units split by a partial arrival: the ones that arrived wait at the receiver once the workflow stops its job.
+    if (decision === contracts_1.DECISION.SCRAP && md.errorCode === 'partial-arrival')
+        await takeUnits(md.toMachine ?? null, md.units ?? [], 8);
+    say(`[operator] ${md.jobId} ${md.errorCode} at ${md.fromMachine ?? 'entry'} -> ${decision}`);
+}
+async function onRow(row) {
+    const md = row.metadata ?? {};
+    if (md.siteId !== line.siteId || md.lineId !== line.lineId)
+        return;
+    counts[row.type] = (counts[row.type] ?? 0) + 1;
+    if (row.type === contracts_1.ROW_TYPE.HANDOFF && !machineRoles.has(row.role) && String(md.jobId ?? '').startsWith(RUN)) {
+        // Each person works their own station; a slow one does not hold up the rest.
+        void receive(row).catch((err) => say(`[driver]   ${err.message}`));
+        return;
+    }
+    if (row.type === contracts_1.ROW_TYPE.HANDOFF)
+        return;
+    if (row.type === contracts_1.ROW_TYPE.HANDOFF_ERROR && String(md.jobId ?? '').startsWith(RUN))
+        return decideFailure(row);
+    if (row.type === contracts_1.ROW_TYPE.ALARM) {
+        say(`[tech]     alarm ${md.code ?? ''} at ${md.machineId}: fixing`);
+        await sleep(1500);
+        if (md.machineId)
+            await fixMachine(md.machineId);
+        return;
+    }
+    say(`[row]      ${row.type} ${row.description ?? ''}`);
+}
+// ── The run ──────────────────────────────────────────────────────────────────
+async function startRoutes(artifact) {
+    const ids = [];
+    for (let i = 0, n = 0; n < UNITS; i++) {
+        const routeKey = `${RUN}-R${i + 1}`;
+        const units = Array.from({ length: Math.min(BATCH, UNITS - n) }, (_, j) => ({ unitId: `${routeKey}-U${j + 1}`, carrierId: `CR-${routeKey}-${j + 1}` }));
+        n += units.length;
+        const name = (0, manifests_1.automatedAt)(i, MIX) ? MANIFEST.AUTOMATED : MANIFEST.MANUAL;
+        const data = {
+            siteId: line.siteId, lineId: line.lineId, routeKey, orderRef: `ORD-${RUN}`, units,
+            steps: (0, manifests_1.manifestSteps)(line, manifests[name]), exitRole: (0, line_1.exitRole)(line), artifact, handoffTimeout: HANDOFF_TIMEOUT,
+        };
+        const workflowId = `mur-${routeKey}`;
+        await api('POST', `/workflows/${route_1.UNIT_ROUTE_WORKFLOW}/invoke`, { workflowId, data, metadata: { source: 'machine-line', manifest: name } });
+        ids.push(workflowId);
+        manifestOf.set(workflowId, name);
+        say(`[route]    ${routeKey} (${name}): ${units.map((u) => u.unitId).join(', ')}`);
+    }
+    return ids;
+}
+async function awaitResults(ids) {
+    const results = new Map();
+    const deadline = Date.now() + TIMEOUT_S * 1000;
+    while (results.size < ids.length && Date.now() < deadline) {
+        await sleep(1000);
+        for (const id of ids.filter((x) => !results.has(x))) {
+            const resp = await api('GET', `/workflows/${id}/result`).catch(() => null);
+            if (resp?.result?.data?.status)
+                results.set(id, resp.result.data);
+        }
+    }
+    return results;
+}
+function report(ids, results) {
+    console.log('\nroute                    manifest   status     hops');
+    let ok = true;
+    const byManifest = {};
+    for (const id of ids) {
+        const data = results.get(id);
+        const name = manifestOf.get(id);
+        const tally = (byManifest[name] ??= { routes: 0, complete: 0, atInspector: 0 });
+        tally.routes++;
+        if (data?.status === 'complete')
+            tally.complete++;
+        else
+            ok = false;
+        const last = data?.history?.[data.history.length - 1];
+        if (last?.to === 'exit' && last.received)
+            tally.atInspector++;
+        const hops = (data?.history ?? []).map((h) => `${h.to}${h.received ? '' : `(${h.errorCode})`}`).join(' > ');
+        console.log(`${id.padEnd(24)} ${name.padEnd(10)} ${(data?.status ?? 'timed out').padEnd(10)} ${hops}`);
+    }
+    console.log('');
+    for (const [name, t] of Object.entries(byManifest)) {
+        console.log(`${name.padEnd(10)} ${t.complete}/${t.routes} complete, ${t.atInspector} received at ${(0, line_1.exitRole)(line)}`);
+    }
+    console.log(`\nrows seen: ${Object.entries(counts).map(([k, v]) => `${k}=${v}`).join('  ') || 'none'}`);
+    return ok;
+}
+async function main() {
+    // 1. Log in, check the mock line is this line
+    token = (await call(BASE_URL, 'POST', '/api/auth/login', { username: 'superadmin', password: 'l0ngt@1l' }, false)).token;
+    const state = await sim('GET', '/sim/state');
+    if (state.siteId !== line.siteId || state.lineId !== line.lineId)
+        throw new Error(`mock runs ${state.siteId}/${state.lineId}, driver expects ${line.siteId}/${line.lineId}`);
+    for (const m of line.machines) {
+        await sim('POST', `/sim/${m.machineId}/disarm`);
+        await fixMachine(m.machineId);
+    }
+    // 2. Watch the rows people act on, one at a time
+    const nc = await (0, nats_1.connect)({ servers: NATS_URL, token: NATS_TOKEN || undefined, name: 'machine-line-driver' });
+    const sc = (0, nats_1.StringCodec)();
+    let chain = Promise.resolve();
+    nc.subscribe('lt.events.system.escalation.*.*.created', {
+        callback: (_err, m) => {
+            const row = JSON.parse(sc.decode(m.data)).data ?? {};
+            chain = chain.then(() => onRow(row)).catch((err) => say(`[driver]   ${err.message}`));
+        },
+    });
+    // 3. A job artifact, the fault, and the routes
+    const artifact = await sim('POST', '/payloads', `machine-line ${RUN}`);
+    await injectFault();
+    const ids = await startRoutes({ url: artifact.url, sha256: artifact.sha256 });
+    // 4. Wait for every route, then report
+    const results = await awaitResults(ids);
+    await chain;
+    await nc.drain();
+    const ok = report(ids, results);
+    process.exit(ok || offLine ? 0 : 1);
+}
+main().catch((err) => {
+    console.error(`[${ts()}] failed: ${err.message}`);
+    process.exit(1);
+});

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

@@ -0,0 +1,29 @@
+/**
+ * Commands as rows. A host asks a machine to start, stop, pause, resume,
+ * change over or cancel a job by parking a machine-command row on the machine's role, from a
+ * workflow step or through the API, the same way it asks a person for
+ * anything. The gateway sends the command and resolves the row with the
+ * machine's reply (CommandResolution), so the step reads the outcome as data.
+ */
+import type { Op } from '../../lib/machines/protocol';
+import { type LineDef } from '../../lib/machines/line';
+import { type CommandFacets } from './contracts';
+/** Where a command goes: the machine and the role its rows land on. */
+export interface CommandTarget {
+    siteId: string;
+    lineId: string;
+    machineId: string;
+    role: string;
+}
+export declare function commandTarget(line: LineDef, machineId: string): CommandTarget;
+/** The row that asks a machine for `op`: pass it to conditional(), or create it through the API. */
+export declare function commandRow(target: CommandTarget, op: Op, args?: Record<string, unknown>): {
+    role: string;
+    type: "machine-command";
+    subtype: Op;
+    description: string;
+    priority: number;
+    metadata: Record<string, unknown>;
+};
+/** A machine-command row's facets; null when the line, machine or op is missing. */
+export declare function readCommandFacets(md?: Record<string, any>): CommandFacets | null;

package/build/services/machines/commands.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Commands as rows. A host asks a machine to start, stop, pause, resume,
+ * change over or cancel a job by parking a machine-command row on the machine's role, from a
+ * workflow step or through the API, the same way it asks a person for
+ * anything. The gateway sends the command and resolves the row with the
+ * machine's reply (CommandResolution), so the step reads the outcome as data.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandTarget = commandTarget;
+exports.commandRow = commandRow;
+exports.readCommandFacets = readCommandFacets;
+const line_1 = require("../../lib/machines/line");
+const contracts_1 = require("./contracts");
+function commandTarget(line, machineId) {
+    return { siteId: line.siteId, lineId: line.lineId, machineId, role: (0, line_1.machineRole)((0, line_1.machineById)(line, machineId)) };
+}
+/** The row that asks a machine for `op`: pass it to conditional(), or create it through the API. */
+function commandRow(target, op, args = {}) {
+    const metadata = { siteId: target.siteId, lineId: target.lineId, machineId: target.machineId, op, args };
+    const recipe = args.recipe;
+    return {
+        role: target.role,
+        type: contracts_1.ROW_TYPE.MACHINE_COMMAND,
+        subtype: op,
+        description: recipe?.id ? `${op} ${target.machineId} to ${recipe.id} v${recipe.version}` : `${op} ${target.machineId}`,
+        priority: 2,
+        metadata: metadata,
+    };
+}
+/** A machine-command row's facets; null when the line, machine or op is missing. */
+function readCommandFacets(md = {}) {
+    if (!md.siteId || !md.lineId || !md.machineId || !md.op)
+        return null;
+    const args = md.args && typeof md.args === 'object' && !Array.isArray(md.args) ? md.args : {};
+    return { siteId: String(md.siteId), lineId: String(md.lineId), machineId: String(md.machineId), op: String(md.op), args };
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Environment for the machine line example. Every backend is chosen here and
+ * an unknown or incomplete selection throws; nothing falls back silently.
+ */
+import type { MqttEndpoint } from '../../types/machines';
+export type { MqttEndpoint };
+export declare const MACHINE_TRANSPORT: {
+    readonly MEMORY: "memory";
+    readonly NATS: "nats";
+    readonly MQTT: "mqtt";
+};
+export type MachineTransportMode = typeof MACHINE_TRANSPORT[keyof typeof MACHINE_TRANSPORT];
+export declare const ESCALATION_FEED: {
+    readonly MEMORY: "memory";
+    readonly CORE: "core";
+    readonly IN_PROCESS: "in-process";
+};
+export type EscalationFeedMode = typeof ESCALATION_FEED[keyof typeof ESCALATION_FEED];
+export interface MachineLineConfig {
+    transport: MachineTransportMode;
+    feed: EscalationFeedMode;
+    topicRoot: string;
+    lineConfigPath?: string;
+    siteNatsUrl?: string;
+    siteNatsUser?: string;
+    siteNatsPassword?: string;
+    ltNatsUrl?: string;
+    ltNatsToken?: string;
+    mqtt?: MqttEndpoint;
+    replyTimeoutMs: number;
+    dispatchAttempts: number;
+    handoffTimeout: string;
+    offlineDebounceMs: number;
+    /** A connected machine silent this long gets a quiet row; 0 turns the check off. */
+    quietMs: number;
+    /** How long a dispatch stays valid at the machine. */
+    dispatchTtlMs: number;
+    /** How long confirmed message ids gather before a receipt goes out. */
+    receiptDelayMs: number;
+    /** Note each job's start, progress steps and pauses on the row that holds it (lifecycle.ts). */
+    lifecycle: boolean;
+    /** With lifecycle notes, progress is noted each time it crosses this many percent; 0 notes none. */
+    progressStep: number;
+    ltBaseUrl: string;
+}
+type Env = Record<string, string | undefined>;
+/** The generic line protocol's topic root when MACHINE_TOPIC_ROOT is unset. */
+export declare const DEFAULT_TOPIC_ROOT = "line/v1";
+export declare function loadMachineLineConfig(env?: Env): MachineLineConfig;

package/build/services/machines/config.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Environment for the machine line example. Every backend is chosen here and
+ * an unknown or incomplete selection throws; nothing falls back silently.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TOPIC_ROOT = exports.ESCALATION_FEED = exports.MACHINE_TRANSPORT = void 0;
+exports.loadMachineLineConfig = loadMachineLineConfig;
+const protocol_1 = require("../../lib/machines/protocol");
+exports.MACHINE_TRANSPORT = { MEMORY: 'memory', NATS: 'nats', MQTT: 'mqtt' };
+exports.ESCALATION_FEED = { MEMORY: 'memory', CORE: 'core', IN_PROCESS: 'in-process' };
+/** The generic line protocol's topic root when MACHINE_TOPIC_ROOT is unset. */
+exports.DEFAULT_TOPIC_ROOT = 'line/v1';
+const SWITCH = { ON: 'on', OFF: 'off' };
+function oneOf(name, value, allowed) {
+    if (!allowed.includes(value)) {
+        throw new Error(`${name}="${value}" is not one of ${allowed.join(', ')}`);
+    }
+    return value;
+}
+function int(env, name, fallback) {
+    const raw = env[name];
+    if (raw === undefined || raw === '')
+        return fallback;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 0)
+        throw new Error(`${name}="${raw}" must be a non-negative integer`);
+    return n;
+}
+function percentStep(env, name, fallback) {
+    const n = int(env, name, fallback);
+    if (n > 100)
+        throw new Error(`${name}="${n}" must be at most 100`);
+    return n;
+}
+function required(env, name, mode) {
+    const value = env[name];
+    if (!value)
+        throw new Error(`MACHINE_TRANSPORT=${mode} needs ${name}`);
+    return value;
+}
+function mqttEndpoint(env, mode, defaultVersion) {
+    const version = int(env, 'MACHINE_MQTT_PROTOCOL', defaultVersion);
+    if (version !== 4 && version !== 5)
+        throw new Error('MACHINE_MQTT_PROTOCOL must be 4 or 5');
+    return {
+        url: required(env, 'MACHINE_MQTT_URL', mode),
+        protocolVersion: version,
+        caFile: env.MACHINE_MQTT_CA,
+        certFile: env.MACHINE_MQTT_CERT,
+        keyFile: env.MACHINE_MQTT_KEY,
+        username: env.MACHINE_MQTT_USERNAME,
+        password: env.MACHINE_MQTT_PASSWORD,
+    };
+}
+const DEFAULT_FEED = {
+    memory: exports.ESCALATION_FEED.MEMORY,
+    nats: exports.ESCALATION_FEED.CORE,
+    mqtt: exports.ESCALATION_FEED.CORE,
+};
+function loadMachineLineConfig(env = process.env) {
+    const transport = oneOf('MACHINE_TRANSPORT', env.MACHINE_TRANSPORT ?? exports.MACHINE_TRANSPORT.MEMORY, Object.values(exports.MACHINE_TRANSPORT));
+    const feed = oneOf('MACHINE_ESCALATION_FEED', env.MACHINE_ESCALATION_FEED ?? DEFAULT_FEED[transport], Object.values(exports.ESCALATION_FEED));
+    const config = {
+        transport,
+        feed,
+        topicRoot: env.MACHINE_TOPIC_ROOT ?? exports.DEFAULT_TOPIC_ROOT,
+        lineConfigPath: env.MACHINE_LINE_CONFIG || undefined,
+        replyTimeoutMs: int(env, 'MACHINE_REPLY_TIMEOUT_MS', protocol_1.REPLY_DEADLINE_MS),
+        dispatchAttempts: Math.max(1, int(env, 'MACHINE_DISPATCH_ATTEMPTS', 3)),
+        handoffTimeout: env.MACHINE_HANDOFF_TIMEOUT ?? '10m',
+        offlineDebounceMs: int(env, 'MACHINE_OFFLINE_DEBOUNCE_MS', 15_000),
+        quietMs: int(env, 'MACHINE_QUIET_MS', 90_000),
+        dispatchTtlMs: int(env, 'MACHINE_DISPATCH_TTL_MS', 600_000),
+        receiptDelayMs: int(env, 'MACHINE_RECEIPT_DELAY_MS', 250),
+        lifecycle: oneOf('MACHINE_LIFECYCLE', env.MACHINE_LIFECYCLE || SWITCH.OFF, Object.values(SWITCH)) === SWITCH.ON,
+        progressStep: percentStep(env, 'MACHINE_PROGRESS_STEP', 25),
+        ltBaseUrl: env.LT_BASE_URL ?? 'http://localhost:3000',
+    };
+    if (transport === exports.MACHINE_TRANSPORT.NATS) {
+        // A site NATS of its own; without one, the streams are Long Tail's messaging.
+        config.siteNatsUrl = env.MACHINE_SITE_NATS_URL || undefined;
+        config.siteNatsUser = env.MACHINE_SITE_NATS_USER;
+        config.siteNatsPassword = env.MACHINE_SITE_NATS_PASSWORD;
+        config.mqtt = mqttEndpoint(env, transport, 5);
+    }
+    if (transport === exports.MACHINE_TRANSPORT.MQTT)
+        config.mqtt = mqttEndpoint(env, transport, 5);
+    if (feed === exports.ESCALATION_FEED.CORE) {
+        config.ltNatsUrl = env.NATS_URL || undefined;
+        config.ltNatsToken = env.NATS_TOKEN;
+    }
+    return config;
+}