@@ -0,0 +1,11 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/console': patch
+---
+
+fix(console): a language picked on the sign-in page is saved as the person's own language when they have none (#30399)
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+A language picked in the sign-in page's menu used to apply on that browser only: after signing in, the person's saved language stayed empty, so another device, or the language their mail is written in, did not follow the pick. The sign-in page now saves the pick to the person's own language setting before it moves on, when they have not chosen one yet. A language they already chose is kept, nothing is saved when no language was picked on the page, and a save that fails does not hold up the sign-in (the pick still applies on that browser). `@object-ui/app-shell` gains `hasSignInLanguagePick`, `saveSignInLanguagePick` and the `SignInLanguagePickWriter` type for the sign-in page. A pick followed by a reload of the sign-in page, or by an identity provider's redirect, is still not saved.
@@ -70,6 +70,8 @@ import {
   InvitationSignUpPrompt,
   invitationArrivalCopy,
   useInvitationArrival,
+  hasSignInLanguagePick,
+  saveSignInLanguagePick,
 } from '@object-ui/app-shell';
 import { AuthLayout } from './AuthLayout';
 import { AuthFooter, readLegalLinks } from './AuthFooter';
@@ -153,6 +155,11 @@ export function LoginPage() {
   const ssoHandoffStartedRef = useRef(false);
   // The same once-only latch for the mobile sign-in hand-off navigation.
   const mobileHandoffStartedRef = useRef(false);
+  // #30399 — a language picked on this page, saved as the person's own before
+  // any exit below navigates away. The ref is the once-only latch; the state
+  // re-runs the post-login effect when the save has settled.
+  const signInPickSaveRef = useRef<'idle' | 'saving' | 'settled'>('idle');
+  const [signInPickSaved, setSignInPickSaved] = useState(false);
 
   // `isLoading` from useAuth() is overloaded: it is true both during the
   // initial session check AND during every in-flight signIn. The full-page
@@ -244,6 +251,27 @@ export function LoginPage() {
   useEffect(() => {
     if (!user) return;
 
+    // 0. A language picked on this page while signed out (#30399): saved as
+    //    this person's own when they have none, and AWAITED before every exit
+    //    below — each leaves by a full navigation, which ends the page-load
+    //    that knows the pick was made here, and a write sent beside it races
+    //    the unload. Without a pick nothing is sent and nothing waits. A failed
+    //    save does not hold the sign-in: the pick still applies on this device.
+    //    A session the hand-off would refuse is not a sign-in yet: skipped.
+    if (signInPickSaveRef.current === 'saving') return;
+    if (
+      signInPickSaveRef.current === 'idle' &&
+      !handoff.holdForSignIn &&
+      hasSignInLanguagePick()
+    ) {
+      signInPickSaveRef.current = 'saving';
+      void saveSignInLanguagePick(String(user.id)).finally(() => {
+        signInPickSaveRef.current = 'settled';
+        setSignInPickSaved(true);
+      });
+      return;
+    }
+
     // 1. OAuth provider hand-off (see file header). Replay the signed
     //    authorize params so the IdP issues the code, then FOLLOW the redirect
     //    it hands back. better-auth's oauth-provider answers a same-origin
@@ -310,6 +338,7 @@ export function LoginPage() {
     switchOrganization,
     handoff.target,
     handoff.holdForSignIn,
+    signInPickSaved,
   ]);
 
   if ((isLoading && !hasBootstrapped) || !signInNeeded) {
 
@@ -0,0 +1,206 @@
+/**
+ * The sign-in page saves a language picked on it before it navigates away
+ * (objectstack#30399, the saved half of objectstack#30338).
+ *
+ * The knowledge that the pick was made on this page is memory, and every exit
+ * of the post-login step is a full navigation that ends it. So the page awaits
+ * app-shell's `saveSignInLanguagePick` before each exit — a write sent beside
+ * the navigation races the unload. What the save writes, and when it writes
+ * nothing, is app-shell's and pinned beside the pick itself
+ * (`userLocaleSignInPick-30338.test.tsx`); this file pins the ORDER on the
+ * page, one case per exit:
+ *
+ *  1. with a pick, nothing navigates while the save is in flight, and the exit
+ *     the page would have taken is taken once it settles;
+ *  2. without a pick, nothing is saved and nothing waits (CONTROL);
+ *  3. a session the mobile hand-off refuses for its age is not a sign-in yet:
+ *     nothing is saved for it.
+ *
+ * The real `AuthProvider` runs over a mock client, as in
+ * `signInHandoff-29971.test.tsx`.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, waitFor } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { AuthProvider } from '@object-ui/auth';
+import type { AuthClient } from '@object-ui/auth';
+
+const pick = vi.hoisted(() => ({
+  held: false,
+  save: vi.fn<(userId: string) => Promise<void>>(),
+}));
+
+vi.mock('@object-ui/app-shell', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  hasSignInLanguagePick: () => pick.held,
+  saveSignInLanguagePick: (userId: string) => pick.save(userId),
+}));
+
+const follow = vi.hoisted(() => vi.fn());
+vi.mock('../followAuthorize', () => ({ followOauthAuthorize: follow }));
+
+import { LoginPage } from '../LoginPage';
+
+const HANDOFF =
+  '/api/v1/auth/one-time-token/handoff?redirect_uri=ai.objectos.mobile%3A%2F%2Fauth%2Fcallback' +
+  '&code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM&code_challenge_method=S256';
+const OAUTH = '?client_id=rp&redirect_uri=https%3A%2F%2Frp.example%2Fcb&state=s';
+
+const USER = { id: 'u1', name: 'Ada', email: 'ada@example.com' };
+const minutesAgo = (n: number) => new Date(Date.now() - n * 60_000);
+
+let baseEl: HTMLBaseElement | null = null;
+let assign: ReturnType<typeof vi.fn>;
+/** Settles the save the page is awaiting. */
+let settleSave: () => void;
+
+beforeEach(() => {
+  window.localStorage.clear();
+  baseEl = document.createElement('base');
+  baseEl.setAttribute('href', '/_console/');
+  document.head.appendChild(baseEl);
+  vi.stubEnv('BASE_URL', './');
+  assign = vi.fn();
+  vi.spyOn(window.location, 'assign').mockImplementation(assign as never);
+  vi.spyOn(console, 'warn').mockImplementation(() => {});
+  follow.mockReset();
+  pick.held = true;
+  pick.save.mockReset();
+  pick.save.mockImplementation(
+    () =>
+      new Promise<void>((resolve) => {
+        settleSave = () => {
+          pick.held = false;
+          resolve();
+        };
+      }),
+  );
+});
+
+afterEach(() => {
+  cleanup();
+  baseEl?.remove();
+  baseEl = null;
+  vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+});
+
+type Orgs = Array<{ id: string; name: string; slug: string }>;
+
+function createMockClient(organizations?: Orgs, createdAt: Date = minutesAgo(1)) {
+  const client = {
+    getSession: vi.fn().mockResolvedValue({ user: USER, session: { token: 't', createdAt } }),
+    getConfig: vi.fn().mockResolvedValue({}),
+    signIn: vi.fn().mockResolvedValue({ user: USER, session: undefined }),
+    signUp: vi.fn(),
+    signInWithProvider: vi.fn(),
+    ...(organizations
+      ? {
+          listOrganizations: vi.fn().mockResolvedValue(organizations),
+          getActiveOrganization: vi.fn().mockResolvedValue(null),
+          setActiveOrganization: vi.fn(async (id: string) => organizations.find((o) => o.id === id) ?? null),
+        }
+      : {}),
+  };
+  return client as typeof client & AuthClient;
+}
+
+function renderLogin(client: AuthClient, search = '') {
+  window.history.replaceState({}, '', `/_console/login${search}`);
+  return render(
+    <AuthProvider authUrl="/api/v1/auth" client={client}>
+      <MemoryRouter initialEntries={[`/login${search}`]}>
+        <LoginPage />
+      </MemoryRouter>
+    </AuthProvider>,
+  );
+}
+
+const lands = (target: string) => new URL(target, document.baseURI).pathname;
+/** Long enough for every effect and microtask the page would run before an exit. */
+const settle = () => new Promise((r) => setTimeout(r, 50));
+
+const EXITS: Array<{
+  exit: string;
+  search: string;
+  organizations?: Orgs;
+  left: () => string | null;
+  expected: string;
+}> = [
+  {
+    exit: 'no organization: the Console root',
+    search: '',
+    left: () => (assign.mock.calls[0] ? lands(assign.mock.calls[0][0] as string) : null),
+    expected: '/_console/',
+  },
+  {
+    exit: 'several organizations, none active: the picker',
+    search: '',
+    organizations: [
+      { id: 'org_1', name: 'One', slug: 'one' },
+      { id: 'org_2', name: 'Two', slug: 'two' },
+    ],
+    left: () => (assign.mock.calls[0] ? lands(assign.mock.calls[0][0] as string) : null),
+    expected: '/_console/organizations',
+  },
+  {
+    exit: 'one organization: selected, then the safe redirect',
+    search: `?redirect=${encodeURIComponent('/settings')}`,
+    organizations: [{ id: 'org_1', name: 'One', slug: 'one' }],
+    left: () => (assign.mock.calls[0] ? lands(assign.mock.calls[0][0] as string) : null),
+    expected: '/_console/settings',
+  },
+  {
+    exit: 'the mobile sign-in hand-off',
+    search: `?redirect=${encodeURIComponent(HANDOFF)}`,
+    left: () => (assign.mock.calls[0] ? (assign.mock.calls[0][0] as string) : null),
+    expected: HANDOFF,
+  },
+  {
+    exit: 'the OAuth provider hand-off',
+    search: OAUTH,
+    left: () => (follow.mock.calls[0] ? (follow.mock.calls[0][0] as string) : null),
+    expected: OAUTH,
+  },
+];
+
+describe('LoginPage — a language picked here is saved before the page leaves (objectstack#30399)', () => {
+  it.each(EXITS)('$exit: nothing leaves while the save is in flight, then the page leaves', async (c) => {
+    renderLogin(createMockClient(c.organizations), c.search);
+
+    await waitFor(() => expect(pick.save).toHaveBeenCalledTimes(1));
+    expect(pick.save).toHaveBeenCalledWith(USER.id);
+    await settle();
+    expect(assign).not.toHaveBeenCalled();
+    expect(follow).not.toHaveBeenCalled();
+
+    settleSave();
+    await waitFor(() => expect(c.left()).toBe(c.expected));
+    expect(assign.mock.calls.length + follow.mock.calls.length).toBe(1);
+    expect(pick.save).toHaveBeenCalledTimes(1);
+  });
+
+  // Which exit, and how often, is not this file's to pin here: with nothing
+  // to wait for, a page whose organizations are still loading can navigate
+  // before they answer and again after — the post-login step's own behaviour,
+  // unchanged by this card.
+  it.each(EXITS)('CONTROL — $exit, with no pick: nothing is saved and the page leaves', async (c) => {
+    pick.held = false;
+    renderLogin(createMockClient(c.organizations), c.search);
+
+    await waitFor(() =>
+      expect(assign.mock.calls.length + follow.mock.calls.length).toBeGreaterThanOrEqual(1),
+    );
+    expect(pick.save).not.toHaveBeenCalled();
+  });
+
+  it('a session the mobile hand-off refuses for its age is not a sign-in yet: nothing is saved', async () => {
+    renderLogin(createMockClient(undefined, minutesAgo(6)), `?redirect=${encodeURIComponent(HANDOFF)}`);
+
+    expect(await screen.findByLabelText('Email')).toBeTruthy();
+    await settle();
+    expect(pick.save).not.toHaveBeenCalled();
+    expect(assign).not.toHaveBeenCalled();
+  });
+});