@oxyhq/core 8.0.0 → 9.0.0

package/src/boot/__tests__/deviceBootReturn.test.ts

@@ -1,158 +0,0 @@
-import type { AuthTokenBundle } from '@oxyhq/contracts';
-import {
-  parseDeviceBootFragment,
-  hashHasBootFragment,
-  consumeDeviceBootReturn,
-  type ConsumeDeviceBootReturnDeps,
-} from '../deviceBootReturn';
-import { createMemoryAuthStateStore } from '../../session/authStateStore';
-
-const STATE = 'st-1234567890';
-const CODE = 'c'.repeat(24);
-const DEVICE_TOKEN = 'd'.repeat(24);
-
-// A loose record (fed to `encodeHash(unknown)` and validated by the schema) so
-// tests can build the session arm plus invalid variants (missing/extra `code`,
-// `v: 2`) without fighting the discriminated-union type.
-function fragmentObject(overrides: Record<string, unknown> = {}): Record<string, unknown> {
-  return { v: 1, state: STATE, reason: 'session', code: CODE, deviceToken: DEVICE_TOKEN, ...overrides };
-}
-
-function encodeHash(obj: unknown): string {
-  const b64 = Buffer.from(JSON.stringify(obj), 'utf-8')
-    .toString('base64')
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/, '');
-  return `#oxy_boot=${b64}`;
-}
-
-const BUNDLE: AuthTokenBundle = {
-  sessionId: 'sess-1',
-  accessToken: 'access-jwt',
-  refreshToken: 'refresh-abcdefghijklmnop',
-  expiresAt: '2030-01-01T00:00:00.000Z',
-  user: { id: 'user-1', name: {} } as AuthTokenBundle['user'],
-};
-
-/** Build the injectable deps around a memory store, recording call order. */
-function makeDeps(
-  hash: string,
-  overrides: Partial<ConsumeDeviceBootReturnDeps> & { expectedState?: string | null } = {},
-): { deps: ConsumeDeviceBootReturnDeps; calls: string[]; store: ReturnType<typeof createMemoryAuthStateStore> } {
-  const calls: string[] = [];
-  const store = createMemoryAuthStateStore();
-  const deps: ConsumeDeviceBootReturnDeps = {
-    hash,
-    stripFragment: () => calls.push('strip'),
-    readExpectedState: () => (overrides.expectedState !== undefined ? overrides.expectedState : STATE),
-    clearExpectedState: () => calls.push('clearState'),
-    store,
-    exchangeBootCode: overrides.exchangeBootCode
-      ?? (async () => {
-        calls.push('exchange');
-        return BUNDLE;
-      }),
-    plantAccessToken: overrides.plantAccessToken ?? ((token) => calls.push(`plant:${token}`)),
-  };
-  return { deps, calls, store };
-}
-
-describe('parseDeviceBootFragment', () => {
-  it('parses a valid base64url fragment', () => {
-    expect(parseDeviceBootFragment(encodeHash(fragmentObject()))).toEqual(fragmentObject());
-  });
-
-  it('returns null when the parameter is absent', () => {
-    expect(parseDeviceBootFragment('#something=else')).toBeNull();
-    expect(parseDeviceBootFragment('')).toBeNull();
-  });
-
-  it('returns null for malformed base64 / non-JSON / wrong shape', () => {
-    expect(parseDeviceBootFragment('#oxy_boot=!!!not-base64!!!')).toBeNull();
-    expect(parseDeviceBootFragment(encodeHash({ nope: true }))).toBeNull();
-    // v must be the literal 1
-    expect(parseDeviceBootFragment(encodeHash(fragmentObject({ v: 2 })))).toBeNull();
-  });
-
-  it('returns null for a session fragment missing its code (discriminated union)', () => {
-    expect(parseDeviceBootFragment(encodeHash(fragmentObject({ code: undefined })))).toBeNull();
-  });
-});
-
-describe('hashHasBootFragment', () => {
-  it('detects the fragment regardless of position', () => {
-    expect(hashHasBootFragment('#oxy_boot=abc')).toBe(true);
-    expect(hashHasBootFragment('#x=1&oxy_boot=abc')).toBe(true);
-    expect(hashHasBootFragment('#other=1')).toBe(false);
-    expect(hashHasBootFragment('')).toBe(false);
-  });
-});
-
-describe('consumeDeviceBootReturn', () => {
-  it('returns none and does not touch the URL when no fragment is present', async () => {
-    const { deps, calls } = makeDeps('#unrelated=1');
-    expect(await consumeDeviceBootReturn(deps)).toEqual({ kind: 'none' });
-    expect(calls).not.toContain('strip');
-  });
-
-  it('strips the fragment BEFORE exchanging the code', async () => {
-    const { deps, calls } = makeDeps(encodeHash(fragmentObject()));
-    const outcome = await consumeDeviceBootReturn(deps);
-    expect(outcome.kind).toBe('session');
-    expect(calls.indexOf('strip')).toBeLessThan(calls.indexOf('exchange'));
-  });
-
-  it('resolves a session, persists it, and plants the token', async () => {
-    const { deps, store } = makeDeps(encodeHash(fragmentObject()));
-    const outcome = await consumeDeviceBootReturn(deps);
-    expect(outcome).toEqual({
-      kind: 'session',
-      session: { sessionId: 'sess-1', userId: 'user-1', accessToken: 'access-jwt' },
-    });
-    expect(await store.load()).toMatchObject({
-      sessionId: 'sess-1',
-      refreshToken: 'refresh-abcdefghijklmnop',
-      userId: 'user-1',
-      deviceToken: DEVICE_TOKEN,
-    });
-    expect(await store.loadDeviceToken()).toBe(DEVICE_TOKEN);
-  });
-
-  it('rejects a state mismatch without persisting or exchanging', async () => {
-    const { deps, calls, store } = makeDeps(encodeHash(fragmentObject()), { expectedState: 'WRONG' });
-    expect(await consumeDeviceBootReturn(deps)).toEqual({ kind: 'state-mismatch' });
-    expect(calls).toContain('strip');
-    expect(calls).not.toContain('exchange');
-    expect(await store.loadDeviceToken()).toBeNull();
-  });
-
-  it('rejects when there is no expected state stashed at all', async () => {
-    const { deps } = makeDeps(encodeHash(fragmentObject()), { expectedState: null });
-    expect(await consumeDeviceBootReturn(deps)).toEqual({ kind: 'state-mismatch' });
-  });
-
-  it('persists the deviceToken but returns no-session for a signed-out device', async () => {
-    const { deps, store, calls } = makeDeps(
-      encodeHash(fragmentObject({ reason: 'new_device', code: undefined })),
-    );
-    expect(await consumeDeviceBootReturn(deps)).toEqual({ kind: 'no-session', reason: 'new_device' });
-    expect(calls).not.toContain('exchange');
-    expect(await store.loadDeviceToken()).toBe(DEVICE_TOKEN);
-  });
-
-  it('returns no-session when the code exchange fails (burned/expired code)', async () => {
-    const { deps } = makeDeps(encodeHash(fragmentObject()), {
-      exchangeBootCode: async () => {
-        throw new Error('code already burned');
-      },
-    });
-    expect(await consumeDeviceBootReturn(deps)).toEqual({ kind: 'no-session', reason: 'no_session' });
-  });
-
-  it('strips even a malformed fragment and returns none', async () => {
-    const { deps, calls } = makeDeps('#oxy_boot=!!!malformed!!!');
-    expect(await consumeDeviceBootReturn(deps)).toEqual({ kind: 'none' });
-    expect(calls).toContain('strip');
-  });
-});

package/src/boot/deviceBootReturn.ts

@@ -1,195 +0,0 @@
-/**
- * Device-boot return-fragment consumption (web cross-apex hop).
- *
- * After the top-level `GET /auth/device/bootstrap` hop, the API 303s back to the
- * RP with a `#oxy_boot=<base64url(JSON)>` fragment. This module parses and
- * consumes it: it strips the fragment from the URL FIRST (so the opaque
- * deviceToken / code never linger in history or a `Referer`), verifies the
- * echoed CSRF `state` against the value the initiator stashed in
- * `sessionStorage`, persists the deviceToken, and — when a session resolved —
- * exchanges the single-use `code` for a token bundle.
- *
- * Pure/injectable: all DOM access (hash, `history.replaceState`,
- * `sessionStorage`) is passed in as callbacks so the logic is unit-testable
- * under the jest `node` environment and reusable by `coldBootV2`.
- *
- * ESM-safe (no `require()`).
- */
-import {
-  deviceBootFragmentSchema,
-  resolveUserId,
-  safeParseContract,
-  type AuthTokenBundle,
-  type DeviceBootFragment,
-  type DeviceBootReason,
-} from '@oxyhq/contracts';
-import type { AuthStateStore, PersistedAuthState } from '../session/authStateStore';
-
-/** The `#oxy_boot=` fragment parameter name the API appends on the return hop. */
-export const BOOT_FRAGMENT_PARAM = 'oxy_boot';
-
-/**
- * `sessionStorage` key under which the bootstrap-hop initiator stashes the
- * 128-bit CSRF `state` before navigating, and which the return step reads back
- * (single-use).
- */
-export const BOOT_STATE_SESSION_KEY = 'oxy.boot.state';
-
-/**
- * Decode a base64url string to UTF-8 text, or `null` on any malformed input.
- * Handles both web (`atob` + `TextDecoder`) and Node (`Buffer`) without a
- * `require()` — the ESM build stays clean.
- */
-function base64UrlDecode(input: string): string | null {
-  try {
-    let b64 = input.replace(/-/g, '+').replace(/_/g, '/');
-    while (b64.length % 4 !== 0) {
-      b64 += '=';
-    }
-    if (typeof atob === 'function') {
-      const binary = atob(b64);
-      const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
-      if (typeof TextDecoder !== 'undefined') {
-        return new TextDecoder().decode(bytes);
-      }
-      return binary;
-    }
-    if (typeof Buffer !== 'undefined') {
-      return Buffer.from(b64, 'base64').toString('utf-8');
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/** True when a location hash carries the `oxy_boot` return fragment. */
-export function hashHasBootFragment(hash: string): boolean {
-  return new RegExp(`(^|[#&])${BOOT_FRAGMENT_PARAM}=`).test(hash);
-}
-
-/**
- * Extract + decode + validate the `oxy_boot` fragment from a location hash.
- * Returns the parsed {@link DeviceBootFragment}, or `null` when the parameter
- * is absent, not valid base64url, not JSON, or fails the contract schema.
- */
-export function parseDeviceBootFragment(hash: string): DeviceBootFragment | null {
-  const withoutHash = hash.startsWith('#') ? hash.slice(1) : hash;
-  const params = new URLSearchParams(withoutHash);
-  const raw = params.get(BOOT_FRAGMENT_PARAM);
-  if (!raw) {
-    return null;
-  }
-  const json = base64UrlDecode(raw);
-  if (!json) {
-    return null;
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(json);
-  } catch {
-    return null;
-  }
-  return safeParseContract(deviceBootFragmentSchema, parsed);
-}
-
-/** The winning session shape a cold-boot step reports. */
-export interface DeviceBootSession {
-  sessionId: string;
-  userId: string;
-  accessToken: string;
-}
-
-/** Outcome of {@link consumeDeviceBootReturn}. */
-export type DeviceBootReturnOutcome =
-  | { kind: 'none' }
-  | { kind: 'state-mismatch' }
-  | { kind: 'session'; session: DeviceBootSession }
-  | { kind: 'no-session'; reason: DeviceBootReason };
-
-export interface ConsumeDeviceBootReturnDeps {
-  /** The current location hash (e.g. `window.location.hash`). */
-  hash: string;
-  /** Strip the fragment from the URL (e.g. `history.replaceState`). */
-  stripFragment: () => void;
-  /** Read the expected CSRF state (e.g. `sessionStorage.getItem(BOOT_STATE_SESSION_KEY)`). */
-  readExpectedState: () => string | null;
-  /** Clear the expected CSRF state (single-use). */
-  clearExpectedState: () => void;
-  store: AuthStateStore;
-  /** Exchange the single-use boot code for a token bundle (`oxy.exchangeBootCode`). */
-  exchangeBootCode: (code: string) => Promise<AuthTokenBundle>;
-  /** Plant the freshly-minted access token on the owner client (`oxy.setTokens`). */
-  plantAccessToken: (accessToken: string) => void;
-}
-
-/**
- * Consume the device-boot return fragment.
- *
- * Order is load-bearing:
- *   1. If no fragment is present, return `none` (no URL mutation).
- *   2. STRIP the fragment from the URL immediately — before validation or any
- *      network — so the deviceToken/code never persist in history/referrer.
- *   3. Verify the echoed `state` against the stashed (single-use) value; a
- *      mismatch returns `state-mismatch` without persisting or exchanging.
- *   4. Persist the deviceToken (survives sign-out).
- *   5. If a session resolved (`reason:'session'` + `code`), exchange the code,
- *      persist the rotated session, plant the token, and return `session`.
- *      Otherwise return `no-session` with the reason.
- */
-export async function consumeDeviceBootReturn(
-  deps: ConsumeDeviceBootReturnDeps,
-): Promise<DeviceBootReturnOutcome> {
-  if (!hashHasBootFragment(deps.hash)) {
-    return { kind: 'none' };
-  }
-
-  // Strip FIRST — even a forged/malformed fragment must not linger in the URL.
-  deps.stripFragment();
-
-  const fragment = parseDeviceBootFragment(deps.hash);
-  if (!fragment) {
-    return { kind: 'none' };
-  }
-
-  const expected = deps.readExpectedState();
-  deps.clearExpectedState();
-  if (!expected || expected !== fragment.state) {
-    return { kind: 'state-mismatch' };
-  }
-
-  await deps.store.saveDeviceToken(fragment.deviceToken);
-
-  // `code` is guaranteed present on the `session` arm (the contract's
-  // discriminated union requires it; a session fragment without a code fails to
-  // parse and never reaches here).
-  if (fragment.reason === 'session') {
-    try {
-      const bundle = await deps.exchangeBootCode(fragment.code);
-      const userId = resolveUserId(bundle.user);
-      if (!userId) {
-        return { kind: 'no-session', reason: 'no_session' };
-      }
-      const next: PersistedAuthState = {
-        sessionId: bundle.sessionId,
-        refreshToken: bundle.refreshToken,
-        userId,
-        deviceToken: fragment.deviceToken,
-        accessToken: bundle.accessToken,
-        expiresAt: bundle.expiresAt,
-      };
-      await deps.store.save(next);
-      deps.plantAccessToken(bundle.accessToken);
-      return {
-        kind: 'session',
-        session: { sessionId: bundle.sessionId, userId, accessToken: bundle.accessToken },
-      };
-    } catch {
-      // The code burned/expired between hop and exchange — resolve signed-out
-      // rather than throwing (the once-ever hop already fired; do not retry).
-      return { kind: 'no-session', reason: 'no_session' };
-    }
-  }
-
-  return { kind: 'no-session', reason: fragment.reason };
-}

package/src/crypto/__tests__/sharedDeviceToken.test.ts

@@ -1,24 +0,0 @@
-/**
- * Shared device-token contract on web. Under the jest `node` environment
- * `getPlatformOS()` resolves to `'web'`, so the shared-keychain device-token
- * methods are no-ops (web persists its deviceToken in the per-origin
- * AuthStateStore instead of a keychain). The native keychain plumbing is
- * exercised via spies in the coldBootV2 suite.
- */
-import { KeyManager } from '../keyManager';
-
-describe('KeyManager shared device token (web)', () => {
-  it('getSharedDeviceToken returns null on web', async () => {
-    expect(await KeyManager.getSharedDeviceToken()).toBeNull();
-  });
-
-  it('setSharedDeviceToken is a no-op that does not throw on web', async () => {
-    await expect(KeyManager.setSharedDeviceToken('dt-web')).resolves.toBeUndefined();
-    // Still null — nothing was persisted on web.
-    expect(await KeyManager.getSharedDeviceToken()).toBeNull();
-  });
-
-  it('clearSharedDeviceToken is a no-op that does not throw on web', async () => {
-    await expect(KeyManager.clearSharedDeviceToken()).resolves.toBeUndefined();
-  });
-});

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

@@ -1,224 +0,0 @@
-import type { DeviceSessionState } from '@oxyhq/contracts';
-
-type Handler = (...args: unknown[]) => void;
-class FakeSocket {
-  connected = false;
-  handlers = new Map<string, Handler[]>();
-  connectCalls = 0;
-  disconnectCalls = 0;
-  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.connectCalls += 1; this.connected = true; this.trigger('connect'); }
-  disconnect() { this.disconnectCalls += 1; this.connected = false; }
-  trigger(event: string, ...args: unknown[]) { for (const h of this.handlers.get(event) ?? []) h(...args); }
-}
-let fakeSocket: FakeSocket;
-let lastOpts: Record<string, unknown> | undefined;
-const ioMock = jest.fn((_uri: string, opts?: Record<string, unknown>) => {
-  lastOpts = opts;
-  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>?])) }));
-
-// A same-name in-process BroadcastChannel bus: postMessage delivers to every
-// OTHER open channel of the same name (never the sender) — matching the spec.
-type BusEntry = { name: string; onmessage: ((event: { data: unknown }) => void) | null };
-const bus = new Set<BusEntry>();
-class FakeBroadcastChannel {
-  private entry: BusEntry;
-  constructor(public name: string) { this.entry = { name, onmessage: null }; bus.add(this.entry); }
-  get onmessage(): ((event: { data: unknown }) => void) | null { return this.entry.onmessage; }
-  set onmessage(cb: ((event: { data: unknown }) => void) | null) { this.entry.onmessage = cb; }
-  postMessage(data: unknown) {
-    for (const e of bus) {
-      if (e === this.entry || e.name !== this.name) continue;
-      e.onmessage?.({ data });
-    }
-  }
-  close() { bus.delete(this.entry); }
-}
-
-import { SessionClient, type SessionClientHost, type SessionClientOptions } from '../SessionClient';
-
-const STATE = (rev: number, accounts = [{ accountId: 'a1', sessionId: 's1', authuser: 0 }]): DeviceSessionState =>
-  ({ deviceId: 'd1', accounts, activeAccountId: accounts[0]?.accountId ?? null, 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: () => null,
-    onTokensChanged: () => () => undefined,
-    setTokens: jest.fn(),
-    getCurrentAccountId: () => null,
-    ...over,
-  };
-}
-
-const flush = async () => { await Promise.resolve(); await Promise.resolve(); };
-
-beforeEach(() => {
-  fakeSocket = new FakeSocket();
-  lastOpts = undefined;
-  ioMock.mockClear();
-  bus.clear();
-  (globalThis as { BroadcastChannel?: unknown }).BroadcastChannel = FakeBroadcastChannel as unknown;
-});
-afterEach(() => {
-  (globalThis as { BroadcastChannel?: unknown }).BroadcastChannel = undefined;
-});
-
-describe('SessionClient signed-out socket', () => {
-  it('opens the socket while signed-out when signedOutSocketAuth resolves true (web cookie), with credentials', async () => {
-    const c = new SessionClient(makeHost(), { signedOutSocketAuth: () => true });
-    await c.start();
-    expect(ioMock).toHaveBeenCalledTimes(1);
-    expect(lastOpts?.autoConnect).toBe(true);
-    expect(lastOpts?.withCredentials).toBe(true);
-    // No bearer, no native token → handshake presents an empty token, no deviceToken.
-    const authCb = jest.fn();
-    (lastOpts?.auth as (cb: (d: unknown) => void) => void)(authCb);
-    expect(authCb).toHaveBeenCalledWith({ token: '' });
-    c.stop();
-  });
-
-  it('presents the native device token in the handshake when signedOutSocketAuth returns a string', async () => {
-    const c = new SessionClient(makeHost(), { signedOutSocketAuth: () => 'dt-native' });
-    await c.start();
-    expect(lastOpts?.autoConnect).toBe(true);
-    const authCb = jest.fn();
-    (lastOpts?.auth as (cb: (d: unknown) => void) => void)(authCb);
-    expect(authCb).toHaveBeenCalledWith({ token: '', deviceToken: 'dt-native' });
-    c.stop();
-  });
-
-  it('does NOT open the socket while signed-out when signedOutSocketAuth is absent (default)', async () => {
-    const c = new SessionClient(makeHost());
-    await c.start();
-    expect(lastOpts?.autoConnect).toBe(false);
-    c.stop();
-  });
-
-  it('does NOT open the socket while signed-out when signedOutSocketAuth resolves false', async () => {
-    const c = new SessionClient(makeHost(), { signedOutSocketAuth: async () => false });
-    await c.start();
-    expect(lastOpts?.autoConnect).toBe(false);
-    c.stop();
-  });
-
-  it('skips the bearer-authenticated bootstrap when signed-out', async () => {
-    const makeRequest = jest.fn().mockResolvedValue(SYNC(1));
-    const c = new SessionClient(makeHost({ makeRequest }), { signedOutSocketAuth: () => true });
-    await c.start();
-    expect(makeRequest).not.toHaveBeenCalled();
-    c.stop();
-  });
-
-  it('a session_state push while signed-out triggers acquisition exactly once for a burst', async () => {
-    const onSessionAppeared = jest.fn(() => new Promise<void>(() => undefined)); // never resolves (in flight)
-    const c = new SessionClient(makeHost(), { signedOutSocketAuth: () => true, onSessionAppeared });
-    await c.start();
-    fakeSocket.trigger('session_state', STATE(9));
-    fakeSocket.trigger('session_state', STATE(10));
-    await flush();
-    expect(onSessionAppeared).toHaveBeenCalledTimes(1);
-    c.stop();
-  });
-
-  it('does NOT acquire when the pushed signed-out state has zero accounts', async () => {
-    const onSessionAppeared = jest.fn();
-    const c = new SessionClient(makeHost(), { signedOutSocketAuth: () => true, onSessionAppeared });
-    await c.start();
-    fakeSocket.trigger('session_state', STATE(9, []));
-    await flush();
-    expect(onSessionAppeared).not.toHaveBeenCalled();
-    c.stop();
-  });
-
-  it('re-acquires on a LATER push after the prior acquisition settled (no permanent lock)', async () => {
-    const onSessionAppeared = jest.fn(() => Promise.resolve());
-    const c = new SessionClient(makeHost(), { signedOutSocketAuth: () => true, onSessionAppeared });
-    await c.start();
-    fakeSocket.trigger('session_state', STATE(9));
-    await flush();
-    expect(onSessionAppeared).toHaveBeenCalledTimes(1);
-    fakeSocket.trigger('session_state', STATE(10));
-    await flush();
-    expect(onSessionAppeared).toHaveBeenCalledTimes(2);
-    c.stop();
-  });
-
-  it('reconnects the anonymous socket authenticated once a token arrives', async () => {
-    let tokenListener: ((t: string | null) => void) | null = null;
-    let token: string | null = null;
-    const host = makeHost({
-      getAccessToken: () => token,
-      onTokensChanged: (l) => { tokenListener = l; return () => undefined; },
-    });
-    const c = new SessionClient(host, { signedOutSocketAuth: () => true });
-    await c.start();
-    expect(fakeSocket.connected).toBe(true); // anonymous connect
-    const before = fakeSocket.disconnectCalls;
-    token = 'fresh';
-    tokenListener?.('fresh');
-    // Anonymous → authenticated: force a reconnect so the handshake re-runs.
-    expect(fakeSocket.disconnectCalls).toBe(before + 1);
-    expect(fakeSocket.connected).toBe(true);
-    c.stop();
-  });
-});
-
-describe('SessionClient BroadcastChannel wake', () => {
-  const opts = (over: Partial<SessionClientOptions>): SessionClientOptions => ({ signedOutSocketAuth: () => true, ...over });
-
-  it('a local mutation wakes a signed-out sibling to acquire', async () => {
-    const onSessionAppeared = jest.fn(() => Promise.resolve());
-    // Signed-out sibling B listening on the channel.
-    const b = new SessionClient(makeHost(), opts({ onSessionAppeared }));
-    await b.start();
-    // Signed-in tab A commits (switchAccount posts a commit ping).
-    const a = new SessionClient(makeHost({ getAccessToken: () => 'tok-a' }), opts({}));
-    await a.start();
-    await a.switchAccount('a1');
-    await flush();
-    expect(onSessionAppeared).toHaveBeenCalledTimes(1);
-    a.stop();
-    b.stop();
-  });
-
-  it('a local mutation wakes a signed-in sibling to re-sync (bootstrap)', async () => {
-    const bMakeRequest = jest.fn().mockResolvedValue(SYNC(1));
-    const b = new SessionClient(makeHost({ makeRequest: bMakeRequest, getAccessToken: () => 'tok-b' }), opts({}));
-    await b.start();
-    bMakeRequest.mockClear();
-    const a = new SessionClient(makeHost({ getAccessToken: () => 'tok-a' }), opts({}));
-    await a.start();
-    await a.addCurrentAccount();
-    await flush();
-    expect(bMakeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-    a.stop();
-    b.stop();
-  });
-
-  it('does not deliver a commit ping back to the posting tab (no self-loop)', async () => {
-    // A signed-out tab that commits locally must not re-trigger its OWN acquisition.
-    const onSessionAppeared = jest.fn();
-    const a = new SessionClient(makeHost(), opts({ onSessionAppeared }));
-    await a.start();
-    await a.addCurrentAccount();
-    await flush();
-    expect(onSessionAppeared).not.toHaveBeenCalled();
-    a.stop();
-  });
-
-  it('is a no-op on platforms without BroadcastChannel (native)', async () => {
-    (globalThis as { BroadcastChannel?: unknown }).BroadcastChannel = undefined;
-    const c = new SessionClient(makeHost({ getAccessToken: () => 'tok' }), { });
-    await c.start();
-    // Mutations must not throw when BroadcastChannel is absent.
-    await expect(c.switchAccount('a1')).resolves.toBeUndefined();
-    c.stop();
-  });
-});