mvc-kit 2.12.0 → 2.12.1

package/src/Channel.test.ts

@@ -0,0 +1,957 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Channel, type ChannelStatus } from './Channel';
+import { EventBus } from './EventBus';
+import { ViewModel } from './ViewModel';
+import { singleton, teardownAll } from './singleton';
+
+// ── Test helpers ──────────────────────────────────────────────────
+
+interface TestMessages {
+  chat: { text: string };
+  typing: { userId: string };
+  status: { online: boolean };
+}
+
+class TestChannel extends Channel<TestMessages> {
+  openCalls: AbortSignal[] = [];
+  closeCalls = 0;
+  openBehavior: 'resolve' | 'reject' | 'pending' = 'resolve';
+  openError = new Error('connection failed');
+  private _pendingResolve: (() => void) | null = null;
+  private _pendingReject: ((e: Error) => void) | null = null;
+
+  // Deterministic delay for test predictability
+  protected override _calculateDelay() { return 1000; }
+
+  protected open(signal: AbortSignal): Promise<void> {
+    this.openCalls.push(signal);
+    if (this.openBehavior === 'resolve') {
+      return Promise.resolve();
+    }
+    if (this.openBehavior === 'reject') {
+      return Promise.reject(this.openError);
+    }
+    // pending — manual control
+    return new Promise<void>((resolve, reject) => {
+      this._pendingResolve = resolve;
+      this._pendingReject = reject;
+    });
+  }
+
+  protected close(): void {
+    this.closeCalls++;
+  }
+
+  // Test helpers
+  resolveOpen(): void { this._pendingResolve?.(); this._pendingResolve = null; }
+  rejectOpen(e?: Error): void { this._pendingReject?.(e ?? this.openError); this._pendingReject = null; }
+  simulateDisconnect(): void { this.disconnected(); }
+  simulateReceive<K extends keyof TestMessages>(type: K, payload: TestMessages[K]): void {
+    this.receive(type, payload);
+  }
+}
+
+class SyncOpenChannel extends Channel<TestMessages> {
+  openCalls = 0;
+  closeCalls = 0;
+
+  protected open(_signal: AbortSignal): void {
+    this.openCalls++;
+    // synchronous open — no Promise returned
+  }
+
+  protected close(): void {
+    this.closeCalls++;
+  }
+
+  simulateDisconnect(): void { this.disconnected(); }
+  simulateReceive<K extends keyof TestMessages>(type: K, payload: TestMessages[K]): void {
+    this.receive(type, payload);
+  }
+}
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe('Channel', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    teardownAll();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    teardownAll();
+  });
+
+  // ── Initialization & Dispose ────────────────────────────────────
+
+  describe('initialization', () => {
+    it('starts uninitialized and undisposed', () => {
+      const ch = new TestChannel();
+      expect(ch.initialized).toBe(false);
+      expect(ch.disposed).toBe(false);
+    });
+
+    it('init sets initialized flag', () => {
+      const ch = new TestChannel();
+      ch.init();
+      expect(ch.initialized).toBe(true);
+    });
+
+    it('init is idempotent', () => {
+      let calls = 0;
+      class InitChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() { calls++; }
+      }
+      const ch = new InitChannel();
+      ch.init();
+      ch.init();
+      expect(calls).toBe(1);
+    });
+
+    it('init does not run after dispose', () => {
+      let calls = 0;
+      class InitChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() { calls++; }
+      }
+      const ch = new InitChannel();
+      ch.dispose();
+      ch.init();
+      expect(calls).toBe(0);
+    });
+
+    it('onInit is called during init', () => {
+      let called = false;
+      class InitChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() { called = true; }
+      }
+      const ch = new InitChannel();
+      ch.init();
+      expect(called).toBe(true);
+    });
+  });
+
+  describe('dispose', () => {
+    it('sets disposed flag', () => {
+      const ch = new TestChannel();
+      ch.dispose();
+      expect(ch.disposed).toBe(true);
+    });
+
+    it('is idempotent', () => {
+      let calls = 0;
+      class DisposeChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onDispose() { calls++; }
+      }
+      const ch = new DisposeChannel();
+      ch.dispose();
+      ch.dispose();
+      expect(calls).toBe(1);
+    });
+
+    it('calls onDispose', () => {
+      let called = false;
+      class DisposeChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onDispose() { called = true; }
+      }
+      const ch = new DisposeChannel();
+      ch.dispose();
+      expect(called).toBe(true);
+    });
+
+    it('calls close on dispose', () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.connect();
+      // Let open resolve
+      vi.runAllTimers();
+      ch.dispose();
+      expect(ch.closeCalls).toBe(1);
+    });
+
+    it('aborts disposeSignal on dispose', () => {
+      const ch = new TestChannel();
+      const signal = ch.disposeSignal;
+      expect(signal.aborted).toBe(false);
+      ch.dispose();
+      expect(signal.aborted).toBe(true);
+    });
+
+    it('runs cleanups on dispose', () => {
+      let cleaned = false;
+      class CleanupChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() { this.addCleanup(() => { cleaned = true; }); }
+      }
+      const ch = new CleanupChannel();
+      ch.init();
+      ch.dispose();
+      expect(cleaned).toBe(true);
+    });
+
+    it('cancels pending reconnect timer on dispose', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0); // let open reject
+      // Now in reconnecting state with a timer scheduled
+      expect(ch.state.reconnecting).toBe(true);
+      ch.dispose();
+      // Timer should not fire after dispose
+      vi.advanceTimersByTime(100_000);
+      expect(ch.disposed).toBe(true);
+    });
+  });
+
+  // ── Subscribable ────────────────────────────────────────────────
+
+  describe('subscribable status', () => {
+    it('initial status is idle', () => {
+      const ch = new TestChannel();
+      expect(ch.state).toEqual({
+        connected: false,
+        reconnecting: false,
+        attempt: 0,
+        error: null,
+      });
+    });
+
+    it('status is frozen', () => {
+      const ch = new TestChannel();
+      expect(Object.isFrozen(ch.state)).toBe(true);
+    });
+
+    it('subscribe notifies on status change', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      const statuses: ChannelStatus[] = [];
+      ch.subscribe((next) => statuses.push(next));
+
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(statuses.length).toBeGreaterThanOrEqual(1);
+      expect(statuses[statuses.length - 1].connected).toBe(true);
+    });
+
+    it('subscribe returns unsubscribe function', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      const statuses: ChannelStatus[] = [];
+      const unsub = ch.subscribe((next) => statuses.push(next));
+      unsub();
+
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(statuses).toHaveLength(0);
+    });
+
+    it('subscribe on disposed channel returns no-op', () => {
+      const ch = new TestChannel();
+      ch.dispose();
+      const unsub = ch.subscribe(() => {});
+      expect(typeof unsub).toBe('function');
+      unsub(); // should not throw
+    });
+
+    it('listener receives prev and next', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      let received: { prev: ChannelStatus; next: ChannelStatus } | null = null;
+      ch.subscribe((next, prev) => { received = { prev, next }; });
+
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(received).not.toBeNull();
+      expect(received!.prev.connected).toBe(false);
+      expect(received!.next.connected).toBe(true);
+    });
+  });
+
+  // ── Message Routing ─────────────────────────────────────────────
+
+  describe('message routing', () => {
+    it('on() receives messages', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const messages: TestMessages['chat'][] = [];
+      ch.on('chat', (msg) => messages.push(msg));
+
+      ch.simulateReceive('chat', { text: 'hello' });
+      expect(messages).toEqual([{ text: 'hello' }]);
+    });
+
+    it('on() returns unsubscribe function', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const messages: TestMessages['chat'][] = [];
+      const unsub = ch.on('chat', (msg) => messages.push(msg));
+
+      ch.simulateReceive('chat', { text: 'hello' });
+      unsub();
+      ch.simulateReceive('chat', { text: 'world' });
+
+      expect(messages).toEqual([{ text: 'hello' }]);
+    });
+
+    it('multiple handlers for same type', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const a: string[] = [];
+      const b: string[] = [];
+      ch.on('chat', (msg) => a.push(msg.text));
+      ch.on('chat', (msg) => b.push(msg.text));
+
+      ch.simulateReceive('chat', { text: 'hello' });
+      expect(a).toEqual(['hello']);
+      expect(b).toEqual(['hello']);
+    });
+
+    it('handlers for different types are independent', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const chats: TestMessages['chat'][] = [];
+      const typings: TestMessages['typing'][] = [];
+      ch.on('chat', (msg) => chats.push(msg));
+      ch.on('typing', (msg) => typings.push(msg));
+
+      ch.simulateReceive('chat', { text: 'hello' });
+      ch.simulateReceive('typing', { userId: 'u1' });
+
+      expect(chats).toEqual([{ text: 'hello' }]);
+      expect(typings).toEqual([{ userId: 'u1' }]);
+    });
+
+    it('once() fires only once', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const messages: TestMessages['chat'][] = [];
+      ch.once('chat', (msg) => messages.push(msg));
+
+      ch.simulateReceive('chat', { text: 'first' });
+      ch.simulateReceive('chat', { text: 'second' });
+
+      expect(messages).toEqual([{ text: 'first' }]);
+    });
+
+    it('once() unsubscribe prevents callback', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const messages: TestMessages['chat'][] = [];
+      const unsub = ch.once('chat', (msg) => messages.push(msg));
+      unsub();
+
+      ch.simulateReceive('chat', { text: 'hello' });
+      expect(messages).toEqual([]);
+    });
+
+    it('receive after dispose is ignored', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const messages: TestMessages['chat'][] = [];
+      ch.on('chat', (msg) => messages.push(msg));
+      ch.dispose();
+
+      // handlers are cleared on dispose, so this should be a no-op
+      ch.simulateReceive('chat', { text: 'hello' });
+      expect(messages).toEqual([]);
+    });
+
+    it('on() on disposed channel returns no-op', () => {
+      const ch = new TestChannel();
+      ch.dispose();
+      const unsub = ch.on('chat', () => {});
+      expect(typeof unsub).toBe('function');
+      unsub(); // should not throw
+    });
+  });
+
+  // ── Connection Lifecycle ────────────────────────────────────────
+
+  describe('connect lifecycle', () => {
+    it('connect calls open with signal', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(ch.openCalls).toHaveLength(1);
+      expect(ch.openCalls[0]).toBeInstanceOf(AbortSignal);
+    });
+
+    it('status transitions to connected on success', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(ch.state.connected).toBe(true);
+      expect(ch.state.reconnecting).toBe(false);
+      expect(ch.state.attempt).toBe(0);
+      expect(ch.state.error).toBeNull();
+    });
+
+    it('synchronous open works', () => {
+      const ch = new SyncOpenChannel();
+      ch.init();
+      ch.connect();
+
+      expect(ch.openCalls).toBe(1);
+      expect(ch.state.connected).toBe(true);
+    });
+
+    it('connect is idempotent when already connected', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      ch.connect();
+      expect(ch.openCalls).toHaveLength(1); // not called again
+    });
+
+    it('connect is idempotent when connecting', () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'pending';
+      ch.init();
+      ch.connect();
+      ch.connect();
+      expect(ch.openCalls).toHaveLength(1);
+    });
+
+    it('connect after dispose is ignored', () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.dispose();
+      ch.connect();
+      expect(ch.openCalls).toHaveLength(0);
+    });
+  });
+
+  describe('disconnect', () => {
+    it('disconnect calls close and resets status', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.connected).toBe(true);
+
+      ch.disconnect();
+      expect(ch.closeCalls).toBe(1);
+      expect(ch.state.connected).toBe(false);
+      expect(ch.state.reconnecting).toBe(false);
+    });
+
+    it('disconnect cancels pending reconnect', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.reconnecting).toBe(true);
+
+      ch.disconnect();
+      expect(ch.state.reconnecting).toBe(false);
+      // Advance timers — should not attempt reconnect
+      vi.advanceTimersByTime(100_000);
+      // Only 1 open call (the initial failed one)
+      expect(ch.openCalls).toHaveLength(1);
+    });
+
+    it('disconnect aborts in-flight connect', () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'pending';
+      ch.init();
+      ch.connect();
+
+      const signal = ch.openCalls[0];
+      expect(signal.aborted).toBe(false);
+
+      ch.disconnect();
+      expect(signal.aborted).toBe(true);
+    });
+
+    it('disconnect on idle is no-op', () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.disconnect();
+      expect(ch.closeCalls).toBe(0);
+    });
+
+    it('disconnect on disposed is no-op', () => {
+      const ch = new TestChannel();
+      ch.dispose();
+      const closesBefore = ch.closeCalls;
+      ch.disconnect();
+      expect(ch.closeCalls).toBe(closesBefore); // disconnect added no extra close calls
+    });
+  });
+
+  // ── Reconnection ───────────────────────────────────────────────
+
+  describe('reconnection', () => {
+    it('reconnects after open failure', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(ch.state.reconnecting).toBe(true);
+      expect(ch.state.attempt).toBe(1);
+      expect(ch.state.error).toBe('connection failed');
+
+      // Switch to resolve for next attempt
+      ch.openBehavior = 'resolve';
+      await vi.advanceTimersByTimeAsync(60_000); // plenty of time
+
+      expect(ch.state.connected).toBe(true);
+      expect(ch.state.reconnecting).toBe(false);
+      expect(ch.openCalls).toHaveLength(2);
+    });
+
+    it('reconnects after disconnected() signal', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.connected).toBe(true);
+
+      ch.simulateDisconnect();
+      expect(ch.state.connected).toBe(false);
+      expect(ch.state.reconnecting).toBe(true);
+      expect(ch.state.attempt).toBe(1);
+
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(ch.state.connected).toBe(true);
+      expect(ch.openCalls).toHaveLength(2);
+    });
+
+    it('stops after MAX_ATTEMPTS', async () => {
+      class LimitedChannel extends TestChannel {
+        static override MAX_ATTEMPTS = 2;
+        protected override _calculateDelay() { return 100; }
+      }
+      const ch = new LimitedChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+
+      // Attempt 0 (initial) → fail → schedule attempt 1
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.reconnecting).toBe(true);
+      expect(ch.state.attempt).toBe(1);
+
+      // Timer fires → attempt 1 → fail → schedule attempt 2
+      await vi.advanceTimersByTimeAsync(100);
+      expect(ch.state.attempt).toBe(2);
+
+      // Timer fires → attempt 2 → fail → attempt 3 > MAX_ATTEMPTS(2) → stop
+      await vi.advanceTimersByTimeAsync(100);
+      expect(ch.state.reconnecting).toBe(false);
+      expect(ch.state.connected).toBe(false);
+      expect(ch.state.error).not.toBeNull();
+    });
+
+    it('static config overrides affect backoff', () => {
+      class FastChannel extends Channel<TestMessages> {
+        static override RECONNECT_BASE = 100;
+        static override RECONNECT_MAX = 500;
+        static override RECONNECT_FACTOR = 1;
+        protected open(): void {}
+        protected close(): void {}
+      }
+
+      const ch = new FastChannel();
+      // Jitter ensures delay is <= RECONNECT_BASE for attempt 0
+      const delay = ch['_calculateDelay'](0);
+      expect(delay).toBeLessThanOrEqual(100);
+      expect(delay).toBeGreaterThanOrEqual(0);
+    });
+
+    it('backoff delay respects max', () => {
+      class MaxChannel extends Channel<TestMessages> {
+        static override RECONNECT_BASE = 1000;
+        static override RECONNECT_MAX = 5000;
+        static override RECONNECT_FACTOR = 10;
+        protected open(): void {}
+        protected close(): void {}
+      }
+
+      const ch = new MaxChannel();
+      // High attempt should cap at max
+      const delay = ch['_calculateDelay'](100);
+      expect(delay).toBeLessThanOrEqual(5000);
+    });
+
+    it('reconnect can be interrupted by disconnect', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.reconnecting).toBe(true);
+
+      ch.disconnect();
+      expect(ch.state.reconnecting).toBe(false);
+
+      // No more connect attempts
+      vi.advanceTimersByTime(100_000);
+      expect(ch.openCalls).toHaveLength(1);
+    });
+
+    it('connect during reconnecting resets attempt', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.reconnecting).toBe(true);
+      expect(ch.state.attempt).toBe(1);
+
+      // User calls connect() — should reset
+      ch.openBehavior = 'resolve';
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(ch.state.connected).toBe(true);
+      expect(ch.state.attempt).toBe(0);
+    });
+  });
+
+  // ── Edge Cases ──────────────────────────────────────────────────
+
+  describe('edge cases', () => {
+    it('disconnected during idle is ignored', () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.simulateDisconnect(); // not connected
+      expect(ch.state.reconnecting).toBe(false);
+    });
+
+    it('disconnected during reconnect is ignored', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.reconnecting).toBe(true);
+      const attempt = ch.state.attempt;
+
+      // disconnected() during reconnect should be ignored
+      ch.simulateDisconnect();
+      expect(ch.state.attempt).toBe(attempt); // unchanged
+    });
+
+    it('dispose during pending open', () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'pending';
+      ch.init();
+      ch.connect();
+
+      const signal = ch.openCalls[0];
+      ch.dispose();
+
+      expect(signal.aborted).toBe(true);
+      expect(ch.disposed).toBe(true);
+    });
+
+    it('dispose during backoff timer', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'reject';
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.reconnecting).toBe(true);
+
+      ch.dispose();
+      // Timer should not fire
+      vi.advanceTimersByTime(100_000);
+      expect(ch.openCalls).toHaveLength(1);
+    });
+
+    it('close error during dispose does not throw', () => {
+      class ThrowCloseChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void { throw new Error('close failed'); }
+      }
+      const ch = new ThrowCloseChannel();
+      ch.init();
+      expect(() => ch.dispose()).not.toThrow();
+    });
+
+    it('subscribeTo auto-cleans up on dispose', () => {
+      let unsubbed = false;
+      const fakeSource = {
+        state: {},
+        disposed: false,
+        disposeSignal: new AbortController().signal,
+        subscribe: () => {
+          return () => { unsubbed = true; };
+        },
+        dispose: () => {},
+      };
+
+      class SubChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() {
+          this.subscribeTo(fakeSource as any, () => {});
+        }
+      }
+
+      const ch = new SubChannel();
+      ch.init();
+      expect(unsubbed).toBe(false);
+      ch.dispose();
+      expect(unsubbed).toBe(true);
+    });
+
+    it('connect then disconnect then connect works', async () => {
+      const ch = new TestChannel();
+      ch.init();
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.connected).toBe(true);
+
+      ch.disconnect();
+      expect(ch.state.connected).toBe(false);
+
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(ch.state.connected).toBe(true);
+      expect(ch.openCalls).toHaveLength(2);
+    });
+  });
+
+  // ── Singleton integration ───────────────────────────────────────
+
+  describe('singleton integration', () => {
+    it('works with singleton registry', () => {
+      const ch1 = singleton(TestChannel);
+      const ch2 = singleton(TestChannel);
+      expect(ch1).toBe(ch2);
+    });
+
+    it('teardownAll disposes channel', () => {
+      const ch = singleton(TestChannel);
+      expect(ch.disposed).toBe(false);
+      teardownAll();
+      expect(ch.disposed).toBe(true);
+    });
+  });
+
+  // ── Auto-tracking with ViewModel ────────────────────────────────
+
+  describe('ViewModel auto-tracking', () => {
+    interface VMState { label: string }
+
+    it('channel status changes trigger ViewModel re-render', async () => {
+      const ch = singleton(TestChannel);
+      ch.init();
+
+      class TrackingVM extends ViewModel<VMState> {
+        private channel = singleton(TestChannel);
+        get isConnected() { return this.channel.state.connected; }
+      }
+
+      const vm = new TrackingVM({ label: '' });
+      vm.init();
+
+      expect(vm.isConnected).toBe(false);
+
+      const listener = vi.fn();
+      vm.subscribe(listener);
+
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      // ViewModel listener should have been called (subscribable notification)
+      expect(listener).toHaveBeenCalled();
+      expect(vm.isConnected).toBe(true);
+
+      vm.dispose();
+    });
+
+    it('channel is auto-detected as subscribable', () => {
+      const ch = new TestChannel();
+      // Duck-type check: has subscribe method
+      expect(typeof ch.subscribe).toBe('function');
+    });
+
+    it('getter re-evaluates when channel status changes', async () => {
+      const ch = singleton(TestChannel);
+      ch.init();
+
+      let computeCount = 0;
+
+      class CountVM extends ViewModel<VMState> {
+        private channel = singleton(TestChannel);
+        get connectionStatus(): string {
+          computeCount++;
+          return this.channel.state.connected ? 'online' : 'offline';
+        }
+      }
+
+      const vm = new CountVM({ label: '' });
+      vm.init();
+
+      expect(vm.connectionStatus).toBe('offline');
+      const firstCount = computeCount;
+
+      // Access again — should be memoized (tier 1)
+      expect(vm.connectionStatus).toBe('offline');
+      expect(computeCount).toBe(firstCount);
+
+      // Change channel status
+      ch.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Getter should recompute
+      expect(vm.connectionStatus).toBe('online');
+      expect(computeCount).toBeGreaterThan(firstCount);
+
+      vm.dispose();
+    });
+  });
+
+  // ── disposeSignal ───────────────────────────────────────────────
+
+  describe('disposeSignal', () => {
+    it('is lazily created', () => {
+      const ch = new TestChannel();
+      const signal = ch.disposeSignal;
+      expect(signal).toBeInstanceOf(AbortSignal);
+      expect(signal).toBe(ch.disposeSignal); // same instance
+    });
+
+    it('is composed into open signal', async () => {
+      const ch = new TestChannel();
+      ch.openBehavior = 'pending';
+      ch.init();
+      ch.connect();
+
+      const openSignal = ch.openCalls[0];
+      expect(openSignal.aborted).toBe(false);
+
+      ch.dispose();
+      expect(openSignal.aborted).toBe(true);
+    });
+  });
+
+  // ── Status change dedup ─────────────────────────────────────────
+
+  describe('status deduplication', () => {
+    it('does not notify when status is unchanged', () => {
+      const ch = new TestChannel();
+      ch.init();
+      const listener = vi.fn();
+      ch.subscribe(listener);
+
+      // disconnect on idle should not produce a status change
+      ch.disconnect();
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('listenTo', () => {
+    interface AppEvents {
+      logout: { reason: string };
+    }
+
+    it('handler is called when event is emitted', () => {
+      const bus = new EventBus<AppEvents>();
+      const reasons: string[] = [];
+
+      class ListenChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() {
+          this.listenTo(bus, 'logout', (e) => reasons.push(e.reason));
+        }
+      }
+
+      const ch = new ListenChannel();
+      ch.init();
+
+      bus.emit('logout', { reason: 'expired' });
+      expect(reasons).toEqual(['expired']);
+    });
+
+    it('auto-unsubscribes on dispose', () => {
+      const bus = new EventBus<AppEvents>();
+      const handler = vi.fn();
+
+      class ListenChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() {
+          this.listenTo(bus, 'logout', handler);
+        }
+      }
+
+      const ch = new ListenChannel();
+      ch.init();
+
+      bus.emit('logout', { reason: 'expired' });
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      ch.dispose();
+
+      bus.emit('logout', { reason: 'manual' });
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns unsubscribe function for manual cleanup', () => {
+      const bus = new EventBus<AppEvents>();
+      const handler = vi.fn();
+      let unsub!: () => void;
+
+      class ListenChannel extends Channel<TestMessages> {
+        protected open(): void {}
+        protected close(): void {}
+        protected onInit() {
+          unsub = this.listenTo(bus, 'logout', handler);
+        }
+      }
+
+      const ch = new ListenChannel();
+      ch.init();
+
+      bus.emit('logout', { reason: 'expired' });
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      unsub();
+
+      bus.emit('logout', { reason: 'manual' });
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('method binding', () => {
+    it('destructured methods work point-free', () => {
+      const ch = new TestChannel();
+      const { on } = ch;
+      const handler = vi.fn();
+      on('chat', handler);
+      ch.init();
+      ch.resolveOpen();
+      ch.simulateReceive('chat', { text: 'hello' });
+      expect(handler).toHaveBeenCalledWith({ text: 'hello' });
+    });
+  });
+});