@hotmeshio/long-tail 0.25.4 → 0.27.0

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

@@ -0,0 +1,24 @@
+/**
+ * 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 { ConsumerSpec, StreamSpec } from '../../../types/messaging';
+import { type LineCodec } from '../protocol/codec';
+export declare const LINE_STREAM: {
+    readonly EVENTS: "LINE_EVENTS";
+    readonly TELEMETRY: "LINE_TELEMETRY";
+};
+/** 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 subject: levels become tokens, `+` becomes `*`, `#` becomes `>`. */
+export declare function filterToSubject(filter: string): string;
+/** 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[];
+/**
+ * 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 lineEventConsumerSpec(codec: StreamCodec | string, siteId: string, lineId: string, name: string): ConsumerSpec;

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

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * 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.lineStreamSpecs = lineStreamSpecs;
+exports.telemetrySubjects = telemetrySubjects;
+exports.lineEventConsumerSpec = lineEventConsumerSpec;
+const codec_1 = require("../protocol/codec");
+exports.LINE_STREAM = {
+    EVENTS: 'LINE_EVENTS',
+    TELEMETRY: 'LINE_TELEMETRY',
+};
+const DAY_MS = 86_400_000;
+const ACK_WAIT_MS = 30_000;
+const GENERIC = (root) => ({ root, channels: codec_1.GENERIC_CHANNELS });
+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 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), 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 = codecOf(codec);
+    return subjectsFor(c, c.channels.telemetry, siteId, lineId);
+}
+/**
+ * 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 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>;
+}

package/build/lib/messaging/memory.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMessagingProvider = void 0;
+const constants_1 = require("./constants");
+const subjects_1 = require("./subjects");
+const DEFAULT_NAK_DELAY_MS = 1_000;
+class MemoryPubSub {
+    constructor() {
+        this.subs = new Set();
+    }
+    async publish(subject, payload) {
+        for (const sub of [...this.subs])
+            if ((0, subjects_1.subjectMatches)(sub.filter, subject))
+                sub.handler({ subject, payload });
+    }
+    subscribe(filter, handler) {
+        const sub = { filter, handler };
+        this.subs.add(sub);
+        return { close: async () => { this.subs.delete(sub); } };
+    }
+}
+class MemoryStreams {
+    constructor() {
+        this.streams = new Map();
+    }
+    async ensureStream(spec) {
+        const existing = this.streams.get(spec.name);
+        if (existing)
+            existing.spec = spec;
+        else
+            this.streams.set(spec.name, { spec, messages: [], seq: 0, consumers: new Map(), wake: new Set() });
+    }
+    async ensureConsumer(stream, spec) {
+        const s = this.stream(stream);
+        const existing = s.consumers.get(spec.name);
+        if (existing) {
+            existing.spec = { ...existing.spec, filterSubjects: spec.filterSubjects };
+            return;
+        }
+        const floor = (spec.startAt ?? constants_1.START_AT.NEW) === constants_1.START_AT.ALL ? 0 : s.seq;
+        s.consumers.set(spec.name, { spec, floor, settled: new Set(), deliveries: new Map(), retryAt: new Map() });
+    }
+    async append(subject, payload) {
+        const now = Date.now();
+        for (const s of this.streams.values()) {
+            if (!s.spec.subjects.some((f) => (0, subjects_1.subjectMatches)(f, subject)))
+                continue;
+            s.messages.push({ seq: ++s.seq, subject, payload, at: now });
+            s.messages = s.messages.filter((m) => now - m.at <= s.spec.maxAgeMs);
+            for (const wake of [...s.wake])
+                wake();
+        }
+    }
+    async consume(stream, consumer, handler, opts = {}) {
+        const s = this.stream(stream);
+        const c = s.consumers.get(consumer);
+        if (!c)
+            throw new Error(`stream ${stream} has no consumer ${consumer}; ensure it first`);
+        const nakDelayMs = opts.nakDelayMs ?? DEFAULT_NAK_DELAY_MS;
+        let open = true;
+        let running = false;
+        let timer;
+        const next = () => {
+            const now = Date.now();
+            let waitMs;
+            for (const m of s.messages) {
+                if (m.seq <= c.floor || c.settled.has(m.seq))
+                    continue;
+                if (!c.spec.filterSubjects.some((f) => (0, subjects_1.subjectMatches)(f, m.subject)))
+                    continue;
+                const at = c.retryAt.get(m.seq);
+                if (at === undefined || at <= now)
+                    return { message: m };
+                waitMs = Math.min(waitMs ?? Infinity, at - now);
+            }
+            return { waitMs };
+        };
+        const pump = async () => {
+            if (running || !open)
+                return;
+            running = true;
+            try {
+                for (let step = next(); open && step.message; step = next()) {
+                    const m = step.message;
+                    const deliveries = (c.deliveries.get(m.seq) ?? 0) + 1;
+                    c.deliveries.set(m.seq, deliveries);
+                    const outcome = await handler({ subject: m.subject, payload: m.payload, deliveries }).catch(() => constants_1.DELIVERY.NAK);
+                    if (outcome === constants_1.DELIVERY.NAK) {
+                        c.retryAt.set(m.seq, Date.now() + nakDelayMs);
+                    }
+                    else {
+                        c.settled.add(m.seq);
+                        c.retryAt.delete(m.seq);
+                    }
+                }
+                const { waitMs } = next();
+                if (open && waitMs !== undefined) {
+                    clearTimeout(timer);
+                    timer = setTimeout(() => void pump(), Math.max(0, waitMs));
+                }
+            }
+            finally {
+                running = false;
+            }
+        };
+        const wake = () => void pump();
+        s.wake.add(wake);
+        void pump();
+        return {
+            close: async () => {
+                open = false;
+                clearTimeout(timer);
+                s.wake.delete(wake);
+            },
+        };
+    }
+    stream(name) {
+        const s = this.streams.get(name);
+        if (!s)
+            throw new Error(`no stream ${name}; ensure it first`);
+        return s;
+    }
+}
+class MemoryMessagingProvider {
+    constructor() {
+        this.name = 'memory';
+        this.pubsub = new MemoryPubSub();
+        this.streams = new MemoryStreams();
+        this.live = false;
+    }
+    get connected() {
+        return this.live;
+    }
+    async connect() {
+        this.live = true;
+    }
+    async disconnect() {
+        this.live = false;
+    }
+}
+exports.MemoryMessagingProvider = MemoryMessagingProvider;

package/build/lib/messaging/nats/permissions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * JetStream rights scoped to named streams and one durable consumer: look up,
+ * create and update those streams, create, read and acknowledge through that
+ * consumer, and nothing else. Deleting or purging a stream is not granted.
+ */
+export interface JsScope {
+    streams: string[];
+    durable: string;
+}
+export declare function jsPermissions({ streams, durable }: JsScope): {
+    publish: string[];
+    subscribe: string[];
+};

package/build/lib/messaging/nats/permissions.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * JetStream rights scoped to named streams and one durable consumer: look up,
+ * create and update those streams, create, read and acknowledge through that
+ * consumer, and nothing else. Deleting or purging a stream is not granted.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsPermissions = jsPermissions;
+function jsPermissions({ streams, durable }) {
+    const perStream = streams.flatMap((s) => [
+        `$JS.API.STREAM.INFO.${s}`,
+        `$JS.API.STREAM.CREATE.${s}`,
+        `$JS.API.STREAM.UPDATE.${s}`,
+        `$JS.API.CONSUMER.INFO.${s}.${durable}`,
+        `$JS.API.CONSUMER.CREATE.${s}.${durable}`,
+        `$JS.API.CONSUMER.CREATE.${s}.${durable}.>`,
+        `$JS.API.CONSUMER.DURABLE.CREATE.${s}.${durable}`,
+        `$JS.API.CONSUMER.MSG.NEXT.${s}.${durable}`,
+        `$JS.ACK.${s}.${durable}.>`,
+    ]);
+    return { publish: ['$JS.API.INFO', ...perStream], subscribe: ['_INBOX.>'] };
+}

package/build/lib/messaging/nats/provider.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Messaging on NATS. One connection carries pub/sub (core NATS subjects) and,
+ * when the server runs JetStream for this account, durable streams. Without
+ * JetStream the provider still serves pub/sub and reports no streams.
+ */
+import type { LTMessagingProvider, LTPubSub, LTStreams } from '../../../types/messaging';
+export interface NatsMessagingOptions {
+    url: string;
+    /** Token auth, or user and password; neither for an open server. */
+    token?: string;
+    user?: string;
+    password?: string;
+    /** The connection's name on the server. */
+    name?: string;
+}
+export declare class NatsMessagingProvider implements LTMessagingProvider {
+    private readonly opts;
+    readonly name = "nats";
+    readonly pubsub: LTPubSub;
+    private nc;
+    private durable;
+    constructor(opts: NatsMessagingOptions);
+    get connected(): boolean;
+    get streams(): LTStreams | null;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /** Streams when the account has JetStream; null otherwise, and pub/sub still serves. */
+    private jetStream;
+    private connection;
+}

package/build/lib/messaging/nats/provider.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Messaging on NATS. One connection carries pub/sub (core NATS subjects) and,
+ * when the server runs JetStream for this account, durable streams. Without
+ * JetStream the provider still serves pub/sub and reports no streams.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsMessagingProvider = void 0;
+const nats_1 = require("nats");
+const logger_1 = require("../../logger");
+const constants_1 = require("../constants");
+const streams_1 = require("./streams");
+class NatsPubSub {
+    constructor(nc) {
+        this.nc = nc;
+    }
+    async publish(subject, payload) {
+        this.nc().publish(subject, payload);
+    }
+    subscribe(filter, handler) {
+        const sub = this.nc().subscribe(filter, {
+            callback: (err, m) => { if (!err)
+                handler({ subject: m.subject, payload: (0, streams_1.payloadOf)(m) }); },
+        });
+        return { close: async () => { sub.unsubscribe(); } };
+    }
+}
+class NatsMessagingProvider {
+    constructor(opts) {
+        this.opts = opts;
+        this.name = 'nats';
+        this.pubsub = new NatsPubSub(() => this.connection());
+        this.nc = null;
+        this.durable = null;
+    }
+    get connected() {
+        return !!this.nc && !this.nc.isClosed();
+    }
+    get streams() {
+        return this.durable;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        const { url, token, user, password, name } = this.opts;
+        this.nc = await (0, nats_1.connect)({ servers: url, token, user, pass: password, name });
+        this.durable = await this.jetStream(this.nc);
+    }
+    async disconnect() {
+        if (!this.nc)
+            return;
+        await this.nc.drain();
+        this.nc = null;
+        this.durable = null;
+    }
+    /** Streams when the account has JetStream; null otherwise, and pub/sub still serves. */
+    async jetStream(nc) {
+        try {
+            const jsm = await nc.jetstreamManager();
+            await jsm.getAccountInfo();
+            return new streams_1.NatsStreams(jsm, nc.jetstream());
+        }
+        catch (err) {
+            const reason = String(err?.message ?? err?.code ?? err);
+            if (!/jetstream not enabled|503|no responders/i.test(reason)) {
+                logger_1.loggerRegistry.warn(`${constants_1.MESSAGING_LOG.STREAMS_UNAVAILABLE} provider=${this.name} reason=${reason}`);
+            }
+            return null;
+        }
+    }
+    connection() {
+        if (!this.nc)
+            throw new Error('NATS messaging is not connected; call connect() first');
+        return this.nc;
+    }
+}
+exports.NatsMessagingProvider = NatsMessagingProvider;