@@ -0,0 +1,13 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/react': patch
+---
+
+Lookup links on a record page and on a custom page now carry the console's base path, so the same link works from a left click, a new tab, a middle-click and a copied link (objectui#12233).
+
+On a console mounted under a router basename, such as `/_console`, a lookup value rendered as an anchor whose href was the bare route `/apps/APP/OBJECT/record/ID`. On a record page this hit, for example, a lead's converted account or contact and its owner. The same held for a lookup, or a grid's link column, on a custom page. A plain left click worked, because the anchor hands it to the console router and the router adds the basename. Opening the link in a new tab, middle-clicking it or pasting a copied link sent the browser to the bare route on the server, which answered `ENDPOINT_NOT_FOUND`.
+
+- `@object-ui/app-shell`: both record-link builders, the record page's and the custom page's, now give lookups an href that includes the router's basename. They read the basename from the router, so a console mounted at the root keeps the bare href. A left click still navigates inside the app, to the same record the href names.
+- `@object-ui/react`: the documentation of `RelatedRecordActionsValue.recordHref` now says the value is a document href that carries the host router's basename, while `openRecord` navigates by the router path. The type is unchanged.
+
+Nothing is added to or removed from any package entry.
@@ -10,7 +10,7 @@
  */
 
 import { lazy, Suspense } from 'react';
-import { useParams, useSearchParams, useNavigate, useLocation } from 'react-router-dom';
+import { useParams, useSearchParams, useNavigate, useLocation, useHref } from 'react-router-dom';
 import {
   SchemaRenderer,
   notifyDataChanged,
@@ -67,6 +67,9 @@ export function PageView() {
   const [searchParams] = useSearchParams();
   const { showDebug } = useMetadataInspector();
   const navigate = useNavigate();
+  // The router's root href, basename included: the page's record navigator
+  // publishes document hrefs from it (objectui#12233).
+  const routerRootHref = useHref('/');
   const location = useLocation();
   // Editing a page mutates the shared metadata definition, so the entry point
   // is admin-only (mirrors the view/report/dashboard runtime editors) — AND
@@ -130,7 +133,7 @@ export function PageView() {
   // The record navigator the page's blocks open a record through
   // (objectui#11293). Not memoised: the schema below is rebuilt on every
   // render too, and nothing may rest on this object's identity (AGENTS.md #10).
-  const pageRecordActions = pageRecordActionsValue(appName, (objects ?? []) as unknown[], navigate);
+  const pageRecordActions = pageRecordActionsValue(appName, (objects ?? []) as unknown[], navigate, routerRootHref);
 
   return (
     // Mount the shared console action runtime so page-level `action:button`s can
 
@@ -69,7 +69,7 @@
  */
 
 import { useCallback, useMemo } from 'react';
-import { useNavigate, useSearchParams } from 'react-router-dom';
+import { useHref, useNavigate, useSearchParams } from 'react-router-dom';
 import {
   RelatedRecordActionsProvider,
   notifyDataChanged,
@@ -85,6 +85,7 @@ import { evalRowPredicate, resolveAffordance, type ActionDef, type RowCrudPredic
 import { actionRendersAt, type ActionLocation } from '@object-ui/types';
 import { usePermissions } from '@object-ui/permissions';
 import { RECORD_FORM_PARAM, RECORD_FORM_OBJECT_PARAM, RECORD_FORM_LINK_PARAM, RECORD_TRAIL_PARAM, appendRecordTrail } from '../urlParams.js';
+import { documentHref } from './documentHref.js';
 
 /**
  * Notify open related lists for `objectName` to refetch.
@@ -250,6 +251,9 @@ export function RelatedRecordActionsBridge({
   // dialog stayed in the authored language.
   const localizeActionTexts = useActionTextLocalizer();
   const base = appName ? `/apps/${appName}` : '';
+  // The router's href for its root, basename included (see `documentHref`).
+  // Read once here, because `recordHref` below runs per rendered lookup.
+  const routerRootHref = useHref('/');
   /** A parent record is in scope: the related lists below sit inside it. */
   const hasParentRecord = parentRecordId != null && parentRecordId !== '';
 
@@ -260,18 +264,18 @@ export function RelatedRecordActionsBridge({
   );
 
   /**
-   * THE record-detail URL builder for this page — one route shape, one place.
+   * THE record-detail route for this page — one route shape, one place.
    *
-   * Serves both the related list's row navigation (`onView`, below) and, since
-   * objectui#4336, the lookup values rendered anywhere under this bridge: a
-   * lookup points at a record of another object, and `LookupCellRenderer` has
-   * no router, so it asks for the href instead of re-deriving `/apps/:app/
-   * :object/record/:id` a second time (the #4472 lesson — one resolver).
+   * A ROUTER path (`/apps/:app/:object/record/:id`, no basename), which is what
+   * `navigate` takes. Both of this page's ways of reaching a record derive from
+   * it: the related list's row navigation (`onView`, through `openRecord`) and
+   * the href the lookup values render (`recordHref`), so the two cannot address
+   * different records.
    *
    * `null` when the host cannot route there (no app segment, or an object that
    * is not in this console's metadata), which renders as the plain value.
    */
-  const recordHref = useCallback(
+  const recordPath = useCallback(
     (objectName: string, recordId: string | number): string | null => {
       if (!base || !objectName || !routableObjects.has(objectName)) return null;
       const url = `${base}/${objectName}/record/${encodeURIComponent(String(recordId))}`;
@@ -296,13 +300,37 @@ export function RelatedRecordActionsBridge({
     [base, routableObjects, parentObjectName, parentRecordId, parentTitle],
   );
 
-  /** SPA-navigate to the destination {@link recordHref} addresses. */
+  /**
+   * The same destination as an HREF, for the lookup values rendered anywhere
+   * under this bridge (objectui#4336): a lookup points at a record of another
+   * object, and `LookupCellRenderer` has no router, so it asks for the href
+   * instead of re-deriving `/apps/:app/:object/record/:id` a second time (the
+   * #4472 lesson — one resolver).
+   *
+   * The browser reads an href, not the router, so it carries the router's
+   * basename (objectui#12233; see {@link documentHref}). The published
+   * contract offers it for "open in new tab" and "copy link address", and a
+   * console mounted at `/_console` used to hand out the bare route instead:
+   * only a plain left click, which `openRecord` routes, reached the record.
+   */
+  const recordHref = useCallback(
+    (objectName: string, recordId: string | number): string | null => {
+      const path = recordPath(objectName, recordId);
+      return path === null ? null : documentHref(routerRootHref, path);
+    },
+    [recordPath, routerRootHref],
+  );
+
+  /**
+   * SPA-navigate to the destination {@link recordHref} addresses — by its
+   * router path, because `navigate` applies the basename itself.
+   */
   const openRecord = useCallback(
     (objectName: string, recordId: string | number) => {
-      const href = recordHref(objectName, recordId);
-      if (href) navigate(href);
+      const path = recordPath(objectName, recordId);
+      if (path) navigate(path);
     },
-    [recordHref, navigate],
+    [recordPath, navigate],
   );
 
   // objectstack-ai/objectstack#2604 D3 — open a child create/edit task as the console's global record
@@ -425,7 +453,7 @@ export function RelatedRecordActionsBridge({
         };
         const handlers: RelatedRecordHandlers = {
           // Viewing a child record is always allowed when the list is visible.
-          // Same builder the lookup links use — `recordHref` above.
+          // Same route the lookup links address — `recordPath` above.
           onView: (id) => openRecord(objectName, id),
         };
 
 
@@ -38,6 +38,8 @@ vi.mock('react-router-dom', () => ({
   useParams: () => ({ pageName: PAGE_NAME }),
   useSearchParams: () => [new URLSearchParams(search), vi.fn()],
   useNavigate: () => vi.fn(),
+  // PageView reads the router's root href for its record navigator (objectui#12233).
+  useHref: () => '/',
   useLocation: () => ({ pathname: `/apps/cloud/page/${PAGE_NAME}`, search: search ? `?${search}` : '' }),
 }));
 
 
@@ -31,6 +31,8 @@ vi.mock('react-router-dom', () => ({
   useParams: () => ({ pageName: 'welcome' }),
   useSearchParams: () => [new URLSearchParams(), vi.fn()],
   useNavigate: () => vi.fn(),
+  // PageView reads the router's root href for its record navigator (objectui#12233).
+  useHref: () => '/',
   useLocation: () => ({ pathname: '/apps/cloud_control/page/welcome', search: '' }),
 }));
 
 
@@ -0,0 +1,128 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectui#12233 — a lookup on a custom page carries the router's basename,
+ * as the record page's lookups do.
+ *
+ * `PageView` publishes the console's record navigator to the blocks on the
+ * page (`pageRecordActionsValue`, objectui#11293), and a lookup there renders
+ * a real anchor from its `recordHref`. That builder returned the bare route
+ * `/apps/APP/OBJECT/record/ID`, so on a console mounted at `/_console` a new
+ * tab, a middle-click or a copied link left the console, while a left click
+ * (routed by `openRecord`) worked.
+ *
+ * The page, the router and the lookup are real: `PageView` under a
+ * `MemoryRouter`, and the real `LookupCellRenderer` reading the context the
+ * page publishes. `SchemaRenderer` is replaced by that one lookup, the stand-in
+ * the objectui#11293 pin beside this file uses for "a block on the page". The
+ * oracle for the href is react-router's own `Link` for the same route. The
+ * control mounts the same tree with no basename and keeps the bare href.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { Link, MemoryRouter, Route, Routes, useLocation } from 'react-router-dom';
+import '@testing-library/jest-dom';
+import { LookupCellRenderer } from '@object-ui/fields';
+
+const PAGE_NAME = 'the_page';
+const APP = 'crm';
+const ACCOUNT = { id: 'A-1', name: 'Acme Corp' };
+const ACCOUNT_ROUTE = `/apps/${APP}/account/record/${ACCOUNT.id}`;
+
+vi.mock('@object-ui/auth', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAuth: () => ({
+    user: { id: 'u1', name: 'User', role: 'user', image: null },
+    activeOrganization: null,
+  }),
+  useWorkspaceAdminStatus: () => ({ isAdmin: false, isResolved: true }),
+  createAuthenticatedFetch: () => vi.fn(),
+}));
+
+vi.mock('@object-ui/i18n', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useObjectTranslation: () => ({
+    t: (k: string, o?: { defaultValue?: string; name?: string }) => o?.defaultValue ?? o?.name ?? k,
+  }),
+}));
+
+vi.mock('../../providers/MetadataProvider', () => ({
+  useMetadata: () => ({
+    pages: [{ name: 'the_page', label: 'A Page', type: 'app' }],
+    objects: [{ name: 'account' }],
+  }),
+}));
+
+vi.mock('../MetadataInspector', () => ({
+  MetadataPanel: () => null,
+  useMetadataInspector: () => ({ showDebug: false }),
+}));
+
+vi.mock('@object-ui/react', async (orig) => {
+  const actual = await orig<typeof import('@object-ui/react')>();
+  return {
+    ...actual,
+    useAdapter: () => ({}),
+    // "A block on the page": one real lookup, reading the context PageView
+    // publishes.
+    SchemaRenderer: () => (
+      <LookupCellRenderer
+        value={{ id: 'A-1', name: 'Acme Corp' }}
+        field={{ type: 'lookup', reference: 'account' } as never}
+      />
+    ),
+  };
+});
+
+import { PageView } from '../PageView';
+
+afterEach(() => {
+  cleanup();
+});
+
+/** The router's own location, basename stripped: where a left click took us. */
+function RouterLocation() {
+  const location = useLocation();
+  return <output data-testid="router-location">{`${location.pathname}${location.search}`}</output>;
+}
+
+function mount(basename?: string) {
+  const root = basename ?? '';
+  return render(
+    <MemoryRouter basename={basename} initialEntries={[`${root}/apps/${APP}/page/${PAGE_NAME}`]}>
+      <Routes>
+        <Route path="/apps/:appName/page/:pageName" element={<PageView />} />
+        <Route path="*" element={null} />
+      </Routes>
+      <Link to={ACCOUNT_ROUTE} data-testid="oracle">
+        oracle
+      </Link>
+      <RouterLocation />
+    </MemoryRouter>,
+  );
+}
+
+const accountAnchor = async () => (await screen.findByText(ACCOUNT.name)).closest('a');
+
+describe('a lookup on a custom page carries the router basename (objectui#12233)', () => {
+  it('under basename /_console: the href is the one react-router renders for the route, and a left click routes there once', async () => {
+    mount('/_console');
+    const anchor = await accountAnchor();
+    const href = anchor?.getAttribute('href') ?? null;
+    expect(href).toBe(`/_console${ACCOUNT_ROUTE}`);
+    expect(href).toBe(screen.getByTestId('oracle').getAttribute('href'));
+    fireEvent.click(anchor as Element, { button: 0 });
+    expect(screen.getByTestId('router-location').textContent).toBe(ACCOUNT_ROUTE);
+  });
+
+  it('control, no basename: the href is the bare route, as before', async () => {
+    mount();
+    const anchor = await accountAnchor();
+    expect(anchor?.getAttribute('href')).toBe(ACCOUNT_ROUTE);
+    expect(anchor?.getAttribute('href')).toBe(screen.getByTestId('oracle').getAttribute('href'));
+    fireEvent.click(anchor as Element, { button: 0 });
+    expect(screen.getByTestId('router-location').textContent).toBe(ACCOUNT_ROUTE);
+  });
+});
@@ -34,6 +34,9 @@ vi.mock('react-router-dom', () => ({
   useParams: () => ({ pageName: PAGE_NAME }),
   useSearchParams: () => [new URLSearchParams(), vi.fn()],
   useNavigate: () => navigate,
+  // The router's root href, which the page's navigator joins its hrefs to
+  // (objectui#12233). `/` is a root mount; the basename case is below.
+  useHref: () => '/',
   useLocation: () => ({ pathname: `/apps/crm/page/${PAGE_NAME}`, search: '' }),
 }));
 
@@ -115,20 +118,29 @@ describe('pageRecordActionsValue — the builder the page publishes', () => {
   const objects = [{ name: 'account' }, { name: '' }, null, { label: 'nameless' }];
 
   it('addresses a routable object under the app route', () => {
-    const value = pageRecordActionsValue('crm', objects, vi.fn());
+    const value = pageRecordActionsValue('crm', objects, vi.fn(), '/');
     expect(value.recordHref!('account', 7)).toBe('/apps/crm/account/record/7');
   });
 
+  it('under a basename, `recordHref` is the document href and `openRecord` still navigates by the router path (objectui#12233)', () => {
+    const go = vi.fn();
+    const value = pageRecordActionsValue('crm', objects, go, '/_console');
+    expect(value.recordHref!('account', 'a/b')).toBe('/_console/apps/crm/account/record/a%2Fb');
+    value.openRecord!('account', 'a/b');
+    expect(go).toHaveBeenCalledWith('/apps/crm/account/record/a%2Fb');
+    expect(value.recordHref!('contact', 7)).toBeNull();
+  });
+
   it('answers null outside an app route, for an unknown object, and for an empty id', () => {
-    expect(pageRecordActionsValue(undefined, objects, vi.fn()).recordHref!('account', 7)).toBeNull();
-    const value = pageRecordActionsValue('crm', objects, vi.fn());
+    expect(pageRecordActionsValue(undefined, objects, vi.fn(), '/').recordHref!('account', 7)).toBeNull();
+    const value = pageRecordActionsValue('crm', objects, vi.fn(), '/');
     expect(value.recordHref!('contact', 7)).toBeNull();
     expect(value.recordHref!('account', '')).toBeNull();
   });
 
   it('`openRecord` navigates to exactly the `recordHref` destination, and to nothing without one', () => {
     const go = vi.fn();
-    const value = pageRecordActionsValue('crm', objects, go);
+    const value = pageRecordActionsValue('crm', objects, go, '/');
     value.openRecord!('account', 'a/b');
     expect(go).toHaveBeenCalledWith(value.recordHref!('account', 'a/b'));
     expect(go).toHaveBeenCalledWith('/apps/crm/account/record/a%2Fb');
 
@@ -22,6 +22,8 @@ vi.mock('react-router-dom', () => ({
   useParams: () => ({ pageName: 'home' }),
   useSearchParams: () => [new URLSearchParams(), vi.fn()],
   useNavigate: () => vi.fn(),
+  // PageView reads the router's root href for its record navigator (objectui#12233).
+  useHref: () => '/',
   useLocation: () => ({ pathname: '/apps/cloud/page/home', search: '' }),
 }));