@furystack/cross-node-bus 1.0.0

package/esm/in-process-cross-node-bus.spec.js

@@ -0,0 +1,737 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { describe, expect, it, vi } from 'vitest';
+import { CrossNodeBusTelemetry } from './cross-node-bus-telemetry.js';
+import { ReplayWindowExceededError } from './errors.js';
+import { InProcessCrossNodeBus } from './in-process-cross-node-bus.js';
+import { MemoryBroker } from './memory-broker.js';
+const collect = async (iterable) => {
+    const out = [];
+    for await (const message of iterable)
+        out.push(message);
+    return out;
+};
+describe('InProcessCrossNodeBus', () => {
+    describe('basics', () => {
+        it('exposes a non-empty nodeId by default', () => {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_1, new InProcessCrossNodeBus(), false);
+                expect(typeof bus.nodeId).toBe('string');
+                expect(bus.nodeId.length).toBeGreaterThan(0);
+                expect(bus.nodeId.startsWith('local-')).toBe(true);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        });
+        it('honors a caller-supplied nodeId', () => {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_2, new InProcessCrossNodeBus({ nodeId: 'fixed' }), false);
+                expect(bus.nodeId).toBe('fixed');
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        });
+        it('declares replay + assignsSequence capabilities and non-persistent', () => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_3, new InProcessCrossNodeBus(), false);
+                expect(bus.capabilities).toEqual({ persistent: false, replay: true, assignsSequence: true });
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        });
+    });
+    describe('publish + subscribe', () => {
+        it('delivers self-published messages by default', async () => {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_4, new InProcessCrossNodeBus({ nodeId: 'self' }), false);
+                const handler = vi.fn();
+                const _sub = __addDisposableResource(env_4, bus.subscribe('topic', handler), false);
+                await bus.publish('topic', { n: 1 });
+                expect(handler).toHaveBeenCalledTimes(1);
+                const message = handler.mock.calls[0]?.[0];
+                expect(message.originId).toBe('self');
+                expect(message.payload).toEqual({ n: 1 });
+                expect(message.seq).toBe('1');
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
+        });
+        it('multiplexes a single broker subscription across local handlers', async () => {
+            const broker = new MemoryBroker();
+            const brokerSubscribe = vi.spyOn(broker, 'subscribe');
+            try {
+                const env_5 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_5, new InProcessCrossNodeBus({ broker, nodeId: 'self' }), false);
+                    const _a = __addDisposableResource(env_5, bus.subscribe('topic', () => undefined), false);
+                    const _b = __addDisposableResource(env_5, bus.subscribe('topic', () => undefined), false);
+                    const _c = __addDisposableResource(env_5, bus.subscribe('topic', () => undefined), false);
+                    expect(brokerSubscribe).toHaveBeenCalledTimes(1);
+                }
+                catch (e_5) {
+                    env_5.error = e_5;
+                    env_5.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_5);
+                }
+            }
+            finally {
+                broker[Symbol.dispose]();
+            }
+        });
+        it('releases the broker subscription when the last local handler disposes', async () => {
+            const env_6 = { stack: [], error: void 0, hasError: false };
+            try {
+                const broker = __addDisposableResource(env_6, new MemoryBroker(), false);
+                const bus = __addDisposableResource(env_6, new InProcessCrossNodeBus({ broker, nodeId: 'self' }), false);
+                const handler = vi.fn();
+                const sub = bus.subscribe('topic', handler);
+                sub[Symbol.dispose]();
+                await bus.publish('topic', null);
+                expect(handler).not.toHaveBeenCalled();
+                const handler2 = vi.fn();
+                const _sub2 = __addDisposableResource(env_6, bus.subscribe('topic', handler2), false);
+                await bus.publish('topic', null);
+                expect(handler2).toHaveBeenCalledTimes(1);
+            }
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
+            }
+            finally {
+                __disposeResources(env_6);
+            }
+        });
+        it('isolates one local handler error from another and from the bus', async () => {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_7, new InProcessCrossNodeBus({ nodeId: 'self' }), false);
+                const ok = vi.fn();
+                const _failing = __addDisposableResource(env_7, bus.subscribe('topic', () => {
+                    throw new Error('boom');
+                }), false);
+                const _ok = __addDisposableResource(env_7, bus.subscribe('topic', ok), false);
+                await expect(bus.publish('topic', null)).resolves.toBeUndefined();
+                expect(ok).toHaveBeenCalledTimes(1);
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        });
+        it('subscribeRemoteOnly skips messages originating on this node', async () => {
+            const env_8 = { stack: [], error: void 0, hasError: false };
+            try {
+                const broker = __addDisposableResource(env_8, new MemoryBroker(), false);
+                const busA = __addDisposableResource(env_8, new InProcessCrossNodeBus({ broker, nodeId: 'a' }), false);
+                const busB = __addDisposableResource(env_8, new InProcessCrossNodeBus({ broker, nodeId: 'b' }), false);
+                const handler = vi.fn();
+                const _sub = __addDisposableResource(env_8, busA.subscribeRemoteOnly('topic', handler), false);
+                await busA.publish('topic', { from: 'a' });
+                await busB.publish('topic', { from: 'b' });
+                expect(handler).toHaveBeenCalledTimes(1);
+                expect((handler.mock.calls[0]?.[0]).originId).toBe('b');
+            }
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
+            }
+            finally {
+                __disposeResources(env_8);
+            }
+        });
+    });
+    describe('topicPrefix + subscribeForeign', () => {
+        it('prefixes topics on the wire and isolates buses with different prefixes', async () => {
+            const env_9 = { stack: [], error: void 0, hasError: false };
+            try {
+                const broker = __addDisposableResource(env_9, new MemoryBroker(), false);
+                const svcA = __addDisposableResource(env_9, new InProcessCrossNodeBus({ broker, nodeId: 'a', topicPrefix: 'svc-a/' }), false);
+                const svcB = __addDisposableResource(env_9, new InProcessCrossNodeBus({ broker, nodeId: 'b', topicPrefix: 'svc-b/' }), false);
+                const onA = vi.fn();
+                const onB = vi.fn();
+                const _subA = __addDisposableResource(env_9, svcA.subscribe('events', onA), false);
+                const _subB = __addDisposableResource(env_9, svcB.subscribe('events', onB), false);
+                await svcA.publish('events', { from: 'a' });
+                expect(onA).toHaveBeenCalledTimes(1);
+                expect(onB).not.toHaveBeenCalled();
+            }
+            catch (e_9) {
+                env_9.error = e_9;
+                env_9.hasError = true;
+            }
+            finally {
+                __disposeResources(env_9);
+            }
+        });
+        it('subscribeForeign delivers messages from a foreign prefix on demand', async () => {
+            const env_10 = { stack: [], error: void 0, hasError: false };
+            try {
+                const broker = __addDisposableResource(env_10, new MemoryBroker(), false);
+                const svcA = __addDisposableResource(env_10, new InProcessCrossNodeBus({ broker, nodeId: 'a', topicPrefix: 'svc-a/' }), false);
+                const svcB = __addDisposableResource(env_10, new InProcessCrossNodeBus({ broker, nodeId: 'b', topicPrefix: 'svc-b/' }), false);
+                const eavesdrop = vi.fn();
+                const _foreign = __addDisposableResource(env_10, svcB.subscribeForeign('svc-a/', 'events', eavesdrop), false);
+                await svcA.publish('events', { from: 'a' });
+                expect(eavesdrop).toHaveBeenCalledTimes(1);
+                expect((eavesdrop.mock.calls[0]?.[0]).originId).toBe('a');
+            }
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
+            }
+            finally {
+                __disposeResources(env_10);
+            }
+        });
+    });
+    describe('replay', () => {
+        it('yields messages newer than fromSeq', async () => {
+            const env_11 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_11, new InProcessCrossNodeBus({ nodeId: 'a' }), false);
+                await bus.publish('topic', { n: 1 });
+                await bus.publish('topic', { n: 2 });
+                await bus.publish('topic', { n: 3 });
+                const yielded = await collect(bus.replay('topic', '1'));
+                expect(yielded.map((m) => m.payload.n)).toEqual([2, 3]);
+            }
+            catch (e_11) {
+                env_11.error = e_11;
+                env_11.hasError = true;
+            }
+            finally {
+                __disposeResources(env_11);
+            }
+        });
+        it('throws ReplayWindowExceededError when fromSeq is too old', () => {
+            const bus = new InProcessCrossNodeBus({ replayWindow: 2 });
+            try {
+                void bus.publish('topic', null);
+                void bus.publish('topic', null);
+                void bus.publish('topic', null);
+                expect(() => bus.replay('topic', '0')).toThrow(ReplayWindowExceededError);
+            }
+            finally {
+                bus[Symbol.dispose]();
+            }
+        });
+    });
+    describe('telemetry', () => {
+        it('emits onCrossNodePublished with byteLength after a successful publish', async () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            try {
+                const env_12 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_12, new InProcessCrossNodeBus({ nodeId: 'a', telemetry }), false);
+                    const events = [];
+                    const _sub = __addDisposableResource(env_12, telemetry.subscribe('onCrossNodePublished', (event) => {
+                        events.push(event);
+                    }), false);
+                    await bus.publish('topic', { hi: 'there' });
+                    expect(events).toEqual([
+                        { topic: 'topic', originId: 'a', byteLength: Buffer.byteLength(JSON.stringify({ hi: 'there' })) },
+                    ]);
+                }
+                catch (e_12) {
+                    env_12.error = e_12;
+                    env_12.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_12);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+        it('emits onCrossNodeReceived once per arrival regardless of handler count', async () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            try {
+                const env_13 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_13, new InProcessCrossNodeBus({ nodeId: 'a', telemetry }), false);
+                    const arrivals = vi.fn();
+                    const _sub = __addDisposableResource(env_13, telemetry.subscribe('onCrossNodeReceived', arrivals), false);
+                    const _h1 = __addDisposableResource(env_13, bus.subscribe('topic', () => undefined), false);
+                    const _h2 = __addDisposableResource(env_13, bus.subscribe('topic', () => undefined), false);
+                    const _h3 = __addDisposableResource(env_13, bus.subscribe('topic', () => undefined), false);
+                    await bus.publish('topic', null);
+                    expect(arrivals).toHaveBeenCalledTimes(1);
+                }
+                catch (e_13) {
+                    env_13.error = e_13;
+                    env_13.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_13);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+        it('emits onCrossNodeError with phase=subscribe when a local handler throws', async () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            try {
+                const env_14 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_14, new InProcessCrossNodeBus({ nodeId: 'a', telemetry }), false);
+                    const errors = [];
+                    const _sub = __addDisposableResource(env_14, telemetry.subscribe('onCrossNodeError', (event) => {
+                        errors.push(event);
+                    }), false);
+                    const _failing = __addDisposableResource(env_14, bus.subscribe('topic', () => {
+                        throw new Error('boom');
+                    }), false);
+                    await bus.publish('topic', null);
+                    expect(errors).toHaveLength(1);
+                    expect(errors[0]?.phase).toBe('subscribe');
+                    expect(errors[0]?.topic).toBe('topic');
+                }
+                catch (e_14) {
+                    env_14.error = e_14;
+                    env_14.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_14);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+        it('emits onCrossNodeError with phase=subscribe when a direct broker subscriber throws during fan-out', async () => {
+            const env_15 = { stack: [], error: void 0, hasError: false };
+            try {
+                const telemetry = new CrossNodeBusTelemetry();
+                const broker = __addDisposableResource(env_15, new MemoryBroker(), false);
+                try {
+                    const env_16 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const bus = __addDisposableResource(env_16, new InProcessCrossNodeBus({ broker, nodeId: 'a', telemetry }), false);
+                        const errors = [];
+                        const _sub = __addDisposableResource(env_16, telemetry.subscribe('onCrossNodeError', (event) => {
+                            errors.push(event);
+                        })
+                        // A direct broker subscriber bypasses the bus's `#deliver` try/catch;
+                        // its throw routes through the broker's `onSubscriberError` sink.
+                        , false);
+                        // A direct broker subscriber bypasses the bus's `#deliver` try/catch;
+                        // its throw routes through the broker's `onSubscriberError` sink.
+                        const _failing = __addDisposableResource(env_16, broker.subscribe('topic', () => {
+                            throw new Error('boom');
+                        }), false);
+                        await bus.publish('topic', null);
+                        expect(errors.some((event) => event.phase === 'subscribe' && event.topic === 'topic')).toBe(true);
+                    }
+                    catch (e_15) {
+                        env_16.error = e_15;
+                        env_16.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_16);
+                    }
+                }
+                finally {
+                    telemetry[Symbol.dispose]();
+                }
+            }
+            catch (e_16) {
+                env_15.error = e_16;
+                env_15.hasError = true;
+            }
+            finally {
+                __disposeResources(env_15);
+            }
+        });
+        it('emits onCrossNodeError with phase=subscribe when broker.subscribe throws on first hookup', () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            const broker = new MemoryBroker();
+            try {
+                const env_17 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_17, new InProcessCrossNodeBus({ broker, nodeId: 'a', telemetry }), false);
+                    const errors = [];
+                    const _sub = __addDisposableResource(env_17, telemetry.subscribe('onCrossNodeError', (event) => {
+                        errors.push(event);
+                    }), false);
+                    broker[Symbol.dispose]();
+                    expect(() => bus.subscribe('topic', () => undefined)).toThrow(/disposed/);
+                    expect(errors.some((event) => event.phase === 'subscribe')).toBe(true);
+                }
+                catch (e_17) {
+                    env_17.error = e_17;
+                    env_17.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_17);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+        it('emits onCrossNodeError with phase=publish when the broker rejects publish', async () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            const broker = new MemoryBroker();
+            try {
+                const env_18 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_18, new InProcessCrossNodeBus({ broker, nodeId: 'a', telemetry }), false);
+                    const errors = [];
+                    const _sub = __addDisposableResource(env_18, telemetry.subscribe('onCrossNodeError', (event) => {
+                        errors.push(event);
+                    }), false);
+                    broker[Symbol.dispose]();
+                    await expect(bus.publish('topic', null)).rejects.toThrow(/disposed/);
+                    expect(errors.some((event) => event.phase === 'publish')).toBe(true);
+                }
+                catch (e_18) {
+                    env_18.error = e_18;
+                    env_18.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_18);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+        it('emits onCrossNodeError with phase=replay when the underlying broker rejects', () => {
+            const env_19 = { stack: [], error: void 0, hasError: false };
+            try {
+                const telemetry = new CrossNodeBusTelemetry();
+                const broker = __addDisposableResource(env_19, new MemoryBroker({ replayWindow: 1 }), false);
+                try {
+                    const env_20 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const bus = __addDisposableResource(env_20, new InProcessCrossNodeBus({ broker, nodeId: 'a', telemetry }), false);
+                        const errors = [];
+                        const _sub = __addDisposableResource(env_20, telemetry.subscribe('onCrossNodeError', (event) => {
+                            errors.push(event);
+                        }), false);
+                        void bus.publish('topic', null);
+                        void bus.publish('topic', null);
+                        expect(() => bus.replay('topic', '0')).toThrow();
+                        expect(errors.some((event) => event.phase === 'replay')).toBe(true);
+                    }
+                    catch (e_19) {
+                        env_20.error = e_19;
+                        env_20.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_20);
+                    }
+                }
+                finally {
+                    telemetry[Symbol.dispose]();
+                }
+            }
+            catch (e_20) {
+                env_19.error = e_20;
+                env_19.hasError = true;
+            }
+            finally {
+                __disposeResources(env_19);
+            }
+        });
+        it('emits onCrossNodeWindowEvicted with displayTopic when a private broker rolls', async () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            try {
+                const env_21 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_21, new InProcessCrossNodeBus({ nodeId: 'a', telemetry, replayWindow: 2 }), false);
+                    const evictions = [];
+                    const _sub = __addDisposableResource(env_21, telemetry.subscribe('onCrossNodeWindowEvicted', (event) => {
+                        evictions.push(event);
+                    })
+                    // No subscriber → displayTopic falls back to wire (= 'topic' here, no prefix)
+                    , false);
+                    // No subscriber → displayTopic falls back to wire (= 'topic' here, no prefix)
+                    await bus.publish('topic', null); // seq 1
+                    await bus.publish('topic', null); // seq 2
+                    await bus.publish('topic', null); // seq 3 → evicts seq 1
+                    expect(evictions).toEqual([{ topic: 'topic', evictedSeq: '1', retainedCount: 2 }]);
+                }
+                catch (e_21) {
+                    env_21.error = e_21;
+                    env_21.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_21);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+        it('attributes window-evicted topic to the original subscribe call when topicPrefix is set', async () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            try {
+                const env_22 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_22, new InProcessCrossNodeBus({ nodeId: 'a', telemetry, replayWindow: 2, topicPrefix: 'svc-a/' }), false);
+                    const _h = __addDisposableResource(env_22, bus.subscribe('events', () => undefined), false);
+                    const evictions = [];
+                    const _sub = __addDisposableResource(env_22, telemetry.subscribe('onCrossNodeWindowEvicted', (event) => {
+                        evictions.push({ topic: event.topic });
+                    }), false);
+                    await bus.publish('events', null);
+                    await bus.publish('events', null);
+                    await bus.publish('events', null); // first eviction
+                    expect(evictions).toEqual([{ topic: 'events' }]);
+                }
+                catch (e_22) {
+                    env_22.error = e_22;
+                    env_22.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_22);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+        it('does not emit onCrossNodeWindowEvicted when the broker is supplied externally', async () => {
+            const env_23 = { stack: [], error: void 0, hasError: false };
+            try {
+                const telemetry = new CrossNodeBusTelemetry();
+                const broker = __addDisposableResource(env_23, new MemoryBroker({ replayWindow: 2 }), false);
+                try {
+                    const env_24 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const bus = __addDisposableResource(env_24, new InProcessCrossNodeBus({ broker, nodeId: 'a', telemetry }), false);
+                        const onEvicted = vi.fn();
+                        const _sub = __addDisposableResource(env_24, telemetry.subscribe('onCrossNodeWindowEvicted', onEvicted), false);
+                        await bus.publish('topic', null);
+                        await bus.publish('topic', null);
+                        await bus.publish('topic', null);
+                        expect(onEvicted).not.toHaveBeenCalled();
+                    }
+                    catch (e_23) {
+                        env_24.error = e_23;
+                        env_24.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_24);
+                    }
+                }
+                finally {
+                    telemetry[Symbol.dispose]();
+                }
+            }
+            catch (e_24) {
+                env_23.error = e_24;
+                env_23.hasError = true;
+            }
+            finally {
+                __disposeResources(env_23);
+            }
+        });
+        it('emits onCrossNodeError with phase=serialize when JSON.stringify throws', async () => {
+            const telemetry = new CrossNodeBusTelemetry();
+            try {
+                const env_25 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const bus = __addDisposableResource(env_25, new InProcessCrossNodeBus({ nodeId: 'a', telemetry }), false);
+                    const errors = [];
+                    const _sub = __addDisposableResource(env_25, telemetry.subscribe('onCrossNodeError', (event) => {
+                        errors.push(event);
+                    }), false);
+                    const cycle = {};
+                    cycle.self = cycle;
+                    await bus.publish('topic', cycle);
+                    expect(errors.some((event) => event.phase === 'serialize')).toBe(true);
+                }
+                catch (e_25) {
+                    env_25.error = e_25;
+                    env_25.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_25);
+                }
+            }
+            finally {
+                telemetry[Symbol.dispose]();
+            }
+        });
+    });
+    describe('compareSeq', () => {
+        it('returns negative, zero, positive for a<b, a==b, a>b', () => {
+            const env_26 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_26, new InProcessCrossNodeBus(), false);
+                expect(bus.compareSeq('1', '2')).toBeLessThan(0);
+                expect(bus.compareSeq('5', '5')).toBe(0);
+                expect(bus.compareSeq('10', '2')).toBeGreaterThan(0);
+            }
+            catch (e_26) {
+                env_26.error = e_26;
+                env_26.hasError = true;
+            }
+            finally {
+                __disposeResources(env_26);
+            }
+        });
+    });
+    describe('oldestSeq', () => {
+        it('returns undefined before any publish', () => {
+            const env_27 = { stack: [], error: void 0, hasError: false };
+            try {
+                const bus = __addDisposableResource(env_27, new InProcessCrossNodeBus(), false);
+                expect(bus.oldestSeq('topic')).toBeUndefined();
+            }
+            catch (e_27) {
+                env_27.error = e_27;
+                env_27.hasError = true;
+            }
+            finally {
+                __disposeResources(env_27);
+            }
+        });
+        it('returns the oldest retained seq honoring topicPrefix', async () => {
+            const env_28 = { stack: [], error: void 0, hasError: false };
+            try {
+                const broker = __addDisposableResource(env_28, new MemoryBroker(), false);
+                const bus = __addDisposableResource(env_28, new InProcessCrossNodeBus({ broker, topicPrefix: 'svc/' }), false);
+                await bus.publish('topic', null);
+                await bus.publish('topic', null);
+                expect(bus.oldestSeq('topic')).toBe('1');
+                // direct broker access proves the prefix was applied on the wire.
+                expect(broker.oldestSeq('svc/topic')).toBe('1');
+            }
+            catch (e_28) {
+                env_28.error = e_28;
+                env_28.hasError = true;
+            }
+            finally {
+                __disposeResources(env_28);
+            }
+        });
+        it('throws after dispose', () => {
+            const bus = new InProcessCrossNodeBus();
+            bus[Symbol.dispose]();
+            expect(() => bus.oldestSeq('topic')).toThrow(/disposed/);
+        });
+    });
+    describe('disposal', () => {
+        it('rejects publish/subscribe/replay after dispose', async () => {
+            const bus = new InProcessCrossNodeBus();
+            bus[Symbol.dispose]();
+            expect(() => bus.subscribe('topic', () => undefined)).toThrow(/disposed/);
+            expect(() => bus.subscribeForeign('p/', 'topic', () => undefined)).toThrow(/disposed/);
+            expect(() => bus.replay('topic', '0')).toThrow(/disposed/);
+            await expect(bus.publish('topic', null)).rejects.toThrow(/disposed/);
+        });
+        it('is idempotent', () => {
+            const bus = new InProcessCrossNodeBus();
+            bus[Symbol.dispose]();
+            expect(() => bus[Symbol.dispose]()).not.toThrow();
+        });
+        it('disposes its private broker when it owns one', () => {
+            const bus = new InProcessCrossNodeBus();
+            const handler = vi.fn();
+            const sub = bus.subscribe('topic', handler);
+            bus[Symbol.dispose]();
+            expect(() => sub[Symbol.dispose]()).not.toThrow();
+        });
+        it('does not dispose a shared broker', () => {
+            const env_29 = { stack: [], error: void 0, hasError: false };
+            try {
+                const broker = __addDisposableResource(env_29, new MemoryBroker(), false);
+                const bus = new InProcessCrossNodeBus({ broker });
+                bus[Symbol.dispose]();
+                expect(() => broker.publish('topic', 'a', null)).not.toThrow();
+            }
+            catch (e_29) {
+                env_29.error = e_29;
+                env_29.hasError = true;
+            }
+            finally {
+                __disposeResources(env_29);
+            }
+        });
+    });
+});
+//# sourceMappingURL=in-process-cross-node-bus.spec.js.map