@oxy.so/core 1.18.1 → 3.0.0

package/src/session/__tests__/SessionClient.httpIntegration.test.ts

@@ -1,65 +0,0 @@
-import type { DeviceSessionState } from '@oxy.so/contracts';
-import { OxyServices } from '../../OxyServices';
-import { SessionClient } from '../SessionClient';
-import { createSessionClientHost } from '../sessionClientHost';
-
-/**
- * Real-stack integration test: a genuine `HttpService` (via `OxyServices`) →
- * `createSessionClientHost` → `SessionClient`, with `global.fetch` stubbed to
- * return the EXACT wire body the server sends for `GET /session/device/state`:
- * `{ data: { state, activeToken } }`.
- *
- * This is the test that would have caught the P0: `HttpService.unwrapResponse`
- * strips the outer `{ data }` envelope, so `makeRequest` already returns
- * `{ state, activeToken }`. If `SessionClient` reads `.data` a SECOND time (or
- * if `HttpService` stops unwrapping), the sync silently discards and neither
- * the state nor the token reach the client — exactly the prod symptom.
- */
-const WIRE_STATE: DeviceSessionState = {
-  deviceId: 'device-real',
-  accounts: [{ accountId: 'acct-1', sessionId: 'sess-1', authuser: 0 }],
-  activeAccountId: 'acct-1',
-  revision: 42,
-  updatedAt: 1720000000000,
-};
-
-const ROUTE_BODY = {
-  data: {
-    state: WIRE_STATE,
-    activeToken: { accessToken: 'planted-access-token', expiresAt: '2026-01-01T00:00:00.000Z' },
-  },
-};
-
-describe('SessionClient over a real HttpService (unwrap contract)', () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-  });
-
-  it('bootstrap() applies the server state and plants the active token through the real unwrap path', async () => {
-    const fetchMock = jest.fn(async () =>
-      new Response(JSON.stringify(ROUTE_BODY), {
-        status: 200,
-        headers: { 'content-type': 'application/json' },
-      }),
-    );
-    global.fetch = fetchMock as unknown as typeof fetch;
-
-    const oxy = new OxyServices({ baseURL: 'http://api.test.invalid' });
-    const host = createSessionClientHost(oxy);
-    const client = new SessionClient(host);
-
-    await client.bootstrap();
-
-    // The exact URL the server route serves.
-    const calledUrl = String((fetchMock.mock.calls[0] ?? [])[0]);
-    expect(calledUrl).toContain('/session/device/state');
-
-    // State reached the client (would be null if `.data` were read twice).
-    expect(client.getState()).toEqual(WIRE_STATE);
-
-    // Active token planted host-side (would be absent on a discarded sync).
-    expect(oxy.getAccessToken()).toBe('planted-access-token');
-  });
-});

package/src/session/__tests__/SessionClient.identityPin.test.ts

@@ -1,175 +0,0 @@
-/**
- * `SessionClient` under an IDENTITY pin.
- *
- * The bug this guards: an account switch performed by ANOTHER app on the same
- * device arrives as a `session_state` push (or as an `activeToken` on a sync
- * response) and silently re-bound the identity vault's bearer to that account.
- *
- * The contract: device state is still tracked TRUTHFULLY (other apps' accounts
- * and the real `activeAccountId` remain visible in `getState()`), but the bearer
- * NEVER follows it. The pinned token's lifecycle belongs to the cold boot /
- * re-mint lane, which mints it with an explicit `accountId`.
- */
-import type { DeviceSessionState } from '@oxy.so/contracts';
-import { SessionClient, type SessionClientHost, type TokenTransport } from '../SessionClient';
-
-const PINNED = 'vault-user';
-const OTHER = 'other-user';
-
-/** A minimal jwt-decode-able token whose `userId` claim is `accountId`. */
-function jwtFor(accountId: string): string {
-  const payload = Buffer.from(JSON.stringify({ userId: accountId })).toString('base64url');
-  return `h.${payload}.s`;
-}
-
-const stateWith = (revision: number, active: string): DeviceSessionState => ({
-  deviceId: 'dev-1',
-  accounts: [
-    { accountId: PINNED, sessionId: 'sess-vault', authuser: 0 },
-    { accountId: OTHER, sessionId: 'sess-other', authuser: 1 },
-  ],
-  activeAccountId: active,
-  revision,
-  updatedAt: 1_720_000_000_000,
-});
-
-function makeHost(initialToken: string | null): SessionClientHost & { planted: () => string | null } {
-  let planted = initialToken;
-  return {
-    makeRequest: jest.fn(),
-    getBaseURL: () => 'http://test.invalid',
-    getAccessToken: () => planted,
-    getDeviceCredential: () => null,
-    onTokensChanged: () => () => undefined,
-    setTokens: (token: string) => {
-      planted = token;
-    },
-    getCurrentAccountId: () => PINNED,
-    planted: () => planted,
-  };
-}
-
-/** `applyState` is protected; a tiny subclass exposes it for the unit tests. */
-class TestClient extends SessionClient {
-  public apply(raw: unknown, origin?: 'request' | 'push', activeToken?: string): boolean {
-    return this.applyState(raw, origin, activeToken);
-  }
-}
-
-describe('SessionClient — pinned bearer', () => {
-  // Node's real `BroadcastChannel` (which `postCommitPing` opens) is ref'd and
-  // would keep the Jest event loop alive forever. Feature-detect it away — the
-  // cross-tab wake has its own suite.
-  const realBroadcastChannel = (globalThis as { BroadcastChannel?: unknown }).BroadcastChannel;
-  beforeAll(() => {
-    (globalThis as { BroadcastChannel?: unknown }).BroadcastChannel = undefined;
-  });
-  afterAll(() => {
-    (globalThis as { BroadcastChannel?: unknown }).BroadcastChannel = realBroadcastChannel;
-  });
-
-  it('tracks a pushed switch in state but does NOT change the planted token', () => {
-    const host = makeHost(jwtFor(PINNED));
-    const client = new TestClient(host, { getPinnedAccountId: () => PINNED });
-
-    expect(client.apply(stateWith(1, PINNED), 'push')).toBe(true);
-    // Another app switched the device to `other-user`.
-    expect(client.apply(stateWith(2, OTHER), 'push')).toBe(true);
-
-    // The state is truthful...
-    expect(client.getState()?.activeAccountId).toBe(OTHER);
-    // ...and the bearer is untouched.
-    expect(host.planted()).toBe(jwtFor(PINNED));
-  });
-
-  it('does NOT plant a sync-supplied activeToken for a non-pinned account', () => {
-    const host = makeHost(jwtFor(PINNED));
-    const client = new TestClient(host, { getPinnedAccountId: () => PINNED });
-
-    client.apply(stateWith(3, OTHER), 'request', jwtFor(OTHER));
-
-    expect(host.planted()).toBe(jwtFor(PINNED));
-  });
-
-  it('DOES plant a sync-supplied activeToken when the active account IS the pinned one', () => {
-    const host = makeHost(null);
-    const client = new TestClient(host, { getPinnedAccountId: () => PINNED });
-
-    client.apply(stateWith(4, PINNED), 'request', jwtFor(PINNED));
-
-    expect(host.planted()).toBe(jwtFor(PINNED));
-  });
-
-  it('never invokes the TokenTransport (whose job is converging on activeAccountId)', () => {
-    const host = makeHost(jwtFor(PINNED));
-    const transport: TokenTransport = { ensureActiveToken: jest.fn().mockResolvedValue(undefined) };
-    const client = new TestClient(host, { transport, getPinnedAccountId: () => PINNED });
-
-    client.apply(stateWith(5, OTHER), 'push');
-
-    expect(transport.ensureActiveToken).not.toHaveBeenCalled();
-  });
-
-  it('notifies subscribers synchronously on a foreign switch (no mint-before-notify gate)', () => {
-    const host = makeHost(jwtFor(PINNED));
-    const transport: TokenTransport = { ensureActiveToken: jest.fn().mockResolvedValue(undefined) };
-    const client = new TestClient(host, { transport, getPinnedAccountId: () => PINNED });
-
-    const seen: Array<string | null> = [];
-    client.subscribe((state) => seen.push(state?.activeAccountId ?? null));
-
-    client.apply(stateWith(6, OTHER), 'push');
-
-    expect(seen).toEqual([OTHER]);
-  });
-
-  it('account mode is unchanged: an activeToken for the new active account IS planted', () => {
-    const host = makeHost(jwtFor(PINNED));
-    const client = new TestClient(host);
-
-    client.apply(stateWith(7, OTHER), 'request', jwtFor(OTHER));
-
-    expect(host.planted()).toBe(jwtFor(OTHER));
-  });
-
-  it('registerAndActivate only ADDS while pinned (never re-elects the device active account)', async () => {
-    const host = makeHost(jwtFor(PINNED));
-    const makeRequest = jest.fn().mockResolvedValue({
-      state: stateWith(8, OTHER),
-      activeToken: null,
-    });
-    const client = new SessionClient(
-      { ...host, makeRequest },
-      { getPinnedAccountId: () => PINNED },
-    );
-
-    await client.registerAndActivate(PINNED);
-
-    expect(makeRequest).toHaveBeenCalledTimes(1);
-    expect(makeRequest).toHaveBeenCalledWith('POST', '/session/device/add', undefined, { cache: false });
-    expect(makeRequest).not.toHaveBeenCalledWith(
-      'POST',
-      '/session/device/switch',
-      expect.anything(),
-      expect.anything(),
-    );
-  });
-
-  it('account mode is unchanged: registerAndActivate still switches to the target', async () => {
-    const host = makeHost(jwtFor(PINNED));
-    const makeRequest = jest.fn().mockResolvedValue({
-      state: stateWith(9, OTHER),
-      activeToken: null,
-    });
-    const client = new SessionClient({ ...host, makeRequest });
-
-    await client.registerAndActivate(PINNED);
-
-    expect(makeRequest).toHaveBeenCalledWith(
-      'POST',
-      '/session/device/switch',
-      { accountId: PINNED },
-      { cache: false },
-    );
-  });
-});

package/src/session/__tests__/SessionClient.rest.test.ts

@@ -1,119 +0,0 @@
-import type { DeviceSessionState } from '@oxy.so/contracts';
-import { SessionClient, type SessionClientHost } from '../SessionClient';
-
-const STATE = (rev: number): DeviceSessionState => ({
-  deviceId: 'd1', accounts: [{ accountId: 'a1', sessionId: 's1', authuser: 0 }], activeAccountId: 'a1', revision: rev, updatedAt: 1720000000000,
-});
-
-function makeHost(makeRequest: jest.Mock): SessionClientHost {
-  return {
-    makeRequest,
-    getBaseURL: () => 'http://test.invalid',
-    getAccessToken: () => 't',
-    getDeviceCredential: () => null,
-    onTokensChanged: () => () => undefined,
-    setTokens: jest.fn(),
-    getCurrentAccountId: () => null,
-  };
-}
-
-// `makeRequest` (HttpService) already strips the server's outer `{ data }` envelope, so it
-// returns the unwrapped sync body directly — that is exactly what SessionClient consumes.
-const SYNC = (rev: number) => ({ state: STATE(rev), activeToken: { accessToken: `jwt-${rev}`, expiresAt: 'x' } });
-
-describe('SessionClient REST', () => {
-  it('adopts state already returned by a mint without another request', () => {
-    const makeRequest = jest.fn();
-    const c = new SessionClient(makeHost(makeRequest));
-
-    expect(c.adoptState(STATE(2))).toBe(true);
-    expect(c.getState()?.revision).toBe(2);
-    expect(makeRequest).not.toHaveBeenCalled();
-  });
-
-  it('bootstrap GETs /session/device/state and applies it', async () => {
-    const makeRequest = jest.fn().mockResolvedValueOnce(SYNC(3));
-    const host = makeHost(makeRequest);
-    const c = new SessionClient(host);
-    await c.bootstrap();
-    expect(makeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-    expect(c.getState()?.revision).toBe(3);
-    expect(host.setTokens).toHaveBeenCalledWith('jwt-3');
-  });
-
-  it('switchAccount POSTs and applies the returned state', async () => {
-    const makeRequest = jest.fn().mockResolvedValueOnce(SYNC(4));
-    const host = makeHost(makeRequest);
-    const c = new SessionClient(host);
-    await c.switchAccount('a1');
-    expect(makeRequest).toHaveBeenCalledWith('POST', '/session/device/switch', { accountId: 'a1' }, { cache: false });
-    expect(c.getState()?.revision).toBe(4);
-    expect(host.setTokens).toHaveBeenCalledWith('jwt-4');
-    c.stop();
-  });
-
-  it('signOut one account POSTs { accountId }', async () => {
-    const makeRequest = jest.fn().mockResolvedValueOnce(SYNC(5));
-    const c = new SessionClient(makeHost(makeRequest));
-    await c.signOut({ accountId: 'a1' });
-    expect(makeRequest).toHaveBeenCalledWith('POST', '/session/device/signout', { accountId: 'a1' }, { cache: false });
-    c.stop();
-  });
-
-  it('signOut all POSTs { all: true }', async () => {
-    const makeRequest = jest.fn().mockResolvedValueOnce(SYNC(6));
-    const c = new SessionClient(makeHost(makeRequest));
-    await c.signOut({ all: true });
-    expect(makeRequest).toHaveBeenCalledWith('POST', '/session/device/signout', { all: true }, { cache: false });
-    c.stop();
-  });
-
-  it('addCurrentAccount POSTs /session/device/add with no body', async () => {
-    const makeRequest = jest.fn().mockResolvedValueOnce(SYNC(2));
-    const c = new SessionClient(makeHost(makeRequest));
-    await c.addCurrentAccount();
-    expect(makeRequest).toHaveBeenCalledWith('POST', '/session/device/add', undefined, { cache: false });
-    c.stop();
-  });
-
-  it('does not throw / does not apply when the server returns invalid state', async () => {
-    const makeRequest = jest.fn().mockResolvedValueOnce({ bogus: true });
-    const c = new SessionClient(makeHost(makeRequest));
-    await c.bootstrap();
-    expect(c.getState()).toBeNull();
-  });
-
-  it('applies state but does not plant a token when activeToken is null', async () => {
-    const makeRequest = jest.fn().mockResolvedValueOnce({ state: STATE(7), activeToken: null });
-    const host = makeHost(makeRequest);
-    const c = new SessionClient(host);
-    await c.bootstrap();
-    expect(c.getState()?.revision).toBe(7);
-    expect(host.setTokens).not.toHaveBeenCalled();
-  });
-
-  it('accepts a NEW device\'s lower-revision state and plants its token (cross-device revision reset)', async () => {
-    const deviceA: DeviceSessionState = {
-      deviceId: 'A', accounts: [{ accountId: 'a1', sessionId: 's1', authuser: 0 }], activeAccountId: 'a1', revision: 10, updatedAt: 1720000000000,
-    };
-    const deviceB: DeviceSessionState = {
-      deviceId: 'B', accounts: [{ accountId: 'a2', sessionId: 's2', authuser: 0 }], activeAccountId: 'a2', revision: 1, updatedAt: 1720000001000,
-    };
-    const makeRequest = jest.fn()
-      .mockResolvedValueOnce({ state: deviceA, activeToken: { accessToken: 'jwt-A', expiresAt: 'x' } })
-      .mockResolvedValueOnce({ state: deviceB, activeToken: { accessToken: 'jwt-B', expiresAt: 'x' } });
-    const host = makeHost(makeRequest);
-    const c = new SessionClient(host);
-
-    await c.bootstrap();
-    expect(c.getState()?.deviceId).toBe('A');
-    expect(host.setTokens).toHaveBeenLastCalledWith('jwt-A');
-
-    // Device B is freshly converged (revision 1) — it must win over device A's
-    // stale-but-higher revision, and its token must be planted.
-    await c.bootstrap();
-    expect(c.getState()?.deviceId).toBe('B');
-    expect(c.getState()?.revision).toBe(1);
-    expect(host.setTokens).toHaveBeenLastCalledWith('jwt-B');
-  });
-});

package/src/session/__tests__/SessionClient.serverEvents.test.ts

@@ -1,72 +0,0 @@
-import type { DeviceSessionState } from '@oxy.so/contracts';
-import type { MinimalSocket, SocketIOFactory } from '../socketLoader';
-import { SessionClient, type SessionClientHost } from '../SessionClient';
-
-type Handler = (...args: unknown[]) => void;
-class FakeSocket implements MinimalSocket {
-  connected = false;
-  handlers = new Map<string, Handler[]>();
-  on(event: string, cb: Handler) { const l = this.handlers.get(event) ?? []; l.push(cb); this.handlers.set(event, l); }
-  off(event: string, cb?: Handler) { if (!cb) { this.handlers.delete(event); return; } this.handlers.set(event, (this.handlers.get(event) ?? []).filter((h) => h !== cb)); }
-  emit(_event: string, ..._args: unknown[]) { /* client→server emit, unused here */ }
-  connect() { this.connected = true; }
-  disconnect() { this.connected = false; }
-  emitServer(event: string, payload: unknown) { for (const h of this.handlers.get(event) ?? []) h(payload); }
-}
-
-const STATE = (rev: number): DeviceSessionState => ({ deviceId: 'd1', accounts: [{ accountId: 'a1', sessionId: 's1', authuser: 0 }], activeAccountId: 'a1', revision: rev, updatedAt: 1720000000000 });
-const SYNC = (rev: number) => ({ state: STATE(rev), activeToken: { accessToken: `jwt-${rev}`, expiresAt: 'x' } });
-
-function makeHost(over: Partial<SessionClientHost> = {}): SessionClientHost {
-  return {
-    makeRequest: jest.fn().mockResolvedValue(SYNC(1)),
-    getBaseURL: () => 'http://test.invalid',
-    getAccessToken: () => 'tok',
-    getDeviceCredential: () => null,
-    onTokensChanged: () => () => undefined,
-    setTokens: jest.fn(),
-    getCurrentAccountId: () => 'a1',
-    ...over,
-  };
-}
-
-describe('SessionClient.onServerEvent', () => {
-  it('delivers a server event to a listener registered BEFORE the socket exists', async () => {
-    let created: FakeSocket | null = null;
-    const factory: SocketIOFactory = jest.fn(() => { created = new FakeSocket(); created.connected = true; return created; });
-    const client = new SessionClient(makeHost(), { socketFactory: factory });
-    const seen: unknown[] = [];
-    client.onServerEvent('civic:attested', (p) => seen.push(p));
-    await client.start();
-    created?.emitServer('civic:attested', { byUserId: 'u2' });
-    expect(seen).toEqual([{ byUserId: 'u2' }]);
-    client.stop();
-  });
-
-  it('delivers to a listener registered AFTER the socket exists, and unsubscribe stops delivery', async () => {
-    let created: FakeSocket | null = null;
-    const factory: SocketIOFactory = jest.fn(() => { created = new FakeSocket(); created.connected = true; return created; });
-    const client = new SessionClient(makeHost(), { socketFactory: factory });
-    await client.start();
-    const seen: unknown[] = [];
-    const unsub = client.onServerEvent('civic:attested', (p) => seen.push(p));
-    created?.emitServer('civic:attested', 1);
-    unsub();
-    created?.emitServer('civic:attested', 2);
-    expect(seen).toEqual([1]);
-    client.stop();
-  });
-
-  it('one listener throwing does not break the others', async () => {
-    let created: FakeSocket | null = null;
-    const factory: SocketIOFactory = jest.fn(() => { created = new FakeSocket(); created.connected = true; return created; });
-    const client = new SessionClient(makeHost(), { socketFactory: factory });
-    await client.start();
-    const seen: unknown[] = [];
-    client.onServerEvent('civic:attested', () => { throw new Error('boom'); });
-    client.onServerEvent('civic:attested', (p) => seen.push(p));
-    created?.emitServer('civic:attested', 'ok');
-    expect(seen).toEqual(['ok']);
-    client.stop();
-  });
-});

package/src/session/__tests__/SessionClient.socket.test.ts

@@ -1,202 +0,0 @@
-import type { DeviceSessionState } from '@oxy.so/contracts';
-
-type Handler = (...args: unknown[]) => void;
-class FakeSocket {
-  connected = false;
-  handlers = new Map<string, Handler[]>();
-  on(event: string, cb: Handler) { const l = this.handlers.get(event) ?? []; l.push(cb); this.handlers.set(event, l); }
-  off(event: string, cb?: Handler) { if (!cb) { this.handlers.delete(event); return; } this.handlers.set(event, (this.handlers.get(event) ?? []).filter((h) => h !== cb)); }
-  connect() { this.connected = true; this.trigger('connect'); }
-  disconnect() { this.connected = false; }
-  trigger(event: string, ...args: unknown[]) { for (const h of this.handlers.get(event) ?? []) h(...args); }
-}
-let fakeSocket: FakeSocket;
-const ioMock = jest.fn((_uri: string, opts?: Record<string, unknown>) => {
-  // honor autoConnect like real socket.io (connect immediately unless autoConnect:false)
-  if (!opts || opts.autoConnect !== false) fakeSocket.connected = true;
-  return fakeSocket;
-});
-jest.mock('socket.io-client', () => ({ __esModule: true, io: (...args: unknown[]) => ioMock(...(args as [string, Record<string, unknown>?])) }));
-
-import { SessionClient, type SessionClientHost } from '../SessionClient';
-
-const STATE = (rev: number): DeviceSessionState => ({ deviceId: 'd1', accounts: [{ accountId: 'a1', sessionId: 's1', authuser: 0 }], activeAccountId: 'a1', revision: rev, updatedAt: 1720000000000 });
-// `makeRequest` (HttpService) already strips the server's outer `{ data }` envelope, so it
-// returns the unwrapped sync body directly — that is exactly what SessionClient consumes.
-const SYNC = (rev: number) => ({ state: STATE(rev), activeToken: { accessToken: `jwt-${rev}`, expiresAt: 'x' } });
-
-function makeHost(over: Partial<SessionClientHost> = {}): SessionClientHost {
-  return {
-    makeRequest: jest.fn().mockResolvedValue(SYNC(1)),
-    getBaseURL: () => 'http://test.invalid',
-    getAccessToken: () => 'tok',
-    getDeviceCredential: () => null,
-    onTokensChanged: () => () => undefined,
-    setTokens: jest.fn(),
-    getCurrentAccountId: () => 'a1',
-    ...over,
-  };
-}
-
-beforeEach(() => { fakeSocket = new FakeSocket(); ioMock.mockClear(); });
-
-describe('SessionClient socket', () => {
-  it('start() bootstraps then opens ONE socket to the base URL with a token-in-handshake auth callback', async () => {
-    const host = makeHost();
-    const c = new SessionClient(host);
-    await c.start();
-    expect(host.makeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-    expect(ioMock).toHaveBeenCalledTimes(1);
-    const [uri, opts] = ioMock.mock.calls[0];
-    expect(uri).toBe('http://test.invalid');
-    const authCb = jest.fn();
-    (opts?.auth as (cb: (d: { token: string }) => void) => void)(authCb);
-    expect(authCb).toHaveBeenCalledWith({ token: 'tok' });
-    c.stop();
-  });
-
-  it('applies a pushed session_state event', async () => {
-    const c = new SessionClient(makeHost());
-    await c.start();
-    fakeSocket.trigger('session_state', STATE(9));
-    expect(c.getState()?.revision).toBe(9);
-    c.stop();
-  });
-
-  it('fetches the active token via bootstrap when a pushed state changes the active account', async () => {
-    const makeRequest = jest.fn().mockResolvedValue(SYNC(1));
-    const host = makeHost({ makeRequest, getCurrentAccountId: () => 'other-account' });
-    const c = new SessionClient(host);
-    await c.start();
-    makeRequest.mockClear();
-    fakeSocket.trigger('session_state', STATE(9));
-    await Promise.resolve();
-    expect(makeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-    c.stop();
-  });
-
-  it('C1 regression: plants the active token on a socket-pushed switch even when the post-push bootstrap returns the SAME revision as the push', async () => {
-    const setTokens = jest.fn();
-    const makeRequest = jest
-      .fn()
-      .mockResolvedValueOnce(SYNC(1)) // initial bootstrap in start()
-      .mockResolvedValue(SYNC(9)); // post-push bootstrap: same revision as the socket push below
-    const host = makeHost({ makeRequest, setTokens, getCurrentAccountId: () => 'other-account' });
-    const c = new SessionClient(host);
-    await c.start();
-    makeRequest.mockClear();
-    setTokens.mockClear();
-    fakeSocket.trigger('session_state', STATE(9));
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(makeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-    expect(setTokens).toHaveBeenCalledWith('jwt-9');
-    c.stop();
-  });
-
-  it('does not re-fetch when the pushed active account matches the host-held account', async () => {
-    const makeRequest = jest.fn().mockResolvedValue(SYNC(1));
-    const host = makeHost({ makeRequest, getCurrentAccountId: () => 'a1' });
-    const c = new SessionClient(host);
-    await c.start();
-    makeRequest.mockClear();
-    fakeSocket.trigger('session_state', STATE(9));
-    await Promise.resolve();
-    expect(makeRequest).not.toHaveBeenCalled();
-    c.stop();
-  });
-
-  it('does not open a socket at all when signed out (bearer-only)', async () => {
-    const c = new SessionClient(makeHost({ getAccessToken: () => null }));
-    await c.start();
-    expect(ioMock).not.toHaveBeenCalled();
-    c.stop();
-  });
-
-  it('reconnects an existing socket when a fresh token arrives after a transient drop', async () => {
-    const listeners: Array<(t: string | null) => void> = [];
-    const host = makeHost({ onTokensChanged: (l) => { listeners.push(l); return () => undefined; } });
-    const c = new SessionClient(host);
-    await c.start();
-    expect(fakeSocket.connected).toBe(true); // authenticated connect on start
-    fakeSocket.connected = false; // simulate a transient socket drop
-    listeners.forEach((l) => l('fresh-token'));
-    expect(fakeSocket.connected).toBe(true);
-    c.stop();
-  });
-
-  it('stop() disconnects the socket', async () => {
-    const c = new SessionClient(makeHost());
-    await c.start();
-    c.stop();
-    expect(fakeSocket.connected).toBe(false);
-  });
-
-  it('session_accounts_changed for the current user refetches device state (GET /session/device/state)', async () => {
-    const makeRequest = jest.fn().mockResolvedValue(SYNC(1));
-    const host = makeHost({ makeRequest, getCurrentAccountId: () => 'a1' });
-    const c = new SessionClient(host);
-    await c.start();
-    makeRequest.mockClear();
-    fakeSocket.trigger('session_accounts_changed', { userId: 'a1', revision: 5, reason: 'add' });
-    await Promise.resolve();
-    expect(makeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-    c.stop();
-  });
-
-  it('session_accounts_changed for a DIFFERENT user is ignored (no refetch)', async () => {
-    const makeRequest = jest.fn().mockResolvedValue(SYNC(1));
-    const host = makeHost({ makeRequest, getCurrentAccountId: () => 'a1' });
-    const c = new SessionClient(host);
-    await c.start();
-    makeRequest.mockClear();
-    fakeSocket.trigger('session_accounts_changed', { userId: 'someone-else', revision: 5, reason: 'switch' });
-    await Promise.resolve();
-    expect(makeRequest).not.toHaveBeenCalled();
-    c.stop();
-  });
-
-  it('session_accounts_changed drops a malformed payload without refetching', async () => {
-    const makeRequest = jest.fn().mockResolvedValue(SYNC(1));
-    const host = makeHost({ makeRequest, getCurrentAccountId: () => 'a1' });
-    const c = new SessionClient(host);
-    await c.start();
-    makeRequest.mockClear();
-    fakeSocket.trigger('session_accounts_changed', { userId: 'a1', reason: 'not-a-real-reason' });
-    await Promise.resolve();
-    expect(makeRequest).not.toHaveBeenCalled();
-    c.stop();
-  });
-
-  it('a socket-pushed empty state fires onUnauthenticated with the PUSH origin (bug #4)', async () => {
-    const onUnauthenticated = jest.fn();
-    const c = new SessionClient(makeHost(), { onUnauthenticated });
-    await c.start();
-
-    const EMPTY: DeviceSessionState = { deviceId: 'd1', accounts: [], activeAccountId: null, revision: 9, updatedAt: 1720000000001 };
-    fakeSocket.trigger('session_state', EMPTY);
-
-    expect(onUnauthenticated).toHaveBeenCalledWith('push');
-    c.stop();
-  });
-
-  it('a REST signOut-all empty response fires onUnauthenticated with the REQUEST origin', async () => {
-    const onUnauthenticated = jest.fn();
-    const EMPTY_SYNC = {
-      state: { deviceId: 'd1', accounts: [], activeAccountId: null, revision: 9, updatedAt: 1720000000001 },
-      activeToken: null,
-    };
-    // bootstrap during start() returns a populated state; the signout (and any
-    // stray reconcile) returns empty.
-    const makeRequest = jest.fn().mockResolvedValue(EMPTY_SYNC).mockResolvedValueOnce(SYNC(1));
-    const c = new SessionClient(makeHost({ makeRequest }), { onUnauthenticated });
-    await c.start();
-
-    await c.signOut({ all: true });
-    // Flush any fire-and-forget post-commit reconcile before asserting/teardown.
-    await Promise.resolve();
-
-    expect(onUnauthenticated).toHaveBeenCalledWith('request');
-    c.stop();
-  });
-});