mvc-kit 2.12.0 → 2.12.2

package/src/Pending.test.ts

@@ -0,0 +1,1719 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Pending } from './Pending';
+import { HttpError } from './errors';
+import { ViewModel } from './ViewModel';
+
+describe('Pending', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('initial state', () => {
+    it('starts with count 0, hasPending false, hasFailed false', () => {
+      const p = new Pending();
+      expect(p.count).toBe(0);
+      expect(p.hasPending).toBe(false);
+      expect(p.hasFailed).toBe(false);
+      expect(p.failedCount).toBe(0);
+    });
+
+    it('getStatus returns null for unknown ID', () => {
+      const p = new Pending();
+      expect(p.getStatus('unknown')).toBe(null);
+    });
+
+    it('has returns false for unknown ID', () => {
+      const p = new Pending();
+      expect(p.has('unknown')).toBe(false);
+    });
+  });
+
+  describe('enqueue', () => {
+    it('sets status to active and notifies', async () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('item-1', 'delete', () => promise);
+
+      // Immediately after enqueue, snapshot is active (pre-microtask)
+      const preStatus = p.getStatus('item-1');
+      expect(preStatus).not.toBe(null);
+      expect(preStatus!.status).toBe('active');
+
+      // After microtask, execute runs
+      await vi.advanceTimersByTimeAsync(0);
+
+      const status = p.getStatus('item-1');
+      expect(status).not.toBe(null);
+      expect(status!.status).toBe('active');
+      expect(status!.operation).toBe('delete');
+      expect(status!.attempts).toBe(1);
+      expect(status!.error).toBe(null);
+      expect(status!.errorCode).toBe(null);
+      expect(status!.nextRetryAt).toBe(null);
+      expect(typeof status!.createdAt).toBe('number');
+      expect(listener).toHaveBeenCalled();
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('getStatus returns PendingOperation with correct maxRetries', async () => {
+      const p = new Pending<string>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'update', () => promise);
+      await vi.advanceTimersByTimeAsync(0);
+
+      const status = p.getStatus('a');
+      expect(status!.maxRetries).toBe(5);
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('has returns true for enqueued ID', async () => {
+      const p = new Pending<string>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'delete', () => promise);
+      expect(p.has('a')).toBe(true);
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('count reflects number of pending operations', () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+      p.enqueue('b', 'op', () => new Promise(() => {}));
+      expect(p.count).toBe(2);
+
+      p.dispose();
+    });
+
+    it('hasPending is true when operations exist', () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+      expect(p.hasPending).toBe(true);
+      p.dispose();
+    });
+
+    it('execute receives an AbortSignal', async () => {
+      const p = new Pending<string>();
+      let receivedSignal: AbortSignal | null = null;
+
+      p.enqueue('a', 'op', async (signal) => {
+        receivedSignal = signal;
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(receivedSignal).toBeInstanceOf(AbortSignal);
+      p.dispose();
+    });
+
+    it('supersedes existing operation for same ID (aborts previous signal)', async () => {
+      const p = new Pending<string>();
+      let secondSignal: AbortSignal | null = null;
+
+      let firstAborted = false;
+
+      p.enqueue('a', 'first', async (signal) => {
+        signal.addEventListener('abort', () => { firstAborted = true; });
+        await new Promise(() => {}); // never resolves
+      });
+
+      // Process the first microtask so execute runs and signal listener is attached
+      await vi.advanceTimersByTimeAsync(0);
+
+      p.enqueue('a', 'second', async (signal) => {
+        secondSignal = signal;
+      });
+
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(firstAborted).toBe(true);
+      expect(secondSignal!.aborted).toBe(false);
+      expect(p.getStatus('a')).toBe(null); // second completed
+      p.dispose();
+    });
+
+    it('is no-op after dispose', () => {
+      const p = new Pending<string>();
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      p.dispose();
+
+      p.enqueue('a', 'op', async () => {});
+      expect(p.count).toBe(0);
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[mvc-kit] Pending.enqueue() called after dispose — ignored.',
+      );
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe('confirmation', () => {
+    it('removes operation on successful execute', async () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'delete', async () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.has('a')).toBe(false);
+      expect(p.getStatus('a')).toBe(null);
+      expect(p.count).toBe(0);
+      p.dispose();
+    });
+
+    it('notifies on confirmation', async () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'op', async () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Now subscribe after active notification
+      const listener = vi.fn();
+      p.subscribe(listener);
+
+      p.enqueue('b', 'op', async () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Should have notified: enqueue (active), _process (active), confirmed (removed)
+      expect(listener.mock.calls.length).toBeGreaterThanOrEqual(2);
+      p.dispose();
+    });
+
+    it('calls onConfirmed hook', async () => {
+      const confirmed = vi.fn();
+
+      class TestPending extends Pending<string> {
+        protected onConfirmed(id: string, operation: string) {
+          confirmed(id, operation);
+        }
+      }
+
+      const p = new TestPending();
+      p.enqueue('item-1', 'delete', async () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(confirmed).toHaveBeenCalledWith('item-1', 'delete');
+      p.dispose();
+    });
+
+    it('getStatus returns null after confirmation', async () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'op', async () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')).toBe(null);
+      p.dispose();
+    });
+  });
+
+  describe('supersede race condition', () => {
+    it('does not delete superseding operation when superseded op rejects', async () => {
+      const p = new Pending<string>();
+      let secondCompleted = false;
+
+      // First operation: hangs forever (will be superseded)
+      p.enqueue('a', 'first', async (signal) => {
+        // Wait until aborted
+        await new Promise((_, reject) => {
+          signal.addEventListener('abort', () => {
+            reject(new DOMException('Aborted', 'AbortError'));
+          });
+        });
+      });
+
+      await vi.advanceTimersByTimeAsync(0);
+      expect(p.getStatus('a')!.operation).toBe('first');
+
+      // Second operation: will succeed
+      p.enqueue('a', 'second', async () => {
+        secondCompleted = true;
+      });
+
+      // Process the second microtask — both the abort rejection from op1
+      // and the execution of op2 happen here
+      await vi.advanceTimersByTimeAsync(0);
+
+      // The second operation should have completed successfully
+      expect(secondCompleted).toBe(true);
+      // And the ID should be gone (confirmed), NOT still present
+      expect(p.has('a')).toBe(false);
+      expect(p.getStatus('a')).toBe(null);
+      p.dispose();
+    });
+
+    it('does not confirm superseded operation when it resolves late', async () => {
+      let resolveFirst!: () => void;
+      const confirmed = vi.fn();
+
+      class TestPending extends Pending<string> {
+        protected onConfirmed(id: string, operation: string) {
+          confirmed(id, operation);
+        }
+      }
+
+      const tp = new TestPending();
+
+      // First operation: controlled resolution
+      tp.enqueue('a', 'first', async () => {
+        await new Promise<void>(r => { resolveFirst = r; });
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Supersede before first resolves
+      tp.enqueue('a', 'second', async () => {
+        await new Promise(() => {}); // hang
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Now resolve the first (it's been superseded)
+      resolveFirst();
+      await vi.advanceTimersByTimeAsync(0);
+
+      // onConfirmed should NOT have been called for 'first'
+      // because it was superseded by 'second'
+      expect(confirmed).not.toHaveBeenCalled();
+      // Second should still be active
+      expect(tp.getStatus('a')!.operation).toBe('second');
+      tp.dispose();
+    });
+
+    it('superseding a retrying operation clears the retry timer', async () => {
+      const p = new Pending<string>();
+      let firstCallCount = 0;
+      let secondCalled = false;
+
+      p.enqueue('a', 'first', async () => {
+        firstCallCount++;
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // First op is now retrying with a timer
+      expect(p.getStatus('a')!.status).toBe('retrying');
+      expect(firstCallCount).toBe(1);
+
+      // Supersede with a new operation
+      p.enqueue('a', 'second', async () => {
+        secondCalled = true;
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(secondCalled).toBe(true);
+      expect(p.has('a')).toBe(false); // second completed
+
+      // Advance past when the old retry timer would have fired — should be no-op
+      await vi.advanceTimersByTimeAsync(60000);
+      expect(firstCallCount).toBe(1); // never retried
+      p.dispose();
+    });
+  });
+
+  describe('retry on transient error', () => {
+    it('retries on network error', async () => {
+      const p = new Pending<string>();
+      let callCount = 0;
+
+      p.enqueue('a', 'op', async () => {
+        callCount++;
+        if (callCount === 1) throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // First call fails — should be retrying
+      expect(p.getStatus('a')!.status).toBe('retrying');
+      expect(callCount).toBe(1);
+
+      // Advance past retry delay
+      await vi.advanceTimersByTimeAsync(30000);
+
+      // Second call succeeds
+      expect(p.has('a')).toBe(false);
+      expect(callCount).toBe(2);
+      p.dispose();
+    });
+
+    it('retries on timeout error', async () => {
+      const p = new Pending<string>();
+      let callCount = 0;
+      const timeoutErr = new Error('Request timed out');
+      timeoutErr.name = 'TimeoutError';
+
+      p.enqueue('a', 'op', async () => {
+        callCount++;
+        if (callCount === 1) throw timeoutErr;
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('retrying');
+      expect(p.getStatus('a')!.errorCode).toBe('timeout');
+
+      await vi.advanceTimersByTimeAsync(30000);
+      expect(callCount).toBe(2);
+      p.dispose();
+    });
+
+    it('retries on server error', async () => {
+      const p = new Pending<string>();
+      let callCount = 0;
+
+      p.enqueue('a', 'op', async () => {
+        callCount++;
+        if (callCount === 1) throw new HttpError(500, 'Internal Server Error');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('retrying');
+      expect(p.getStatus('a')!.errorCode).toBe('server_error');
+
+      await vi.advanceTimersByTimeAsync(30000);
+      expect(callCount).toBe(2);
+      p.dispose();
+    });
+
+    it('sets status to retrying between attempts', async () => {
+      const p = new Pending<string>();
+      const statuses: string[] = [];
+      const listener = () => {
+        const s = p.getStatus('a');
+        if (s) statuses.push(s.status);
+      };
+      p.subscribe(listener);
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(statuses).toContain('retrying');
+      p.dispose();
+    });
+
+    it('increments attempts counter', async () => {
+      vi.spyOn(Math, 'random').mockReturnValue(1);
+
+      class SlowRetryPending extends Pending<string> {
+        static override RETRY_BASE = 10000;
+        static override MAX_RETRIES = 5;
+      }
+
+      const p = new SlowRetryPending();
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.attempts).toBe(1);
+
+      // Advance just past the first retry delay (10000ms)
+      await vi.advanceTimersByTimeAsync(10001);
+      expect(p.getStatus('a')!.attempts).toBe(2);
+
+      vi.spyOn(Math, 'random').mockRestore();
+      p.dispose();
+    });
+
+    it('sets nextRetryAt with delay', async () => {
+      vi.spyOn(Math, 'random').mockReturnValue(0.5);
+
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      const status = p.getStatus('a')!;
+      expect(status.nextRetryAt).not.toBe(null);
+      expect(status.nextRetryAt).toBeGreaterThan(0);
+
+      vi.spyOn(Math, 'random').mockRestore();
+      p.dispose();
+    });
+
+    it('respects MAX_RETRIES limit', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 2;
+      }
+
+      const p = new LimitedPending();
+      let callCount = 0;
+
+      p.enqueue('a', 'op', async () => {
+        callCount++;
+        throw new TypeError('Failed to fetch');
+      });
+
+      // Process through all retries
+      await vi.advanceTimersByTimeAsync(0);
+      expect(callCount).toBe(1);
+
+      await vi.advanceTimersByTimeAsync(30000);
+      expect(callCount).toBe(2);
+
+      // Should be failed, not retrying again
+      expect(p.getStatus('a')!.status).toBe('failed');
+      p.dispose();
+    });
+
+    it('uses exponential backoff with jitter', async () => {
+      vi.spyOn(Math, 'random').mockReturnValue(1); // Max jitter for deterministic testing
+
+      const p = new Pending<string>();
+      const setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout');
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Collect the delay from the retry setTimeout call
+      const retryCalls = setTimeoutSpy.mock.calls.filter(
+        call => typeof call[1] === 'number' && call[1] > 0,
+      );
+
+      // With Math.random()=1, RETRY_BASE=1000, RETRY_FACTOR=2:
+      // attempt 0: Math.random() * min(1000 * 2^0, 30000) = 1 * 1000 = 1000
+      expect(retryCalls[retryCalls.length - 1][1]).toBe(1000);
+
+      vi.spyOn(Math, 'random').mockRestore();
+      setTimeoutSpy.mockRestore();
+      p.dispose();
+    });
+
+    it('transitions to failed after max retries', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(503, 'Service Unavailable');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // First attempt fails, at max retries
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('a')!.error).toBe('Service Unavailable');
+      expect(p.getStatus('a')!.errorCode).toBe('server_error');
+      p.dispose();
+    });
+
+    it('calls onFailed hook after max retries', async () => {
+      const failed = vi.fn();
+
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+        protected onFailed(id: string, operation: string, error: unknown) {
+          failed(id, operation, error);
+        }
+      }
+
+      const p = new LimitedPending();
+      const err = new HttpError(500, 'Server Error');
+
+      p.enqueue('a', 'delete', async () => { throw err; });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(failed).toHaveBeenCalledWith('a', 'delete', err);
+      p.dispose();
+    });
+  });
+
+  describe('non-retryable errors', () => {
+    it('fails immediately on 401 (unauthorized)', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(401, 'Unauthorized');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('a')!.errorCode).toBe('unauthorized');
+      p.dispose();
+    });
+
+    it('fails immediately on 403 (forbidden)', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(403, 'Forbidden');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('a')!.errorCode).toBe('forbidden');
+      p.dispose();
+    });
+
+    it('fails immediately on 404 (not_found)', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(404, 'Not Found');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('a')!.errorCode).toBe('not_found');
+      p.dispose();
+    });
+
+    it('fails immediately on 422 (validation)', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(422, 'Unprocessable Entity');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('a')!.errorCode).toBe('validation');
+      p.dispose();
+    });
+
+    it('calls onFailed hook immediately', async () => {
+      const failed = vi.fn();
+
+      class TestPending extends Pending<string> {
+        protected onFailed(id: string, operation: string, error: unknown) {
+          failed(id, operation, error);
+        }
+      }
+
+      const p = new TestPending();
+      const err = new HttpError(403, 'Forbidden');
+
+      p.enqueue('a', 'update', async () => { throw err; });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(failed).toHaveBeenCalledWith('a', 'update', err);
+      p.dispose();
+    });
+
+    it('sets error and errorCode on the operation', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(404, 'Not Found');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      const status = p.getStatus('a')!;
+      expect(status.error).toBe('Not Found');
+      expect(status.errorCode).toBe('not_found');
+      p.dispose();
+    });
+  });
+
+  describe('abort handling', () => {
+    it('removes operation silently on AbortError', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        const err = new Error('The operation was aborted');
+        err.name = 'AbortError';
+        throw err;
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.has('a')).toBe(false);
+      expect(p.getStatus('a')).toBe(null);
+      p.dispose();
+    });
+
+    it('does not call onFailed for AbortError', async () => {
+      const failed = vi.fn();
+
+      class TestPending extends Pending<string> {
+        protected onFailed(id: string, operation: string, error: unknown) {
+          failed(id, operation, error);
+        }
+      }
+
+      const p = new TestPending();
+
+      p.enqueue('a', 'op', async () => {
+        const err = new Error('Aborted');
+        err.name = 'AbortError';
+        throw err;
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(failed).not.toHaveBeenCalled();
+      p.dispose();
+    });
+  });
+
+  describe('retry(id)', () => {
+    it('re-processes a failed operation', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+      let callCount = 0;
+
+      p.enqueue('a', 'op', async () => {
+        callCount++;
+        if (callCount === 1) throw new HttpError(500, 'Server Error');
+        // Second call succeeds
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(callCount).toBe(1);
+
+      p.retry('a');
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.has('a')).toBe(false); // succeeded on retry
+      expect(callCount).toBe(2);
+      p.dispose();
+    });
+
+    it('resets attempts to 0', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(500, 'Error');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.attempts).toBe(1);
+
+      p.retry('a');
+      // After retry starts, attempts should be 1 (reset to 0, then incremented by _process)
+      await vi.advanceTimersByTimeAsync(0);
+      expect(p.getStatus('a')!.attempts).toBe(1);
+      p.dispose();
+    });
+
+    it('is no-op for non-failed operations', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+      await vi.advanceTimersByTimeAsync(0);
+
+      const statusBefore = p.getStatus('a');
+      p.retry('a'); // should be no-op since status is 'active'
+      const statusAfter = p.getStatus('a');
+
+      expect(statusBefore).toEqual(statusAfter);
+      p.dispose();
+    });
+
+    it('is no-op for unknown IDs', () => {
+      const p = new Pending<string>();
+      // Should not throw
+      p.retry('nonexistent');
+      p.dispose();
+    });
+  });
+
+  describe('retryAll', () => {
+    it('retries all failed operations', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+      let aCount = 0;
+      let bCount = 0;
+
+      p.enqueue('a', 'op', async () => {
+        aCount++;
+        if (aCount === 1) throw new HttpError(500, 'Error');
+      });
+      p.enqueue('b', 'op', async () => {
+        bCount++;
+        if (bCount === 1) throw new HttpError(502, 'Error');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('b')!.status).toBe('failed');
+
+      p.retryAll();
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Both should have succeeded on retry
+      expect(p.has('a')).toBe(false);
+      expect(p.has('b')).toBe(false);
+      expect(aCount).toBe(2);
+      expect(bCount).toBe(2);
+      p.dispose();
+    });
+  });
+
+  describe('cancel', () => {
+    it('aborts the signal', async () => {
+      const p = new Pending<string>();
+      let capturedSignal: AbortSignal | null = null;
+
+      p.enqueue('a', 'op', async (signal) => {
+        capturedSignal = signal;
+        await new Promise(() => {}); // hang
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      p.cancel('a');
+      expect(capturedSignal!.aborted).toBe(true);
+      p.dispose();
+    });
+
+    it('clears the retry timer', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('retrying');
+
+      p.cancel('a');
+      expect(p.has('a')).toBe(false);
+
+      // Advance timers — nothing should happen
+      await vi.advanceTimersByTimeAsync(60000);
+      expect(p.count).toBe(0);
+      p.dispose();
+    });
+
+    it('removes from maps', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+      await vi.advanceTimersByTimeAsync(0);
+
+      p.cancel('a');
+      expect(p.has('a')).toBe(false);
+      expect(p.getStatus('a')).toBe(null);
+      expect(p.count).toBe(0);
+      p.dispose();
+    });
+
+    it('notifies listeners', async () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+      await vi.advanceTimersByTimeAsync(0);
+
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.cancel('a');
+      expect(listener).toHaveBeenCalledTimes(1);
+      p.dispose();
+    });
+
+    it('is no-op for unknown IDs', () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.cancel('nonexistent');
+      expect(listener).not.toHaveBeenCalled();
+      p.dispose();
+    });
+  });
+
+  describe('cancelAll', () => {
+    it('cancels all pending operations', async () => {
+      const p = new Pending<string>();
+      let signalA: AbortSignal | null = null;
+      let signalB: AbortSignal | null = null;
+
+      p.enqueue('a', 'op', async (signal) => {
+        signalA = signal;
+        await new Promise(() => {});
+      });
+      p.enqueue('b', 'op', async (signal) => {
+        signalB = signal;
+        await new Promise(() => {});
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      p.cancelAll();
+
+      expect(signalA!.aborted).toBe(true);
+      expect(signalB!.aborted).toBe(true);
+      expect(p.count).toBe(0);
+      expect(p.has('a')).toBe(false);
+      expect(p.has('b')).toBe(false);
+      p.dispose();
+    });
+  });
+
+  describe('dismiss', () => {
+    it('removes a failed operation', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(404, 'Not Found');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+
+      p.dismiss('a');
+      expect(p.has('a')).toBe(false);
+      expect(p.getStatus('a')).toBe(null);
+      expect(p.count).toBe(0);
+      p.dispose();
+    });
+
+    it('notifies listeners', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(404, 'Not Found');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.dismiss('a');
+      expect(listener).toHaveBeenCalledTimes(1);
+      p.dispose();
+    });
+
+    it('is no-op for active operations', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+      await vi.advanceTimersByTimeAsync(0);
+
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.dismiss('a'); // active, not failed
+      expect(listener).not.toHaveBeenCalled();
+      expect(p.has('a')).toBe(true);
+      p.dispose();
+    });
+
+    it('is no-op for retrying operations', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('retrying');
+
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.dismiss('a'); // retrying, not failed
+      expect(listener).not.toHaveBeenCalled();
+      expect(p.has('a')).toBe(true);
+      p.dispose();
+    });
+
+    it('is no-op for unknown IDs', () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.dismiss('nonexistent');
+      expect(listener).not.toHaveBeenCalled();
+      p.dispose();
+    });
+  });
+
+  describe('dismissAll', () => {
+    it('removes all failed operations', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => { throw new HttpError(404, 'Not Found'); });
+      p.enqueue('b', 'op', async () => { throw new HttpError(403, 'Forbidden'); });
+      p.enqueue('c', 'op', () => new Promise(() => {})); // stays active
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.failedCount).toBe(2);
+      expect(p.count).toBe(3);
+
+      p.dismissAll();
+
+      expect(p.failedCount).toBe(0);
+      expect(p.count).toBe(1); // only 'c' remains
+      expect(p.has('a')).toBe(false);
+      expect(p.has('b')).toBe(false);
+      expect(p.has('c')).toBe(true);
+      p.dispose();
+    });
+
+    it('fires single notification', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => { throw new HttpError(404, 'NF'); });
+      p.enqueue('b', 'op', async () => { throw new HttpError(403, 'F'); });
+      await vi.advanceTimersByTimeAsync(0);
+
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.dismissAll();
+      expect(listener).toHaveBeenCalledTimes(1);
+      p.dispose();
+    });
+
+    it('does not affect retrying operations', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 2;
+      }
+
+      const p = new LimitedPending();
+
+      // 'a' will fail immediately (non-retryable)
+      p.enqueue('a', 'op', async () => { throw new HttpError(404, 'Not Found'); });
+      // 'b' will be retrying (retryable, under max)
+      p.enqueue('b', 'op', async () => { throw new TypeError('Failed to fetch'); });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('b')!.status).toBe('retrying');
+
+      p.dismissAll();
+
+      expect(p.has('a')).toBe(false); // dismissed
+      expect(p.has('b')).toBe(true);  // still retrying
+      expect(p.getStatus('b')!.status).toBe('retrying');
+      p.dispose();
+    });
+
+    it('is no-op when no failed operations', () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.dismissAll();
+      expect(listener).not.toHaveBeenCalled();
+      p.dispose();
+    });
+  });
+
+  describe('hasPending', () => {
+    it('is false when only failed operations exist', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => {
+        throw new HttpError(404, 'Not Found');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.count).toBe(1);
+      expect(p.hasPending).toBe(false);
+      expect(p.hasFailed).toBe(true);
+      p.dispose();
+    });
+
+    it('is true when there are active and failed operations', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => { throw new HttpError(404, 'NF'); });
+      p.enqueue('b', 'op', () => new Promise(() => {})); // stays active
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.hasPending).toBe(true);
+      expect(p.hasFailed).toBe(true);
+      p.dispose();
+    });
+
+    it('is true when there are retrying operations (no active, no failed)', async () => {
+      const p = new Pending<string>();
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('retrying');
+      expect(p.hasPending).toBe(true);
+      expect(p.hasFailed).toBe(false);
+      p.dispose();
+    });
+  });
+
+  describe('failedCount', () => {
+    it('returns 0 when no failures', () => {
+      const p = new Pending<string>();
+      expect(p.failedCount).toBe(0);
+      p.dispose();
+    });
+
+    it('counts failed operations', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => { throw new HttpError(404, 'NF'); });
+      p.enqueue('b', 'op', async () => { throw new HttpError(403, 'F'); });
+      p.enqueue('c', 'op', () => new Promise(() => {})); // active
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.failedCount).toBe(2);
+      expect(p.count).toBe(3);
+      p.dispose();
+    });
+
+    it('decreases when failed op is dismissed', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+
+      p.enqueue('a', 'op', async () => { throw new HttpError(404, 'NF'); });
+      p.enqueue('b', 'op', async () => { throw new HttpError(403, 'F'); });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.failedCount).toBe(2);
+      p.dismiss('a');
+      expect(p.failedCount).toBe(1);
+      p.dispose();
+    });
+
+    it('decreases when failed op is retried', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+      let callCount = 0;
+
+      p.enqueue('a', 'op', async () => {
+        callCount++;
+        if (callCount === 1) throw new HttpError(500, 'Error');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.failedCount).toBe(1);
+
+      p.retry('a');
+      // After retry starts, op is active — no longer failed
+      expect(p.failedCount).toBe(0);
+
+      await vi.advanceTimersByTimeAsync(0);
+      // Succeeded on retry — removed entirely
+      expect(p.count).toBe(0);
+      p.dispose();
+    });
+  });
+
+  describe('no queued status', () => {
+    it('initial snapshot from enqueue is active, not queued', () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+
+      // Synchronously after enqueue, before microtask
+      const status = p.getStatus('a');
+      expect(status!.status).toBe('active');
+      p.dispose();
+    });
+
+    it('status transitions are active → retrying → failed (no queued)', async () => {
+      class LimitedPending extends Pending<string> {
+        static override MAX_RETRIES = 1;
+      }
+
+      const p = new LimitedPending();
+      const statuses: string[] = [];
+      p.subscribe(() => {
+        const s = p.getStatus('a');
+        if (s && !statuses.includes(s.status)) statuses.push(s.status);
+      });
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(statuses).toEqual(['active', 'failed']);
+      expect(statuses).not.toContain('queued');
+      p.dispose();
+    });
+  });
+
+  describe('isRetryable override', () => {
+    it('subclass can override to customize retry logic', async () => {
+      class CustomPending extends Pending<string> {
+        protected override isRetryable(_error: unknown): boolean {
+          return false; // never retry
+        }
+      }
+
+      const p = new CustomPending();
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch'); // normally retryable
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Should fail immediately despite being a network error
+      expect(p.getStatus('a')!.status).toBe('failed');
+      p.dispose();
+    });
+  });
+
+  describe('static config override', () => {
+    it('subclass can override MAX_RETRIES', async () => {
+      class CustomPending extends Pending<string> {
+        static override MAX_RETRIES = 2;
+      }
+
+      const p = new CustomPending();
+      let callCount = 0;
+
+      p.enqueue('a', 'op', async () => {
+        callCount++;
+        throw new TypeError('Failed to fetch');
+      });
+
+      await vi.advanceTimersByTimeAsync(0);
+      expect(callCount).toBe(1);
+
+      await vi.advanceTimersByTimeAsync(30000);
+      expect(callCount).toBe(2);
+      expect(p.getStatus('a')!.status).toBe('failed');
+      expect(p.getStatus('a')!.maxRetries).toBe(2);
+      p.dispose();
+    });
+
+    it('backoff respects overridden RETRY_BASE and RETRY_FACTOR', async () => {
+      vi.spyOn(Math, 'random').mockReturnValue(1);
+
+      class FastPending extends Pending<string> {
+        static override RETRY_BASE = 100;
+        static override RETRY_FACTOR = 3;
+        static override RETRY_MAX = 50000;
+      }
+
+      const p = new FastPending();
+      const setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout');
+
+      p.enqueue('a', 'op', async () => {
+        throw new TypeError('Failed to fetch');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      // With random()=1: delay = 1 * min(100 * 3^0, 50000) = 100
+      const retryCalls = setTimeoutSpy.mock.calls.filter(
+        call => typeof call[1] === 'number' && call[1] > 0,
+      );
+      expect(retryCalls[retryCalls.length - 1][1]).toBe(100);
+
+      vi.spyOn(Math, 'random').mockRestore();
+      setTimeoutSpy.mockRestore();
+      p.dispose();
+    });
+  });
+
+  describe('subscribe', () => {
+    it('notifies on enqueue', () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+
+      p.enqueue('a', 'op', async () => {});
+      expect(listener).toHaveBeenCalled();
+      p.dispose();
+    });
+
+    it('notifies on status change', async () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+
+      p.enqueue('a', 'op', async () => {});
+      const countAfterEnqueue = listener.mock.calls.length;
+
+      await vi.advanceTimersByTimeAsync(0);
+      // Should have been notified again when _process ran
+      expect(listener.mock.calls.length).toBeGreaterThan(countAfterEnqueue);
+      p.dispose();
+    });
+
+    it('notifies on confirmation', async () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+
+      p.enqueue('a', 'op', async () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Should have notifications for: enqueue (active), _process (active), confirmed (removed)
+      expect(listener.mock.calls.length).toBeGreaterThanOrEqual(2);
+      p.dispose();
+    });
+
+    it('notifies on cancellation', async () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'op', () => new Promise(() => {}));
+      await vi.advanceTimersByTimeAsync(0);
+
+      const listener = vi.fn();
+      p.subscribe(listener);
+      p.cancel('a');
+      expect(listener).toHaveBeenCalledTimes(1);
+      p.dispose();
+    });
+
+    it('unsubscribe stops notifications', () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      const unsub = p.subscribe(listener);
+      unsub();
+
+      p.enqueue('a', 'op', async () => {});
+      expect(listener).not.toHaveBeenCalled();
+      p.dispose();
+    });
+  });
+
+  describe('dispose', () => {
+    it('cancels all operations', async () => {
+      const p = new Pending<string>();
+      let signal: AbortSignal | null = null;
+
+      p.enqueue('a', 'op', async (s) => {
+        signal = s;
+        await new Promise(() => {});
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      p.dispose();
+      expect(signal!.aborted).toBe(true);
+      expect(p.count).toBe(0);
+    });
+
+    it('clears all listeners', async () => {
+      const p = new Pending<string>();
+      const listener = vi.fn();
+      p.subscribe(listener);
+
+      p.dispose();
+      listener.mockClear();
+
+      // Even if somehow a notification fires, listener shouldn't be called
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it('subsequent enqueue is no-op', () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const p = new Pending<string>();
+      p.dispose();
+
+      p.enqueue('a', 'op', async () => {});
+      expect(p.count).toBe(0);
+      expect(p.disposed).toBe(true);
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe('ViewModel auto-tracking integration', () => {
+    it('is auto-tracked when assigned as ViewModel property', () => {
+      class TestVM extends ViewModel {
+        readonly pending = new Pending<string>();
+
+        get pendingCount() {
+          return this.pending.count;
+        }
+      }
+
+      const vm = new TestVM();
+      vm.init();
+
+      const listener = vi.fn();
+      vm.subscribe(listener);
+
+      vm.pending.enqueue('a', 'op', () => new Promise(() => {}));
+      expect(listener).toHaveBeenCalled();
+
+      vm.dispose();
+    });
+
+    it('ViewModel getter recomputes when operation status changes', async () => {
+      let computeCount = 0;
+
+      class TestVM extends ViewModel {
+        readonly pending = new Pending<string>();
+
+        get pendingCount() {
+          computeCount++;
+          return this.pending.count;
+        }
+      }
+
+      const vm = new TestVM();
+      vm.init();
+
+      expect(vm.pendingCount).toBe(0);
+      expect(computeCount).toBe(1);
+
+      // Cached
+      vm.pendingCount;
+      expect(computeCount).toBe(1);
+
+      // Enqueue — getter should recompute
+      vm.pending.enqueue('a', 'op', async () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      // After completion, count is 0 again
+      expect(vm.pendingCount).toBe(0);
+      expect(computeCount).toBeGreaterThan(1);
+
+      vm.dispose();
+    });
+
+    it('ViewModel getter caches when no change', () => {
+      let computeCount = 0;
+
+      class TestVM extends ViewModel {
+        readonly pending = new Pending<string>();
+
+        get hasFailed() {
+          computeCount++;
+          return this.pending.hasFailed;
+        }
+      }
+
+      const vm = new TestVM();
+      vm.init();
+
+      expect(vm.hasFailed).toBe(false);
+      expect(computeCount).toBe(1);
+
+      // Cached — same result
+      vm.hasFailed;
+      expect(computeCount).toBe(1);
+
+      vm.dispose();
+    });
+  });
+
+  describe('meta', () => {
+    interface TestMeta { label: string; priority: number }
+
+    it('enqueue with meta stores it on snapshot', async () => {
+      const p = new Pending<string, TestMeta>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'send', () => promise, { label: 'hello', priority: 1 });
+      await vi.advanceTimersByTimeAsync(0);
+
+      const status = p.getStatus('a');
+      expect(status!.meta).toEqual({ label: 'hello', priority: 1 });
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('enqueue without meta defaults to null', async () => {
+      const p = new Pending<string, TestMeta>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'send', () => promise);
+      await vi.advanceTimersByTimeAsync(0);
+
+      const status = p.getStatus('a');
+      expect(status!.meta).toBe(null);
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('untyped Pending has meta: null', async () => {
+      const p = new Pending<string>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'delete', () => promise);
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.meta).toBe(null);
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('meta survives retry cycles', async () => {
+      const p = new Pending<string, TestMeta>();
+      let callCount = 0;
+
+      p.enqueue('a', 'send', async () => {
+        callCount++;
+        if (callCount === 1) throw new TypeError('Failed to fetch');
+      }, { label: 'retry-test', priority: 5 });
+
+      // First attempt — fails, enters retrying
+      await vi.advanceTimersByTimeAsync(0);
+      expect(p.getStatus('a')!.status).toBe('retrying');
+      expect(p.getStatus('a')!.meta).toEqual({ label: 'retry-test', priority: 5 });
+
+      // Second attempt — succeeds, removed
+      await vi.advanceTimersByTimeAsync(30_000);
+      expect(p.getStatus('a')).toBe(null);
+      expect(callCount).toBe(2);
+
+      p.dispose();
+    });
+
+    it('supersede replaces meta', async () => {
+      const p = new Pending<string, TestMeta>();
+      let resolve1!: () => void;
+      const promise1 = new Promise<void>(r => { resolve1 = r; });
+
+      p.enqueue('a', 'send', () => promise1, { label: 'first', priority: 1 });
+      await vi.advanceTimersByTimeAsync(0);
+      expect(p.getStatus('a')!.meta).toEqual({ label: 'first', priority: 1 });
+
+      // Supersede with different meta
+      let resolve2!: () => void;
+      const promise2 = new Promise<void>(r => { resolve2 = r; });
+      p.enqueue('a', 'send', () => promise2, { label: 'second', priority: 2 });
+      await vi.advanceTimersByTimeAsync(0);
+      expect(p.getStatus('a')!.meta).toEqual({ label: 'second', priority: 2 });
+
+      resolve2();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('meta is frozen on snapshot', async () => {
+      const p = new Pending<string, TestMeta>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'send', () => promise, { label: 'frozen', priority: 1 });
+      await vi.advanceTimersByTimeAsync(0);
+
+      const status = p.getStatus('a')!;
+      expect(() => { (status as any).meta = 'changed'; }).toThrow();
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+  });
+
+  describe('entries', () => {
+    it('returns empty array when no operations', () => {
+      const p = new Pending<string>();
+      expect(p.entries).toEqual([]);
+      expect(p.entries.length).toBe(0);
+      p.dispose();
+    });
+
+    it('returns all operations with ids', async () => {
+      const p = new Pending<string>();
+      let resolve1!: () => void;
+      let resolve2!: () => void;
+      const p1 = new Promise<void>(r => { resolve1 = r; });
+      const p2 = new Promise<void>(r => { resolve2 = r; });
+
+      p.enqueue('a', 'delete', () => p1);
+      p.enqueue('b', 'update', () => p2);
+      await vi.advanceTimersByTimeAsync(0);
+
+      const entries = p.entries;
+      expect(entries.length).toBe(2);
+
+      const entryA = entries.find(e => e.id === 'a');
+      const entryB = entries.find(e => e.id === 'b');
+      expect(entryA).toBeDefined();
+      expect(entryA!.operation).toBe('delete');
+      expect(entryA!.status).toBe('active');
+      expect(entryB).toBeDefined();
+      expect(entryB!.operation).toBe('update');
+
+      resolve1();
+      resolve2();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('entries include meta', async () => {
+      interface Meta { label: string }
+      const p = new Pending<string, Meta>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'send', () => promise, { label: 'test-meta' });
+      await vi.advanceTimersByTimeAsync(0);
+
+      const entry = p.entries[0]!;
+      expect(entry.id).toBe('a');
+      expect(entry.meta).toEqual({ label: 'test-meta' });
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('entries are reference-stable between reads without changes', async () => {
+      const p = new Pending<string>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'delete', () => promise);
+      await vi.advanceTimersByTimeAsync(0);
+
+      const first = p.entries;
+      const second = p.entries;
+      expect(first).toBe(second); // same reference
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('entries cache invalidates on enqueue', async () => {
+      const p = new Pending<string>();
+      let resolve1!: () => void;
+      let resolve2!: () => void;
+      const p1 = new Promise<void>(r => { resolve1 = r; });
+      const p2 = new Promise<void>(r => { resolve2 = r; });
+
+      p.enqueue('a', 'delete', () => p1);
+      await vi.advanceTimersByTimeAsync(0);
+
+      const before = p.entries;
+      expect(before.length).toBe(1);
+
+      p.enqueue('b', 'update', () => p2);
+      await vi.advanceTimersByTimeAsync(0);
+
+      const after = p.entries;
+      expect(after).not.toBe(before); // new reference
+      expect(after.length).toBe(2);
+
+      resolve1();
+      resolve2();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('entries cache invalidates on cancel', async () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'delete', () => new Promise(() => {}));
+      await vi.advanceTimersByTimeAsync(0);
+
+      const before = p.entries;
+      expect(before.length).toBe(1);
+
+      p.cancel('a');
+
+      const after = p.entries;
+      expect(after).not.toBe(before);
+      expect(after.length).toBe(0);
+
+      p.dispose();
+    });
+
+    it('entries cache invalidates on dismiss', async () => {
+      const p = new Pending<string>();
+      p.enqueue('a', 'delete', async () => {
+        throw new HttpError(422, 'Validation failed');
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(p.getStatus('a')!.status).toBe('failed');
+      const before = p.entries;
+      expect(before.length).toBe(1);
+
+      p.dismiss('a');
+
+      const after = p.entries;
+      expect(after).not.toBe(before);
+      expect(after.length).toBe(0);
+
+      p.dispose();
+    });
+
+    it('entries are frozen', async () => {
+      const p = new Pending<string>();
+      let resolve!: () => void;
+      const promise = new Promise<void>(r => { resolve = r; });
+
+      p.enqueue('a', 'delete', () => promise);
+      await vi.advanceTimersByTimeAsync(0);
+
+      const entries = p.entries;
+      expect(() => { (entries as any).push('x'); }).toThrow();
+      expect(() => { (entries[0] as any).id = 'changed'; }).toThrow();
+
+      resolve();
+      await vi.advanceTimersByTimeAsync(0);
+      p.dispose();
+    });
+
+    it('empty entries array is reference-stable', () => {
+      const p = new Pending<string>();
+      const first = p.entries;
+      const second = p.entries;
+      expect(first).toBe(second);
+      expect(first.length).toBe(0);
+      p.dispose();
+    });
+  });
+
+  describe('method binding', () => {
+    it('destructured methods work point-free', () => {
+      const pending = new Pending<string>();
+      const { enqueue, has, getStatus } = pending;
+      enqueue('1', 'save', async () => {});
+      expect(has('1')).toBe(true);
+      expect(getStatus('1')).not.toBeNull();
+    });
+  });
+});