From 1a00c21bacba7ebfb51a163edf62dec849da1ed7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 16 Oct 2026 14:20:55 +0000
Subject: [PATCH] feat(app-shell): console lists link names that point at
 another object

The list host's record-URL builder answered the listed object only, so a
lookup cell or a record-pointer cell naming another object's record drew a
name that could not be opened. It now answers any routable object through
the record page's own builder (appRecordPath over routableObjectNames,
exported by RelatedRecordActionsBridge), as a document href carrying the
router basename, with in-app navigation on a plain click and no from-trail
(a list page has no parent record). The listed object keeps its own route.

Claude-Session: https://claude.ai/code/session_01CrvmqMe8FLB3kXU3NHq25T
Co-authored-by: Claude <noreply@anthropic.com>
---
 .changeset/12673-list-cross-object-links.md   |  12 +
 ...ectView.listCrossObjectHost-12673.test.tsx | 218 +++++++++++++++
 .../views/ObjectView.listRecordHref.test.ts   |  76 ++++-
 packages/app-shell/src/views/ObjectView.tsx   |  88 ++++--
 .../src/views/RelatedRecordActionsBridge.tsx  |  47 +++-
 .../listCrossObjectCells-12673.test.tsx       | 263 ++++++++++++++++++
 6 files changed, 672 insertions(+), 32 deletions(-)
 create mode 100644 .changeset/12673-list-cross-object-links.md
 create mode 100644 packages/app-shell/src/views/ObjectView.listCrossObjectHost-12673.test.tsx
 create mode 100644 packages/app-shell/src/views/__tests__/listCrossObjectCells-12673.test.tsx

diff --git a/.changeset/12673-list-cross-object-links.md b/.changeset/12673-list-cross-object-links.md
new file mode 100644
index 0000000000..2b35ad4dfc
--- /dev/null
+++ b/.changeset/12673-list-cross-object-links.md
@@ -0,0 +1,12 @@
+---
+'@object-ui/app-shell': patch
+---
+
+Console lists link names that point at another object's record, the way the record page does (objectui#12673).
+
+In an object list, a lookup value (an opportunity's account) and a record-pointer value (the record an approval request is about) showed the target record's name but could not be opened: the list page built record links for the listed object only. The list page now builds them with the record page's own builder, so these names link to `/apps/APP/OBJECT/record/ID` in the current app. A plain click opens the record in the console; ⌘-click, Ctrl-click or a middle click opens it in a new tab, and the copied link carries the console's base path.
+
+- A click elsewhere on the row still opens the row's own record.
+- A target the viewer cannot read, or that no longer exists, keeps its "record unavailable" face and draws no link.
+- An object this console has no route to stays plain text.
+- The record page's links, including their way back to the parent record, are unchanged. A list page has no parent record, so links opened from a list carry no way-back entry.
diff --git a/packages/app-shell/src/views/ObjectView.listCrossObjectHost-12673.test.tsx b/packages/app-shell/src/views/ObjectView.listCrossObjectHost-12673.test.tsx
new file mode 100644
index 0000000000..4be088b961
--- /dev/null
+++ b/packages/app-shell/src/views/ObjectView.listCrossObjectHost-12673.test.tsx
@@ -0,0 +1,218 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectui#12673 — the real `ObjectView` publishes, to everything its list
+ * renders, a record-URL builder that answers ANY routable object, and it is
+ * the record page's builder: the same route the record page's
+ * `RelatedRecordActionsBridge` hands its lookups, minus the `?from=` trail a
+ * list page has no parent record for.
+ *
+ * The list body is a probe (the `ObjectView.listLinksPlural-11733` harness)
+ * that reads `recordHref` / `openRecord` off the context the page publishes,
+ * so what is pinned is the page's wiring, under a router mounted at
+ * `/_console`. The cells that consume it are pinned with the real grid in
+ * `__tests__/listCrossObjectCells-12673.test.tsx`.
+ *
+ * CONTROL: the record page's bridge, mounted on the same objects, keeps its
+ * `?from=` trail and its answer for an unroutable object.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, cleanup, screen, fireEvent } from '@testing-library/react';
+import { MemoryRouter, Routes, Route, useLocation } from 'react-router-dom';
+import { useRelatedRecordActions } from '@object-ui/react';
+
+vi.mock('@object-ui/permissions', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@object-ui/permissions')>();
+  const perms = {
+    check: () => ({ allowed: true }),
+    checkField: () => true,
+    getFieldPermissions: () => [],
+    getRowFilter: () => undefined,
+    getObjectApiOperations: () => undefined,
+    roles: [],
+    isLoaded: false,
+    hasCapabilities: () => true,
+    can: () => true,
+    cannot: () => false,
+  };
+  const fieldPerms = { canRead: () => true, canWrite: () => true, permissions: [] };
+  return { ...actual, usePermissions: () => perms, useFieldPermissions: () => fieldPerms };
+});
+
+vi.mock('@object-ui/auth', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAuth: () => ({ user: { id: 'u1', name: 'Ada' }, activeOrganization: null }),
+  useWorkspaceAdminStatus: () => ({ isAdmin: false, isResolved: true }),
+  createAuthenticatedFetch: () => vi.fn(),
+}));
+
+vi.mock('@object-ui/collaboration', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useRealtimeSubscription: () => ({ lastMessage: null }),
+  useConflictResolution: () => ({ hasConflicts: false, resolveAllConflicts: () => {} }),
+}));
+
+vi.mock('sonner', () => ({
+  toast: Object.assign(vi.fn(), {
+    success: vi.fn(), error: vi.fn(), info: vi.fn(),
+    warning: vi.fn(), loading: vi.fn(), dismiss: vi.fn(),
+  }),
+}));
+
+/** What the probe reads off the page's record-link context. */
+function HrefProbe({ objectName, recordId, testId }: { objectName: string; recordId: string; testId: string }) {
+  const host = useRelatedRecordActions();
+  return (
+    <>
+      <output data-testid={`${testId}-href`}>{host?.recordHref?.(objectName, recordId) ?? '(null)'}</output>
+      <button type="button" data-testid={`${testId}-open`} onClick={() => host?.openRecord?.(objectName, recordId)} />
+    </>
+  );
+}
+
+vi.mock('@object-ui/plugin-view', async (importOriginal) => {
+  const ListProbe = () => (
+    <>
+      <HrefProbe objectName="crm_account" recordId="acc-1" testId="account" />
+      <HrefProbe objectName="legacy_ledger" recordId="led-1" testId="ledger" />
+    </>
+  );
+  return {
+    ...(await importOriginal<Record<string, unknown>>()),
+    ObjectView: ListProbe,
+    ViewTabBar: () => null,
+    ManageViewsDialog: () => null,
+  };
+});
+
+vi.mock('./MetadataInspector', () => ({
+  MetadataPanel: () => null,
+  useMetadataInspector: () => ({ showDebug: false, toggle: () => {} }),
+}));
+vi.mock('./RecordDetailView', () => ({ RecordDetailView: () => null }));
+
+import { ObjectView } from './ObjectView';
+import { RelatedRecordActionsBridge } from './RelatedRecordActionsBridge';
+import { ExpressionProvider } from '../providers/ExpressionProvider';
+
+const BASENAME = '/_console';
+const FIELDS = { id: { type: 'text', label: 'Id' }, name: { type: 'text', label: 'Name' } };
+const LIST_VIEW = { grid: { type: 'grid', label: 'All', columns: ['name'] } };
+/** The console's object definitions; `legacy_ledger` is not among them. */
+const OBJECTS = [
+  { name: 'crm_opportunity', label: 'Opportunity', fields: FIELDS, listViews: LIST_VIEW },
+  { name: 'crm_account', label: 'Account', fields: FIELDS, listViews: LIST_VIEW },
+];
+
+/** The record route: where an in-app open landed. */
+function LandedProbe() {
+  const location = useLocation();
+  return <div data-testid="landed">{`${location.pathname}${location.search}`}</div>;
+}
+
+beforeEach(() => {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(async () =>
+      new Response(JSON.stringify({ data: [] }), { status: 200, headers: { 'content-type': 'application/json' } }),
+    ),
+  );
+});
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+});
+
+async function mountList(): Promise<void> {
+  const dataSource = {
+    find: vi.fn(async () => ({ data: [], total: 0 })),
+    findOne: vi.fn(async () => null),
+    create: vi.fn(async () => ({})),
+    update: vi.fn(async () => ({})),
+    delete: vi.fn(async () => ({})),
+  } as never;
+  render(
+    <ExpressionProvider user={{ id: 'u1', name: 'Ada', profile: 'user' }}>
+      <MemoryRouter basename={BASENAME} initialEntries={[`${BASENAME}/apps/hotcrm/crm_opportunity`]}>
+        <Routes>
+          <Route
+            path="/apps/:appName/:objectName"
+            element={<ObjectView dataSource={dataSource} objects={OBJECTS} onEdit={() => {}} />}
+          />
+          <Route path="/apps/:appName/:objectName/record/:recordId" element={<LandedProbe />} />
+        </Routes>
+      </MemoryRouter>
+    </ExpressionProvider>,
+  );
+  await screen.findByTestId('account-href', {}, { timeout: 5000 });
+}
+
+function mountRecordPageBridge() {
+  render(
+    <MemoryRouter basename={BASENAME} initialEntries={[`${BASENAME}/apps/hotcrm/crm_opportunity/record/opp-1`]}>
+      <RelatedRecordActionsBridge
+        appName="hotcrm"
+        objects={OBJECTS}
+        dataSource={null}
+        parentObjectName="crm_opportunity"
+        parentRecordId="opp-1"
+        parentTitle="Globex Manufacturing Suite"
+      >
+        <HrefProbe objectName="crm_account" recordId="acc-1" testId="account" />
+        <HrefProbe objectName="legacy_ledger" recordId="led-1" testId="ledger" />
+      </RelatedRecordActionsBridge>
+    </MemoryRouter>,
+  );
+}
+
+const text = (testId: string) => screen.getByTestId(testId).textContent ?? '';
+
+describe('ObjectView publishes the record page builder to its list (objectui#12673)', () => {
+  it('another routable object: the href carries the basename and the app, with no `?from=` trail', async () => {
+    await mountList();
+    expect(text('account-href')).toBe('/_console/apps/hotcrm/crm_account/record/acc-1');
+  });
+
+  it('another routable object: a left click opens that record in-app', async () => {
+    await mountList();
+    fireEvent.click(screen.getByTestId('account-open'));
+    expect(text('landed')).toBe('/apps/hotcrm/crm_account/record/acc-1');
+  });
+
+  it('an object the console cannot route to: no href, and opening it goes nowhere', async () => {
+    await mountList();
+    expect(text('ledger-href')).toBe('(null)');
+    fireEvent.click(screen.getByTestId('ledger-open'));
+    expect(screen.queryByTestId('landed')).toBeNull();
+  });
+
+  it('one builder: the list page addresses the same route the record page does', async () => {
+    await mountList();
+    const fromList = text('account-href');
+    cleanup();
+    mountRecordPageBridge();
+    expect(text('account-href').split('?')[0]).toBe(fromList);
+  });
+});
+
+describe('CONTROL — the record page links are unchanged (objectui#12673)', () => {
+  it('the record page keeps its `?from=` trail for the parent record', () => {
+    mountRecordPageBridge();
+    const href = text('account-href');
+    expect(href.startsWith('/_console/apps/hotcrm/crm_account/record/acc-1?from=')).toBe(true);
+  });
+
+  it('the record page still answers no href for an object it cannot route to', () => {
+    mountRecordPageBridge();
+    expect(text('ledger-href')).toBe('(null)');
+  });
+});
diff --git a/packages/app-shell/src/views/ObjectView.listRecordHref.test.ts b/packages/app-shell/src/views/ObjectView.listRecordHref.test.ts
index 63db8415e2..7ead7977ec 100644
--- a/packages/app-shell/src/views/ObjectView.listRecordHref.test.ts
+++ b/packages/app-shell/src/views/ObjectView.listRecordHref.test.ts
@@ -34,7 +34,7 @@
  */
 import { describe, it, expect, vi } from 'vitest';
 
-import { listRecordDetailUrl, listRecordActionsValue } from './ObjectView';
+import { listRecordDetailUrl, listRecordActionsValue, type ListRecordRoutes } from './ObjectView';
 
 describe('listRecordDetailUrl — one record-route shape for the list surface (#4490)', () => {
   it('strips the trailing view segment and appends the record route', () => {
@@ -70,12 +70,13 @@ describe('listRecordActionsValue — what the list page publishes (#4490)', () =
     expect(value.recordHref!('crm_lead', 'r1')).toBe('/apps/demo/crm_lead/record/r1');
   });
 
-  it('publishes NO href for any other object — this builder cannot name one', () => {
+  it('without the console routes, publishes NO href for any other object', () => {
     const value = listRecordActionsValue('crm_lead', vi.fn(), pathname);
-    // A lookup cell pointing at a third object must render as the plain value,
-    // which is what `null` means to the consumer. The console-wide builder is
-    // the detail page's bridge, which has the routable-object set this page
-    // does not — inventing a URL here is exactly the #4472 mistake.
+    // With no routable-object set there is nothing to build another object's
+    // route from, so a lookup cell pointing at a third object renders as the
+    // plain value, which is what `null` means to the consumer. Inventing a URL
+    // here is exactly the #4472 mistake; `ObjectView` passes the routes
+    // (objectui#12673, pinned below).
     expect(value.recordHref!('crm_account', 'acc-1')).toBeNull();
   });
 
@@ -122,3 +123,66 @@ describe('listRecordActionsValue — what the list page publishes (#4490)', () =
     );
   });
 });
+
+describe('listRecordActionsValue — any routable object, through the record page builder (objectui#12673)', () => {
+  const pathname = () => '/_console/apps/demo/crm_lead/view/all';
+  const routes = (over: Partial<ListRecordRoutes> = {}): ListRecordRoutes => ({
+    appName: 'demo',
+    objects: [{ name: 'crm_lead' }, { name: 'crm_account' }, { name: 'sys_approval_request' }],
+    navigate: vi.fn(),
+    routerRootHref: '/_console/',
+    ...over,
+  });
+
+  it('publishes the document href of another routable object: basename, app, object, encoded id', () => {
+    const value = listRecordActionsValue('crm_lead', vi.fn(), pathname, routes());
+    expect(value.recordHref!('crm_account', 'a/1')).toBe('/_console/apps/demo/crm_account/record/a%2F1');
+  });
+
+  it('adds no `?from=` trail: a list page has no parent record', () => {
+    const value = listRecordActionsValue('crm_lead', vi.fn(), pathname, routes());
+    expect(value.recordHref!('crm_account', 'acc-1')).not.toContain('?');
+  });
+
+  it('openRecord navigates by the ROUTER path (the router applies its basename)', () => {
+    const r = routes();
+    const openPage = vi.fn();
+    const value = listRecordActionsValue('crm_lead', openPage, pathname, r);
+    value.openRecord!('crm_account', 'acc-1');
+    expect(r.navigate).toHaveBeenCalledTimes(1);
+    expect(r.navigate).toHaveBeenCalledWith('/apps/demo/crm_account/record/acc-1');
+    // Another object's record is not the listed object's record page.
+    expect(openPage).not.toHaveBeenCalled();
+  });
+
+  it('an object the console cannot route to: no href, and openRecord does nothing', () => {
+    const r = routes();
+    const value = listRecordActionsValue('crm_lead', vi.fn(), pathname, r);
+    expect(value.recordHref!('legacy_ledger', 'x-1')).toBeNull();
+    value.openRecord!('legacy_ledger', 'x-1');
+    expect(r.navigate).not.toHaveBeenCalled();
+  });
+
+  it('no app segment: no href for another object', () => {
+    const value = listRecordActionsValue('crm_lead', vi.fn(), pathname, routes({ appName: undefined }));
+    expect(value.recordHref!('crm_account', 'acc-1')).toBeNull();
+  });
+
+  it('a record with no id: no href, and openRecord does nothing', () => {
+    const r = routes();
+    const value = listRecordActionsValue('crm_lead', vi.fn(), pathname, r);
+    expect(value.recordHref!('crm_account', '')).toBeNull();
+    value.openRecord!('crm_account', '');
+    expect(r.navigate).not.toHaveBeenCalled();
+  });
+
+  it('the listed object keeps its own route and its own record navigation (control)', () => {
+    const r = routes();
+    const openPage = vi.fn();
+    const value = listRecordActionsValue('crm_lead', openPage, pathname, r);
+    expect(value.recordHref!('crm_lead', 'r1')).toBe('/_console/apps/demo/crm_lead/record/r1');
+    value.openRecord!('crm_lead', 'r1');
+    expect(openPage).toHaveBeenCalledWith('r1');
+    expect(r.navigate).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/app-shell/src/views/ObjectView.tsx b/packages/app-shell/src/views/ObjectView.tsx
index 887d98dda1..337ff5a5cc 100644
--- a/packages/app-shell/src/views/ObjectView.tsx
+++ b/packages/app-shell/src/views/ObjectView.tsx
@@ -10,7 +10,7 @@
  */
 
 import { useMemo, useState, useCallback, useEffect, useRef, lazy, Suspense, createElement, type ComponentType } from 'react';
-import { useParams, useSearchParams, useNavigate, useLocation } from 'react-router-dom';
+import { useParams, useSearchParams, useNavigate, useLocation, useHref } from 'react-router-dom';
 import { resolveFilterPlaceholders, DENSITY_MODE_TO_ROW_HEIGHT, normalizeListViewSchema, leadWithNameField, resolveAffordance, isRecordScopedAction, type FilterTokenScope, type SchemaLike } from '@object-ui/core';
 import {
     parseUserFilterParams,
@@ -76,6 +76,8 @@ import { useMobileViewSwitcherRegistration } from '../layout/MobileViewSwitcherC
 import type { MobileViewSwitcherItem } from '../layout/MobileViewSwitcherContext.js';
 import { ManagedByBadge } from '../components/ManagedByBadge.js';
 import { RecordDetailView } from './RecordDetailView.js';
+import { appRecordPath, routableObjectNames } from './RelatedRecordActionsBridge.js';
+import { documentHref } from './documentHref.js';
 import type { RowCrudPredicates } from '../utils/crudAffordances.js';
 import { createIdentityImportDataSource, IDENTITY_IMPORT_OBJECT, type IdentityPasswordPolicy } from './identityImport.js';
 import { IdentityImportOptions, IdentityImportResultExtra, identityImportFields } from './IdentityImportPanels.js';
@@ -623,7 +625,7 @@ const NO_RELATED_HANDLERS: RelatedRecordHandlers = Object.freeze({});
  * pair here, so `LinkCell` can render a real anchor without knowing anything
  * about routes — one mechanism, all three surfaces.
  *
- * Two deliberate limits:
+ * One deliberate limit:
  *
  *  - **`resolve` returns no handlers.** This surface has no related lists — a
  *    list page's rows are not a child collection — so there is nothing to
@@ -631,13 +633,24 @@ const NO_RELATED_HANDLERS: RelatedRecordHandlers = Object.freeze({});
  *    "capability unavailable", i.e. the same read-only outcome a consumer gets
  *    with no provider at all, so nothing that renders under this page gains an
  *    affordance it did not have.
- *  - **`recordHref` addresses THIS view's object only.** {@link
- *    listRecordDetailUrl} is derived from the current list's pathname, so it
- *    can only name records of the object being listed; any other object is
- *    `null`, which consumers must render as the plain value (a lookup cell
- *    pointing at a third object stays exactly as it renders today). The
- *    console-wide, any-object builder lives on the detail page's bridge, which
- *    has the routable-object set this page does not.
+ *
+ * **Any routable object, through the record page's builder (objectui#12673).**
+ * A lookup cell or a record-pointer (`referenceVia`) cell names a record of
+ * ANOTHER object, and the list used to answer `null` for it, so the name was
+ * readable and could not be opened. With `routes` the list now answers those
+ * the way the record page's `RelatedRecordActionsBridge` does, through the
+ * same builder (`appRecordPath` over `routableObjectNames`, both exported by
+ * the bridge): `/apps/:app/:object/record/:id`, published as a document href
+ * (`documentHref`) so a new tab or a copied link carries the router's
+ * basename, and navigated by its router path on a plain click. A list page
+ * has no parent record, so no `?from=` trail entry is added. An object this
+ * console cannot route to still answers `null`, which consumers render as the
+ * plain value, so no link points at a page that would refuse.
+ *
+ * The listed object itself keeps its own route: {@link listRecordDetailUrl}
+ * derived from the current pathname, opened through the page's own record
+ * navigation (which carries the list as the record's origin). Without
+ * `routes`, only that object is addressable, as before.
  *
  * `pathname` is read at CALL time (not captured) so a view switch or a drill-in
  * cannot leave a stale base behind — the same freshness rule the bridge's
@@ -649,22 +662,50 @@ export function listRecordActionsValue(
     objectName: string,
     openRecordPage: (recordId: string | number) => void,
     getPathname: () => string = () => window.location.pathname,
+    routes?: ListRecordRoutes,
 ): RelatedRecordActionsValue {
-    const addressable = (targetObjectName: string, recordId: string | number) =>
-        targetObjectName === objectName && recordId != null && recordId !== '';
+    const hasId = (recordId: string | number) => recordId != null && recordId !== '';
+    const routable = routes ? routableObjectNames(routes.objects) : null;
+    /** The router path of another object's record, or `null` when unroutable. */
+    const otherRecordPath = (targetObjectName: string, recordId: string | number): string | null =>
+        routes && routable && targetObjectName !== objectName && hasId(recordId)
+            ? appRecordPath(routes.appName, routable, targetObjectName, recordId)
+            : null;
     return {
         resolve: () => NO_RELATED_HANDLERS,
-        recordHref: (targetObjectName, recordId) =>
-            addressable(targetObjectName, recordId)
-                ? listRecordDetailUrl(getPathname(), recordId)
-                : null,
+        recordHref: (targetObjectName, recordId) => {
+            if (targetObjectName === objectName) {
+                return hasId(recordId) ? listRecordDetailUrl(getPathname(), recordId) : null;
+            }
+            const path = otherRecordPath(targetObjectName, recordId);
+            return routes && path !== null ? documentHref(routes.routerRootHref, path) : null;
+        },
         openRecord: (targetObjectName, recordId) => {
-            if (!addressable(targetObjectName, recordId)) return;
-            openRecordPage(recordId);
+            if (targetObjectName === objectName) {
+                if (hasId(recordId)) openRecordPage(recordId);
+                return;
+            }
+            const path = otherRecordPath(targetObjectName, recordId);
+            if (path !== null) routes?.navigate(path);
         },
     };
 }
 
+/**
+ * What {@link listRecordActionsValue} needs to address records of objects other
+ * than the listed one: the inputs the record page's bridge reads (objectui#12673).
+ */
+export interface ListRecordRoutes {
+    /** The current app segment (`/apps/:appName/...`); no app, no route. */
+    appName: string | undefined;
+    /** The console's object definitions; their names are the routable set. */
+    objects: ReadonlyArray<unknown>;
+    /** SPA navigation by router path (the router applies its basename). */
+    navigate: (to: string) => void;
+    /** `useHref('/')`: the router's root href, basename included. */
+    routerRootHref: string;
+}
+
 export function defaultListColumnsFromObject(
     objectDef: any,
     limit = 5,
@@ -1415,6 +1456,9 @@ export function ObjectView({ dataSource, objects, onEdit, externalRefreshKey }:
  */
 function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: ConsoleObjectViewProps) {
     const navigate = useNavigate();
+    // The router's root href, basename included: the join every console host
+    // publishing `recordHref` uses (`documentHref`, objectui#12233).
+    const routerRootHref = useHref('/');
     const { appName, objectName, viewId } = useParams();
     const [searchParams, setSearchParams] = useSearchParams();
     const location = useLocation();
@@ -2782,8 +2826,14 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
      * nearer provider keeps owning the detail surface, exactly as before.
      */
     const listRecordActions = useMemo(
-        () => listRecordActionsValue(objectDef.name, handleNavOverlayNavigate),
-        [objectDef.name, handleNavOverlayNavigate],
+        () =>
+            listRecordActionsValue(objectDef.name, handleNavOverlayNavigate, undefined, {
+                appName,
+                objects,
+                navigate,
+                routerRootHref,
+            }),
+        [objectDef.name, handleNavOverlayNavigate, appName, objects, navigate, routerRootHref],
     );
     const navOverlay = useNavigationOverlay({
         navigation: detailNavigation,
diff --git a/packages/app-shell/src/views/RelatedRecordActionsBridge.tsx b/packages/app-shell/src/views/RelatedRecordActionsBridge.tsx
index 0a115e7038..2e3063a76a 100644
--- a/packages/app-shell/src/views/RelatedRecordActionsBridge.tsx
+++ b/packages/app-shell/src/views/RelatedRecordActionsBridge.tsx
@@ -138,6 +138,42 @@ function evalCreatePredicate(
   });
 }
 
+/**
+ * The names of the objects a console host can route to: one record route
+ * exists per object definition it holds (objectui#12673).
+ *
+ * Shared by this bridge and the object list host (`listRecordActionsValue` in
+ * `ObjectView`), which both read the console's `objects` prop, so the two
+ * cannot disagree on which targets are linkable.
+ */
+export function routableObjectNames(objects: ReadonlyArray<unknown> | null | undefined): Set<string> {
+  return new Set(
+    (objects ?? [])
+      .map((o) => (o as { name?: unknown } | null | undefined)?.name)
+      .filter((name): name is string => typeof name === 'string' && name !== ''),
+  );
+}
+
+/**
+ * THE record-detail route shape, as a ROUTER path (no basename):
+ * `/apps/:app/:object/record/:id` (objectui#12673).
+ *
+ * `null` when the host cannot route there: no app segment, or an object that
+ * is not in this console's metadata. Consumers render `null` as the plain
+ * value, so a non-routable target never yields a link to a page that would
+ * refuse. The record page's bridge adds its `?from=` trail on top; the list
+ * host, which has no parent record, uses it as is.
+ */
+export function appRecordPath(
+  appName: string | undefined,
+  routableObjects: ReadonlySet<string>,
+  objectName: string,
+  recordId: string | number,
+): string | null {
+  if (!appName || !objectName || !routableObjects.has(objectName)) return null;
+  return `/apps/${appName}/${objectName}/record/${encodeURIComponent(String(recordId))}`;
+}
+
 export interface RelatedRecordActionsBridgeProps {
   /** Current app segment used to build `/apps/:appName/...` routes. */
   appName?: string;
@@ -258,10 +294,7 @@ export function RelatedRecordActionsBridge({
   const hasParentRecord = parentRecordId != null && parentRecordId !== '';
 
   /** Objects this host can route to — the record route exists per object def. */
-  const routableObjects = useMemo(
-    () => new Set((objects ?? []).map((o: any) => o?.name).filter(Boolean)),
-    [objects],
-  );
+  const routableObjects = useMemo(() => routableObjectNames(objects), [objects]);
 
   /**
    * THE record-detail route for this page — one route shape, one place.
@@ -277,8 +310,8 @@ export function RelatedRecordActionsBridge({
    */
   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))}`;
+      const url = appRecordPath(appName, routableObjects, objectName, recordId);
+      if (url === null) return null;
       // Carry the parent record into the target's `?from=` trail so the
       // breadcrumb (and the record body's back link) can path back up.
       // Read the current trail off the live URL — this bridge outlives a
@@ -297,7 +330,7 @@ export function RelatedRecordActionsBridge({
       }
       return url;
     },
-    [base, routableObjects, parentObjectName, parentRecordId, parentTitle],
+    [appName, routableObjects, parentObjectName, parentRecordId, parentTitle],
   );
 
   /**
diff --git a/packages/app-shell/src/views/__tests__/listCrossObjectCells-12673.test.tsx b/packages/app-shell/src/views/__tests__/listCrossObjectCells-12673.test.tsx
new file mode 100644
index 0000000000..9094fd615c
--- /dev/null
+++ b/packages/app-shell/src/views/__tests__/listCrossObjectCells-12673.test.tsx
@@ -0,0 +1,263 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectui#12673 — in a console list, a name that points at ANOTHER object's
+ * record opens that record, the way the record page's names do.
+ *
+ * The list host (`listRecordActionsValue`) used to answer `recordHref` for the
+ * listed object only, so a lookup cell (an opportunity's account) and a
+ * record-pointer cell (`referenceVia`: an approval request's record) drew a
+ * name that could not be opened. It now answers any routable object through
+ * the record page's builder (`appRecordPath` over `routableObjectNames`).
+ *
+ * Each case mounts what the list page mounts around its grid: the real
+ * `listRecordActionsValue` (fed by the router's own `navigate` and
+ * `useHref('/')`, as `ObjectView` feeds it) under a router mounted at
+ * `/_console`, over the real `ObjectGrid` and the real cell renderers. The
+ * oracle for every href is react-router's own `Link` for the same route, so
+ * the pin does not restate how a basename is joined.
+ *
+ * The click areas (the card's second measurement): a link in a cell owns its
+ * text only; a click anywhere else on the row still opens the row's own record.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { Link, MemoryRouter, useHref, useLocation, useNavigate } from 'react-router-dom';
+import '@testing-library/jest-dom';
+import { ActionProvider, RelatedRecordActionsProvider } from '@object-ui/react';
+import { registerAllFields } from '@object-ui/fields';
+import { ObjectGrid } from '@object-ui/plugin-grid';
+
+import { listRecordActionsValue } from '../ObjectView';
+
+registerAllFields();
+
+afterEach(() => {
+  cleanup();
+});
+
+const APP = 'hotcrm';
+const BASENAME = '/_console';
+
+const OPPORTUNITY_DEF = {
+  name: 'crm_opportunity',
+  label: 'Opportunity',
+  icon: 'briefcase',
+  nameField: 'name',
+  fields: {
+    name: { name: 'name', type: 'text', label: 'Name' },
+    stage: { name: 'stage', type: 'text', label: 'Stage' },
+    account: { name: 'account', type: 'lookup', label: 'Account', reference: 'crm_account' },
+    ledger: { name: 'ledger', type: 'lookup', label: 'Ledger', reference: 'legacy_ledger' },
+  },
+};
+
+const REQUEST_DEF = {
+  name: 'sys_approval_request',
+  label: 'Approval Request',
+  fields: {
+    process_name: { name: 'process_name', type: 'text', label: 'Source' },
+    object_name: { name: 'object_name', type: 'text', label: 'Object' },
+    record_id: { name: 'record_id', type: 'text', label: 'Record ID', referenceVia: 'object_name' },
+  },
+};
+
+const ACCOUNT_DEF = { name: 'crm_account', label: 'Account', nameField: 'name', fields: { name: { name: 'name', type: 'text' } } };
+
+/**
+ * The console's object definitions: the routable set. `legacy_ledger` is
+ * deliberately absent, so the console cannot route to it.
+ */
+const CONSOLE_OBJECTS = [OPPORTUNITY_DEF, REQUEST_DEF, ACCOUNT_DEF];
+
+const OPPORTUNITIES = [
+  { id: 'opp-1', name: 'Globex Manufacturing Suite' },
+  { id: 'opp-2', name: 'Acme renewal' },
+];
+
+function makeDataSource() {
+  const find = vi.fn(async (objectName: string, params?: any) => {
+    if (objectName !== 'crm_opportunity') return { data: [] };
+    const wanted: string[] = params?.$filter?.id?.$in ?? [];
+    return { data: OPPORTUNITIES.filter((r) => wanted.includes(r.id)) };
+  });
+  const getObjectSchema = vi.fn(async (objectName: string) => {
+    const def = CONSOLE_OBJECTS.find((o) => o.name === objectName);
+    if (!def) throw new Error('unknown object');
+    return def;
+  });
+  return { find, getObjectSchema, findOne: vi.fn(async () => null) } as any;
+}
+
+/** The router's own location, basename stripped: where a click took us. */
+function RouterLocation() {
+  const location = useLocation();
+  return <output data-testid="router-location">{location.pathname}</output>;
+}
+
+/** What `ObjectView` mounts around its grid, fed the way `ObjectView` feeds it. */
+function ListHost({
+  listedObject,
+  openRecordPage,
+  children,
+}: {
+  listedObject: string;
+  openRecordPage: (recordId: string | number) => void;
+  children: React.ReactNode;
+}) {
+  const navigate = useNavigate();
+  const routerRootHref = useHref('/');
+  const value = listRecordActionsValue(
+    listedObject,
+    openRecordPage,
+    () => `${BASENAME}/apps/${APP}/${listedObject}`,
+    { appName: APP, objects: CONSOLE_OBJECTS, navigate, routerRootHref },
+  );
+  return <RelatedRecordActionsProvider value={value}>{children}</RelatedRecordActionsProvider>;
+}
+
+function mountGrid(opts: {
+  objectName: string;
+  columns: string[];
+  rows: Array<Record<string, unknown>>;
+  onRowClick?: (record: any) => void;
+  openRecordPage?: (recordId: string | number) => void;
+}) {
+  const schema: any = {
+    type: 'object-grid' as const,
+    objectName: opts.objectName,
+    columns: opts.columns,
+    data: { provider: 'value', items: opts.rows },
+  };
+  return render(
+    <MemoryRouter basename={BASENAME} initialEntries={[`${BASENAME}/apps/${APP}/${opts.objectName}`]}>
+      <ActionProvider>
+        <ListHost listedObject={opts.objectName} openRecordPage={opts.openRecordPage ?? vi.fn()}>
+          <ObjectGrid schema={schema} dataSource={makeDataSource()} onRowClick={opts.onRowClick} />
+        </ListHost>
+      </ActionProvider>
+      <Link to={`/apps/${APP}/crm_account/record/acc-1`} data-testid="oracle-account">oracle</Link>
+      <Link to={`/apps/${APP}/crm_opportunity/record/opp-1`} data-testid="oracle-opportunity">oracle</Link>
+      <RouterLocation />
+    </MemoryRouter>,
+  );
+}
+
+const OPPORTUNITY_ROWS = [
+  {
+    id: 'opp-1',
+    name: 'Globex Manufacturing Suite',
+    stage: 'Proposal',
+    account: { id: 'acc-1', name: 'Acme Corp' },
+    ledger: { id: 'led-1', name: 'Ledger 2026' },
+  },
+];
+
+const REQUEST_ROWS = [
+  { id: 'req-1', process_name: 'flow:opportunity_approval', object_name: 'crm_opportunity', record_id: 'opp-1' },
+  { id: 'req-2', process_name: 'flow:opportunity_approval', object_name: 'crm_opportunity', record_id: 'opp-gone' },
+];
+
+describe('a console list links names that point at another object (objectui#12673)', () => {
+  it('a lookup cell pointing at another object links to that record: href and left click', async () => {
+    const onRowClick = vi.fn();
+    mountGrid({ objectName: 'crm_opportunity', columns: ['name', 'stage', 'account'], rows: OPPORTUNITY_ROWS, onRowClick });
+
+    const link = (await screen.findByText('Acme Corp')).closest('a');
+    expect(link).not.toBeNull();
+    expect(link).toHaveAttribute('href', `${BASENAME}/apps/${APP}/crm_account/record/acc-1`);
+    // The href is the one react-router renders for the same route.
+    expect(link!.getAttribute('href')).toBe(screen.getByTestId('oracle-account').getAttribute('href'));
+    // A list page has no parent record, so no `?from=` trail entry is added.
+    expect(link!.getAttribute('href')).not.toContain('?');
+
+    fireEvent.click(link!, { button: 0 });
+    expect(screen.getByTestId('router-location').textContent).toBe(`/apps/${APP}/crm_account/record/acc-1`);
+    // Following the reference does not also open the row's own record.
+    expect(onRowClick).not.toHaveBeenCalled();
+  });
+
+  it('a modifier click on the lookup link is left to the browser (new tab), not routed in-app', async () => {
+    mountGrid({ objectName: 'crm_opportunity', columns: ['name', 'account'], rows: OPPORTUNITY_ROWS });
+    const link = (await screen.findByText('Acme Corp')).closest('a')!;
+    const notPrevented = fireEvent.click(link, { button: 0, metaKey: true });
+    expect(notPrevented).toBe(true);
+    expect(screen.getByTestId('router-location').textContent).toBe(`/apps/${APP}/crm_opportunity`);
+  });
+
+  it('a referenceVia cell pointing at another object links to that record', async () => {
+    mountGrid({ objectName: 'sys_approval_request', columns: ['process_name', 'record_id'], rows: REQUEST_ROWS });
+
+    const link = await screen.findByRole('link', { name: 'Globex Manufacturing Suite' });
+    expect(link).toHaveAttribute('href', `${BASENAME}/apps/${APP}/crm_opportunity/record/opp-1`);
+    expect(link.getAttribute('href')).toBe(screen.getByTestId('oracle-opportunity').getAttribute('href'));
+
+    fireEvent.click(link, { button: 0 });
+    expect(screen.getByTestId('router-location').textContent).toBe(`/apps/${APP}/crm_opportunity/record/opp-1`);
+  });
+
+  it('an unreadable or missing referenceVia target keeps its unavailable face and draws no anchor', async () => {
+    mountGrid({ objectName: 'sys_approval_request', columns: ['process_name', 'record_id'], rows: REQUEST_ROWS });
+
+    const unavailable = await screen.findByText('Opportunity · record unavailable');
+    const cell = unavailable.closest('[data-record-pointer="unreadable"]') as HTMLElement;
+    expect(cell).not.toBeNull();
+    expect(cell.querySelector('a')).toBeNull();
+    expect(cell.closest('a')).toBeNull();
+    // The id is not printed as cell text, and no href names the missing record.
+    expect(screen.queryByText('opp-gone')).toBeNull();
+    expect(document.querySelector('a[href*="opp-gone"]')).toBeNull();
+  });
+
+  it('a lookup whose target the viewer cannot read (no value served) draws no anchor', async () => {
+    mountGrid({
+      objectName: 'crm_opportunity',
+      columns: ['name', 'account'],
+      rows: [{ id: 'opp-9', name: 'Hidden account deal', account: null }],
+    });
+    await screen.findByText('Hidden account deal');
+    expect(document.querySelector('a[href*="crm_account"]:not([data-testid^="oracle"])')).toBeNull();
+  });
+
+  it('a lookup pointing at an object the console cannot route to draws no anchor', async () => {
+    mountGrid({ objectName: 'crm_opportunity', columns: ['name', 'ledger'], rows: OPPORTUNITY_ROWS });
+
+    const name = await screen.findByText('Ledger 2026');
+    expect(name.closest('a')).toBeNull();
+    expect(document.querySelector('a[href*="legacy_ledger"]')).toBeNull();
+  });
+
+  it('a row click outside the link still opens the row’s own record', async () => {
+    const onRowClick = vi.fn();
+    mountGrid({ objectName: 'crm_opportunity', columns: ['name', 'stage', 'account'], rows: OPPORTUNITY_ROWS, onRowClick });
+
+    await screen.findByText('Acme Corp');
+    // The stage cell holds no link: its click belongs to the row.
+    const stage = screen.getByText('Proposal');
+    expect(stage.closest('a')).toBeNull();
+    fireEvent.click(stage);
+    await waitFor(() => expect(onRowClick).toHaveBeenCalledTimes(1));
+    expect(onRowClick.mock.calls[0][0]).toMatchObject({ id: 'opp-1' });
+    // The click went to the row, not to the referenced record.
+    expect(screen.getByTestId('router-location').textContent).toBe(`/apps/${APP}/crm_opportunity`);
+  });
+
+  it('the in-cell link owns its text only: the cell around it is not an anchor', async () => {
+    mountGrid({ objectName: 'crm_opportunity', columns: ['name', 'stage', 'account'], rows: OPPORTUNITY_ROWS });
+    const link = (await screen.findByText('Acme Corp')).closest('a')!;
+    const cell = link.closest('td');
+    expect(cell).not.toBeNull();
+    expect(cell!.querySelectorAll('a')).toHaveLength(1);
+    expect(cell!.closest('a')).toBeNull();
+    // objectui#11817: no anchor anywhere inside an anchor.
+    expect(document.querySelectorAll('a a')).toHaveLength(0);
+  });
+});