@hotmeshio/long-tail 0.26.0 → 0.27.0

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/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;

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

@@ -1,9 +1,9 @@
 /**
- * The site's durable log. Machine events and telemetry each land in a
- * JetStream stream; the gateway reads events through a durable consumer, so
- * a restart or a link outage replays instead of losing.
+ * The line's durable log, as specs for the messaging capability. Machine
+ * events and telemetry each land in a stream; the gateway reads events through
+ * a durable consumer, so a restart or a link outage replays instead of losing.
  */
-import { type ConsumerConfig, type JetStreamManager, type StreamConfig } from 'nats';
+import type { ConsumerSpec, StreamSpec } from '../../../types/messaging';
 import { type LineCodec } from '../protocol/codec';
 export declare const LINE_STREAM: {
     readonly EVENTS: "LINE_EVENTS";
@@ -11,18 +11,14 @@ export declare const LINE_STREAM: {
 };
 /** What the streams need from a codec: its root, channels and topic layout. */
 export type StreamCodec = Pick<LineCodec, 'root' | 'channels' | 'topicFor'>;
-/** An MQTT filter as a NATS subject: levels become tokens, `+` becomes `*`, `#` becomes `>`. */
+/** An MQTT filter as a subject: levels become tokens, `+` becomes `*`, `#` becomes `>`. */
 export declare function filterToSubject(filter: string): string;
-/** The site's streams, for every line under the codec's root; a root alone means the generic layout. */
-export declare function lineStreamConfigs(codec: StreamCodec | string): Partial<StreamConfig>[];
+/** The line streams, for every line under the codec's root; a root alone means the generic layout. */
+export declare function lineStreamSpecs(codec: StreamCodec | string): StreamSpec[];
 /** The telemetry subjects for one line, read live rather than replayed. */
 export declare function telemetrySubjects(codec: StreamCodec | string, siteId: string, lineId: string): string[];
 /**
- * A durable consumer. It starts at new messages the first time (open rows
- * are reconciled at boot); after that its position survives restarts.
+ * One line's event consumer. It starts at new messages the first time (open
+ * rows are reconciled at boot); after that its position survives restarts.
  */
-export declare function durableConsumer(name: string, filterSubjects: string[]): Partial<ConsumerConfig>;
-export declare function lineEventConsumer(codec: StreamCodec | string, siteId: string, lineId: string, name: string): Partial<ConsumerConfig>;
-/** Create or update each stream, then the consumer. Safe on every boot. */
-export declare function ensureStreams(jsm: JetStreamManager, streams: Partial<StreamConfig>[]): Promise<void>;
-export declare function ensureConsumer(jsm: JetStreamManager, stream: string, config: Partial<ConsumerConfig>): Promise<void>;
+export declare function lineEventConsumerSpec(codec: StreamCodec | string, siteId: string, lineId: string, name: string): ConsumerSpec;

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

@@ -1,19 +1,15 @@
 "use strict";
 /**
- * The site's durable log. Machine events and telemetry each land in a
- * JetStream stream; the gateway reads events through a durable consumer, so
- * a restart or a link outage replays instead of losing.
+ * The line's durable log, as specs for the messaging capability. Machine
+ * events and telemetry each land in a stream; the gateway reads events through
+ * a durable consumer, so a restart or a link outage replays instead of losing.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LINE_STREAM = void 0;
 exports.filterToSubject = filterToSubject;
-exports.lineStreamConfigs = lineStreamConfigs;
+exports.lineStreamSpecs = lineStreamSpecs;
 exports.telemetrySubjects = telemetrySubjects;
-exports.durableConsumer = durableConsumer;
-exports.lineEventConsumer = lineEventConsumer;
-exports.ensureStreams = ensureStreams;
-exports.ensureConsumer = ensureConsumer;
-const nats_1 = require("nats");
+exports.lineEventConsumerSpec = lineEventConsumerSpec;
 const codec_1 = require("../protocol/codec");
 exports.LINE_STREAM = {
     EVENTS: 'LINE_EVENTS',
@@ -22,71 +18,32 @@ exports.LINE_STREAM = {
 const DAY_MS = 86_400_000;
 const ACK_WAIT_MS = 30_000;
 const GENERIC = (root) => ({ root, channels: codec_1.GENERIC_CHANNELS });
-/** An MQTT filter as a NATS subject: levels become tokens, `+` becomes `*`, `#` becomes `>`. */
+const codecOf = (codec) => (typeof codec === 'string' ? GENERIC(codec) : codec);
+/** An MQTT filter as a subject: levels become tokens, `+` becomes `*`, `#` becomes `>`. */
 function filterToSubject(filter) {
     return filter.split('/').map((level) => (level === '+' ? '*' : level === '#' ? '>' : level)).join('.');
 }
 function subjectsFor(codec, channels, siteId, lineId) {
     return channels.map((c) => filterToSubject((0, codec_1.topicOf)(codec, { siteId, lineId }, c)));
 }
-/** The site's streams, for every line under the codec's root; a root alone means the generic layout. */
-function lineStreamConfigs(codec) {
-    const c = typeof codec === 'string' ? GENERIC(codec) : codec;
+/** The line streams, for every line under the codec's root; a root alone means the generic layout. */
+function lineStreamSpecs(codec) {
+    const c = codecOf(codec);
     return [
-        { name: exports.LINE_STREAM.EVENTS, subjects: subjectsFor(c, c.channels.events), max_age: (0, nats_1.nanos)(30 * DAY_MS), storage: nats_1.StorageType.File },
-        { name: exports.LINE_STREAM.TELEMETRY, subjects: subjectsFor(c, c.channels.telemetry), max_age: (0, nats_1.nanos)(3 * DAY_MS), storage: nats_1.StorageType.File },
+        { name: exports.LINE_STREAM.EVENTS, subjects: subjectsFor(c, c.channels.events), maxAgeMs: 30 * DAY_MS },
+        { name: exports.LINE_STREAM.TELEMETRY, subjects: subjectsFor(c, c.channels.telemetry), maxAgeMs: 3 * DAY_MS },
     ];
 }
 /** The telemetry subjects for one line, read live rather than replayed. */
 function telemetrySubjects(codec, siteId, lineId) {
-    const c = typeof codec === 'string' ? GENERIC(codec) : codec;
+    const c = codecOf(codec);
     return subjectsFor(c, c.channels.telemetry, siteId, lineId);
 }
 /**
- * A durable consumer. It starts at new messages the first time (open rows
- * are reconciled at boot); after that its position survives restarts.
+ * One line's event consumer. It starts at new messages the first time (open
+ * rows are reconciled at boot); after that its position survives restarts.
  */
-function durableConsumer(name, filterSubjects) {
-    return {
-        durable_name: name,
-        ack_policy: nats_1.AckPolicy.Explicit,
-        deliver_policy: nats_1.DeliverPolicy.New,
-        ack_wait: (0, nats_1.nanos)(ACK_WAIT_MS),
-        filter_subjects: filterSubjects,
-    };
-}
-function lineEventConsumer(codec, siteId, lineId, name) {
-    const c = typeof codec === 'string' ? GENERIC(codec) : codec;
-    return durableConsumer(name, subjectsFor(c, c.channels.events, siteId, lineId));
-}
-/** Create or update each stream, then the consumer. Safe on every boot. */
-async function ensureStreams(jsm, streams) {
-    for (const config of streams) {
-        try {
-            await jsm.streams.info(config.name);
-            await jsm.streams.update(config.name, config);
-        }
-        catch (err) {
-            if (!/stream not found/i.test(err?.message ?? ''))
-                throw err;
-            await jsm.streams.add(config);
-        }
-    }
-}
-async function ensureConsumer(jsm, stream, config) {
-    let existing;
-    try {
-        existing = await jsm.consumers.info(stream, config.durable_name);
-    }
-    catch (err) {
-        if (!/consumer not found/i.test(err?.message ?? ''))
-            throw err;
-        await jsm.consumers.add(stream, config);
-        return;
-    }
-    // The consumer keeps its position; only its subjects follow the codec's channels.
-    const want = [...(config.filter_subjects ?? [])].sort();
-    const have = [...(existing.config.filter_subjects ?? [])].sort();
-    if (want.join('|') !== have.join('|'))
-        await jsm.consumers.update(stream, config.durable_name, { filter_subjects: config.filter_subjects });
+function lineEventConsumerSpec(codec, siteId, lineId, name) {
+    const c = codecOf(codec);
+    return { name, filterSubjects: subjectsFor(c, c.channels.events, siteId, lineId), ackWaitMs: ACK_WAIT_MS, startAt: 'new' };
 }

package/build/lib/messaging/config.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Which messaging provider a deployment runs, from start() or the environment.
+ * Precedence: an explicit provider, then `messaging.nats` or `messaging.memory`,
+ * then LT_MESSAGING with LT_NATS_*, then `events.nats` (the same NATS, configured
+ * as events always have been). With none, Long Tail runs without messaging.
+ */
+import type { LTMessagingProvider } from '../../types/messaging';
+import type { LTStartConfig } from '../../types/startup';
+export declare const MESSAGING_KIND: {
+    readonly NATS: "nats";
+    readonly MEMORY: "memory";
+};
+/** What browsers need to reach the provider's events: a public WebSocket URL, a proxy target, a credential. */
+export interface MessagingWs {
+    url?: string;
+    proxy?: string;
+    token?: string;
+}
+export interface ResolvedMessaging {
+    provider: LTMessagingProvider | null;
+    ws: MessagingWs;
+}
+type Env = Record<string, string | undefined>;
+export declare function resolveMessaging(start: Pick<LTStartConfig, 'messaging' | 'events'>, env?: Env): ResolvedMessaging;
+export {};

package/build/lib/messaging/config.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Which messaging provider a deployment runs, from start() or the environment.
+ * Precedence: an explicit provider, then `messaging.nats` or `messaging.memory`,
+ * then LT_MESSAGING with LT_NATS_*, then `events.nats` (the same NATS, configured
+ * as events always have been). With none, Long Tail runs without messaging.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGING_KIND = void 0;
+exports.resolveMessaging = resolveMessaging;
+const config_1 = require("../../modules/config");
+const memory_1 = require("./memory");
+const provider_1 = require("./nats/provider");
+exports.MESSAGING_KIND = { NATS: 'nats', MEMORY: 'memory' };
+const NONE = { provider: null, ws: {} };
+function fromEnv(env) {
+    const kind = env.LT_MESSAGING;
+    if (!kind)
+        return null;
+    if (kind === exports.MESSAGING_KIND.MEMORY)
+        return { provider: new memory_1.MemoryMessagingProvider(), ws: {} };
+    if (kind !== exports.MESSAGING_KIND.NATS)
+        throw new Error(`LT_MESSAGING="${kind}" is not one of ${Object.values(exports.MESSAGING_KIND).join(', ')}`);
+    const url = env.LT_NATS_URL;
+    if (!url)
+        throw new Error('LT_MESSAGING=nats needs LT_NATS_URL');
+    const token = env.LT_NATS_TOKEN || undefined;
+    return {
+        provider: new provider_1.NatsMessagingProvider({ url, token, user: env.LT_NATS_USER || undefined, password: env.LT_NATS_PASSWORD || undefined, name: 'long-tail' }),
+        ws: { url: env.LT_NATS_WS_URL || undefined, proxy: env.LT_NATS_WS_PROXY || undefined, token },
+    };
+}
+function resolveMessaging(start, env = process.env) {
+    const m = start.messaging;
+    if (m?.provider)
+        return { provider: m.provider, ws: m.nats?.ws ?? {} };
+    if (m?.nats) {
+        const { ws, ...nats } = m.nats;
+        return { provider: new provider_1.NatsMessagingProvider({ name: 'long-tail', ...nats }), ws: { ...ws, token: ws?.token ?? nats.token } };
+    }
+    if (m?.memory)
+        return { provider: new memory_1.MemoryMessagingProvider(), ws: {} };
+    const configured = fromEnv(env);
+    if (configured)
+        return configured;
+    const legacy = start.events?.nats;
+    if (legacy) {
+        const token = legacy.token || config_1.config.NATS_TOKEN || undefined;
+        return {
+            provider: new provider_1.NatsMessagingProvider({ url: legacy.url || config_1.config.NATS_URL, token, name: 'long-tail' }),
+            ws: { url: legacy.wsUrl || config_1.config.NATS_WS_URL || undefined, proxy: legacy.wsProxy, token },
+        };
+    }
+    return NONE;
+}

package/build/lib/messaging/constants.d.ts

@@ -0,0 +1,26 @@
+/** Deliveries, log events and subjects for the messaging capability. */
+/** What a consumer does with a stream message. */
+export declare const DELIVERY: {
+    /** Handled; do not deliver again. */
+    readonly ACK: "ack";
+    /** Not yet actionable; deliver again after a delay. */
+    readonly NAK: "nak";
+    /** Never actionable; drop it. */
+    readonly TERM: "term";
+};
+/** Where a new consumer starts: only messages appended after it, or the whole retained history. */
+export declare const START_AT: {
+    readonly NEW: "new";
+    readonly ALL: "all";
+};
+export declare const MESSAGING_LOG: {
+    readonly CONNECTED: "messaging.provider.connected";
+    readonly DISCONNECTED: "messaging.provider.disconnected";
+    readonly CONNECT_FAILED: "messaging.provider.connect_failed";
+    readonly STREAMS_UNAVAILABLE: "messaging.provider.streams_unavailable";
+};
+/** Subjects Long Tail itself publishes under. */
+export declare const LT_SUBJECTS: {
+    readonly EVENTS: "lt.events";
+    readonly ESCALATIONS: "lt.events.system.escalation.>";
+};

package/build/lib/messaging/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+/** Deliveries, log events and subjects for the messaging capability. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LT_SUBJECTS = exports.MESSAGING_LOG = exports.START_AT = exports.DELIVERY = void 0;
+/** What a consumer does with a stream message. */
+exports.DELIVERY = {
+    /** Handled; do not deliver again. */
+    ACK: 'ack',
+    /** Not yet actionable; deliver again after a delay. */
+    NAK: 'nak',
+    /** Never actionable; drop it. */
+    TERM: 'term',
+};
+/** Where a new consumer starts: only messages appended after it, or the whole retained history. */
+exports.START_AT = { NEW: 'new', ALL: 'all' };
+exports.MESSAGING_LOG = {
+    CONNECTED: 'messaging.provider.connected',
+    DISCONNECTED: 'messaging.provider.disconnected',
+    CONNECT_FAILED: 'messaging.provider.connect_failed',
+    STREAMS_UNAVAILABLE: 'messaging.provider.streams_unavailable',
+};
+/** Subjects Long Tail itself publishes under. */
+exports.LT_SUBJECTS = {
+    EVENTS: 'lt.events',
+    ESCALATIONS: 'lt.events.system.escalation.>',
+};

package/build/lib/messaging/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The messaging registry: one provider, registered at startup and shared by
+ * every part of Long Tail that needs pub/sub or durable streams (events, the
+ * machine surface). Asking for messaging that is not configured fails loudly,
+ * because a caller that gets nothing back would believe it was handled.
+ */
+import type { LTMessagingProvider, LTPubSub, LTStreams } from '../../types/messaging';
+declare class LTMessagingRegistry {
+    private current;
+    /** Register the provider; replaces any registered before. Call before connect(). */
+    register(provider: LTMessagingProvider): void;
+    get hasProvider(): boolean;
+    get provider(): LTMessagingProvider;
+    get pubsub(): LTPubSub;
+    get streams(): LTStreams;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /** Forget the provider (tests). */
+    clear(): void;
+}
+export declare const messagingRegistry: LTMessagingRegistry;
+export { MemoryMessagingProvider } from './memory';
+export { subjectMatches, isSubject } from './subjects';
+export { DELIVERY, START_AT, MESSAGING_LOG, LT_SUBJECTS } from './constants';

package/build/lib/messaging/index.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * The messaging registry: one provider, registered at startup and shared by
+ * every part of Long Tail that needs pub/sub or durable streams (events, the
+ * machine surface). Asking for messaging that is not configured fails loudly,
+ * because a caller that gets nothing back would believe it was handled.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LT_SUBJECTS = exports.MESSAGING_LOG = exports.START_AT = exports.DELIVERY = exports.isSubject = exports.subjectMatches = exports.MemoryMessagingProvider = exports.messagingRegistry = void 0;
+const logger_1 = require("../logger");
+const constants_1 = require("./constants");
+const NOT_CONFIGURED = 'No messaging provider is configured: set LT_MESSAGING=nats with LT_NATS_URL, or pass start({ messaging })';
+class LTMessagingRegistry {
+    constructor() {
+        this.current = null;
+    }
+    /** Register the provider; replaces any registered before. Call before connect(). */
+    register(provider) {
+        this.current = provider;
+    }
+    get hasProvider() {
+        return this.current !== null;
+    }
+    get provider() {
+        if (!this.current)
+            throw new Error(NOT_CONFIGURED);
+        return this.current;
+    }
+    get pubsub() {
+        return this.provider.pubsub;
+    }
+    get streams() {
+        const streams = this.provider.streams;
+        if (!streams)
+            throw new Error(`Messaging provider ${this.provider.name} has no durable streams; enable JetStream on its NATS server`);
+        return streams;
+    }
+    async connect() {
+        if (!this.current || this.current.connected)
+            return;
+        await this.current.connect();
+        logger_1.loggerRegistry.info(`${constants_1.MESSAGING_LOG.CONNECTED} provider=${this.current.name} streams=${this.current.streams ? 'yes' : 'no'}`);
+    }
+    async disconnect() {
+        if (!this.current?.connected)
+            return;
+        await this.current.disconnect();
+        logger_1.loggerRegistry.info(`${constants_1.MESSAGING_LOG.DISCONNECTED} provider=${this.current.name}`);
+    }
+    /** Forget the provider (tests). */
+    clear() {
+        this.current = null;
+    }
+}
+exports.messagingRegistry = new LTMessagingRegistry();
+var memory_1 = require("./memory");
+Object.defineProperty(exports, "MemoryMessagingProvider", { enumerable: true, get: function () { return memory_1.MemoryMessagingProvider; } });
+var subjects_1 = require("./subjects");
+Object.defineProperty(exports, "subjectMatches", { enumerable: true, get: function () { return subjects_1.subjectMatches; } });
+Object.defineProperty(exports, "isSubject", { enumerable: true, get: function () { return subjects_1.isSubject; } });
+var constants_2 = require("./constants");
+Object.defineProperty(exports, "DELIVERY", { enumerable: true, get: function () { return constants_2.DELIVERY; } });
+Object.defineProperty(exports, "START_AT", { enumerable: true, get: function () { return constants_2.START_AT; } });
+Object.defineProperty(exports, "MESSAGING_LOG", { enumerable: true, get: function () { return constants_2.MESSAGING_LOG; } });
+Object.defineProperty(exports, "LT_SUBJECTS", { enumerable: true, get: function () { return constants_2.LT_SUBJECTS; } });

package/build/lib/messaging/memory.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Messaging in memory, for tests and single-process development. Pub/sub fans
+ * out to every matching subscriber. Streams keep each message until it ages
+ * out, and deliver to each consumer one at a time in order; a nak'd message
+ * comes back after its delay while later messages go on, as JetStream does.
+ */
+import type { LTMessagingProvider, LTPubSub, LTStreams } from '../../types/messaging';
+export declare class MemoryMessagingProvider implements LTMessagingProvider {
+    readonly name = "memory";
+    readonly pubsub: LTPubSub;
+    readonly streams: LTStreams;
+    private live;
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}