diff --git a/.changeset/11865-h-console-pages-shared-select.md b/.changeset/11865-h-console-pages-shared-select.md
new file mode 100644
index 0000000000..229e091a48
--- /dev/null
+++ b/.changeset/11865-h-console-pages-shared-select.md
@@ -0,0 +1,13 @@
+---
+'@object-ui/console': patch
+---
+
+The console's Public Forms, Flow Runs and Profile pages pick with the shared `Select`, the control the rest of the console picks with (objectui#11865, the console pages' part of that card).
+
+Four pickers were browser-native selects, so they looked and behaved differently from the console's other dropdowns: on Public Forms, the FormView to publish and "After submit"; on Flow Runs, the flow to test; on Profile, the preferred language. They now use the shared Radix `Select`: the same trigger, dropdown and keyboard behaviour.
+
+What they write is unchanged. Publishing saves the picked view as before, and "— Select a FormView —" still leaves nothing to publish. Each "After submit" option saves the same `submitBehavior` as before. The picked flow is still the one Run Flow executes and whose runs are listed. Each language saves the same `locale` as before, and "Use the deployment default" still saves `null`. Re-picking the current option writes nothing. Each picker keeps the accessible name it had: "FormView", "After submit" and "Preferred language" from their labels; the flow picker had no label and still has none. The language picker's read-only state is the shared control's disabled trigger.
+
+One display change: a value none of a picker's options carries now shows as itself. The native select showed its first option instead, which is not what the page holds: for example, a flow picked before a Refresh that no longer lists it.
+
+**Clause-②: no.** No published face moves: the console's package entry is unchanged, and no i18n key is added. What moves is these pages' own markup, described above.
diff --git a/apps/console/src/pages/consoleFaces.displayLocale-9909.test.tsx b/apps/console/src/pages/consoleFaces.displayLocale-9909.test.tsx
index 1fbbbd6ee7..45ba544ecd 100644
--- a/apps/console/src/pages/consoleFaces.displayLocale-9909.test.tsx
+++ b/apps/console/src/pages/consoleFaces.displayLocale-9909.test.tsx
@@ -66,13 +66,17 @@ const { STORED, approvalsApiStub, ADAPTER, AUTH, I18N } = vi.hoisted(() => {
     reject: async () => ({ data: ROW, finalized: true }),
   };
   const listRuns = async () => ({ runs: [{ id: 'run_1', status: 'completed', startedAt: STORED, durationMs: 9 }] });
+  // One client, as the real adapter's `getClient()` hands out: Flow Runs keys
+  // its flow and run loads on it, so a fresh one per call re-ran them on every
+  // render and its runs table never settled (objectui#11865 surfaced it).
+  const client = {
+    meta: { getItems: async (type: string) => (type === 'flow' ? [{ spec: { name: 'sync_flow', label: 'Sync' } }] : []) },
+    automation: { execute: async () => ({ success: true }), listRuns, getRun: async () => ({ run: null }) },
+  };
   const ADAPTER = {
     find: async () => ({ data: [{ id: 'po_1' }] }),
     getObjectSchema: async () => ({ fields: {} }),
-    getClient: () => ({
-      meta: { getItems: async (type: string) => (type === 'flow' ? [{ spec: { name: 'sync_flow', label: 'Sync' } }] : []) },
-      automation: { execute: async () => ({ success: true }), listRuns, getRun: async () => ({ run: null }) },
-    }),
+    getClient: () => client,
   };
   const AUTH = { user: { id: 'u_1', email: 'approver@example.com' } };
   const I18N = {
diff --git a/apps/console/src/pages/developer/FlowRunsPage.sharedSelect-11865.test.tsx b/apps/console/src/pages/developer/FlowRunsPage.sharedSelect-11865.test.tsx
new file mode 100644
index 0000000000..8104e7a02c
--- /dev/null
+++ b/apps/console/src/pages/developer/FlowRunsPage.sharedSelect-11865.test.tsx
@@ -0,0 +1,183 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * The Flow Runs flow picker is the shared `Select` (objectui#11865).
+ *
+ * The page picked the flow to test with a browser-native select, beside the
+ * shared Radix `Select` the rest of the console picks with. The card asks for
+ * one control for one kind of choice, surface by surface.
+ *
+ * What is pinned:
+ *   - the picker IS the primitive (a Radix combobox trigger), shows the picked
+ *     flow, and no native select is left;
+ *   - the trigger's accessible name is what the native control's was;
+ *   - every flow, picked, is the one Run Flow executes and whose runs are
+ *     listed, the same calls the native control led to, compared as JSON text;
+ *   - a flow a Refresh no longer lists is what the trigger shows;
+ *   - the keyboard alone opens the picker and selects.
+ *
+ * Read-only: the page has no such state.
+ *
+ * DIRECTION, observed against the native control: every pin here but the name
+ * pin is red there, because each one reads the picker as the primitive's
+ * trigger. What makes the call pins guards of "the conversion changed nothing
+ * the page runs" is the literal each compares against: a `change` event on the
+ * pre-conversion page's native control, then the same Run Flow click, led to
+ * those same calls, read once on that page with these fixtures. The name and
+ * the Refresh reading were taken there the same way.
+ *
+ * A pick reloads the flow list (the page's `loadFlows` depends on the picked
+ * name), so the picker unmounts while the list loads and mounts again: each
+ * case finds the trigger afresh after a pick, as a user's next look would.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+
+const { execute, listRuns, catalog, ADAPTER } = vi.hoisted(() => {
+  const catalog = { flows: [] as Array<{ spec: Record<string, unknown> }> };
+  const execute = vi.fn(async () => ({ success: true, status: 'completed', durationMs: 1 }));
+  const listRuns = vi.fn(async () => ({ runs: [] }));
+  // A STABLE singleton: a fresh object per render loops the page's fetch effects.
+  const client = {
+    meta: { getItems: async (type: string) => (type === 'flow' ? catalog.flows : []) },
+    automation: { execute, listRuns },
+  };
+  return { execute, listRuns, catalog, ADAPTER: { getClient: () => client } };
+});
+
+vi.mock('@object-ui/app-shell', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAdapter: () => ADAPTER,
+  useMetadata: () => ({ objects: [] }),
+}));
+
+// Imported AFTER the mocks so the page picks them up.
+import { FlowRunsPage } from './FlowRunsPage';
+
+const REASSIGN = { spec: { name: 'reassign_wizard', label: 'Reassign', variables: [] } };
+const NIGHTLY = { spec: { name: 'nightly_sync', variables: [] } };
+
+beforeEach(() => {
+  catalog.flows = [REASSIGN, NIGHTLY];
+  execute.mockClear();
+  listRuns.mockClear();
+});
+afterEach(cleanup);
+
+/** The picker, once the flow list has loaded (again). */
+async function picker(): Promise<HTMLElement> {
+  await screen.findByRole('button', { name: /Run Flow/i });
+  return screen.findByRole('combobox');
+}
+
+/** Open the picker from the keyboard and return the options it lists, in order. */
+async function openPicker(trigger: HTMLElement): Promise<HTMLElement[]> {
+  fireEvent.keyDown(trigger, { key: 'ArrowDown' });
+  const listbox = await screen.findByRole('listbox');
+  return within(listbox).getAllByRole('option');
+}
+
+async function pick(label: string): Promise<void> {
+  const options = await openPicker(await picker());
+  const option = options.find((o) => o.textContent === label);
+  if (!option) throw new Error(`no "${label}" listed: ${options.map((o) => o.textContent).join(' | ')}`);
+  fireEvent.click(option);
+  await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+}
+
+describe('the flow picker is the shared Select (objectui#11865)', () => {
+  it('renders the picker as the Radix combobox trigger, showing the first flow', async () => {
+    render(<FlowRunsPage />);
+    const trigger = await picker();
+    expect(trigger.tagName).toBe('BUTTON');
+    expect(trigger).toHaveTextContent('Reassign (reassign_wizard)');
+    expect(document.querySelector('select')).toBeNull();
+  });
+
+  it('lists the flows in the order the native control did', async () => {
+    render(<FlowRunsPage />);
+    expect((await openPicker(await picker())).map((o) => o.textContent)).toEqual([
+      'Reassign (reassign_wizard)',
+      'nightly_sync',
+    ]);
+  });
+
+  // Green against the native control too, by design. That control had no
+  // label, id or aria-label, so its accessible name was empty; the swap keeps
+  // that, and adds none.
+  it('keeps the accessible name the native control had: none', async () => {
+    render(<FlowRunsPage />);
+    const trigger = await picker();
+    expect(screen.getByRole('combobox', { name: '' })).toBe(trigger);
+  });
+});
+
+/**
+ * [the flow picked away from, its label, option label, Run Flow's `execute`
+ * calls, the panel's `listRuns` calls once the pick has settled].
+ */
+const RUN_WRITES: ReadonlyArray<
+  readonly [from: string, fromLabel: string, label: string, execute: string, listRuns: string]
+> = [
+  ['nightly_sync', 'nightly_sync', 'Reassign (reassign_wizard)', '[["reassign_wizard",{"params":{}}]]', '[["reassign_wizard",{"limit":20}]]'],
+  ['reassign_wizard', 'Reassign (reassign_wizard)', 'nightly_sync', '[["nightly_sync",{"params":{}}]]', '[["nightly_sync",{"limit":20}]]'],
+];
+
+describe('every flow, picked, is the one the page runs', () => {
+  it.each(RUN_WRITES)('from %s (shown as %s), picking %s', async (from, fromLabel, label, executed, listed) => {
+    render(<FlowRunsPage />);
+    await picker();
+    if (from !== 'reassign_wizard') await pick(fromLabel);
+    // Settled on the flow picked away from before anything is counted.
+    expect(await picker()).toHaveTextContent(fromLabel);
+    await waitFor(() => expect(listRuns).toHaveBeenLastCalledWith(from, { limit: 20 }));
+    execute.mockClear();
+    listRuns.mockClear();
+    await pick(label);
+    await waitFor(() => expect(listRuns).toHaveBeenCalled());
+    expect(await picker()).toHaveTextContent(label);
+    fireEvent.click(screen.getByRole('button', { name: /Run Flow/i }));
+    await waitFor(() => expect(execute).toHaveBeenCalledTimes(1));
+    expect(JSON.stringify(execute.mock.calls)).toBe(executed);
+    expect(JSON.stringify(listRuns.mock.calls)).toBe(listed);
+  });
+});
+
+describe('a flow no option carries is what the trigger shows', () => {
+  it('a picked flow a Refresh no longer lists: shown, not the first flow, and re-picking it runs nothing', async () => {
+    render(<FlowRunsPage />);
+    await pick('nightly_sync');
+    await picker();
+    catalog.flows = [REASSIGN];
+    fireEvent.click(screen.getAllByRole('button', { name: /Refresh/i })[0]);
+    // The page still holds `nightly_sync` and shows no runner for it. The
+    // native control showed "Reassign (reassign_wizard)" here.
+    await waitFor(() => expect(screen.queryByRole('button', { name: /Run Flow/i })).not.toBeInTheDocument());
+    const trigger = await screen.findByRole('combobox');
+    expect(trigger).toHaveTextContent('nightly_sync');
+    const listed = (await openPicker(trigger)).map((o) => o.textContent);
+    expect(listed).toEqual(['nightly_sync', 'Reassign (reassign_wizard)']);
+    execute.mockClear();
+    listRuns.mockClear();
+    fireEvent.click(screen.getAllByRole('option')[0]);
+    await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+    expect(screen.getByRole('combobox')).toHaveTextContent('nightly_sync');
+    expect(screen.queryByRole('button', { name: /Run Flow/i })).not.toBeInTheDocument();
+    expect(listRuns).not.toHaveBeenCalled();
+  });
+});
+
+describe('the keyboard alone picks', () => {
+  it('Enter opens the picker and Enter on a flow selects it', async () => {
+    render(<FlowRunsPage />);
+    fireEvent.keyDown(await picker(), { key: 'Enter' });
+    const listbox = await screen.findByRole('listbox');
+    fireEvent.keyDown(within(listbox).getByRole('option', { name: 'nightly_sync' }), { key: 'Enter' });
+    await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+    expect(await picker()).toHaveTextContent('nightly_sync');
+    fireEvent.click(screen.getByRole('button', { name: /Run Flow/i }));
+    await waitFor(() => expect(execute).toHaveBeenCalledWith('nightly_sync', { params: {} }));
+  });
+});
diff --git a/apps/console/src/pages/developer/FlowRunsPage.tsx b/apps/console/src/pages/developer/FlowRunsPage.tsx
index b5c6471b6c..5b3af536c6 100644
--- a/apps/console/src/pages/developer/FlowRunsPage.tsx
+++ b/apps/console/src/pages/developer/FlowRunsPage.tsx
@@ -45,6 +45,11 @@ import {
   SheetTitle,
   SheetDescription,
   ScrollArea,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
 } from '@object-ui/components';
 import {
   Play, Loader2, CheckCircle2, XCircle, Clock, AlertCircle, RefreshCw, Workflow,
@@ -130,6 +135,61 @@ function JsonBlock({ data }: { data: unknown }) {
   );
 }
 
+/** The item a value none of the picker's options carries is shown by. */
+const OUTSIDE_OPTIONS = 'outside';
+
+/**
+ * objectui#11865 — the flow picker, drawn with the shared `Select` the rest of
+ * the console picks with. It used to be a browser-native `<select>`. What a
+ * pick writes is unchanged: `onPick` receives the picked flow's `name`, the
+ * string the native control's `change` carried. Re-picking the current flow
+ * writes nothing, as it did there.
+ *
+ * - Items carry their option's INDEX, not the flow's name, as the card's other
+ *   pickers do; an index cannot collide with a name.
+ * - A value none of the options carries gets an item of its own, labelled with
+ *   the value: a flow picked before a Refresh that no longer lists it. The
+ *   trigger then shows the flow the page still holds (no runner is shown for
+ *   it). The native control showed the first flow there. Picking that item
+ *   writes nothing.
+ * - Like the native control, the trigger has no label: none is associated
+ *   with it today, and this swap keeps the name it had.
+ * - The page has no read-only state.
+ */
+function FlowPicker({
+  value,
+  options,
+  onPick,
+}: {
+  value: string;
+  options: ReadonlyArray<{ value: string; label: string }>;
+  onPick: (value: string) => void;
+}) {
+  const at = options.findIndex((o) => o.value === value);
+  return (
+    <Select
+      value={at !== -1 ? String(at) : OUTSIDE_OPTIONS}
+      onValueChange={(token) => {
+        // `undefined` for the outside item: it is the page's own value, so there is nothing to write.
+        const picked = options[Number(token)];
+        if (picked) onPick(picked.value);
+      }}
+    >
+      <SelectTrigger className="h-9 max-w-md">
+        <SelectValue />
+      </SelectTrigger>
+      <SelectContent>
+        {at === -1 && <SelectItem value={OUTSIDE_OPTIONS}>{value}</SelectItem>}
+        {options.map((o, i) => (
+          <SelectItem key={`${i}:${o.value}`} value={String(i)}>
+            {o.label}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
+
 export function FlowRunsPage() {
   const adapter = useAdapter();
   const client: any = adapter?.getClient?.();
@@ -216,17 +276,14 @@ export function FlowRunsPage() {
             <p className="text-sm text-muted-foreground">No flow definitions found.</p>
           )}
           {!flowsLoading && !flowsError && flows.length > 0 && (
-            <select
+            <FlowPicker
               value={selectedFlowName}
-              onChange={e => setSelectedFlowName(e.target.value)}
-              className="flex h-9 w-full max-w-md rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm focus:outline-none focus:ring-1 focus:ring-ring"
-            >
-              {flows.map(f => (
-                <option key={f.name} value={f.name}>
-                  {f.label ? `${f.label} (${f.name})` : f.name}
-                </option>
-              ))}
-            </select>
+              options={flows.map(f => ({
+                value: f.name,
+                label: f.label ? `${f.label} (${f.name})` : f.name,
+              }))}
+              onPick={setSelectedFlowName}
+            />
           )}
         </CardContent>
       </Card>
diff --git a/apps/console/src/pages/developer/PublicFormsPage.redirect.test.tsx b/apps/console/src/pages/developer/PublicFormsPage.redirect.test.tsx
index ad0b479722..faedcd6419 100644
--- a/apps/console/src/pages/developer/PublicFormsPage.redirect.test.tsx
+++ b/apps/console/src/pages/developer/PublicFormsPage.redirect.test.tsx
@@ -48,7 +48,7 @@
  */
 
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen, cleanup, waitFor, fireEvent } from '@testing-library/react';
+import { render, screen, cleanup, waitFor, fireEvent, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 // The page asks the router where the anonymous route is served (objectui#11769),
 // so it renders inside one, as it does in the app.
@@ -119,14 +119,19 @@ function setUrl(field: HTMLElement, value: string) {
   fireEvent.change(field, { target: { value } });
 }
 
-/** Open the row's editor and switch the post-submit behavior to `redirect`. */
+/**
+ * Open the row's editor and switch the post-submit behavior to `redirect`,
+ * through the shared `Select` the picker is (objectui#11865): open it from the
+ * keyboard, choose the option.
+ */
 async function openRedirectEditor(user: ReturnType<typeof userEvent.setup>) {
   render(<PublicFormsPage />, { wrapper: MemoryRouter });
   await user.click(
     await screen.findByRole('button', { name: /Edit sharing & post-submit behavior/i }),
   );
-  await user.selectOptions(await screen.findByLabelText(/After submit/i), 'redirect');
-  return screen.getByLabelText(/Redirect URL/i);
+  fireEvent.keyDown(await screen.findByRole('combobox', { name: /After submit/i }), { key: 'ArrowDown' });
+  fireEvent.click(within(await screen.findByRole('listbox')).getByRole('option', { name: 'Redirect to a URL' }));
+  return screen.findByLabelText(/Redirect URL/i);
 }
 
 beforeEach(() => saveItem.mockClear());
diff --git a/apps/console/src/pages/developer/PublicFormsPage.sharedSelect-11865.test.tsx b/apps/console/src/pages/developer/PublicFormsPage.sharedSelect-11865.test.tsx
new file mode 100644
index 0000000000..06405eea71
--- /dev/null
+++ b/apps/console/src/pages/developer/PublicFormsPage.sharedSelect-11865.test.tsx
@@ -0,0 +1,266 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * The Public Forms dialogs pick with the shared `Select` (objectui#11865).
+ *
+ * *Publish a FormView* asked for the view, and the edit dialog for what happens
+ * after submit, with browser-native selects, beside the shared Radix `Select`
+ * the rest of the console picks with. The card asks for one control for one
+ * kind of choice, surface by surface; this suite covers this page's two
+ * pickers.
+ *
+ * What is pinned:
+ *   - each picker IS the primitive (a Radix combobox trigger), shows the
+ *     dialog's value, and no native select is left;
+ *   - each picker keeps the name its `<Label htmlFor>` gave the native control;
+ *   - every option writes the `meta.saveItem` call the native control led to,
+ *     compared as JSON text, "— Select a FormView —" (value `''`) included;
+ *   - a stored kind no option carries is what the trigger shows;
+ *   - the keyboard alone opens a picker and selects.
+ *
+ * Read-only: neither dialog has such a state; both open only from this page's
+ * own Publish and Edit buttons.
+ *
+ * DIRECTION, observed against the native controls: every pin here but the name
+ * pin is red there, because each one reads the pickers as the primitive's
+ * triggers. The name pin is green there too: it pins what the conversion kept.
+ * What makes the write pins guards of "the conversion changed nothing the page
+ * saves" is the literal each compares against: a `change` event on the
+ * pre-conversion page's native control, then the same Publish or Save click,
+ * led to that same `saveItem` JSON, read once on that page with these
+ * fixtures. The names and the stored-kind reading were taken there the same
+ * way.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+// The page asks the router where the anonymous route is served (objectui#11769),
+// so it renders inside one, as it does in the app.
+import { MemoryRouter } from 'react-router-dom';
+
+/**
+ * One published public form (whose stored `submitBehavior` each case sets) and
+ * two FormViews that are not public yet: one with a label and an object, one
+ * with neither.
+ */
+const { saveItem, stored, ADAPTER } = vi.hoisted(() => {
+  const stored: { submitBehavior: unknown } = { submitBehavior: undefined };
+  const published = () => ({
+    name: 'showcase_task.public',
+    label: 'Log Time',
+    object: 'showcase_task',
+    type: 'simple',
+    sections: [{ label: 'Task', fields: ['title'] }],
+    sharing: { enabled: true, allowAnonymous: true, publicLink: '/forms/log-time' },
+    ...(stored.submitBehavior ? { submitBehavior: stored.submitBehavior } : {}),
+  });
+  const lead = {
+    name: 'lead.intake',
+    label: 'Lead intake',
+    object: 'lead',
+    type: 'simple',
+    sections: [{ label: 'Lead', fields: ['name'] }],
+  };
+  const survey = { name: 'survey.form', viewType: 'form', sections: [] };
+  const saveItem = vi.fn(async () => ({ ok: true }));
+  // A STABLE singleton: a fresh object per render loops the page's load effect.
+  const ADAPTER = {
+    getClient: () => ({
+      meta: {
+        getItems: async (type: string) =>
+          type === 'view' ? [{ spec: published() }, { spec: lead }, { spec: survey }] : [],
+        saveItem,
+      },
+    }),
+  };
+  return { saveItem, stored, ADAPTER };
+});
+
+vi.mock('@object-ui/app-shell', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAdapter: () => ADAPTER,
+}));
+vi.mock('sonner', () => ({ toast: { success: vi.fn(), error: vi.fn() } }));
+
+// Imported AFTER the mocks so the page picks them up.
+import { PublicFormsPage } from './PublicFormsPage';
+
+afterEach(() => {
+  cleanup();
+  saveItem.mockClear();
+  stored.submitBehavior = undefined;
+});
+
+const PLACEHOLDER = '— Select a FormView —';
+const LEAD = 'Lead intake (lead.intake) · lead';
+// The native option's text, trailing space and all: the label has no object to append.
+const SURVEY = 'survey.form (survey.form) ';
+const THANK_YOU = 'Show a thank-you panel';
+const REDIRECT = 'Redirect to a URL';
+const CONTINUE = 'Reset for another response';
+const NEXT_RECORD = 'Advance to next record (internal queues)';
+
+async function openPublish(): Promise<HTMLElement> {
+  render(<PublicFormsPage />, { wrapper: MemoryRouter });
+  await screen.findByRole('button', { name: /Edit sharing/i });
+  fireEvent.click(screen.getByRole('button', { name: /Publish form/i }));
+  return screen.findByRole('combobox', { name: 'FormView' });
+}
+
+async function openEdit(submitBehavior?: unknown): Promise<HTMLElement> {
+  stored.submitBehavior = submitBehavior;
+  render(<PublicFormsPage />, { wrapper: MemoryRouter });
+  fireEvent.click(await screen.findByRole('button', { name: /Edit sharing/i }));
+  return screen.findByRole('combobox', { name: 'After submit' });
+}
+
+/** Open a picker from the keyboard and return the options it lists, in order. */
+async function openPicker(trigger: HTMLElement): Promise<HTMLElement[]> {
+  fireEvent.keyDown(trigger, { key: 'ArrowDown' });
+  const listbox = await screen.findByRole('listbox');
+  return within(listbox).getAllByRole('option');
+}
+
+async function pick(trigger: HTMLElement, label: string): Promise<void> {
+  const options = await openPicker(trigger);
+  const option = options.find((o) => o.textContent === label);
+  if (!option) throw new Error(`no "${label}" listed: ${options.map((o) => o.textContent).join(' | ')}`);
+  fireEvent.click(option);
+  await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+}
+
+describe('the Public Forms pickers are the shared Select (objectui#11865)', () => {
+  it('renders each picker as the Radix combobox trigger, showing the dialog’s value', async () => {
+    const view = await openPublish();
+    expect(view.tagName).toBe('BUTTON');
+    expect(view).toHaveTextContent(PLACEHOLDER);
+    expect(document.querySelector('select')).toBeNull();
+    cleanup();
+
+    const behavior = await openEdit({ kind: 'continue' });
+    expect(behavior.tagName).toBe('BUTTON');
+    expect(behavior).toHaveTextContent(CONTINUE);
+    expect(document.querySelector('select')).toBeNull();
+  });
+
+  // Green against the native controls too, by design: it pins what the conversion kept.
+  it('each picker keeps the name its label gave the native control', async () => {
+    expect(await openPublish()).toHaveAttribute('id', 'publish-view');
+    cleanup();
+    expect(await openEdit()).toHaveAttribute('id', 'edit-behavior');
+  });
+
+  it('each picker lists its options in the order the native control did', async () => {
+    expect((await openPicker(await openPublish())).map((o) => o.textContent)).toEqual([
+      PLACEHOLDER,
+      LEAD,
+      SURVEY,
+    ]);
+    cleanup();
+    expect((await openPicker(await openEdit())).map((o) => o.textContent)).toEqual([
+      THANK_YOU,
+      REDIRECT,
+      CONTINUE,
+      NEXT_RECORD,
+    ]);
+  });
+});
+
+/** The `saveItem` call publishing a view at slug `contact-us`, as the native control led to it. */
+const PUBLISH_WRITES: ReadonlyArray<readonly [label: string, json: string]> = [
+  [
+    LEAD,
+    '["view","lead.intake",{"name":"lead.intake","label":"Lead intake","object":"lead","type":"simple","sections":[{"label":"Lead","fields":["name"]}],"sharing":{"enabled":true,"allowAnonymous":true,"publicLink":"/forms/contact-us"}}]',
+  ],
+  [
+    SURVEY,
+    '["view","survey.form",{"name":"survey.form","viewType":"form","sections":[],"sharing":{"enabled":true,"allowAnonymous":true,"publicLink":"/forms/contact-us"}}]',
+  ],
+];
+
+const SAVED_SPEC =
+  '"name":"showcase_task.public","label":"Log Time","object":"showcase_task","type":"simple","sections":[{"label":"Task","fields":["title"]}],"sharing":{"enabled":true,"allowAnonymous":true,"publicLink":"/forms/log-time"}';
+
+/** [the stored submitBehavior, option label, the `submitBehavior` JSON Save wrote]. */
+const BEHAVIOR_WRITES: ReadonlyArray<readonly [from: unknown, label: string, json: string]> = [
+  [undefined, THANK_YOU, '{"kind":"thank-you"}'],
+  [undefined, REDIRECT, '{"kind":"redirect","url":"/thanks"}'],
+  [undefined, CONTINUE, '{"kind":"continue"}'],
+  [undefined, NEXT_RECORD, '{"kind":"next-record"}'],
+  [{ kind: 'redirect', url: '/done' }, THANK_YOU, '{"kind":"thank-you"}'],
+  [{ kind: 'redirect', url: '/done' }, REDIRECT, '{"kind":"redirect","url":"/done"}'],
+  [{ kind: 'redirect', url: '/done' }, CONTINUE, '{"kind":"continue"}'],
+  [{ kind: 'redirect', url: '/done' }, NEXT_RECORD, '{"kind":"next-record"}'],
+  [{ kind: 'continue' }, THANK_YOU, '{"kind":"thank-you"}'],
+  [{ kind: 'continue' }, REDIRECT, '{"kind":"redirect","url":"/thanks"}'],
+  [{ kind: 'continue' }, CONTINUE, '{"kind":"continue"}'],
+  [{ kind: 'continue' }, NEXT_RECORD, '{"kind":"next-record"}'],
+];
+
+describe('every option writes what the native control wrote', () => {
+  it.each(PUBLISH_WRITES)('publishing %s', async (label, json) => {
+    const view = await openPublish();
+    await pick(view, label);
+    expect(view).toHaveTextContent(label.trim());
+    fireEvent.change(screen.getByLabelText('URL slug'), { target: { value: 'Contact Us' } });
+    fireEvent.click(screen.getByRole('button', { name: /^Publish$/ }));
+    await waitFor(() => expect(saveItem).toHaveBeenCalledTimes(1));
+    expect(JSON.stringify(saveItem.mock.calls[0])).toBe(json);
+  });
+
+  it('"— Select a FormView —" puts the dialog back on no view, and nothing can be published', async () => {
+    const view = await openPublish();
+    await pick(view, LEAD);
+    await pick(view, PLACEHOLDER);
+    expect(view).toHaveTextContent(PLACEHOLDER);
+    fireEvent.change(screen.getByLabelText('URL slug'), { target: { value: 'Contact Us' } });
+    expect(screen.getByRole('button', { name: /^Publish$/ })).toBeDisabled();
+    expect(saveItem).not.toHaveBeenCalled();
+  });
+
+  it.each(
+    BEHAVIOR_WRITES.map(
+      ([from, label, json]) => [`after submit ${JSON.stringify(from) ?? 'unset'} → ${label}`, from, label, json] as const,
+    ),
+  )('%s', async (_name, from, label, json) => {
+    const behavior = await openEdit(from);
+    await pick(behavior, label);
+    expect(behavior).toHaveTextContent(label);
+    const url = screen.queryByLabelText('Redirect URL');
+    if (url && (url as HTMLInputElement).value === '') fireEvent.change(url, { target: { value: '/thanks' } });
+    fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
+    await waitFor(() => expect(saveItem).toHaveBeenCalledTimes(1));
+    expect(JSON.stringify(saveItem.mock.calls[0])).toBe(
+      `["view","showcase_task.public",{${SAVED_SPEC},"submitBehavior":${json}}]`,
+    );
+  });
+});
+
+describe('a value no option carries is what the trigger shows', () => {
+  it('a stored kind none of the four options names: shown and listed first, and re-picking it writes nothing', async () => {
+    // The native control showed "Show a thank-you panel" here while the dialog
+    // held `bogus`, and rendered none of the thank-you fields it names.
+    const behavior = await openEdit({ kind: 'bogus' });
+    expect(behavior).toHaveTextContent('bogus');
+    expect(screen.queryByLabelText('Title')).not.toBeInTheDocument();
+    const listed = (await openPicker(behavior)).map((o) => o.textContent);
+    expect(listed).toEqual(['bogus', THANK_YOU, REDIRECT, CONTINUE, NEXT_RECORD]);
+    fireEvent.click(screen.getAllByRole('option')[0]);
+    await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+    expect(behavior).toHaveTextContent('bogus');
+    expect(screen.queryByLabelText('Title')).not.toBeInTheDocument();
+    expect(screen.queryByLabelText('Redirect URL')).not.toBeInTheDocument();
+  });
+});
+
+describe('the keyboard alone picks', () => {
+  it('Enter opens "After submit" and Enter on an option selects it', async () => {
+    const behavior = await openEdit();
+    fireEvent.keyDown(behavior, { key: 'Enter' });
+    const listbox = await screen.findByRole('listbox');
+    fireEvent.keyDown(within(listbox).getByRole('option', { name: REDIRECT }), { key: 'Enter' });
+    expect(await screen.findByLabelText('Redirect URL')).toBeInTheDocument();
+    expect(behavior).toHaveTextContent(REDIRECT);
+  });
+});
diff --git a/apps/console/src/pages/developer/PublicFormsPage.tsx b/apps/console/src/pages/developer/PublicFormsPage.tsx
index c8a3e7d2c5..07174548dc 100644
--- a/apps/console/src/pages/developer/PublicFormsPage.tsx
+++ b/apps/console/src/pages/developer/PublicFormsPage.tsx
@@ -69,6 +69,11 @@ import {
   Input,
   Label,
   EmptyValue,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
 } from '@object-ui/components';
 import { Copy, ExternalLink, FormInput, RefreshCw, Code2, Link2, Settings2, Plus } from 'lucide-react';
 import { toast } from 'sonner';
@@ -104,6 +109,76 @@ function sanitizeSlug(s: string): string {
 /** The anonymous form route's prefix, as `App.tsx` declares it (`/f/:slug`). */
 const PUBLIC_FORM_ROUTE = '/f';
 
+type SubmitBehaviorKind = 'thank-you' | 'redirect' | 'continue' | 'next-record';
+
+/** The "After submit" picker's options, in the order the dialog offers them. */
+const SUBMIT_BEHAVIOR_OPTIONS: ReadonlyArray<{ value: SubmitBehaviorKind; label: string }> = [
+  { value: 'thank-you', label: 'Show a thank-you panel' },
+  { value: 'redirect', label: 'Redirect to a URL' },
+  { value: 'continue', label: 'Reset for another response' },
+  { value: 'next-record', label: 'Advance to next record (internal queues)' },
+];
+
+/** The item a value none of a picker's options carries is shown by. */
+const OUTSIDE_OPTIONS = 'outside';
+
+/**
+ * objectui#11865 — the two dialogs' pickers (the FormView to publish, and what
+ * happens after submit), drawn with the shared `Select` the rest of the
+ * console picks with. They used to be browser-native `<select>`s. What a pick
+ * writes is unchanged: `onPick` receives the picked option's own `value`, the
+ * string the native control's `change` carried. Re-picking the current option
+ * writes nothing, as it did there.
+ *
+ * - Items carry their option's INDEX, not its value. The FormView picker opens
+ *   on "— Select a FormView —", whose value is `''`, which `SelectItem`
+ *   refuses; an index cannot collide with a view's name, as any stand-in
+ *   string could.
+ * - A value none of the options carries gets an item of its own, labelled with
+ *   the value, so the trigger shows what the dialog holds and would save. The
+ *   native control showed its first option there. Picking that item writes
+ *   nothing.
+ * - `id` lands on the trigger, so the field's `<Label htmlFor>` names it as it
+ *   named the native control.
+ * - Neither dialog has a read-only state: both are reached only from this
+ *   page's own Publish and Edit buttons.
+ */
+function FormsPicker<V extends string>({
+  id,
+  value,
+  options,
+  onPick,
+}: {
+  id: string;
+  value: V;
+  options: ReadonlyArray<{ value: V; label: string }>;
+  onPick: (value: V) => void;
+}) {
+  const at = options.findIndex((o) => o.value === value);
+  return (
+    <Select
+      value={at !== -1 ? String(at) : OUTSIDE_OPTIONS}
+      onValueChange={(token) => {
+        // `undefined` for the outside item: it is the dialog's own value, so there is nothing to write.
+        const picked = options[Number(token)];
+        if (picked) onPick(picked.value);
+      }}
+    >
+      <SelectTrigger id={id} className="h-9">
+        <SelectValue />
+      </SelectTrigger>
+      <SelectContent>
+        {at === -1 && <SelectItem value={OUTSIDE_OPTIONS}>{value}</SelectItem>}
+        {options.map((o, i) => (
+          <SelectItem key={`${i}:${o.value}`} value={String(i)}>
+            {o.label}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
+
 export function PublicFormsPage() {
   const adapter = useAdapter();
   const client: any = adapter?.getClient?.();
@@ -121,7 +196,7 @@ export function PublicFormsPage() {
   const [editOpen, setEditOpen] = useState(false);
   const [editRow, setEditRow] = useState<PublicFormRow | null>(null);
   const [editSlug, setEditSlug] = useState('');
-  const [editBehavior, setEditBehavior] = useState<'thank-you' | 'redirect' | 'continue' | 'next-record'>('thank-you');
+  const [editBehavior, setEditBehavior] = useState<SubmitBehaviorKind>('thank-you');
   const [editBehaviorTitle, setEditBehaviorTitle] = useState('');
   const [editBehaviorMessage, setEditBehaviorMessage] = useState('');
   const [editBehaviorUrl, setEditBehaviorUrl] = useState('');
@@ -478,19 +553,18 @@ export function PublicFormsPage() {
           <div className="space-y-3">
             <div className="space-y-1.5">
               <Label htmlFor="publish-view">FormView</Label>
-              <select
+              <FormsPicker
                 id="publish-view"
-                className="flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm"
                 value={publishView}
-                onChange={(e) => setPublishView(e.target.value)}
-              >
-                <option value="">— Select a FormView —</option>
-                {publishable.map((p) => (
-                  <option key={p.name} value={p.name}>
-                    {p.label ?? p.name} ({p.name}) {p.object ? `· ${p.object}` : ''}
-                  </option>
-                ))}
-              </select>
+                options={[
+                  { value: '', label: '— Select a FormView —' },
+                  ...publishable.map((p) => ({
+                    value: p.name,
+                    label: `${p.label ?? p.name} (${p.name}) ${p.object ? `· ${p.object}` : ''}`,
+                  })),
+                ]}
+                onPick={setPublishView}
+              />
             </div>
             <div className="space-y-1.5">
               <Label htmlFor="publish-slug">URL slug</Label>
@@ -543,20 +617,15 @@ export function PublicFormsPage() {
             </div>
             <div className="space-y-1.5">
               <Label htmlFor="edit-behavior">After submit</Label>
-              <select
+              <FormsPicker
                 id="edit-behavior"
-                className="flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm"
                 value={editBehavior}
-                onChange={(e) => {
-                  setEditBehavior(e.target.value as any);
+                options={SUBMIT_BEHAVIOR_OPTIONS}
+                onPick={(kind) => {
+                  setEditBehavior(kind);
                   setEditUrlRefusal(null);
                 }}
-              >
-                <option value="thank-you">Show a thank-you panel</option>
-                <option value="redirect">Redirect to a URL</option>
-                <option value="continue">Reset for another response</option>
-                <option value="next-record">Advance to next record (internal queues)</option>
-              </select>
+              />
             </div>
             {editBehavior === 'thank-you' && (
               <>
diff --git a/apps/console/src/pages/developer/developerMetadataEnvelope.contractEnvelope-6917.test.tsx b/apps/console/src/pages/developer/developerMetadataEnvelope.contractEnvelope-6917.test.tsx
index e20f4d57d6..9f9754a884 100644
--- a/apps/console/src/pages/developer/developerMetadataEnvelope.contractEnvelope-6917.test.tsx
+++ b/apps/console/src/pages/developer/developerMetadataEnvelope.contractEnvelope-6917.test.tsx
@@ -47,19 +47,22 @@ import { MemoryRouter } from 'react-router-dom';
 
 /**
  * One mutable answer, read by BOTH pages' `meta.getItems`. A stable singleton
- * adapter: a fresh object per render loops the pages' load effects.
+ * adapter: a fresh object per render loops the pages' load effects. Its client
+ * is a singleton too, as the real adapter's `getClient()` is: Flow Runs keys its
+ * flow and run loads on the client, so a fresh one per call re-ran them on
+ * every render, and the flow picker's shared `Select` (objectui#11865) never
+ * settled long enough to show its value.
  */
 const { ADAPTER, state } = vi.hoisted(() => {
   const state: { answer: unknown } = { answer: [] };
-  const ADAPTER = {
-    getClient: () => ({
-      meta: {
-        getItems: async () => state.answer,
-        saveItem: vi.fn(async () => ({ ok: true })),
-      },
-      automation: { execute: vi.fn(), listRuns: async () => ({ runs: [] }) },
-    }),
+  const client = {
+    meta: {
+      getItems: async () => state.answer,
+      saveItem: vi.fn(async () => ({ ok: true })),
+    },
+    automation: { execute: vi.fn(), listRuns: async () => ({ runs: [] }) },
   };
+  const ADAPTER = { getClient: () => client };
   return { ADAPTER, state };
 });
 
diff --git a/apps/console/src/pages/system/ProfilePage.tsx b/apps/console/src/pages/system/ProfilePage.tsx
index 4f03c7cf3a..f1d73f080a 100644
--- a/apps/console/src/pages/system/ProfilePage.tsx
+++ b/apps/console/src/pages/system/ProfilePage.tsx
@@ -29,6 +29,11 @@ import {
   Badge,
   Alert,
   AlertDescription,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
 } from '@object-ui/components';
 import { useUpload } from '@object-ui/providers';
 import { useObjectTranslation, type TranslateFn } from '@object-ui/i18n';
@@ -331,9 +336,85 @@ function nativeLanguageName(code: string): string {
   }
 }
 
-/** The `<option>` value standing for "no stored tag" — see {@link LanguageCard}. */
+/** The picker option's value standing for "no stored tag" — see {@link LanguageCard}. */
 const USE_DEPLOYMENT_DEFAULT = '';
 
+/** The item a value none of the picker's options carries is shown by. */
+const OUTSIDE_OPTIONS = 'outside';
+
+/**
+ * objectui#11865 — the language picker, drawn with the shared `Select` the rest
+ * of the console picks with. It used to be a browser-native `<select>`. What a
+ * pick writes is unchanged: `onPick` receives the picked option's own `value`,
+ * the string the native control's `change` carried, and {@link LanguageCard}
+ * saves it as before. Re-picking the current option writes nothing, as it did
+ * there.
+ *
+ * - Items carry their option's INDEX, not its value. The first option is
+ *   {@link USE_DEPLOYMENT_DEFAULT}, whose value is `''`, which `SelectItem`
+ *   refuses; an index cannot collide with a language tag, as any stand-in
+ *   string could.
+ * - The card already lists a stored tag the deployment no longer publishes.
+ *   A value none of the options carries all the same (a pick the offered list
+ *   dropped since) gets an item of its own, labelled with the value, so the
+ *   trigger shows what Save would write. The native control showed its first
+ *   option there. Picking that item writes nothing.
+ * - Read-only follows the primitive (objectui#11781): `disabled` disables the
+ *   trigger itself.
+ * - `id` lands on the trigger, so the card's `<Label htmlFor>` names it as it
+ *   named the native control, and the refusal stays attached to it.
+ */
+function LanguagePicker({
+  id,
+  testId,
+  value,
+  options,
+  onPick,
+  disabled,
+  invalid,
+  describedBy,
+}: {
+  id: string;
+  testId: string;
+  value: string;
+  options: ReadonlyArray<{ value: string; label: string }>;
+  onPick: (value: string) => void;
+  disabled: boolean;
+  invalid: boolean;
+  describedBy: string | undefined;
+}) {
+  const at = options.findIndex((o) => o.value === value);
+  return (
+    <Select
+      value={at !== -1 ? String(at) : OUTSIDE_OPTIONS}
+      onValueChange={(token) => {
+        // `undefined` for the outside item: it is the card's own value, so there is nothing to write.
+        const picked = options[Number(token)];
+        if (picked) onPick(picked.value);
+      }}
+      disabled={disabled}
+    >
+      <SelectTrigger
+        id={id}
+        data-testid={testId}
+        aria-invalid={invalid ? true : undefined}
+        aria-describedby={describedBy}
+        className="h-9"
+      >
+        <SelectValue />
+      </SelectTrigger>
+      <SelectContent>
+        {at === -1 && <SelectItem value={OUTSIDE_OPTIONS}>{value}</SelectItem>}
+        {options.map((o, i) => (
+          <SelectItem key={`${i}:${o.value}`} value={String(i)}>
+            {o.label}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
+
 interface LanguageCardProps {
   /** The signed-in user's `sys_user` record id. */
   userId: string;
@@ -514,31 +595,28 @@ function LanguageCard({ userId }: LanguageCardProps) {
             <Label htmlFor="profile-language">
               {t('profile.language.label', { defaultValue: 'Preferred language' })}
             </Label>
-            <select
+            <LanguagePicker
               id="profile-language"
-              data-testid="profile-language-select"
+              testId="profile-language-select"
               value={choice}
-              onChange={(e: React.ChangeEvent<HTMLSelectElement>) => {
-                setChoice(e.target.value);
+              options={[
+                {
+                  value: USE_DEPLOYMENT_DEFAULT,
+                  label: t('profile.language.systemDefault', {
+                    defaultValue: 'Use the deployment default',
+                  }),
+                },
+                ...codes.map((code) => ({ value: code, label: nativeLanguageName(code) })),
+              ]}
+              onPick={(next) => {
+                setChoice(next);
                 setFieldError(null);
                 setSaved(false);
               }}
               disabled={!writable || submitting}
-              aria-invalid={fieldError ? true : undefined}
-              aria-describedby={fieldError ? 'profile-language-error' : undefined}
-              className="flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm focus:outline-none focus:ring-1 focus:ring-ring disabled:cursor-not-allowed disabled:opacity-50"
-            >
-              <option value={USE_DEPLOYMENT_DEFAULT}>
-                {t('profile.language.systemDefault', {
-                  defaultValue: 'Use the deployment default',
-                })}
-              </option>
-              {codes.map((code) => (
-                <option key={code} value={code}>
-                  {nativeLanguageName(code)}
-                </option>
-              ))}
-            </select>
+              invalid={!!fieldError}
+              describedBy={fieldError ? 'profile-language-error' : undefined}
+            />
             {fieldError && (
               <p id="profile-language-error" className="text-sm text-destructive">
                 {fieldError}
diff --git a/apps/console/src/pages/system/__tests__/ProfilePage.language.test.tsx b/apps/console/src/pages/system/__tests__/ProfilePage.language.test.tsx
index 60bf316cbb..e651e3b7fd 100644
--- a/apps/console/src/pages/system/__tests__/ProfilePage.language.test.tsx
+++ b/apps/console/src/pages/system/__tests__/ProfilePage.language.test.tsx
@@ -33,13 +33,13 @@
  * ## Why the form is driven with `fireEvent`, not `userEvent`
  *
  * Measured here, not preferred on style. Under the DOM environment these
- * console tests run in, `userEvent.selectOptions` leaves this controlled
- * `<select>`'s `value` at `''`, and a `userEvent.click` on the submit button
- * never reaches the form's `onSubmit` — so the save cases would fail for
- * reasons that have nothing to do with the control. `fireEvent.change` +
- * `fireEvent.submit` are what this repo's other form tests use for the same
- * reason. The button is still asserted present and ENABLED at that moment, so
- * "the user could reach this submit" stays pinned.
+ * console tests run in, a `userEvent.click` on the submit button never reaches
+ * the form's `onSubmit` — so the save cases would fail for reasons that have
+ * nothing to do with the control. `fireEvent.submit` is what this repo's other
+ * form tests use for the same reason. The button is still asserted present and
+ * ENABLED at that moment, so "the user could reach this submit" stays pinned.
+ * The control is the shared `Select` (objectui#11865), picked the way a
+ * keyboard user picks: open the trigger, choose the option.
  *
  * ## Reverse verification — both legs run, from the committed fix
  *
@@ -55,7 +55,7 @@
  */
 
 import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
 import { normaliseClientError } from '@object-ui/data-objectstack';
 
 const { user, updateUser, findOne, update, offerable, writable } = vi.hoisted(() => ({
@@ -101,9 +101,16 @@ vi.mock('@object-ui/i18n', async (importOriginal) => ({
   }),
 }));
 
+/**
+ * A STABLE adapter, as the app's provider hands out: a fresh object per render
+ * re-runs the card's row read on every render, and its answer resets the
+ * picked language to the stored one before Save can be reached.
+ */
+const ADAPTER = vi.hoisted(() => ({ findOne, update }));
+
 vi.mock('@object-ui/react', async (importOriginal) => ({
   ...(await importOriginal<Record<string, unknown>>()),
-  useAdapter: () => ({ findOne, update }),
+  useAdapter: () => ADAPTER,
 }));
 
 vi.mock('@object-ui/permissions', async (importOriginal) => ({
@@ -113,10 +120,28 @@ vi.mock('@object-ui/permissions', async (importOriginal) => ({
 
 const { ProfilePage } = await import('../ProfilePage');
 
-/** The select, once the row read has settled and the card has mounted. */
+/** The picker's trigger, once the row read has settled and the card has mounted. */
 async function renderProfile() {
   render(<ProfilePage />);
-  return (await screen.findByTestId('profile-language-select')) as HTMLSelectElement;
+  return screen.findByTestId('profile-language-select');
+}
+
+/** Open the picker and return the labels it lists, in order. */
+async function listed(trigger: HTMLElement): Promise<string[]> {
+  fireEvent.keyDown(trigger, { key: 'ArrowDown' });
+  const listbox = await screen.findByRole('listbox');
+  const labels = within(listbox).getAllByRole('option').map((o) => o.textContent ?? '');
+  fireEvent.keyDown(listbox, { key: 'Escape' });
+  await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+  return labels;
+}
+
+/** Pick one option by its label. */
+async function pick(trigger: HTMLElement, label: string) {
+  fireEvent.keyDown(trigger, { key: 'ArrowDown' });
+  const listbox = await screen.findByRole('listbox');
+  fireEvent.click(within(listbox).getByRole('option', { name: label }));
+  await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
 }
 
 describe('ProfilePage — my language (objectui#7501)', () => {
@@ -133,9 +158,10 @@ describe('ProfilePage — my language (objectui#7501)', () => {
     const select = await renderProfile();
 
     expect(findOne).toHaveBeenCalledWith('sys_user', 'usr_1');
-    const options = Array.from(select.options);
-    expect(options.map((o) => o.value)).toEqual(['', 'en', 'zh', 'ja']);
-    expect(options.map((o) => o.textContent)).toEqual([
+    // What each option writes is pinned option by option in
+    // `ProfilePage.sharedSelect-11865`; here, what the menu offers.
+    const options = await listed(select);
+    expect(options).toEqual([
       'Use the deployment default',
       'English',
       '中文',
@@ -144,22 +170,28 @@ describe('ProfilePage — my language (objectui#7501)', () => {
     // The list is the provider's, not a built-in ten: `ko`/`de`/`fr` ship
     // catalogues in this repo and are deliberately NOT in `offerableLanguages`
     // here. A hard-coded menu would light these up.
-    expect(options.map((o) => o.value)).not.toContain('ko');
-    expect(options.map((o) => o.value)).not.toContain('de');
+    expect(options).not.toContain('한국어');
+    expect(options).not.toContain('Deutsch');
   });
 
   it('seeds from the stored tag, and shows one the deployment no longer publishes', async () => {
     findOne.mockResolvedValue({ id: 'usr_1', locale: 'pt-BR' });
     const select = await renderProfile();
 
-    expect(select.value).toBe('pt-BR');
-    expect(Array.from(select.options).map((o) => o.value)).toEqual(['', 'pt-BR', 'en', 'zh', 'ja']);
+    expect(select).toHaveTextContent('Português (Brasil)');
+    expect(await listed(select)).toEqual([
+      'Use the deployment default',
+      'Português (Brasil)',
+      'English',
+      '中文',
+      '日本語',
+    ]);
   });
 
   it('saves the pick through the data API — not through better-auth', async () => {
     const select = await renderProfile();
 
-    fireEvent.change(select, { target: { value: 'ja' } });
+    await pick(select, '日本語');
     expect(screen.getByRole('button', { name: 'Save' })).toBeEnabled();
     fireEvent.submit(select.closest('form')!);
 
@@ -174,9 +206,9 @@ describe('ProfilePage — my language (objectui#7501)', () => {
   it('clears back to the deployment default by writing null, not an empty tag', async () => {
     findOne.mockResolvedValue({ id: 'usr_1', locale: 'ja' });
     const select = await renderProfile();
-    expect(select.value).toBe('ja');
+    expect(select).toHaveTextContent('日本語');
 
-    fireEvent.change(select, { target: { value: '' } });
+    await pick(select, 'Use the deployment default');
     expect(screen.getByRole('button', { name: 'Save' })).toBeEnabled();
     fireEvent.submit(select.closest('form')!);
 
@@ -202,7 +234,7 @@ describe('ProfilePage — my language (objectui#7501)', () => {
     );
 
     const select = await renderProfile();
-    fireEvent.change(select, { target: { value: 'zh' } });
+    await pick(select, '中文');
     expect(screen.getByRole('button', { name: 'Save' })).toBeEnabled();
     fireEvent.submit(select.closest('form')!);
 
diff --git a/apps/console/src/pages/system/__tests__/ProfilePage.sharedSelect-11865.test.tsx b/apps/console/src/pages/system/__tests__/ProfilePage.sharedSelect-11865.test.tsx
new file mode 100644
index 0000000000..085f89da72
--- /dev/null
+++ b/apps/console/src/pages/system/__tests__/ProfilePage.sharedSelect-11865.test.tsx
@@ -0,0 +1,222 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * The profile page's preferred language is the shared `Select`
+ * (objectui#11865).
+ *
+ * The language card picked with a browser-native select, beside the shared
+ * Radix `Select` the rest of the console picks with. The card asks for one
+ * control for one kind of choice, surface by surface.
+ *
+ * What is pinned:
+ *   - the picker IS the primitive (a Radix combobox trigger) and shows the
+ *     stored tag; the only native select left is Radix's own hidden form
+ *     mirror;
+ *   - the trigger keeps the name the card's `<Label htmlFor>` gave the native
+ *     control;
+ *   - every option writes the `adapter.update` call the native control led to,
+ *     compared as JSON text, "Use the deployment default" (value `''`, saved
+ *     as `null`) included, and re-picking the current option leaves nothing
+ *     to save;
+ *   - a pick the offered list has since dropped is what the trigger shows;
+ *   - the keyboard alone opens the picker and selects.
+ *
+ * Read-only follows the primitive (objectui#11781): `ProfilePage.language`'s
+ * "degrades to read-only" case pins the disabled trigger.
+ *
+ * DIRECTION, observed against the native control: every pin here but the name
+ * pin is red there, because each one reads the picker as the primitive's
+ * trigger. What makes the write pins guards of "the conversion changed nothing
+ * the card saves" is the literal each compares against: a `change` event on
+ * the pre-conversion card's native control, then the same submit, led to that
+ * same `update` JSON, read once on that card with these fixtures. The name and
+ * the dropped-pick reading were taken there the same way.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+
+const { findOne, update, offerable } = vi.hoisted(() => ({
+  findOne: vi.fn<(resource: string, id: string) => Promise<unknown>>(async () => ({ id: 'usr_1' })),
+  update: vi.fn<(resource: string, id: string, data: unknown) => Promise<unknown>>(async () => ({})),
+  offerable: { value: ['en', 'zh', 'ja'] as readonly string[] },
+}));
+
+vi.mock('@object-ui/auth', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAuth: () => ({
+    user: { id: 'usr_1', name: 'Ada', email: 'ada@example.com' },
+    updateUser: async () => {},
+    isLoading: false,
+    changePassword: async () => {},
+    setInitialPassword: async () => {},
+    hasLocalPassword: async () => true,
+  }),
+}));
+
+vi.mock('@object-ui/providers', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useUpload: () => ({ upload: async () => ({ url: '' }) }),
+}));
+
+/** Each call site's own `defaultValue`, as an English console renders it. */
+vi.mock('@object-ui/i18n', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useObjectTranslation: () => ({
+    t: (key: string, options?: Record<string, unknown>) => String(options?.defaultValue ?? key),
+    offerableLanguages: offerable.value,
+  }),
+}));
+
+/**
+ * A STABLE adapter, as the app's provider hands out: a fresh object per render
+ * re-runs the card's row read on every render, and its answer resets the
+ * picked language to the stored one before Save can be reached.
+ */
+const ADAPTER = vi.hoisted(() => ({ findOne, update }));
+
+vi.mock('@object-ui/react', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAdapter: () => ADAPTER,
+}));
+
+vi.mock('@object-ui/permissions', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  usePermissions: () => ({ checkField: () => true }),
+}));
+
+const { ProfilePage } = await import('../ProfilePage');
+
+const DEFAULT = 'Use the deployment default';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  offerable.value = ['en', 'zh', 'ja'];
+  findOne.mockResolvedValue({ id: 'usr_1' });
+  update.mockResolvedValue({});
+});
+
+/** The picker, once the row read has settled and the card has mounted. */
+async function renderCard(locale?: string) {
+  findOne.mockResolvedValue(locale ? { id: 'usr_1', locale } : { id: 'usr_1' });
+  const utils = render(<ProfilePage />);
+  const trigger = await screen.findByTestId('profile-language-select');
+  return { ...utils, trigger };
+}
+
+/** Open the picker from the keyboard and return the options it lists, in order. */
+async function openPicker(trigger: HTMLElement): Promise<HTMLElement[]> {
+  fireEvent.keyDown(trigger, { key: 'ArrowDown' });
+  const listbox = await screen.findByRole('listbox');
+  return within(listbox).getAllByRole('option');
+}
+
+async function pick(trigger: HTMLElement, label: string): Promise<void> {
+  const options = await openPicker(trigger);
+  const option = options.find((o) => o.textContent === label);
+  if (!option) throw new Error(`no "${label}" listed: ${options.map((o) => o.textContent).join(' | ')}`);
+  fireEvent.click(option);
+  await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+}
+
+describe('the language picker is the shared Select (objectui#11865)', () => {
+  it('renders the picker as the Radix combobox trigger, showing the stored tag', async () => {
+    const { trigger } = await renderCard('ja');
+    expect(trigger.tagName).toBe('BUTTON');
+    expect(trigger).toHaveAttribute('role', 'combobox');
+    expect(trigger).toHaveTextContent('日本語');
+    // Radix mirrors the value into a hidden native select inside a form; it is
+    // aria-hidden and out of the tab order. No other native select is left.
+    expect(document.querySelectorAll('select:not([aria-hidden="true"])')).toHaveLength(0);
+  });
+
+  // Green against the native control too, by design: it pins what the conversion kept.
+  it('keeps the name the card’s label gave the native control', async () => {
+    const { trigger } = await renderCard();
+    expect(screen.getByRole('combobox', { name: 'Preferred language' })).toBe(trigger);
+    expect(trigger).toHaveAttribute('id', 'profile-language');
+  });
+});
+
+/**
+ * [the stored tag, option label, the JSON text of `adapter.update`'s call].
+ * `null`: nothing to save — the option is the current one, so Save stays
+ * disabled.
+ */
+const WRITES: ReadonlyArray<readonly [stored: string | undefined, label: string, json: string | null]> = [
+  [undefined, DEFAULT, null],
+  [undefined, 'English', '["sys_user","usr_1",{"locale":"en"}]'],
+  [undefined, '中文', '["sys_user","usr_1",{"locale":"zh"}]'],
+  [undefined, '日本語', '["sys_user","usr_1",{"locale":"ja"}]'],
+  ['ja', DEFAULT, '["sys_user","usr_1",{"locale":null}]'],
+  ['ja', 'English', '["sys_user","usr_1",{"locale":"en"}]'],
+  ['ja', '中文', '["sys_user","usr_1",{"locale":"zh"}]'],
+  ['ja', '日本語', null],
+  ['pt-BR', DEFAULT, '["sys_user","usr_1",{"locale":null}]'],
+  ['pt-BR', 'English', '["sys_user","usr_1",{"locale":"en"}]'],
+  ['pt-BR', '中文', '["sys_user","usr_1",{"locale":"zh"}]'],
+  ['pt-BR', '日本語', '["sys_user","usr_1",{"locale":"ja"}]'],
+  ['pt-BR', 'Português (Brasil)', null],
+];
+
+describe('every option writes what the native control wrote', () => {
+  it('lists the options in the order the native control did', async () => {
+    const { trigger } = await renderCard('pt-BR');
+    expect((await openPicker(trigger)).map((o) => o.textContent)).toEqual([
+      DEFAULT,
+      'Português (Brasil)',
+      'English',
+      '中文',
+      '日本語',
+    ]);
+  });
+
+  it.each(WRITES.map(([stored, label, json]) => [`stored ${stored ?? 'none'} → ${label}`, stored, label, json] as const))(
+    '%s',
+    async (_name, stored, label, json) => {
+      const { trigger } = await renderCard(stored);
+      await pick(trigger, label);
+      expect(trigger).toHaveTextContent(label);
+      const save = screen.getByRole('button', { name: 'Save' });
+      if (json === null) {
+        expect(save).toBeDisabled();
+        expect(update).not.toHaveBeenCalled();
+        return;
+      }
+      expect(save).toBeEnabled();
+      fireEvent.submit(trigger.closest('form')!);
+      await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+      expect(JSON.stringify(update.mock.calls[0])).toBe(json);
+    },
+  );
+});
+
+describe('a value no option carries is what the trigger shows', () => {
+  it('a pick the offered list has since dropped: shown and saved as picked', async () => {
+    const { trigger, rerender } = await renderCard();
+    await pick(trigger, '中文');
+    offerable.value = ['en', 'ja'];
+    rerender(<ProfilePage />);
+    // The native control showed its first option here while Save would write `zh`.
+    expect(trigger).toHaveTextContent('zh');
+    expect((await openPicker(trigger)).map((o) => o.textContent)).toEqual(['zh', DEFAULT, 'English', '日本語']);
+    fireEvent.keyDown(screen.getByRole('listbox'), { key: 'Escape' });
+    await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+    fireEvent.submit(trigger.closest('form')!);
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    expect(JSON.stringify(update.mock.calls[0])).toBe('["sys_user","usr_1",{"locale":"zh"}]');
+  });
+});
+
+describe('the keyboard alone picks', () => {
+  it('Enter opens the picker and Enter on an option selects it', async () => {
+    const { trigger } = await renderCard();
+    fireEvent.keyDown(trigger, { key: 'Enter' });
+    const listbox = await screen.findByRole('listbox');
+    fireEvent.keyDown(within(listbox).getByRole('option', { name: 'English' }), { key: 'Enter' });
+    await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+    expect(trigger).toHaveTextContent('English');
+    expect(screen.getByRole('button', { name: 'Save' })).toBeEnabled();
+  });
+});