@oxyhq/core 7.0.0 → 7.1.0

package/src/session/__tests__/accountDialogController.test.ts

@@ -0,0 +1,469 @@
+import type { DeviceSessionState } from '@oxyhq/contracts';
+import type { OxyServices } from '../../OxyServices';
+import type { User } from '../../models/interfaces';
+import type { SessionLoginResponse, MinimalUserData } from '../../models/session';
+import type { AccountNode } from '../../mixins/OxyServices.accounts';
+import { SessionClient, type SessionClientHost } from '../SessionClient';
+import {
+  AccountDialogController,
+  createAccountDialogController,
+} from '../accountDialogController';
+
+// A SessionClient whose applied state can be driven directly (applyState is
+// protected on the base) — mirrors the existing TestClient pattern.
+class TestSessionClient extends SessionClient {
+  set(state: DeviceSessionState): void {
+    this.applyState(state);
+  }
+}
+
+function host(): SessionClientHost {
+  return {
+    makeRequest: jest.fn(),
+    getBaseURL: () => 'http://test.invalid',
+    getAccessToken: () => 'token',
+    onTokensChanged: () => () => undefined,
+    setTokens: jest.fn(),
+    getCurrentAccountId: () => null,
+  };
+}
+
+function state(
+  accounts: Array<{ accountId: string; sessionId: string }>,
+  activeAccountId: string | null,
+  revision = 1,
+): DeviceSessionState {
+  return {
+    deviceId: 'device-1',
+    accounts: accounts.map((a) => ({ accountId: a.accountId, sessionId: a.sessionId, authuser: 0 })),
+    activeAccountId,
+    revision,
+    updatedAt: 1_720_000_000_000,
+  };
+}
+
+function user(id: string, over: Partial<User> = {}): User {
+  return {
+    id,
+    publicKey: `pk_${id}`,
+    username: `user_${id}`,
+    name: { displayName: `User ${id}` },
+    ...over,
+  } as User;
+}
+
+function graphNode(id: string, over: Partial<AccountNode> = {}): AccountNode {
+  return {
+    accountId: id,
+    kind: 'organization',
+    parentAccountId: null,
+    account: user(id),
+    relationship: 'owner',
+    callerMembership: null,
+    ...over,
+  };
+}
+
+interface OxyMock {
+  listAccounts: jest.Mock;
+  getUsersByIds: jest.Mock;
+  getFileDownloadUrl: jest.Mock;
+  switchToAccount: jest.Mock;
+  startCommonsSignIn: jest.Mock;
+  pollCommonsSignIn: jest.Mock;
+  claimSessionByToken: jest.Mock;
+  signInWithSharedIdentity: jest.Mock;
+}
+
+function makeOxy(): OxyMock {
+  return {
+    listAccounts: jest.fn().mockResolvedValue([]),
+    getUsersByIds: jest.fn().mockResolvedValue([]),
+    getFileDownloadUrl: jest.fn((id: string) => `https://cdn/${id}`),
+    switchToAccount: jest.fn(),
+    startCommonsSignIn: jest.fn(),
+    pollCommonsSignIn: jest.fn(),
+    claimSessionByToken: jest.fn(),
+    signInWithSharedIdentity: jest.fn().mockResolvedValue(null),
+  };
+}
+
+interface Harness {
+  controller: AccountDialogController;
+  oxy: OxyMock;
+  sc: TestSessionClient;
+  commitSession: jest.Mock;
+  onSignedIn: jest.Mock;
+}
+
+function makeHarness(over: Partial<{ clientId: string | null }> = {}): Harness {
+  const oxy = makeOxy();
+  const sc = new TestSessionClient(host());
+  const commitSession = jest.fn().mockResolvedValue(undefined);
+  const onSignedIn = jest.fn();
+  const controller = createAccountDialogController({
+    oxyServices: oxy as unknown as OxyServices,
+    sessionClient: sc,
+    clientId: 'clientId' in over ? over.clientId : 'oxy_dk_test',
+    commitSession,
+    onSignedIn,
+    pollIntervalMs: 1000,
+  });
+  return { controller, oxy, sc, commitSession, onSignedIn };
+}
+
+describe('AccountDialogController — initial + views', () => {
+  it('starts on the accounts view with an empty list and idle sign-in', () => {
+    const { controller } = makeHarness();
+    const snap = controller.getSnapshot();
+    expect(snap.view).toBe('accounts');
+    expect(snap.accounts).toEqual([]);
+    expect(snap.activeAccountId).toBeNull();
+    expect(snap.loading).toBe(false);
+    expect(snap.switchingAccountId).toBeNull();
+    expect(snap.signIn.phase).toBe('idle');
+  });
+
+  it('setView / add / close move between views and notify subscribers', () => {
+    const { controller } = makeHarness();
+    const seen: string[] = [];
+    controller.subscribe((s) => seen.push(s.view));
+
+    controller.add();
+    expect(controller.getSnapshot().view).toBe('add');
+    controller.setView('signin');
+    expect(controller.getSnapshot().view).toBe('signin');
+    controller.close();
+    expect(controller.getSnapshot().view).toBe('accounts');
+
+    expect(seen).toEqual(['add', 'signin', 'accounts']);
+  });
+
+  it('getSnapshot returns a stable reference until a change occurs', () => {
+    const { controller } = makeHarness();
+    const a = controller.getSnapshot();
+    expect(controller.getSnapshot()).toBe(a);
+    controller.setView('add');
+    expect(controller.getSnapshot()).not.toBe(a);
+  });
+});
+
+describe('AccountDialogController — account list', () => {
+  it('refresh loads graph + profiles and projects the unified list', async () => {
+    const { controller, oxy, sc } = makeHarness();
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }], 'a1'));
+    oxy.getUsersByIds.mockResolvedValue([user('a1'), user('org1')]);
+    oxy.listAccounts.mockResolvedValue([graphNode('org1')]);
+
+    await controller.refresh();
+
+    const snap = controller.getSnapshot();
+    expect(oxy.getUsersByIds).toHaveBeenCalledWith(['a1', 'org1']);
+    expect(snap.accounts.map((r) => r.accountId)).toEqual(['a1', 'org1']);
+    expect(snap.activeAccountId).toBe('a1');
+    expect(snap.accounts[0].isCurrent).toBe(true);
+    expect(snap.accounts[1].onDevice).toBe(false);
+    expect(snap.loading).toBe(false);
+  });
+
+  it('start subscribes to SessionClient so a device-state change re-projects', async () => {
+    const { controller, oxy, sc } = makeHarness();
+    oxy.getUsersByIds.mockResolvedValue([user('a1')]);
+    controller.start();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }], 'a1'));
+    // The subscription re-projects synchronously from the new device state.
+    expect(controller.getSnapshot().activeAccountId).toBe('a1');
+    controller.destroy();
+  });
+
+  it('keeps device rows and surfaces the error when listAccounts fails', async () => {
+    const { controller, oxy, sc } = makeHarness();
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }], 'a1'));
+    oxy.getUsersByIds.mockResolvedValue([user('a1')]);
+    oxy.listAccounts.mockRejectedValue(new Error('graph boom'));
+
+    await controller.refresh();
+
+    const snap = controller.getSnapshot();
+    expect(snap.error).toBe('graph boom');
+    expect(snap.accounts.map((r) => r.accountId)).toEqual(['a1']);
+  });
+});
+
+describe('AccountDialogController — switchTo (uniform switch)', () => {
+  it('uses SessionClient.switchAccount for an account already on the device', async () => {
+    const { controller, oxy, sc } = makeHarness();
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }, { accountId: 'a2', sessionId: 's2' }], 'a1'));
+    const switchSpy = jest.spyOn(sc, 'switchAccount').mockResolvedValue(undefined);
+    oxy.getUsersByIds.mockResolvedValue([user('a1'), user('a2')]);
+
+    await controller.switchTo('a2');
+
+    expect(switchSpy).toHaveBeenCalledWith('a2');
+    expect(oxy.switchToAccount).not.toHaveBeenCalled();
+    expect(controller.getSnapshot().switchingAccountId).toBeNull();
+  });
+
+  it('mints via oxyServices.switchToAccount + commitSession on first entry into a graph account', async () => {
+    const { controller, oxy, sc, commitSession } = makeHarness();
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }], 'a1'));
+    const switchSpy = jest.spyOn(sc, 'switchAccount').mockResolvedValue(undefined);
+    oxy.switchToAccount.mockResolvedValue({
+      sessionId: 'sess-org',
+      deviceId: 'device-1',
+      expiresAt: '2030-01-01T00:00:00Z',
+      accessToken: 'access-org',
+      user: user('org1'),
+    });
+    oxy.getUsersByIds.mockResolvedValue([user('a1'), user('org1')]);
+
+    await controller.switchTo('org1');
+
+    expect(oxy.switchToAccount).toHaveBeenCalledWith('org1');
+    expect(switchSpy).not.toHaveBeenCalled();
+    expect(commitSession).toHaveBeenCalledTimes(1);
+    expect(commitSession.mock.calls[0][0]).toMatchObject({ sessionId: 'sess-org', accessToken: 'access-org' });
+  });
+
+  it('falls back to SessionClient.registerAndActivate when no commitSession is supplied', async () => {
+    const oxy = makeOxy();
+    const sc = new TestSessionClient(host());
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }], 'a1'));
+    const registerSpy = jest.spyOn(sc, 'registerAndActivate').mockResolvedValue(undefined);
+    oxy.switchToAccount.mockResolvedValue({
+      sessionId: 'sess-org',
+      deviceId: 'device-1',
+      expiresAt: '2030-01-01T00:00:00Z',
+      accessToken: 'access-org',
+      user: user('org1'),
+    });
+    const controller = new AccountDialogController({
+      oxyServices: oxy as unknown as OxyServices,
+      sessionClient: sc,
+      clientId: 'oxy_dk_test',
+    });
+
+    await controller.switchTo('org1');
+    expect(registerSpy).toHaveBeenCalledWith('org1');
+  });
+
+  it('ignores a concurrent switch while one is in flight', async () => {
+    const { controller, oxy, sc } = makeHarness();
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }, { accountId: 'a2', sessionId: 's2' }], 'a1'));
+    let release: () => void = () => undefined;
+    jest.spyOn(sc, 'switchAccount').mockImplementation(
+      () => new Promise<void>((resolve) => { release = resolve; }),
+    );
+
+    const first = controller.switchTo('a2');
+    expect(controller.getSnapshot().switchingAccountId).toBe('a2');
+    await controller.switchTo('a1'); // ignored — a switch is in flight
+    expect(sc.switchAccount).toHaveBeenCalledTimes(1);
+
+    release();
+    await first;
+  });
+});
+
+describe('AccountDialogController — sign in with Oxy', () => {
+  it('completes silently when a shared identity mints a session', async () => {
+    const { controller, oxy, commitSession, onSignedIn } = makeHarness();
+    const session: SessionLoginResponse = {
+      sessionId: 'sess-shared',
+      deviceId: 'device-1',
+      expiresAt: '2030-01-01T00:00:00Z',
+      accessToken: 'access-shared',
+      user: { id: 'a1', username: 'user_a1', name: { displayName: 'User a1' } },
+    };
+    oxy.signInWithSharedIdentity.mockResolvedValue(session);
+
+    await controller.signInWithOxy();
+
+    expect(commitSession).toHaveBeenCalledWith(expect.objectContaining({ sessionId: 'sess-shared' }));
+    expect(onSignedIn).toHaveBeenCalledWith(expect.objectContaining({ id: 'a1' }));
+    expect(controller.getSnapshot().view).toBe('accounts');
+    expect(controller.getSnapshot().signIn.phase).toBe('idle');
+    expect(oxy.startCommonsSignIn).not.toHaveBeenCalled();
+  });
+
+  it('falls through to the QR handoff when no shared identity is present', async () => {
+    const { controller, oxy } = makeHarness();
+    oxy.signInWithSharedIdentity.mockResolvedValue(null);
+    oxy.startCommonsSignIn.mockResolvedValue({
+      sessionToken: 'secret-tok',
+      authorizeCode: 'AUTH-CODE',
+      qrPayload: 'oxycommons://approve?v=1&code=AUTH-CODE',
+      expiresAt: Date.now() + 300_000,
+      status: 'pending',
+    });
+
+    await controller.signInWithOxy();
+
+    expect(oxy.startCommonsSignIn).toHaveBeenCalledWith({ clientId: 'oxy_dk_test' });
+    const snap = controller.getSnapshot();
+    expect(snap.view).toBe('qr');
+    expect(snap.signIn.phase).toBe('waiting');
+    expect(snap.signIn.authorizeCode).toBe('AUTH-CODE');
+    expect(snap.signIn.qrPayload).toBe('oxycommons://approve?v=1&code=AUTH-CODE');
+    controller.cancelSignIn();
+  });
+
+  it('errors when showQr is called without a clientId', async () => {
+    const { controller } = makeHarness({ clientId: null });
+    await controller.showQr();
+    const snap = controller.getSnapshot();
+    expect(snap.signIn.phase).toBe('error');
+    expect(snap.signIn.error).toMatch(/clientId/);
+  });
+
+  it('polls, claims, and commits when the QR flow is authorized', async () => {
+    jest.useFakeTimers();
+    try {
+      const { controller, oxy, commitSession, onSignedIn } = makeHarness();
+      oxy.startCommonsSignIn.mockResolvedValue({
+        sessionToken: 'secret-tok',
+        authorizeCode: 'AUTH-CODE',
+        qrPayload: 'oxycommons://approve?v=1&code=AUTH-CODE',
+        expiresAt: Date.now() + 600_000,
+        status: 'pending',
+      });
+      oxy.pollCommonsSignIn
+        .mockResolvedValueOnce({ authorized: false, status: 'pending' })
+        .mockResolvedValueOnce({ authorized: true, sessionId: 'sess-1', status: 'authorized' });
+      oxy.claimSessionByToken.mockResolvedValue({
+        accessToken: 'access-1',
+        sessionId: 'sess-1',
+        deviceId: 'device-1',
+        expiresAt: '2030-01-01T00:00:00Z',
+        user: user('a1'),
+      });
+
+      await controller.showQr();
+      expect(controller.getSnapshot().signIn.phase).toBe('waiting');
+
+      await jest.advanceTimersByTimeAsync(1000); // first poll → pending
+      expect(oxy.pollCommonsSignIn).toHaveBeenCalledTimes(1);
+
+      await jest.advanceTimersByTimeAsync(1000); // second poll → authorized → claim
+      expect(oxy.claimSessionByToken).toHaveBeenCalledWith('secret-tok');
+      expect(commitSession).toHaveBeenCalledWith(expect.objectContaining({ sessionId: 'sess-1', accessToken: 'access-1' }));
+      expect(onSignedIn).toHaveBeenCalledWith(expect.objectContaining({ id: 'a1' }));
+      expect(controller.getSnapshot().view).toBe('accounts');
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('surfaces a denied QR authorization as an error and stops polling', async () => {
+    jest.useFakeTimers();
+    try {
+      const { controller, oxy } = makeHarness();
+      oxy.startCommonsSignIn.mockResolvedValue({
+        sessionToken: 'secret-tok',
+        authorizeCode: 'AUTH-CODE',
+        qrPayload: 'oxycommons://approve',
+        expiresAt: Date.now() + 600_000,
+        status: 'pending',
+      });
+      oxy.pollCommonsSignIn.mockResolvedValue({ authorized: false, status: 'cancelled' });
+
+      await controller.showQr();
+      await jest.advanceTimersByTimeAsync(1000);
+
+      expect(controller.getSnapshot().signIn.phase).toBe('error');
+      expect(controller.getSnapshot().signIn.error).toMatch(/denied/i);
+
+      // No further polls after the terminal error.
+      await jest.advanceTimersByTimeAsync(5000);
+      expect(oxy.pollCommonsSignIn).toHaveBeenCalledTimes(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('cancelSignIn stops the poll and resets to idle', async () => {
+    jest.useFakeTimers();
+    try {
+      const { controller, oxy } = makeHarness();
+      oxy.startCommonsSignIn.mockResolvedValue({
+        sessionToken: 'secret-tok',
+        authorizeCode: 'AUTH-CODE',
+        qrPayload: 'oxycommons://approve',
+        expiresAt: Date.now() + 600_000,
+        status: 'pending',
+      });
+      oxy.pollCommonsSignIn.mockResolvedValue({ authorized: false, status: 'pending' });
+
+      await controller.showQr();
+      controller.cancelSignIn();
+      expect(controller.getSnapshot().signIn.phase).toBe('idle');
+
+      await jest.advanceTimersByTimeAsync(5000);
+      expect(oxy.pollCommonsSignIn).not.toHaveBeenCalled();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+});
+
+describe('AccountDialogController — openPasswordAtOxyAuth', () => {
+  it('builds the IdP sign-in URL with redirect_uri + client_id and invokes openUrl', () => {
+    const oxy = makeOxy();
+    const sc = new TestSessionClient(host());
+    const openUrl = jest.fn();
+    const controller = new AccountDialogController({
+      oxyServices: oxy as unknown as OxyServices,
+      sessionClient: sc,
+      clientId: 'oxy_dk_test',
+      openUrl,
+    });
+
+    const url = controller.openPasswordAtOxyAuth({ returnUrl: 'https://mention.earth/', state: 'xyz' });
+    const parsed = new URL(url);
+    expect(parsed.origin).toBe('https://auth.oxy.so');
+    expect(parsed.pathname).toBe('/login');
+    expect(parsed.searchParams.get('redirect_uri')).toBe('https://mention.earth/');
+    expect(parsed.searchParams.get('client_id')).toBe('oxy_dk_test');
+    expect(parsed.searchParams.get('state')).toBe('xyz');
+    expect(openUrl).toHaveBeenCalledWith(url);
+  });
+
+  it('honors an idpApex override', () => {
+    const oxy = makeOxy();
+    const sc = new TestSessionClient(host());
+    const controller = new AccountDialogController({
+      oxyServices: oxy as unknown as OxyServices,
+      sessionClient: sc,
+      idpApex: 'alia.onl',
+    });
+    const url = controller.openPasswordAtOxyAuth({ returnUrl: 'https://alia.onl/' });
+    expect(new URL(url).origin).toBe('https://auth.alia.onl');
+  });
+});
+
+describe('AccountDialogController — lifecycle', () => {
+  it('destroy unsubscribes so later device-state changes do not notify', async () => {
+    const { controller, oxy, sc } = makeHarness();
+    oxy.getUsersByIds.mockResolvedValue([user('a1')]);
+    controller.start();
+    await Promise.resolve();
+    const seen: string[] = [];
+    controller.subscribe((s) => seen.push(s.view));
+    controller.destroy();
+    // destroy clears all listeners; a subsequent state push notifies nobody.
+    sc.set(state([{ accountId: 'a1', sessionId: 's1' }], 'a1'));
+    expect(seen).toEqual([]);
+  });
+});
+
+it('createAccountDialogController returns an AccountDialogController instance', () => {
+  const { controller } = makeHarness();
+  expect(controller).toBeInstanceOf(AccountDialogController);
+});
+
+// Ensure the exported type surface is reachable at compile time for binders.
+const _typecheck: MinimalUserData | null = null;
+void _typecheck;

package/src/session/__tests__/accountProjection.test.ts

@@ -0,0 +1,181 @@
+import type { DeviceSessionState } from '@oxyhq/contracts';
+import type { User } from '../../models/interfaces';
+import type { AccountNode } from '../../mixins/OxyServices.accounts';
+import {
+  projectSwitchableAccounts,
+  switchableAccountIds,
+} from '../accountProjection';
+
+function user(id: string, over: Partial<User> = {}): User {
+  return {
+    id,
+    publicKey: `pk_${id}`,
+    username: `user_${id}`,
+    name: { displayName: `User ${id}` },
+    ...over,
+  } as User;
+}
+
+function state(
+  accounts: Array<{ accountId: string; sessionId: string; authuser?: number }>,
+  activeAccountId: string | null,
+): DeviceSessionState {
+  return {
+    deviceId: 'device-1',
+    accounts: accounts.map((a) => ({ accountId: a.accountId, sessionId: a.sessionId, authuser: a.authuser ?? 0 })),
+    activeAccountId,
+    revision: 1,
+    updatedAt: 1_720_000_000_000,
+  };
+}
+
+function graphNode(id: string, over: Partial<AccountNode> = {}): AccountNode {
+  return {
+    accountId: id,
+    kind: 'organization',
+    parentAccountId: null,
+    account: user(id),
+    relationship: 'owner',
+    callerMembership: null,
+    ...over,
+  };
+}
+
+const mapOf = (...users: User[]): Map<string, User> => {
+  const map = new Map<string, User>();
+  for (const u of users) map.set(u.id, u);
+  return map;
+};
+
+const noAvatar = (): undefined => undefined;
+
+describe('projectSwitchableAccounts', () => {
+  it('returns [] for null state and empty graph', () => {
+    expect(
+      projectSwitchableAccounts({ state: null, graph: [], profilesById: new Map(), resolveAvatarUrl: noAvatar }),
+    ).toEqual([]);
+  });
+
+  it('projects device rows and flags the active account current', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1', authuser: 0 }, { accountId: 'a2', sessionId: 's2', authuser: 1 }], 'a2'),
+      graph: [],
+      profilesById: mapOf(user('a1'), user('a2')),
+      resolveAvatarUrl: noAvatar,
+    });
+
+    expect(rows.map((r) => r.accountId)).toEqual(['a1', 'a2']);
+    expect(rows.map((r) => r.isCurrent)).toEqual([false, true]);
+    expect(rows.every((r) => r.onDevice)).toBe(true);
+    expect(rows[1].sessionId).toBe('s2');
+    expect(rows[1].authuser).toBe(1);
+  });
+
+  it('omits device accounts whose profile is not resolved (except the active one via activeUser)', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1' }, { accountId: 'a2', sessionId: 's2' }], 'a1'),
+      graph: [],
+      // a2 has no resolved profile; a1 is active and provided via activeUser.
+      profilesById: new Map(),
+      activeUser: user('a1', { name: { displayName: 'Fresh A1' } }),
+      resolveAvatarUrl: noAvatar,
+    });
+
+    expect(rows.map((r) => r.accountId)).toEqual(['a1']);
+    expect(rows[0].displayName).toBe('Fresh A1');
+    expect(rows[0].isCurrent).toBe(true);
+  });
+
+  it('prefers activeUser over profilesById for the active row (freshness)', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1' }], 'a1'),
+      graph: [],
+      profilesById: mapOf(user('a1', { name: { displayName: 'Stale' } })),
+      activeUser: user('a1', { name: { displayName: 'Fresh' } }),
+      resolveAvatarUrl: noAvatar,
+    });
+    expect(rows[0].displayName).toBe('Fresh');
+  });
+
+  it('merges graph-only accounts after device rows, carrying graph metadata', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1' }], 'a1'),
+      graph: [graphNode('org1', { kind: 'organization', relationship: 'owner', parentAccountId: 'a1' })],
+      profilesById: mapOf(user('a1')),
+      resolveAvatarUrl: noAvatar,
+    });
+
+    expect(rows.map((r) => r.accountId)).toEqual(['a1', 'org1']);
+    const org = rows[1];
+    expect(org.onDevice).toBe(false);
+    expect(org.isCurrent).toBe(false);
+    expect(org.sessionId).toBeUndefined();
+    expect(org.kind).toBe('organization');
+    expect(org.relationship).toBe('owner');
+    expect(org.parentAccountId).toBe('a1');
+  });
+
+  it('dedups an account present as BOTH device session and graph node into ONE enriched row', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1', authuser: 0 }], 'a1'),
+      graph: [graphNode('a1', { kind: 'personal', relationship: 'self', callerMembership: null })],
+      profilesById: mapOf(user('a1')),
+      resolveAvatarUrl: noAvatar,
+    });
+
+    expect(rows).toHaveLength(1);
+    const row = rows[0];
+    // Keeps the device sessionId + active flag, gains the graph metadata.
+    expect(row.sessionId).toBe('s1');
+    expect(row.onDevice).toBe(true);
+    expect(row.isCurrent).toBe(true);
+    expect(row.kind).toBe('personal');
+    expect(row.relationship).toBe('self');
+  });
+
+  it('resolves avatar url via the injected resolver and falls back email to @handle', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1' }], 'a1'),
+      graph: [],
+      profilesById: mapOf(user('a1', { avatar: 'file123', email: undefined, username: 'nate' })),
+      resolveAvatarUrl: (avatar) => (avatar ? `https://cdn/${avatar}` : undefined),
+    });
+    expect(rows[0].avatarUrl).toBe('https://cdn/file123');
+    // No real email → `@handle` secondary line, never synthesized.
+    expect(rows[0].email).toBe('@nate');
+  });
+
+  it('uses a real email when present', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1' }], 'a1'),
+      graph: [],
+      profilesById: mapOf(user('a1', { email: 'real@oxy.so' })),
+      resolveAvatarUrl: noAvatar,
+    });
+    expect(rows[0].email).toBe('real@oxy.so');
+  });
+
+  it('marks no row current when activeAccountId is null', () => {
+    const rows = projectSwitchableAccounts({
+      state: state([{ accountId: 'a1', sessionId: 's1' }], null),
+      graph: [],
+      profilesById: mapOf(user('a1')),
+      resolveAvatarUrl: noAvatar,
+    });
+    expect(rows.every((r) => !r.isCurrent)).toBe(true);
+  });
+});
+
+describe('switchableAccountIds', () => {
+  it('unions device + graph ids, deduped and sorted', () => {
+    const ids = switchableAccountIds(
+      state([{ accountId: 'b', sessionId: 's1' }, { accountId: 'a', sessionId: 's2' }], 'a'),
+      [graphNode('c'), graphNode('a')],
+    );
+    expect(ids).toEqual(['a', 'b', 'c']);
+  });
+
+  it('returns [] for null state and empty graph', () => {
+    expect(switchableAccountIds(null, [])).toEqual([]);
+  });
+});