fix(auth): serialize session-state commits

With async encryption, two overlapping project selections could interleave
across the await in commitSessionState: an earlier selection completing
last would overwrite the newer stored session and published state (and
persistSession's own read of the prior selection could race), leaving the
committed selection stale — not the one the user picked last.

Serialize commits onto a promise chain so each commit's persist-then-publish
runs to completion before the next begins; the latest selection now wins
consistently across the in-memory session, storage, and subscribers. The
stored chain swallows rejections so a failed commit can't wedge later ones,
while the returned promise still rejects for the caller. Add a regression
test that overlaps two selections, drains encryption newest-first, and
asserts the latest selection wins everywhere.

Generated-By: PostHog Code
Task-Id: 77d13a30-444d-4045-9d80-5e2a9f2e68ae

Author: gantoine

packages/core/src/auth/auth.test.ts

@@ -610,6 +610,77 @@ describe("AuthService", () => {
     );
   });
 
+  it("keeps overlapping selections consistent so the latest one wins", async () => {
+    const orgs = {
+      "org-1": {
+        name: "Org 1",
+        projects: [
+          { id: 42, name: "Project 42" },
+          { id: 84, name: "Project 84" },
+          { id: 99, name: "Project 99" },
+        ],
+      },
+    };
+    oauthFlow.startFlow.mockResolvedValue(
+      mockTokenResponse({
+        accessToken: "initial-access-token",
+        refreshToken: "initial-refresh-token",
+      }),
+    );
+    stubAuthFetch({ orgs });
+
+    // Encryption is gated so overlapping selection commits stay in flight and
+    // can be resolved out of order below.
+    let deferEncrypt = false;
+    const pending: Array<() => void> = [];
+    const gatedCipher: IAuthTokenCipher = {
+      encrypt: (plaintext) =>
+        deferEncrypt
+          ? new Promise<string>((resolve) => {
+              pending.push(() => resolve(plaintext));
+            })
+          : Promise.resolve(plaintext),
+      decrypt: (encrypted) => Promise.resolve(encrypted),
+    };
+    service = new AuthService(
+      preferencePort,
+      sessionPort,
+      oauthFlow as unknown as IAuthOAuthFlowService,
+      connectivity,
+      gatedCipher,
+      mockPowerManager as unknown as IPowerManager,
+      mockLogger,
+      null,
+    );
+    service.init();
+    await service.initialize();
+    await service.login("us");
+    expect(service.getState().currentProjectId).toBe(42);
+
+    deferEncrypt = true;
+    // Two overlapping selections: 84 first, then 99 (the latest intent).
+    const first = service.selectProject(84);
+    const second = service.selectProject(99);
+
+    // Drain pending encryptions newest-first each round to surface any
+    // out-of-order completion, until both commits settle. Serialized commits
+    // only expose one pending encryption at a time; unserialized ones would
+    // let the stale 84 commit land last.
+    const flush = () => new Promise((r) => setTimeout(r, 0));
+    await flush();
+    while (pending.length > 0) {
+      for (const resolve of pending.splice(0).reverse()) resolve();
+      await flush();
+    }
+    await Promise.all([first, second]);
+
+    // The latest selection wins everywhere — no stale overwrite and no split
+    // between the in-memory session (getState), stored session, and preference.
+    expect(service.getState().currentProjectId).toBe(99);
+    expect(sessionPort.getCurrent()?.selectedProjectId).toBe(99);
+    expect(preferencePort.get("user-1", "us")?.lastSelectedProjectId).toBe(99);
+  });
+
   it("restores the selected project after app restart while logged out", async () => {
     const orgs = {
       "org-1": {

packages/core/src/auth/auth.ts

@@ -86,6 +86,9 @@ export class AuthService extends TypedEventEmitter<AuthServiceEvents> {
   private session: InMemorySession | null = null;
   private initializePromise: Promise<void> | null = null;
   private refreshPromise: Promise<InMemorySession> | null = null;
+  // Serializes session-state commits so overlapping selections can't interleave
+  // across async encryption (see commitSessionState).
+  private commitChain: Promise<void> = Promise.resolve();
   constructor(
     @inject(AUTH_PREFERENCE_STORE)
     private readonly authPreference: IAuthPreferenceStore,
@@ -326,7 +329,30 @@ export class AuthService extends TypedEventEmitter<AuthServiceEvents> {
     }
     return orgProjects[0]?.id ?? null;
   }
-  private async commitSessionState(
+  private commitSessionState(
+    prevSession: InMemorySession,
+    next: {
+      orgProjectsMap: OrgProjectsMap;
+      currentOrgId: string | null;
+      currentProjectId: number | null;
+    },
+  ): Promise<void> {
+    // Serialize commits onto a chain. Encryption is async, so two overlapping
+    // selections would otherwise interleave across the await — an earlier one
+    // completing last would clobber the newer stored session and published
+    // state (and persistSession's own read of the prior selection would race).
+    // Chaining runs each commit's persist-then-publish to completion before the
+    // next starts, so the latest selection wins consistently across the
+    // in-memory session, storage, and subscribers. The stored chain swallows
+    // rejections so one failed commit doesn't wedge later ones; the returned
+    // promise still rejects for the caller.
+    const run = this.commitChain.then(() =>
+      this.applyCommittedSession(prevSession, next),
+    );
+    this.commitChain = run.catch(() => {});
+    return run;
+  }
+  private async applyCommittedSession(
     prevSession: InMemorySession,
     next: {
       orgProjectsMap: OrgProjectsMap;