@hotmeshio/long-tail 0.25.4 → 0.27.0

package/build/lib/machines/transport/mqtt-bus.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * The gateway over plain MQTT, for any broker. The persistent session keeps
+ * QoS 1 messages while the gateway is away; there is no stream to replay
+ * beyond that, and a message that is not yet actionable is retried in this
+ * process.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MqttMachineBus = void 0;
+const mqtt_session_1 = require("./mqtt-session");
+const serial_1 = require("./serial");
+class MqttMachineBus {
+    constructor(endpoint, clientId, filter, nakDelayMs = 1_000) {
+        this.endpoint = endpoint;
+        this.clientId = clientId;
+        this.filter = filter;
+        this.redelivery = new serial_1.LocalRedelivery(new serial_1.SerialQueue(), nakDelayMs);
+    }
+    async connect() {
+        this.session = await mqtt_session_1.MqttSession.open(this.endpoint, this.clientId);
+    }
+    async consume(handler) {
+        await this.connected().subscribe(this.filter, (msg) => {
+            void this.redelivery.deliver((deliveries) => handler({ ...msg, deliveries }));
+        });
+    }
+    async publish(topic, payload, opts = {}) {
+        await this.connected().publish(topic, payload, 1, opts.retain ?? false);
+    }
+    retained(filter) {
+        return this.connected().retained(filter);
+    }
+    async close() {
+        await this.redelivery.stop();
+        await this.session?.close(true);
+    }
+    connected() {
+        if (!this.session)
+            throw new Error('MQTT bus used before connect()');
+        return this.session;
+    }
+}
+exports.MqttMachineBus = MqttMachineBus;

package/build/lib/machines/transport/mqtt-link.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The machine side over MQTT: one persistent session per machine, logged in
+ * with its own credentials, with a will that marks it offline.
+ */
+import type { MqttEndpoint } from '../../../services/machines/config';
+import type { InboundMessage, LinkConnectOptions, MachineLink, PublishOptions } from './delivery';
+export declare class MqttMachineLink implements MachineLink {
+    private readonly endpoint;
+    private session?;
+    constructor(endpoint: MqttEndpoint);
+    get connected(): boolean;
+    connect(opts: LinkConnectOptions): Promise<void>;
+    publish(topic: string, payload: string, opts: PublishOptions): Promise<void>;
+    subscribe(filter: string, handler: (msg: InboundMessage) => void): Promise<void>;
+    disconnect(graceful: boolean): Promise<void>;
+}

package/build/lib/machines/transport/mqtt-link.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * The machine side over MQTT: one persistent session per machine, logged in
+ * with its own credentials, with a will that marks it offline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MqttMachineLink = void 0;
+const mqtt_session_1 = require("./mqtt-session");
+class MqttMachineLink {
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+    }
+    get connected() {
+        return !!this.session?.connected;
+    }
+    async connect(opts) {
+        if (this.session)
+            await this.session.close(false);
+        this.session = await mqtt_session_1.MqttSession.open(this.endpoint, opts.clientId, { will: opts.will, onRestored: opts.onRestored });
+    }
+    async publish(topic, payload, opts) {
+        if (!this.session)
+            throw new Error(`publish before connect: ${topic}`);
+        await this.session.publish(topic, payload, opts.qos, opts.retain ?? false);
+    }
+    async subscribe(filter, handler) {
+        if (!this.session)
+            throw new Error('subscribe before connect');
+        await this.session.subscribe(filter, handler);
+    }
+    async disconnect(graceful) {
+        const session = this.session;
+        this.session = undefined;
+        await session?.close(graceful);
+    }
+}
+exports.MqttMachineLink = MqttMachineLink;

package/build/lib/machines/transport/mqtt-session.d.ts

@@ -0,0 +1,34 @@
+/**
+ * One MQTT client with a persistent session (clean start off), shared by the
+ * machine link and the controller buses. A session resumed after a restart
+ * delivers queued QoS 1 messages right after the connect acknowledgement,
+ * before anyone has subscribed again; those are held in the process until a
+ * handler for their topic registers, so a queued command is not dropped.
+ */
+import type { IClientOptions, MqttClient } from 'mqtt';
+import type { MqttEndpoint } from '../../../services/machines/config';
+import { type InboundMessage, type LinkWill } from './delivery';
+type Handler = (msg: InboundMessage) => void;
+export interface SessionOptions {
+    will?: LinkWill;
+    onRestored?: () => void;
+}
+/** Client options for one identity; `{clientId}` in a path or username picks that identity's credentials. */
+export declare function mqttOptions(endpoint: MqttEndpoint, clientId: string, will?: LinkWill): IClientOptions;
+export declare class MqttSession {
+    readonly client: MqttClient;
+    private handlers;
+    private held;
+    private constructor();
+    /** Connect and wait for the broker's acknowledgement; a refusal rejects. */
+    static open(endpoint: MqttEndpoint, clientId: string, opts?: SessionOptions): Promise<MqttSession>;
+    get connected(): boolean;
+    subscribe(filter: string, handler: Handler): Promise<void>;
+    publish(topic: string, payload: string, qos: 0 | 1, retain?: boolean): Promise<void>;
+    /** Retained messages under `filter`, as the broker sends them on subscribe. */
+    retained(filter: string, settleMs?: number): Promise<InboundMessage[]>;
+    /** Graceful sends DISCONNECT, so the broker drops the will; otherwise the socket just closes. */
+    close(graceful: boolean): Promise<void>;
+    private route;
+}
+export {};

package/build/lib/machines/transport/mqtt-session.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * One MQTT client with a persistent session (clean start off), shared by the
+ * machine link and the controller buses. A session resumed after a restart
+ * delivers queued QoS 1 messages right after the connect acknowledgement,
+ * before anyone has subscribed again; those are held in the process until a
+ * handler for their topic registers, so a queued command is not dropped.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MqttSession = void 0;
+exports.mqttOptions = mqttOptions;
+const fs_1 = require("fs");
+const delivery_1 = require("./delivery");
+const HELD_LIMIT = 1_000;
+const MQTT_MISSING = 'the MQTT transport needs the "mqtt" package (npm install mqtt)';
+/** mqtt is an optional peer dependency, loaded only when an MQTT transport is used. */
+function loadMqtt() {
+    try {
+        return require('mqtt');
+    }
+    catch (err) {
+        const error = new Error(MQTT_MISSING);
+        error.cause = err;
+        throw error;
+    }
+}
+const SESSION_EXPIRY_SEC = 86_400;
+const RECONNECT_MS = 1_000;
+const CONNECT_TIMEOUT_MS = 10_000;
+/** Client options for one identity; `{clientId}` in a path or username picks that identity's credentials. */
+function mqttOptions(endpoint, clientId, will) {
+    const fill = (value) => value?.split('{clientId}').join(clientId);
+    const file = (path) => (path ? (0, fs_1.readFileSync)(fill(path)) : undefined);
+    return {
+        clientId,
+        protocolVersion: endpoint.protocolVersion,
+        clean: false,
+        ...(endpoint.protocolVersion === 5 ? { properties: { sessionExpiryInterval: SESSION_EXPIRY_SEC } } : {}),
+        ca: file(endpoint.caFile),
+        cert: file(endpoint.certFile),
+        key: file(endpoint.keyFile),
+        username: fill(endpoint.username),
+        password: endpoint.password,
+        reconnectPeriod: RECONNECT_MS,
+        connectTimeout: CONNECT_TIMEOUT_MS,
+        will: will ? { topic: will.topic, payload: Buffer.from(will.payload), qos: 1, retain: will.retain } : undefined,
+    };
+}
+class MqttSession {
+    constructor(client) {
+        this.client = client;
+        this.handlers = [];
+        this.held = [];
+        client.on('message', (topic, payload, packet) => {
+            this.route({ topic, payload: payload.toString(), retained: packet.retain, deliveries: packet.dup ? 2 : 1 });
+        });
+    }
+    /** Connect and wait for the broker's acknowledgement; a refusal rejects. */
+    static open(endpoint, clientId, opts = {}) {
+        const client = loadMqtt().connect(endpoint.url, mqttOptions(endpoint, clientId, opts.will));
+        const session = new MqttSession(client);
+        return new Promise((resolve, reject) => {
+            const fail = (err) => {
+                client.end(true);
+                reject(new Error(`MQTT ${clientId} could not connect to ${endpoint.url}: ${err.message}`));
+            };
+            client.once('error', fail);
+            client.once('connect', () => {
+                client.off('error', fail);
+                client.on('error', () => undefined);
+                client.on('connect', () => opts.onRestored?.());
+                resolve(session);
+            });
+        });
+    }
+    get connected() {
+        return this.client.connected;
+    }
+    async subscribe(filter, handler) {
+        this.handlers.push({ filter, handler });
+        const ready = this.held.filter((m) => (0, delivery_1.topicMatches)(filter, m.topic));
+        this.held = this.held.filter((m) => !(0, delivery_1.topicMatches)(filter, m.topic));
+        await this.client.subscribeAsync(filter, { qos: 1 });
+        for (const m of ready)
+            handler(m);
+    }
+    async publish(topic, payload, qos, retain = false) {
+        await this.client.publishAsync(topic, payload, { qos, retain });
+    }
+    /** Retained messages under `filter`, as the broker sends them on subscribe. */
+    async retained(filter, settleMs = 250) {
+        const seen = [];
+        const collect = (topic, payload, packet) => {
+            if (packet.retain && (0, delivery_1.topicMatches)(filter, topic))
+                seen.push({ topic, payload: payload.toString(), retained: true, deliveries: 1 });
+        };
+        this.client.on('message', collect);
+        try {
+            await this.client.subscribeAsync(filter, { qos: 1 });
+            await new Promise((r) => setTimeout(r, settleMs));
+            await this.client.unsubscribeAsync(filter);
+        }
+        finally {
+            this.client.off('message', collect);
+        }
+        return seen;
+    }
+    /** Graceful sends DISCONNECT, so the broker drops the will; otherwise the socket just closes. */
+    async close(graceful) {
+        if (graceful)
+            await this.client.endAsync(false);
+        else
+            this.client.end(true);
+    }
+    route(msg) {
+        const matching = this.handlers.filter((h) => (0, delivery_1.topicMatches)(h.filter, msg.topic));
+        if (matching.length) {
+            for (const h of matching)
+                h.handler(msg);
+            return;
+        }
+        this.held.push(msg);
+        if (this.held.length > HELD_LIMIT)
+            this.held.shift();
+    }
+}
+exports.MqttSession = MqttSession;

package/build/lib/machines/transport/nats-bus.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The gateway on a NATS server of the site's own (MACHINE_SITE_NATS_*): the
+ * stream bus on a NATS messaging provider this bus connects and closes itself.
+ * With Long Tail's messaging configured, the stream bus runs on that instead.
+ */
+import type { MqttEndpoint } from '../../../services/machines/config';
+import type { StreamCodec } from './streams';
+import type { Disposition, InboundMessage, MachineBus } from './delivery';
+export interface NatsBusOptions {
+    natsUrl: string;
+    user?: string;
+    password?: string;
+    mqtt: MqttEndpoint;
+    /** The gateway's broker identity; also its MQTT client id. */
+    controllerId: string;
+    siteId: string;
+    lineId: string;
+    /** The codec's topics: which subjects are durable events and which are live telemetry. */
+    codec: StreamCodec;
+    nakDelayMs?: number;
+}
+export declare class NatsMachineBus implements MachineBus {
+    private readonly opts;
+    private readonly provider;
+    private bus?;
+    constructor(opts: NatsBusOptions);
+    get durableName(): string;
+    connect(): Promise<void>;
+    consume(handler: (msg: InboundMessage) => Promise<Disposition>): Promise<void>;
+    publish(topic: string, payload: string, opts?: {
+        retain?: boolean;
+    }): Promise<void>;
+    retained(filter: string): Promise<InboundMessage[]>;
+    close(): Promise<void>;
+    private stream;
+}

package/build/lib/machines/transport/nats-bus.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * The gateway on a NATS server of the site's own (MACHINE_SITE_NATS_*): the
+ * stream bus on a NATS messaging provider this bus connects and closes itself.
+ * With Long Tail's messaging configured, the stream bus runs on that instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsMachineBus = void 0;
+const provider_1 = require("../../messaging/nats/provider");
+const stream_bus_1 = require("./stream-bus");
+class NatsMachineBus {
+    constructor(opts) {
+        this.opts = opts;
+        this.provider = new provider_1.NatsMessagingProvider({ url: opts.natsUrl, user: opts.user, password: opts.password, name: opts.controllerId });
+    }
+    get durableName() {
+        return `${this.opts.controllerId}-events`;
+    }
+    async connect() {
+        await this.provider.connect();
+        const streams = this.provider.streams;
+        if (!streams)
+            throw new Error(`the site NATS at ${this.opts.natsUrl} has no JetStream for the gateway`);
+        const { natsUrl: _url, user: _user, password: _password, ...rest } = this.opts;
+        this.bus = new stream_bus_1.StreamMachineBus({ ...rest, streams, pubsub: this.provider.pubsub });
+        await this.bus.connect();
+    }
+    consume(handler) {
+        return this.stream().consume(handler);
+    }
+    publish(topic, payload, opts) {
+        return this.stream().publish(topic, payload, opts);
+    }
+    retained(filter) {
+        return this.stream().retained(filter);
+    }
+    async close() {
+        await this.bus?.close();
+        await this.provider.disconnect();
+    }
+    stream() {
+        if (!this.bus)
+            throw new Error('NATS bus used before connect()');
+        return this.bus;
+    }
+}
+exports.NatsMachineBus = NatsMachineBus;

package/build/lib/machines/transport/nats-feed.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Long Tail's escalation events for a gateway running outside Long Tail: a
+ * subscription to Long Tail's NATS. Nothing is replayed; a not-yet-actionable
+ * event is retried in this process, and the gateway reconciles open rows
+ * when it starts leading a line.
+ */
+import { type Disposition, type EscalationEvent, type EscalationFeed } from './delivery';
+type Handler = (event: EscalationEvent) => Promise<Disposition>;
+/** Long Tail publishes every LTEvent as `lt.events.<type>`. */
+export declare const LT_ESCALATION_SUBJECTS = "lt.events.system.escalation.>";
+export interface CoreFeedOptions {
+    natsUrl: string;
+    token?: string;
+    nakDelayMs?: number;
+}
+export declare class CoreEscalationFeed implements EscalationFeed {
+    private readonly opts;
+    private nc?;
+    private sub?;
+    private readonly redelivery;
+    constructor(opts: CoreFeedOptions);
+    connect(): Promise<void>;
+    consume(handler: Handler): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/build/lib/machines/transport/nats-feed.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Long Tail's escalation events for a gateway running outside Long Tail: a
+ * subscription to Long Tail's NATS. Nothing is replayed; a not-yet-actionable
+ * event is retried in this process, and the gateway reconciles open rows
+ * when it starts leading a line.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreEscalationFeed = exports.LT_ESCALATION_SUBJECTS = void 0;
+const nats_1 = require("nats");
+const streams_1 = require("../../messaging/nats/streams");
+const serial_1 = require("./serial");
+const delivery_1 = require("./delivery");
+/** Long Tail publishes every LTEvent as `lt.events.<type>`. */
+exports.LT_ESCALATION_SUBJECTS = 'lt.events.system.escalation.>';
+function decode(payload) {
+    try {
+        return (0, delivery_1.toEscalationEvent)(JSON.parse(payload));
+    }
+    catch {
+        return null;
+    }
+}
+class CoreEscalationFeed {
+    constructor(opts) {
+        this.opts = opts;
+        this.redelivery = new serial_1.LocalRedelivery(new serial_1.SerialQueue(), opts.nakDelayMs ?? 1_000);
+    }
+    async connect() {
+        this.nc = await (0, nats_1.connect)({ servers: this.opts.natsUrl, token: this.opts.token, name: 'line-gateway-escalations' });
+    }
+    async consume(handler) {
+        if (!this.nc)
+            throw new Error('escalation feed used before connect()');
+        this.sub = this.nc.subscribe(exports.LT_ESCALATION_SUBJECTS, {
+            callback: (_err, m) => {
+                const event = decode((0, streams_1.payloadOf)(m));
+                if (event)
+                    void this.redelivery.deliver(() => handler(event));
+            },
+        });
+    }
+    async close() {
+        this.sub?.unsubscribe();
+        await this.redelivery.stop();
+        await this.nc?.drain();
+    }
+}
+exports.CoreEscalationFeed = CoreEscalationFeed;

package/build/lib/machines/transport/pubsub-feed.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Long Tail's escalation events for a gateway running outside Long Tail, over
+ * Long Tail's messaging pub/sub. Nothing is replayed; a not-yet-actionable
+ * event is retried in this process, and the gateway reconciles open rows when
+ * it starts leading a line.
+ */
+import type { LTPubSub } from '../../../types/messaging';
+import { type Disposition, type EscalationEvent, type EscalationFeed } from './delivery';
+export declare class PubSubEscalationFeed implements EscalationFeed {
+    private readonly pubsub;
+    private sub?;
+    private readonly redelivery;
+    constructor(pubsub: LTPubSub, nakDelayMs?: number);
+    connect(): Promise<void>;
+    consume(handler: (event: EscalationEvent) => Promise<Disposition>): Promise<void>;
+    close(): Promise<void>;
+}

package/build/lib/machines/transport/pubsub-feed.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Long Tail's escalation events for a gateway running outside Long Tail, over
+ * Long Tail's messaging pub/sub. Nothing is replayed; a not-yet-actionable
+ * event is retried in this process, and the gateway reconciles open rows when
+ * it starts leading a line.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSubEscalationFeed = void 0;
+const constants_1 = require("../../messaging/constants");
+const serial_1 = require("./serial");
+const delivery_1 = require("./delivery");
+class PubSubEscalationFeed {
+    constructor(pubsub, nakDelayMs = 1_000) {
+        this.pubsub = pubsub;
+        this.redelivery = new serial_1.LocalRedelivery(new serial_1.SerialQueue(), nakDelayMs);
+    }
+    async connect() {
+        // The shared connection belongs to Long Tail's messaging registry.
+    }
+    async consume(handler) {
+        this.sub = this.pubsub.subscribe(constants_1.LT_SUBJECTS.ESCALATIONS, (m) => {
+            let event = null;
+            try {
+                event = (0, delivery_1.toEscalationEvent)(JSON.parse(m.payload));
+            }
+            catch {
+                event = null;
+            }
+            if (event)
+                void this.redelivery.deliver(() => handler(event));
+        });
+    }
+    async close() {
+        await this.sub?.close();
+        await this.redelivery.stop();
+    }
+}
+exports.PubSubEscalationFeed = PubSubEscalationFeed;

package/build/lib/machines/transport/serial.d.ts

@@ -0,0 +1,21 @@
+import { type Disposition } from './delivery';
+/** Runs async work one item at a time, in arrival order. */
+export declare class SerialQueue {
+    private tail;
+    run<T>(work: () => Promise<T>): Promise<T>;
+    /** Resolves once everything queued so far has run. */
+    drained(): Promise<void>;
+}
+/**
+ * Delivery through a SerialQueue that tries a not-yet-actionable item again
+ * after a delay, for transports without a broker-side redelivery.
+ */
+export declare class LocalRedelivery {
+    readonly queue: SerialQueue;
+    private readonly delayMs;
+    private readonly timers;
+    private stopped;
+    constructor(queue: SerialQueue, delayMs: number);
+    deliver(attempt: (deliveries: number) => Promise<Disposition>, deliveries?: number): Promise<void>;
+    stop(): Promise<void>;
+}

package/build/lib/machines/transport/serial.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRedelivery = exports.SerialQueue = void 0;
+const delivery_1 = require("./delivery");
+/** Runs async work one item at a time, in arrival order. */
+class SerialQueue {
+    constructor() {
+        this.tail = Promise.resolve();
+    }
+    run(work) {
+        const next = this.tail.then(work, work);
+        this.tail = next.catch(() => undefined);
+        return next;
+    }
+    /** Resolves once everything queued so far has run. */
+    drained() {
+        return this.tail.then(() => undefined);
+    }
+}
+exports.SerialQueue = SerialQueue;
+/**
+ * Delivery through a SerialQueue that tries a not-yet-actionable item again
+ * after a delay, for transports without a broker-side redelivery.
+ */
+class LocalRedelivery {
+    constructor(queue, delayMs) {
+        this.queue = queue;
+        this.delayMs = delayMs;
+        this.timers = new Set();
+        this.stopped = false;
+    }
+    deliver(attempt, deliveries = 1) {
+        return this.queue.run(async () => {
+            if (this.stopped)
+                return;
+            const disposition = await attempt(deliveries).catch(() => delivery_1.DISPOSITION.NAK);
+            if (disposition !== delivery_1.DISPOSITION.NAK)
+                return;
+            const timer = setTimeout(() => {
+                this.timers.delete(timer);
+                void this.deliver(attempt, deliveries + 1);
+            }, this.delayMs);
+            this.timers.add(timer);
+        });
+    }
+    async stop() {
+        this.stopped = true;
+        for (const t of this.timers)
+            clearTimeout(t);
+        this.timers.clear();
+        await this.queue.drained();
+    }
+}
+exports.LocalRedelivery = LocalRedelivery;

package/build/lib/machines/transport/stream-bus.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The gateway on Long Tail's messaging capability. Machine events come from the
+ * line's durable consumer on LINE_EVENTS (replayed after a restart); telemetry
+ * is read live, since it only proves a machine is alive. Commands leave through
+ * an MQTT session at QoS 1 on the site broker, which queues them for a machine
+ * that is away; retained machine state is read there too.
+ */
+import type { LTPubSub, LTStreams } from '../../../types/messaging';
+import type { MqttEndpoint } from '../../../services/machines/config';
+import { type StreamCodec } from './streams';
+import type { Disposition, InboundMessage, MachineBus } from './delivery';
+export interface StreamBusOptions {
+    streams: LTStreams;
+    pubsub: LTPubSub;
+    mqtt: MqttEndpoint;
+    /** The gateway's broker identity; also its MQTT client id and the root of its consumer's name. */
+    controllerId: string;
+    siteId: string;
+    lineId: string;
+    /** The codec's topics: which subjects are durable events and which are live telemetry. */
+    codec: StreamCodec;
+    nakDelayMs?: number;
+}
+export declare class StreamMachineBus implements MachineBus {
+    private readonly opts;
+    private session?;
+    private subs;
+    /** Events and telemetry reach the gateway one at a time, in arrival order. */
+    private readonly queue;
+    constructor(opts: StreamBusOptions);
+    get durableName(): string;
+    connect(): Promise<void>;
+    consume(handler: (msg: InboundMessage) => Promise<Disposition>): Promise<void>;
+    publish(topic: string, payload: string, opts?: {
+        retain?: boolean;
+    }): Promise<void>;
+    retained(filter: string): Promise<InboundMessage[]>;
+    close(): Promise<void>;
+    private mqtt;
+}

package/build/lib/machines/transport/stream-bus.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * The gateway on Long Tail's messaging capability. Machine events come from the
+ * line's durable consumer on LINE_EVENTS (replayed after a restart); telemetry
+ * is read live, since it only proves a machine is alive. Commands leave through
+ * an MQTT session at QoS 1 on the site broker, which queues them for a machine
+ * that is away; retained machine state is read there too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamMachineBus = void 0;
+const protocol_1 = require("../protocol");
+const mqtt_session_1 = require("./mqtt-session");
+const serial_1 = require("./serial");
+const streams_1 = require("./streams");
+class StreamMachineBus {
+    constructor(opts) {
+        this.opts = opts;
+        this.subs = [];
+        /** Events and telemetry reach the gateway one at a time, in arrival order. */
+        this.queue = new serial_1.SerialQueue();
+    }
+    get durableName() {
+        return `${this.opts.controllerId}-events`;
+    }
+    async connect() {
+        const { streams, codec, siteId, lineId, controllerId } = this.opts;
+        for (const spec of (0, streams_1.lineStreamSpecs)(codec))
+            await streams.ensureStream(spec);
+        await streams.ensureConsumer(streams_1.LINE_STREAM.EVENTS, (0, streams_1.lineEventConsumerSpec)(codec, siteId, lineId, this.durableName));
+        this.session = await mqtt_session_1.MqttSession.open(this.opts.mqtt, controllerId);
+    }
+    async consume(handler) {
+        const { streams, pubsub, codec, siteId, lineId, nakDelayMs = 1_000 } = this.opts;
+        this.subs.push(await streams.consume(streams_1.LINE_STREAM.EVENTS, this.durableName, (m) => this.queue.run(() => handler({ topic: (0, protocol_1.toTopic)(m.subject), payload: m.payload, deliveries: m.deliveries })), { nakDelayMs }));
+        for (const subject of (0, streams_1.telemetrySubjects)(codec, siteId, lineId)) {
+            this.subs.push(pubsub.subscribe(subject, (m) => void this.queue.run(() => handler({ topic: (0, protocol_1.toTopic)(m.subject), payload: m.payload, deliveries: 1 }))));
+        }
+    }
+    async publish(topic, payload, opts = {}) {
+        await this.mqtt().publish(topic, payload, 1, opts.retain ?? false);
+    }
+    retained(filter) {
+        return this.mqtt().retained(filter);
+    }
+    async close() {
+        for (const sub of this.subs.splice(0))
+            await sub.close();
+        await this.queue.drained();
+        await this.session?.close(true);
+    }
+    mqtt() {
+        if (!this.session)
+            throw new Error('stream bus used before connect()');
+        return this.session;
+    }
+}
+exports.StreamMachineBus = StreamMachineBus;