diff --git a/.changeset/11774-nav-surface-identity.md b/.changeset/11774-nav-surface-identity.md
new file mode 100644
index 0000000000..a8e7e1f59d
--- /dev/null
+++ b/.changeset/11774-nav-surface-identity.md
@@ -0,0 +1,13 @@
+---
+'@object-ui/app-shell': patch
+---
+
+Studio's Interfaces rail tells apart nav entries that open the same object, and previews each one's data slice or named view (objectui#11774).
+
+An app's navigation can hold several entries on one object: the plain list, slices of it (`filters`) and named views of it (`viewName`). The Interfaces rail identified an entry by its target alone, so every entry on that object was the same surface. Clicking a slice such as "Urgent Tasks" highlighted every entry on the object at once, previewed the whole unfiltered list, and a reload or a shared link landed on the first of them.
+
+- **Highlight:** only the entry you clicked is active. Entries are told apart by their nav item `id`.
+- **Preview:** the canvas shows what the running app opens for that entry: a `filters` entry previews its slice, read the way the app's data surface reads the entry's link, and a `viewName` entry previews that named view of the object.
+- **Deep link:** the Interfaces pillar now writes the open entry's id beside `?surface=`, as `&nav=` followed by the id, so a reload or a shared link opens the same entry. A `?surface=` link without it, including every link made before this release, resolves exactly as before, and so does one whose entry no longer exists.
+
+Apps whose entries each open a different object behave as before.
diff --git a/packages/app-shell/src/views/studio-design/StudioDesignSurface.navEntryIdentity-11774.test.tsx b/packages/app-shell/src/views/studio-design/StudioDesignSurface.navEntryIdentity-11774.test.tsx
new file mode 100644
index 0000000000..f8c3a9acc0
--- /dev/null
+++ b/packages/app-shell/src/views/studio-design/StudioDesignSurface.navEntryIdentity-11774.test.tsx
@@ -0,0 +1,266 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectui#11774 — the Interfaces rail's surface is the nav ENTRY, not its
+ * target.
+ *
+ * The showcase app's nav holds five entries on one object, `showcase_task`:
+ * the plain list, three data slices (`filters`) and one named view
+ * (`viewName`). The pillar identified a surface by `{type, name}` alone, so
+ * for the filer, clicking *Urgent Tasks* previewed every task (Low and Medium
+ * included), highlighted all five rows, and a reload landed on *Tasks*.
+ *
+ * These pins mount the real `InterfacesPillar` over a mocked metadata client
+ * and keep the DEFAULT object canvas, so what is asserted is the schema that
+ * canvas hands the list renderer: `object-view` is replaced by a recorder.
+ * Each pin is one of the claim's acceptance points; the last is the control,
+ * an app whose entries each open a distinct object.
+ */
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+import { render, screen, fireEvent, cleanup, waitFor, within } from '@testing-library/react';
+import { MemoryRouter, useLocation } from 'react-router-dom';
+import { NavigationItemSchema } from '@objectstack/spec/ui';
+import { ComponentRegistry } from '@object-ui/core';
+import { MetadataCtx, type MetadataContextValue } from '@object-ui/react';
+
+const PKG = 'com.example.showcase';
+
+/** The showcase nav, abridged to the entries on `showcase_task` and a first leaf ahead of them. */
+const SHOWCASE_NAV = [
+  { id: 'nav_home', type: 'page', pageName: 'home', label: 'Home' },
+  {
+    id: 'grp_data',
+    type: 'group',
+    label: 'Data Model',
+    children: [{ id: 'nav_tasks', type: 'object', objectName: 'showcase_task', label: 'Tasks' }],
+  },
+  {
+    id: 'grp_slices',
+    type: 'group',
+    label: 'Data Slices (filters)',
+    children: [
+      { id: 'nav_slice_in_progress', type: 'object', objectName: 'showcase_task', filters: { status: 'in_progress' }, label: 'In-Progress Tasks' },
+      { id: 'nav_slice_urgent', type: 'object', objectName: 'showcase_task', filters: { priority: 'urgent' }, label: 'Urgent Tasks' },
+      { id: 'nav_slice_review', type: 'object', objectName: 'showcase_task', filters: { status: 'in_review' }, label: 'In-Review Tasks' },
+    ],
+  },
+  {
+    id: 'grp_analytics',
+    type: 'group',
+    label: 'Analytics',
+    children: [{ id: 'nav_report_tabular', type: 'object', objectName: 'showcase_task', viewName: 'tabular', label: 'Task List' }],
+  },
+];
+
+/** The control: every entry opens a distinct object. */
+const DISTINCT_NAV = [
+  { id: 'nav_projects', type: 'object', objectName: 'showcase_project', label: 'Projects' },
+  { id: 'nav_tasks', type: 'object', objectName: 'showcase_task', label: 'Tasks' },
+  { id: 'nav_accounts', type: 'object', objectName: 'showcase_account', label: 'Accounts' },
+];
+
+let nav: unknown[] = SHOWCASE_NAV;
+
+const mockClient = {
+  list: vi.fn(async (type: string) => (type === 'app' ? [{ name: 'showcase_app', label: 'Showcase' }] : [])),
+  listDrafts: vi.fn(async () => []),
+  layered: vi.fn(async (type: string, name: string) => {
+    if (type === 'app') return { effective: { name: 'showcase_app', label: 'Showcase', navigation: nav } };
+    if (type === 'page') return { effective: { name, label: name, type: 'app', regions: [{ name: 'main', components: [] }] } };
+    return { effective: { name, label: name } };
+  }),
+  getDraft: vi.fn(async () => null),
+  save: vi.fn(async () => ({})),
+  get: vi.fn(async () => undefined),
+};
+
+vi.mock('../metadata-admin/useMetadata', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('../metadata-admin/useMetadata')>();
+  return { ...mod, useMetadataClient: () => mockClient, useMetadataTypes: () => ({ entries: [] }) };
+});
+
+vi.mock('./packages-io', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('./packages-io')>();
+  return { ...mod, fetchPackages: vi.fn(async () => []) };
+});
+
+vi.mock('@object-ui/react', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('@object-ui/react')>();
+  return { ...mod, useAdapter: () => ({}) };
+});
+
+import { InterfacesPillar } from './StudioDesignSurface';
+
+/** The object's merged `listViews`, as the shell's metadata cache holds them. */
+const TABULAR = {
+  name: 'showcase_task.tabular',
+  label: 'Task List',
+  type: 'grid',
+  columns: [{ field: 'title' }, { field: 'status' }],
+  sort: [{ field: 'estimate_hours', order: 'desc' }],
+};
+const METADATA: MetadataContextValue = {
+  apps: [],
+  objects: [{ name: 'showcase_task', label: 'Task', listViews: { 'showcase_task.tabular': TABULAR } }],
+  dashboards: [],
+  reports: [],
+  pages: [],
+  loading: false,
+  error: null,
+  refresh: async () => {},
+  invalidate: () => {},
+  ensureType: async () => [],
+  getItem: async () => null,
+  getItemsByType: () => [],
+};
+
+/** Stands in for `plugin-view`'s `object-view`: records the schema the canvas hands it. */
+function ObjectViewRecorder({ schema }: { schema: Record<string, unknown> }) {
+  return <pre data-testid="object-view-schema">{JSON.stringify(schema)}</pre>;
+}
+
+function LocationProbe() {
+  const location = useLocation();
+  return <output data-testid="location-search">{location.search}</output>;
+}
+
+beforeAll(() => {
+  ComponentRegistry.register('object-view', ObjectViewRecorder as never, { namespace: 'plugin-view' });
+});
+
+afterEach(() => {
+  cleanup();
+  nav = SHOWCASE_NAV;
+});
+
+function mountPillar(search = '') {
+  return render(
+    <MetadataCtx.Provider value={METADATA}>
+      <MemoryRouter initialEntries={[`/studio/${PKG}/interfaces${search}`]}>
+        <InterfacesPillar packageId={PKG} />
+        <LocationProbe />
+      </MemoryRouter>
+    </MetadataCtx.Provider>,
+  );
+}
+
+/** Every rail row that opens a surface (its `title` is the `type · name` pair). */
+function railRows(): HTMLElement[] {
+  return screen.getAllByRole('button').filter((b) => /^(object|page) · /.test(b.getAttribute('title') ?? ''));
+}
+
+/** The rail row whose label is `label`, exactly. */
+function railRow(label: string): HTMLElement {
+  const row = railRows().find((r) => within(r).queryByText(label, { exact: true }) !== null);
+  if (!row) throw new Error(`no rail row labelled ${label}`);
+  return row;
+}
+
+/** The labels of the rows the rail shows as active. */
+function activeLabels(): string[] {
+  return railRows()
+    .filter((r) => r.className.includes('font-medium'))
+    .map((r) => r.querySelector('.truncate')?.textContent ?? '');
+}
+
+function canvasSchema(): unknown {
+  return JSON.parse(screen.getByTestId('object-view-schema').textContent ?? 'null');
+}
+
+const search = () => new URLSearchParams(screen.getByTestId('location-search').textContent ?? '');
+
+const PLAIN = { type: 'object-view', objectName: 'showcase_task' };
+const sliced = (field: string, value: string) => ({ ...PLAIN, table: { filter: [[field, '=', value]] } });
+
+/** Each `showcase_task` entry and the schema its preview must hand the list renderer. */
+const ENTRIES: Array<{ label: string; navId: string; schema: unknown }> = [
+  { label: 'Tasks', navId: 'nav_tasks', schema: PLAIN },
+  { label: 'In-Progress Tasks', navId: 'nav_slice_in_progress', schema: sliced('status', 'in_progress') },
+  { label: 'Urgent Tasks', navId: 'nav_slice_urgent', schema: sliced('priority', 'urgent') },
+  { label: 'In-Review Tasks', navId: 'nav_slice_review', schema: sliced('status', 'in_review') },
+  {
+    label: 'Task List',
+    navId: 'nav_report_tabular',
+    schema: { ...PLAIN, listViews: { 'showcase_task.tabular': TABULAR }, defaultListView: 'showcase_task.tabular' },
+  },
+];
+
+describe('the objectui#11774 fixtures are what the spec accepts', () => {
+  it('every nav item of both apps parses against NavigationItemSchema', () => {
+    for (const item of [...SHOWCASE_NAV, ...DISTINCT_NAV]) {
+      expect(NavigationItemSchema.safeParse(item).success).toBe(true);
+    }
+  });
+});
+
+describe('Interfaces rail — one object, five entries (objectui#11774)', () => {
+  it('clicking each entry makes exactly that entry active, and the preview gets its slice or view', async () => {
+    mountPillar();
+    await waitFor(() => expect(activeLabels()).toEqual(['Home']), { timeout: 4000 });
+    for (const entry of ENTRIES) {
+      fireEvent.click(railRow(entry.label));
+      await waitFor(() => expect(activeLabels()).toEqual([entry.label]), { timeout: 4000 });
+      await waitFor(() => expect(canvasSchema()).toEqual(entry.schema), { timeout: 4000 });
+      expect(search().get('nav')).toBe(entry.navId);
+    }
+  });
+
+  it('the deep link round-trips: Urgent Tasks, read back from the URL, is the entry that opens', async () => {
+    mountPillar();
+    await waitFor(() => expect(activeLabels()).toEqual(['Home']), { timeout: 4000 });
+    fireEvent.click(railRow('Urgent Tasks'));
+    await waitFor(() => expect(search().get('nav')).toBe('nav_slice_urgent'), { timeout: 4000 });
+    expect(search().get('surface')).toBe('object:showcase_task');
+    const link = `?${search().toString()}`;
+    cleanup();
+
+    mountPillar(link);
+    await waitFor(() => expect(activeLabels()).toEqual(['Urgent Tasks']), { timeout: 4000 });
+    await waitFor(() => expect(canvasSchema()).toEqual(sliced('priority', 'urgent')), { timeout: 4000 });
+  });
+
+  it('BACK-COMPAT: a `?surface=object:showcase_task` link with no entry id opens the first match, as before', async () => {
+    mountPillar('?surface=object:showcase_task');
+    await waitFor(() => expect(activeLabels()).toEqual(['Tasks']), { timeout: 4000 });
+    await waitFor(() => expect(canvasSchema()).toEqual(PLAIN), { timeout: 4000 });
+  });
+
+  it('an entry id that no longer exists falls back exactly as the same link without it', async () => {
+    mountPillar('?surface=object:showcase_task&nav=nav_deleted');
+    await waitFor(() => expect(activeLabels()).toEqual(['Tasks']), { timeout: 4000 });
+    // The URL heals to the entry that opened.
+    await waitFor(() => expect(search().get('nav')).toBe('nav_tasks'), { timeout: 4000 });
+    cleanup();
+
+    // An unknown target as well: the pillar opens its first leaf, as it does for the bare link.
+    mountPillar('?surface=object:deleted_object&nav=nav_deleted');
+    await waitFor(() => expect(activeLabels()).toEqual(['Home']), { timeout: 4000 });
+    cleanup();
+    mountPillar('?surface=object:deleted_object');
+    await waitFor(() => expect(activeLabels()).toEqual(['Home']), { timeout: 4000 });
+  });
+});
+
+describe('Interfaces rail — CONTROL: entries on distinct objects (objectui#11774)', () => {
+  it('one row active per click, the plain list of that object, and a `?surface=` link opens its entry', async () => {
+    nav = DISTINCT_NAV;
+    mountPillar();
+    await waitFor(() => expect(activeLabels()).toEqual(['Projects']), { timeout: 4000 });
+    for (const [label, objectName] of [
+      ['Tasks', 'showcase_task'],
+      ['Accounts', 'showcase_account'],
+      ['Projects', 'showcase_project'],
+    ]) {
+      fireEvent.click(railRow(label));
+      await waitFor(() => expect(activeLabels()).toEqual([label]), { timeout: 4000 });
+      await waitFor(() => expect(canvasSchema()).toEqual({ type: 'object-view', objectName }), { timeout: 4000 });
+      expect(search().get('surface')).toBe(`object:${objectName}`);
+    }
+    cleanup();
+
+    mountPillar('?surface=object:showcase_account');
+    await waitFor(() => expect(activeLabels()).toEqual(['Accounts']), { timeout: 4000 });
+  });
+});
diff --git a/packages/app-shell/src/views/studio-design/StudioDesignSurface.tsx b/packages/app-shell/src/views/studio-design/StudioDesignSurface.tsx
index 55836d46cd..34cf14857b 100644
--- a/packages/app-shell/src/views/studio-design/StudioDesignSurface.tsx
+++ b/packages/app-shell/src/views/studio-design/StudioDesignSurface.tsx
@@ -89,7 +89,7 @@ import {
   listMetadataPreviewTypes,
   type MetadataSelection,
 } from '../metadata-admin/preview-registry.js';
-import { getStudioCanvasPreview } from './studio-canvas-preview.js';
+import { getStudioCanvasPreview, StudioCanvasNavEntryContext, type StudioCanvasNavEntry } from './studio-canvas-preview.js';
 import { PermissionMatrixEditPage } from '../metadata-admin/PermissionMatrixEditor.js';
 import { AccessExplainPanel } from '../metadata-admin/AccessExplainPanel.js';
 import {
@@ -120,7 +120,7 @@ import {
 } from './studioScope.js';
 import { useMetadataRefreshNonce } from './useMetadataRefreshNonce.js';
 import { useHomePath } from '../../hooks/useHomePath.js';
-import { resolveSurface, findSurfaceInTree, type NavNode, type Surface } from './navSurface.js';
+import { resolveSurface, findSurfaceInTree, isSameSurface, type NavNode, type Surface } from './navSurface.js';
 import { useSurfaceDeepLink, resolveSurfaceDeepLink, type SurfaceTarget } from './useSurfaceDeepLink.js';
 import { isStudioRunLanding } from './studioLanding.js';
 import { SurfaceDeepLinkProvider, useRequestedSurface } from './surfaceDeepLinkChannel.js';
@@ -1709,7 +1709,9 @@ function NavTree({
         // type-generic fallback.
         const objIcon = surface?.type === 'object' ? objectIcons?.[surface.name] : undefined;
         const Icon: React.ElementType = node.icon ? getIcon(node.icon) : objIcon ? getIcon(objIcon) : navIcon(node.type);
-        const isActive = !!surface && active?.type === surface.type && active?.name === surface.name;
+        // objectui#11774 — the ENTRY is active, not every entry of its target:
+        // compared by nav id when both carry one (see `isSameSurface`).
+        const isActive = !!surface && !!active && isSameSurface(active, surface);
         return (
           <button type="button"
             key={node.id ?? i}
@@ -2370,6 +2372,8 @@ export function InterfacesPillar({
         })(tree);
         // A `?surface=` deep-link wins over the first-leaf default when it
         // still resolves to a leaf in this app's nav; otherwise fall back.
+        // Its `?nav=` entry id, when that entry still exists, picks the entry
+        // among several that open one target (objectui#11774).
         const deepLinked = initialSurface ? findSurfaceInTree(tree, initialSurface, locale, resolveTarget) : null;
         setCurrent((cur) => cur ?? deepLinked ?? firstLeaf);
       } catch (e) {
@@ -2390,6 +2394,13 @@ export function InterfacesPillar({
   // runtime records grid, not the field-form designer that is `object`'s
   // MetadataPreview). Overridable/extendable via `registerStudioCanvasPreview`.
   const StudioCanvas = getStudioCanvasPreview(current?.type ?? '');
+  // objectui#11774 — the entry the canvas is open on (its id, and an object
+  // entry's `filters` / `viewName`), handed to the studio canvas beside its
+  // props. Read by value downstream, never by this object's identity.
+  const canvasNavEntry = React.useMemo<StudioCanvasNavEntry | null>(
+    () => (current ? { navId: current.navId, filters: current.filters, viewName: current.viewName } : null),
+    [current],
+  );
   const Inspector = getMetadataInspector(current?.type ?? '');
   // The "home" (no-selection) inspector for the surface type — e.g. a page's
   // interfaceConfig form. Interface/list pages (kanban/calendar boards) have no
@@ -2759,7 +2770,12 @@ export function InterfacesPillar({
           // grid, not the field-form preview. Default lives in
           // `studio-canvas-preview`; downstream can override via
           // `registerStudioCanvasPreview()` instead of forking this component.
-          <StudioCanvas type={current.type} name={current.name} draft={draft} locale={locale} />
+          // objectui#11774 — the open nav entry rides beside the props, not in
+          // them (`StudioCanvasPreviewProps` is a published face): the default
+          // object canvas previews the entry's slice or named view.
+          <StudioCanvasNavEntryContext.Provider value={canvasNavEntry}>
+            <StudioCanvas type={current.type} name={current.name} draft={draft} locale={locale} />
+          </StudioCanvasNavEntryContext.Provider>
         ) : isSourcePage ? (
           // Source pages have no block tree — the canvas shows only the live
           // preview; the code editor lives in the inspector's Source tab.
diff --git a/packages/app-shell/src/views/studio-design/navSurface.test.ts b/packages/app-shell/src/views/studio-design/navSurface.test.ts
index 04ef5fc2b6..8a2181a320 100644
--- a/packages/app-shell/src/views/studio-design/navSurface.test.ts
+++ b/packages/app-shell/src/views/studio-design/navSurface.test.ts
@@ -21,7 +21,7 @@
 import { describe, expect, expectTypeOf, it } from 'vitest';
 import { NavigationItemSchema, type I18nLabel } from '@objectstack/spec/ui';
 import type { NavTargetLabelResolver } from '@object-ui/layout';
-import { resolveSurface, findSurfaceInTree, type NavNode } from './navSurface';
+import { resolveSurface, findSurfaceInTree, isSameSurface, type NavNode } from './navSurface';
 
 /**
  * The designer locale these binding cases run in. The binding never reads it;
@@ -49,6 +49,7 @@ describe('resolveSurface — action nav items (objectui#4019)', () => {
       type: 'action',
       name: 'sync_now',
       label: 'Run Sync',
+      navId: 'nav_run_sync',
     });
   });
 
@@ -83,6 +84,7 @@ describe('resolveSurface — action nav items (objectui#4019)', () => {
       type: 'action',
       name: 'sync_now',
       label: 'Run Sync',
+      navId: 'nav_run_sync',
     });
   });
 });
@@ -162,7 +164,7 @@ describe.each(VARIANTS)(
     it('the canonical fixture is spec-VALID and resolves to its surface', () => {
       const node = { id: `nav_${name}`, type, label, [canonicalKey]: name } as NavNode;
       expect(NavigationItemSchema.safeParse(node).success).toBe(true);
-      expect(resolveSurface(node, LOCALE)).toEqual({ type, name, label });
+      expect(resolveSurface(node, LOCALE)).toEqual({ type, name, label, navId: `nav_${name}` });
     });
 
     it('the bare spelling is `unrecognized_keys` in the spec AND unresolved here', () => {
@@ -204,7 +206,15 @@ describe('resolveSurface — there is no `view` nav variant (objectui#4881)', ()
     // property of an object nav item, not a navigation variant of its own.
     const node = { id: 'nav_lead', type: 'object', label: 'Leads', objectName: 'crm_lead', viewName: 'all' } as NavNode;
     expect(NavigationItemSchema.safeParse(node).success).toBe(true);
-    expect(resolveSurface(node, LOCALE)).toEqual({ type: 'object', name: 'crm_lead', label: 'Leads' });
+    // objectui#11774 — and the entry's `viewName` rides on the Surface, as
+    // authored, for the canvas preview; the binding is still `object:crm_lead`.
+    expect(resolveSurface(node, LOCALE)).toEqual({
+      type: 'object',
+      name: 'crm_lead',
+      label: 'Leads',
+      navId: 'nav_lead',
+      viewName: 'all',
+    });
   });
 
   it('the bare `view` key is `unrecognized_keys` even on an otherwise valid object item', () => {
@@ -241,7 +251,7 @@ describe('resolveSurface resolves a locale-map label in the designer locale (obj
     ['en-US', 'Home'],
     ['zh-CN', '首页'],
   ])('under %s the Surface carries the text %s, not the map', (locale, text) => {
-    expect(resolveSurface(MAP_NODE, locale)).toEqual({ type: 'page', name: 'home', label: text });
+    expect(resolveSurface(MAP_NODE, locale)).toEqual({ type: 'page', name: 'home', label: text, navId: 'nav_home' });
   });
 
   it('a plain-string label is carried as authored in both locales (the control)', () => {
@@ -256,13 +266,13 @@ describe('resolveSurface resolves a locale-map label in the designer locale (obj
     // its `pageName` — so the caption, breadcrumb and chip name the leaf as
     // the rail does. The inheritance cases themselves are pinned below.
     const node: NavNode = { id: 'nav_home', type: 'page', pageName: 'home' };
-    expect(resolveSurface(node, 'zh-CN')).toEqual({ type: 'page', name: 'home', label: 'home' });
+    expect(resolveSurface(node, 'zh-CN')).toEqual({ type: 'page', name: 'home', label: 'home', navId: 'nav_home' });
   });
 
-  it('`findSurfaceInTree` matches on {type,name} alone, so the same leaf is found in both locales', () => {
+  it('`findSurfaceInTree` matches on {type,name} (no nav id asked), so the same leaf is found in both locales', () => {
     const tree: NavNode[] = [{ id: 'nav_main', type: 'group', label: { en: 'Main', 'zh-CN': '主要' }, children: [MAP_NODE] }];
-    expect(findSurfaceInTree(tree, { type: 'page', name: 'home' }, 'en-US')).toEqual({ type: 'page', name: 'home', label: 'Home' });
-    expect(findSurfaceInTree(tree, { type: 'page', name: 'home' }, 'zh-CN')).toEqual({ type: 'page', name: 'home', label: '首页' });
+    expect(findSurfaceInTree(tree, { type: 'page', name: 'home' }, 'en-US')).toEqual({ type: 'page', name: 'home', label: 'Home', navId: 'nav_home' });
+    expect(findSurfaceInTree(tree, { type: 'page', name: 'home' }, 'zh-CN')).toEqual({ type: 'page', name: 'home', label: '首页', navId: 'nav_home' });
   });
 });
 
@@ -287,7 +297,7 @@ describe('resolveSurface names a label-less leaf by what it inherits (objectui#1
   });
 
   it("with the resolver, a label-less object leaf carries its object's label", () => {
-    expect(resolveSurface(LABEL_LESS, LOCALE, targetLabel)).toEqual({ type: 'object', name: 'crm_lead', label: 'Leads' });
+    expect(resolveSurface(LABEL_LESS, LOCALE, targetLabel)).toEqual({ type: 'object', name: 'crm_lead', label: 'Leads', navId: 'nav_lead' });
   });
 
   it('without one, it carries the rule’s machine-name rung, as the console does before its metadata loads', () => {
@@ -307,3 +317,114 @@ describe('resolveSurface names a label-less leaf by what it inherits (objectui#1
     expect(findSurfaceInTree(tree, { type: 'object', name: 'crm_lead' }, LOCALE, targetLabel)?.label).toBe('Leads');
   });
 });
+
+/**
+ * objectui#11774 — a Surface is a nav ENTRY, and several entries can open one
+ * target. The showcase app's nav holds five entries on `showcase_task`: the
+ * plain list, three data slices (`filters`) and one named view (`viewName`).
+ * Each binds `object:showcase_task`; before this card each resolved to exactly
+ * `{type, name, label}`, so the rail, the deep link and the canvas could not
+ * tell them apart — all five highlighted, one unfiltered preview, and a reload
+ * landed on the first.
+ *
+ * The fixture parses against the spec (`id` is required on every nav item),
+ * so it is an input the designer must handle.
+ */
+describe('one object, five entries — a Surface carries its entry (objectui#11774)', () => {
+  const TASKS: NavNode = { id: 'nav_tasks', type: 'object', objectName: 'showcase_task', label: 'Tasks' };
+  const IN_PROGRESS: NavNode = {
+    id: 'nav_slice_in_progress',
+    type: 'object',
+    objectName: 'showcase_task',
+    filters: { status: 'in_progress' },
+    label: 'In-Progress Tasks',
+  };
+  const URGENT: NavNode = {
+    id: 'nav_slice_urgent',
+    type: 'object',
+    objectName: 'showcase_task',
+    filters: { priority: 'urgent' },
+    label: 'Urgent Tasks',
+  };
+  const IN_REVIEW: NavNode = {
+    id: 'nav_slice_review',
+    type: 'object',
+    objectName: 'showcase_task',
+    filters: { status: 'in_review' },
+    label: 'In-Review Tasks',
+  };
+  const TASK_LIST: NavNode = {
+    id: 'nav_report_tabular',
+    type: 'object',
+    objectName: 'showcase_task',
+    viewName: 'tabular',
+    label: 'Task List',
+  };
+  const ENTRIES = [TASKS, IN_PROGRESS, URGENT, IN_REVIEW, TASK_LIST];
+  const HOME: NavNode = { id: 'nav_home', type: 'page', pageName: 'home', label: 'Home' };
+  const TREE: NavNode[] = [
+    HOME,
+    { id: 'grp_data', type: 'group', label: 'Data Model', children: [TASKS] },
+    { id: 'grp_slices', type: 'group', label: 'Data Slices', children: [IN_PROGRESS, URGENT, IN_REVIEW] },
+    { id: 'grp_analytics', type: 'group', label: 'Analytics', children: [TASK_LIST] },
+  ];
+
+  it('the fixture is spec-VALID, entry by entry', () => {
+    for (const node of ENTRIES) expect(NavigationItemSchema.safeParse(node).success).toBe(true);
+  });
+
+  it('each entry resolves to the same target, carrying its own id and its own slice or view', () => {
+    expect(ENTRIES.map((n) => resolveSurface(n, LOCALE))).toEqual([
+      { type: 'object', name: 'showcase_task', label: 'Tasks', navId: 'nav_tasks' },
+      { type: 'object', name: 'showcase_task', label: 'In-Progress Tasks', navId: 'nav_slice_in_progress', filters: { status: 'in_progress' } },
+      { type: 'object', name: 'showcase_task', label: 'Urgent Tasks', navId: 'nav_slice_urgent', filters: { priority: 'urgent' } },
+      { type: 'object', name: 'showcase_task', label: 'In-Review Tasks', navId: 'nav_slice_review', filters: { status: 'in_review' } },
+      { type: 'object', name: 'showcase_task', label: 'Task List', navId: 'nav_report_tabular', viewName: 'tabular' },
+    ]);
+  });
+
+  it('`isSameSurface` holds for an entry and itself only — never across two entries of one target', () => {
+    const surfaces = ENTRIES.map((n) => resolveSurface(n, LOCALE)!);
+    for (const a of surfaces) {
+      expect(surfaces.filter((b) => isSameSurface(a, b))).toEqual([a]);
+    }
+  });
+
+  it('an id-less side is compared by {type,name}, the rule before ids were carried', () => {
+    const urgent = resolveSurface(URGENT, LOCALE)!;
+    expect(isSameSurface(urgent, { type: 'object', name: 'showcase_task' })).toBe(true);
+    expect(isSameSurface({ type: 'object', name: 'showcase_task' }, urgent)).toBe(true);
+    expect(isSameSurface(urgent, { type: 'object', name: 'showcase_project' })).toBe(false);
+  });
+
+  it('a deep link that names a nav id opens THAT entry, not the first of its target', () => {
+    expect(
+      findSurfaceInTree(TREE, { type: 'object', name: 'showcase_task', navId: 'nav_slice_urgent' }, LOCALE)?.label,
+    ).toBe('Urgent Tasks');
+    expect(
+      findSurfaceInTree(TREE, { type: 'object', name: 'showcase_task', navId: 'nav_report_tabular' }, LOCALE)?.viewName,
+    ).toBe('tabular');
+  });
+
+  it('BACK-COMPAT: a `<type>:<name>` link with no nav id resolves as before, to the first matching entry', () => {
+    expect(findSurfaceInTree(TREE, { type: 'object', name: 'showcase_task' }, LOCALE)?.navId).toBe('nav_tasks');
+  });
+
+  it('a nav id no entry carries any more falls back exactly as the same link without it does', () => {
+    const gone = { type: 'object', name: 'showcase_task', navId: 'nav_deleted' };
+    expect(findSurfaceInTree(TREE, gone, LOCALE)).toEqual(
+      findSurfaceInTree(TREE, { type: 'object', name: 'showcase_task' }, LOCALE),
+    );
+    // An unknown target too: nothing found, so the pillar opens its first leaf.
+    expect(findSurfaceInTree(TREE, { type: 'object', name: 'deleted_object', navId: 'nav_deleted' }, LOCALE)).toBeNull();
+  });
+
+  it('CONTROL: entries on distinct objects keep resolving one target each', () => {
+    const distinct: NavNode[] = [
+      { id: 'nav_projects', type: 'object', objectName: 'showcase_project', label: 'Projects' },
+      { id: 'nav_tasks', type: 'object', objectName: 'showcase_task', label: 'Tasks' },
+    ];
+    expect(findSurfaceInTree(distinct, { type: 'object', name: 'showcase_task' }, LOCALE)?.label).toBe('Tasks');
+    expect(findSurfaceInTree(distinct, { type: 'object', name: 'showcase_project' }, LOCALE)?.label).toBe('Projects');
+  });
+});
diff --git a/packages/app-shell/src/views/studio-design/navSurface.ts b/packages/app-shell/src/views/studio-design/navSurface.ts
index fd83e0d587..4d19ee7b9d 100644
--- a/packages/app-shell/src/views/studio-design/navSurface.ts
+++ b/packages/app-shell/src/views/studio-design/navSurface.ts
@@ -18,7 +18,7 @@
  * `centerTab.ts` live beside it.
  */
 
-import type { I18nLabel } from '@objectstack/spec/ui';
+import type { I18nLabel, ObjectNavItem } from '@objectstack/spec/ui';
 import type { NavTargetLabelResolver } from '@object-ui/layout';
 import { navEntryLabelText } from '../metadata-admin/previews/navItemLabel.js';
 
@@ -39,6 +39,44 @@ export interface Surface {
   label: string;
   /** Lucide icon name from the object's metadata (`icon` field); falls back per getIcon. */
   icon?: string;
+  /**
+   * The nav entry's spec `id` (objectui#11774) — the entry's IDENTITY, which
+   * `{type,name}` is not: an app may hold several entries that open one
+   * object, each its own data slice (`filters`) or named view (`viewName`).
+   * Compared through {@link isSameSurface}. Absent only for an entry with no
+   * id, which the spec refuses (`id` is required on every nav item) and the
+   * nav save backfills.
+   */
+  navId?: string;
+  /**
+   * An `object` entry's `filters`, carried as authored for the canvas preview
+   * (objectui#11774). Interpreted only by the runtime's own nav reading (see
+   * `studio-canvas-preview`), never here.
+   */
+  filters?: ObjectNavItem['filters'];
+  /** An `object` entry's `viewName`, carried as authored for the canvas preview (objectui#11774). */
+  viewName?: ObjectNavItem['viewName'];
+}
+
+/**
+ * What a Surface is known by — a rail row, the open leaf, or a `?surface=`
+ * deep-link target (whose `navId` is the link's `nav` param).
+ */
+export type SurfaceIdentity = Pick<Surface, 'type' | 'name' | 'navId'>;
+
+/**
+ * The one identity rule for two surfaces (objectui#11774): the nav entry's
+ * `id` when both sides carry one, else `{type,name}` — the rule every reader
+ * used before ids were carried, kept for an id-less side.
+ *
+ * `{type,name}` alone named the TARGET, not the entry, so every entry of one
+ * object was the same surface: all of them highlighted at once, and a reload
+ * landed on the first. The rail's `isActive` reads this; `findSurfaceInTree`
+ * prefers an exact id the same way.
+ */
+export function isSameSurface(a: SurfaceIdentity, b: SurfaceIdentity): boolean {
+  if (a.navId && b.navId) return a.navId === b.navId;
+  return a.type === b.type && a.name === b.name;
 }
 
 export interface NavNode {
@@ -70,6 +108,13 @@ export interface NavNode {
   objectName?: string;
   dashboardName?: string;
   reportName?: string;
+  /**
+   * `ObjectNavItemSchema`'s list modifiers, typed as the spec types them
+   * (objectui#11774). Carried onto an `object` Surface as authored; the
+   * binding itself never reads them.
+   */
+  filters?: ObjectNavItem['filters'];
+  viewName?: ObjectNavItem['viewName'];
   /**
    * `ActionNavItemSchema.actionDef` — a `.strict()` object of exactly
    * `{ actionName, params? }`. The spec answers `action` / `name` / `args` /
@@ -101,22 +146,39 @@ export interface NavNode {
  * caller in the Studio passes. Without one the runtime's rule answers its
  * machine-name rung, as the console does before its metadata loads. The
  * binding itself never reads the label, the locale or the resolver.
+ *
+ * objectui#11774 — the Surface also carries the entry it came from: its `id`
+ * (`navId`) on every variant, and on `object` its `filters` / `viewName` as
+ * authored. Neither changes the binding: the five showcase entries that open
+ * `showcase_task` all bind `object:showcase_task`, and are told apart by id.
  */
 export function resolveSurface(
   node: NavNode,
   locale: string,
   targetLabel?: NavTargetLabelResolver,
 ): Surface | null {
-  const label = navEntryLabelText(node, locale, targetLabel);
+  const target = bindTarget(node);
+  if (!target) return null;
+  const surface: Surface = { ...target, label: navEntryLabelText(node, locale, targetLabel) };
+  if (node.id) surface.navId = node.id;
+  if (target.type === 'object') {
+    if (node.filters) surface.filters = node.filters;
+    if (node.viewName) surface.viewName = node.viewName;
+  }
+  return surface;
+}
+
+/** The `{type,name}` a leaf binds to, or `null` — the binding half of {@link resolveSurface}. */
+function bindTarget(node: NavNode): { type: string; name: string } | null {
   switch (node.type) {
     case 'page':
-      return node.pageName ? { type: 'page', name: String(node.pageName), label } : null;
+      return node.pageName ? { type: 'page', name: String(node.pageName) } : null;
     case 'object':
-      return node.objectName ? { type: 'object', name: String(node.objectName), label } : null;
+      return node.objectName ? { type: 'object', name: String(node.objectName) } : null;
     case 'dashboard':
-      return node.dashboardName ? { type: 'dashboard', name: String(node.dashboardName), label } : null;
+      return node.dashboardName ? { type: 'dashboard', name: String(node.dashboardName) } : null;
     case 'report':
-      return node.reportName ? { type: 'report', name: String(node.reportName), label } : null;
+      return node.reportName ? { type: 'report', name: String(node.reportName) } : null;
     // A nav action is a GLOBAL action by construction: `ActionNavItemSchema` is
     // `.strict()` with exactly `{ actionName, params? }` and carries no
     // `objectName`, so an object-scoped action is not addressable from the nav
@@ -130,35 +192,52 @@ export function resolveSurface(
     // (`ObjectActionsPanel`, objectui#2330) — this case cannot reach them and
     // must not try to.
     case 'action':
-      return node.actionDef?.actionName
-        ? { type: 'action', name: String(node.actionDef.actionName), label }
-        : null;
+      return node.actionDef?.actionName ? { type: 'action', name: String(node.actionDef.actionName) } : null;
     default:
       return null;
   }
 }
 
 /**
- * Walk the nav tree for the leaf that binds to `{type,name}`, returning its
+ * Walk the nav tree for the leaf a `?surface=` deep-link names, returning its
  * resolved Surface (carrying the node's label so the canvas title / highlight
- * match). Backs the `?surface=` deep-link restore — a shared URL only names
- * the target, so we re-derive the label from the live tree. The match is on
- * `{type,name}` alone: `locale` and `targetLabel` only resolve the label of the
- * leaf found.
+ * match). Backs the deep-link restore — a shared URL only names the target, so
+ * we re-derive the label from the live tree. `locale` and `targetLabel` only
+ * resolve the label of the leaf found.
+ *
+ * objectui#11774 — a target that names a nav id (`?nav=`) which still exists
+ * opens THAT entry, wherever it sits in the tree. Otherwise — no id, or an id
+ * no entry carries any more — the match is on `{type,name}` and the first such
+ * leaf in tree order wins, exactly as every `<type>:<name>` link resolved
+ * before ids were carried.
  */
 export function findSurfaceInTree(
   nodes: NavNode[],
-  target: { type: string; name: string },
+  target: SurfaceIdentity,
+  locale: string,
+  targetLabel?: NavTargetLabelResolver,
+): Surface | null {
+  if (target.navId) {
+    const byId = findLeaf(nodes, (s) => s.navId === target.navId, locale, targetLabel);
+    if (byId) return byId;
+  }
+  return findLeaf(nodes, (s) => s.type === target.type && s.name === target.name, locale, targetLabel);
+}
+
+/** The first leaf, in tree order, whose resolved Surface satisfies `match`. */
+function findLeaf(
+  nodes: NavNode[],
+  match: (s: Surface) => boolean,
   locale: string,
   targetLabel?: NavTargetLabelResolver,
 ): Surface | null {
   for (const node of nodes) {
     if (node.type === 'group' || node.children?.length) {
-      const hit = findSurfaceInTree(node.children ?? [], target, locale, targetLabel);
+      const hit = findLeaf(node.children ?? [], match, locale, targetLabel);
       if (hit) return hit;
     } else {
       const s = resolveSurface(node, locale, targetLabel);
-      if (s && s.type === target.type && s.name === target.name) return s;
+      if (s && match(s)) return s;
     }
   }
   return null;
diff --git a/packages/app-shell/src/views/studio-design/studio-canvas-preview.test.tsx b/packages/app-shell/src/views/studio-design/studio-canvas-preview.test.tsx
index 8447a1e833..9cff4e9ccb 100644
--- a/packages/app-shell/src/views/studio-design/studio-canvas-preview.test.tsx
+++ b/packages/app-shell/src/views/studio-design/studio-canvas-preview.test.tsx
@@ -13,12 +13,19 @@
  *   3. Registration is last-write-wins (so downstream can override without
  *      forking the surface).
  */
-import { describe, expect, it } from 'vitest';
-import type { StudioCanvasPreviewProps } from './studio-canvas-preview';
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { afterEach, beforeAll, describe, expect, it } from 'vitest';
+import { cleanup, render, screen } from '@testing-library/react';
+import { ComponentRegistry } from '@object-ui/core';
+import { MetadataCtx, type MetadataContextValue } from '@object-ui/react';
+import type { StudioCanvasNavEntry, StudioCanvasPreviewProps } from './studio-canvas-preview';
 import {
   getStudioCanvasPreview,
   registerStudioCanvasPreview,
   listStudioCanvasPreviewTypes,
+  navEntryListTarget,
+  StudioCanvasNavEntryContext,
   StudioObjectRecordsCanvas,
 } from './studio-canvas-preview';
 
@@ -50,3 +57,115 @@ describe('studio-canvas-preview registry', () => {
     expect(getStudioCanvasPreview('object')).toBe(StudioObjectRecordsCanvas);
   });
 });
+
+/**
+ * objectui#11774 — the default `object` canvas previews the nav entry it is
+ * open on: an entry's `filters` (a data slice) or `viewName` (a named view).
+ *
+ * It does not interpret either key itself. `navEntryListTarget` asks
+ * `resolveHref` where the running app takes the entry and reads that landing
+ * the way the route does (`parseUrlFilterTriples` for `/data`, the
+ * `/view/:viewId` segment for a view), so these pins state what the RUNTIME
+ * reading answers, and the render pins what the canvas hands the renderer.
+ *
+ * The entry reaches the canvas through `StudioCanvasNavEntryContext`, beside
+ * `StudioCanvasPreviewProps` and not in them: those props are on the package
+ * entry. With no context the canvas renders the schema it always rendered.
+ */
+describe('navEntryListTarget — the runtime reading of an object entry (objectui#11774)', () => {
+  it('a `filters` entry lands on `/data`, read as its equality conditions', () => {
+    expect(navEntryListTarget('showcase_task', { navId: 'nav_slice_urgent', filters: { priority: 'urgent' } })).toEqual({
+      filter: [['priority', '=', 'urgent']],
+    });
+  });
+
+  it('a `viewName` entry lands on the view it names', () => {
+    expect(navEntryListTarget('showcase_task', { navId: 'nav_report_tabular', viewName: 'tabular' })).toEqual({
+      filter: [],
+      viewName: 'tabular',
+    });
+  });
+
+  it('a template value is substituted from the session, as the sidebar substitutes it', () => {
+    expect(
+      navEntryListTarget('showcase_task', { filters: { assignee: '{current_user_id}' } }, { currentUserId: 'usr_1' }),
+    ).toEqual({ filter: [['assignee', '=', 'usr_1']] });
+  });
+
+  it('a template value the session cannot resolve is dropped, as `resolveHref` drops it', () => {
+    expect(navEntryListTarget('showcase_task', { filters: { assignee: '{current_user_id}' } })).toEqual({ filter: [] });
+  });
+
+  it('CONTROL: a plain entry, and no entry at all, change nothing', () => {
+    expect(navEntryListTarget('showcase_task', { navId: 'nav_tasks' })).toEqual({ filter: [] });
+    expect(navEntryListTarget('showcase_task', null)).toEqual({ filter: [] });
+  });
+});
+
+describe('StudioObjectRecordsCanvas — renders the entry it is open on (objectui#11774)', () => {
+  /** Stands in for `plugin-view`'s `object-view`, recording the schema it is handed. */
+  function ObjectViewRecorder({ schema }: { schema: Record<string, unknown> }) {
+    return <pre data-testid="object-view-schema">{JSON.stringify(schema)}</pre>;
+  }
+  const VIEW = { name: 'showcase_task.tabular', label: 'Task List', type: 'grid', columns: [{ field: 'title' }] };
+  const METADATA: MetadataContextValue = {
+    apps: [],
+    objects: [{ name: 'showcase_task', label: 'Task', listViews: { 'showcase_task.tabular': VIEW } }],
+    dashboards: [],
+    reports: [],
+    pages: [],
+    loading: false,
+    error: null,
+    refresh: async () => {},
+    invalidate: () => {},
+    ensureType: async () => [],
+    getItem: async () => null,
+    getItemsByType: () => [],
+  };
+
+  beforeAll(() => {
+    ComponentRegistry.register('object-view', ObjectViewRecorder as never, { namespace: 'plugin-view' });
+  });
+  afterEach(cleanup);
+
+  function renderedSchema(entry: StudioCanvasNavEntry | null): Record<string, unknown> {
+    render(
+      <MetadataCtx.Provider value={METADATA}>
+        <StudioCanvasNavEntryContext.Provider value={entry}>
+          <StudioObjectRecordsCanvas type="object" name="showcase_task" draft={{}} />
+        </StudioCanvasNavEntryContext.Provider>
+      </MetadataCtx.Provider>,
+    );
+    return JSON.parse(screen.getByTestId('object-view-schema').textContent ?? 'null');
+  }
+
+  it('a data-slice entry hands the renderer its conditions as the list filter', () => {
+    expect(renderedSchema({ navId: 'nav_slice_urgent', filters: { priority: 'urgent' } })).toEqual({
+      type: 'object-view',
+      objectName: 'showcase_task',
+      table: { filter: [['priority', '=', 'urgent']] },
+    });
+  });
+
+  it('a named-view entry hands the renderer that view of the object, opened', () => {
+    expect(renderedSchema({ navId: 'nav_report_tabular', viewName: 'tabular' })).toEqual({
+      type: 'object-view',
+      objectName: 'showcase_task',
+      listViews: { 'showcase_task.tabular': VIEW },
+      defaultListView: 'showcase_task.tabular',
+    });
+  });
+
+  it('a view the object does not have opens the plain list, as the runtime falls back to its default', () => {
+    expect(renderedSchema({ navId: 'nav_gone', viewName: 'no_such_view' })).toEqual({
+      type: 'object-view',
+      objectName: 'showcase_task',
+    });
+  });
+
+  it('CONTROL: a plain entry, and no entry, render exactly the schema rendered before', () => {
+    expect(renderedSchema({ navId: 'nav_tasks' })).toEqual({ type: 'object-view', objectName: 'showcase_task' });
+    cleanup();
+    expect(renderedSchema(null)).toEqual({ type: 'object-view', objectName: 'showcase_task' });
+  });
+});
diff --git a/packages/app-shell/src/views/studio-design/studio-canvas-preview.tsx b/packages/app-shell/src/views/studio-design/studio-canvas-preview.tsx
index 9d57312af4..36db644d01 100644
--- a/packages/app-shell/src/views/studio-design/studio-canvas-preview.tsx
+++ b/packages/app-shell/src/views/studio-design/studio-canvas-preview.tsx
@@ -32,7 +32,14 @@
  */
 
 import * as React from 'react';
-import { SchemaRenderer } from '@object-ui/react';
+import { SchemaRenderer, useMetadata } from '@object-ui/react';
+import { resolveViewId } from '@object-ui/core';
+import { useAuth } from '@object-ui/auth';
+import { resolveHref, type NavTemplateContext } from '@object-ui/layout';
+import type { NavigationEntryItem } from '@object-ui/types';
+import type { ObjectNavItem } from '@objectstack/spec/ui';
+import { parseUrlFilterTriples, type FilterTriple } from '../drillUrlFilters.js';
+import { findByName } from '../../hooks/useNavTargetLabel.js';
 
 /**
  * Props handed to a Studio-canvas renderer. Intentionally a small, read-only
@@ -78,17 +85,132 @@ export function listStudioCanvasPreviewTypes(): string[] {
   return Array.from(REGISTRY.keys()).sort();
 }
 
+/**
+ * The Interfaces nav entry the canvas is open on, as far as its list goes
+ * (objectui#11774): an `object` entry's `filters` (a data slice) or `viewName`
+ * (a named view), as authored, with the entry's `id`.
+ *
+ * ⛔ Studio-internal. A context and not a member of
+ * {@link StudioCanvasPreviewProps}: those props are on the package entry, and
+ * carrying an entry's modifiers to every registered canvas would widen that
+ * published face. The Interfaces pillar provides it around the canvas it
+ * renders; the built-in default below reads it. A canvas registered over the
+ * default, or one rendered outside the pillar, sees `null` and renders as it
+ * always did.
+ */
+export interface StudioCanvasNavEntry {
+  navId?: string;
+  filters?: ObjectNavItem['filters'];
+  viewName?: ObjectNavItem['viewName'];
+}
+
+export const StudioCanvasNavEntryContext = React.createContext<StudioCanvasNavEntry | null>(null);
+
+/** What an entry changes about the object's list: the slice's conditions, or the named view to open. */
+export interface NavEntryListTarget {
+  /** The entry's `filters` as the `/data` surface reads them; empty when it lands elsewhere. */
+  filter: FilterTriple[];
+  /** The view the entry lands on (`/view/:viewId`), as the entry names it; absent otherwise. */
+  viewName?: string;
+}
+
+/**
+ * Where the running app takes an `object` nav entry, read the way the route it
+ * lands on reads it (objectui#11774). The preview asks the runtime rather than
+ * interpreting `filters` / `viewName` a second time:
+ *
+ *  - `resolveHref` (`@object-ui/layout`) is the shell's single source of truth
+ *    for nav → URL. It decides the landing — `recordId` → `filters` →
+ *    `viewName` — and substitutes `{current_user_id}`-style values, dropping
+ *    an entry it cannot resolve, as the sidebar does;
+ *  - a `/data` landing is the bare data surface, whose `filter[...]` params
+ *    `ObjectDataPage` reads through `parseUrlFilterTriples` — read here by the
+ *    same function;
+ *  - a `/view/:viewId` landing names the view `ObjectView` opens; the caller
+ *    matches it as `ObjectView` does (`resolveViewId`).
+ *
+ * Any other landing (the plain list, a `recordId` detail page) changes nothing
+ * here, so such an entry previews the object's list as before.
+ */
+export function navEntryListTarget(
+  objectName: string,
+  entry: StudioCanvasNavEntry | null,
+  templateContext?: NavTemplateContext,
+): NavEntryListTarget {
+  if (!entry || (!entry.filters && !entry.viewName)) return { filter: [] };
+  // The question is where an entry with these modifiers lands; `resolveHref`
+  // reads no `id` off an object entry, so the id is carried only for the type.
+  const item: NavigationEntryItem = {
+    id: entry.navId ?? '',
+    type: 'object',
+    objectName,
+    ...(entry.filters ? { filters: entry.filters } : {}),
+    ...(entry.viewName ? { viewName: entry.viewName } : {}),
+  };
+  const { href } = resolveHref(item, '', templateContext);
+  const q = href.indexOf('?');
+  const route = (q < 0 ? href : href.slice(0, q)).slice(`/${objectName}`.length);
+  if (route === '/data') {
+    return { filter: parseUrlFilterTriples(new URLSearchParams(q < 0 ? '' : href.slice(q + 1))) };
+  }
+  const VIEW = '/view/';
+  if (route.startsWith(VIEW) && route.length > VIEW.length) {
+    return { filter: [], viewName: route.slice(VIEW.length) };
+  }
+  return { filter: [] };
+}
+
 /**
  * Default Studio-canvas renderer for `object` leaves: the runtime records grid,
  * exactly as the running app shows it (preview = runtime). Schema editing lives
  * in the Data pillar, so this is the object-view grid — NOT the field-form
  * designer that is the `object` entry in the MetadataPreviewRegistry.
  *
+ * objectui#11774 — opened on a nav entry that slices the object (`filters`) or
+ * names one of its views (`viewName`), it shows that slice or that view, as the
+ * running app does (see {@link navEntryListTarget}). The named view is the
+ * object's own, from the merged `listViews` the shell's metadata holds — the
+ * map `ObjectView` and the rail's label resolver (`useNavTargetLabel`) read —
+ * handed to the renderer as the Studio's view preview hands one. With no entry
+ * (or a plain one) the schema is exactly the one this rendered before.
+ *
  * Exported so downstream renderers can compose/wrap it; override the default
  * wholesale via `registerStudioCanvasPreview('object', …)`.
  */
 export function StudioObjectRecordsCanvas({ name }: StudioCanvasPreviewProps) {
-  return <SchemaRenderer schema={{ type: 'object-view', objectName: name } as never} />;
+  const entry = React.useContext(StudioCanvasNavEntryContext);
+  const { user, activeOrganization } = useAuth();
+  const currentUserId = user?.id ?? null;
+  const currentOrgId = activeOrganization?.id ?? null;
+  // Keyed on the values, never on the context object's identity (AGENTS.md #10).
+  const navId = entry?.navId;
+  const filtersKey = JSON.stringify(entry?.filters ?? null);
+  const entryViewName = entry?.viewName;
+  const target = React.useMemo(() => {
+    const filters = (JSON.parse(filtersKey) as StudioCanvasNavEntry['filters'] | null) ?? undefined;
+    return navEntryListTarget(name, { navId, filters, viewName: entryViewName }, { currentUserId, currentOrgId });
+  }, [name, navId, filtersKey, entryViewName, currentUserId, currentOrgId]);
+  // Read only for an entry that names a view: a plain entry asks the metadata
+  // cache for nothing, as before.
+  const metadata = useMetadata();
+  const objectViews = target.viewName ? listViewsOf(findByName(metadata.objects, name)) : undefined;
+  const viewId = objectViews && target.viewName ? resolveViewId(target.viewName, Object.keys(objectViews), name) : undefined;
+  const view = viewId ? objectViews?.[viewId] : undefined;
+  const schema = {
+    type: 'object-view',
+    objectName: name,
+    ...(target.filter.length > 0 ? { table: { filter: target.filter } } : {}),
+    ...(viewId && view ? { listViews: { [viewId]: view }, defaultListView: viewId } : {}),
+  };
+  // The renderer settles its named view once, at mount, so a different view is
+  // a different mount; a different slice of the same list is a refetch.
+  return <SchemaRenderer key={view ? viewId : ''} schema={schema as never} />;
+}
+
+/** An object definition's merged `listViews` map, or `{}` when it has none. */
+function listViewsOf(def: { listViews?: unknown } | undefined): Record<string, unknown> {
+  const views = def?.listViews;
+  return views && typeof views === 'object' ? (views as Record<string, unknown>) : {};
 }
 
 // Side-effect: register the built-in defaults. Kept inline (rather than a
diff --git a/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.test.ts b/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.test.ts
index 05734c95f4..21307114ad 100644
--- a/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.test.ts
+++ b/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.test.ts
@@ -1,7 +1,7 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import { describe, it, expect } from 'vitest';
-import { resolveSurfaceDeepLink } from './useSurfaceDeepLink';
+import { resolveSurfaceDeepLink, parseSurfaceTarget, DESIGNER_SURFACE_NAV_PARAM } from './useSurfaceDeepLink';
 
 /**
  * Pure half of the shared `?surface=` deep-link plumbing — the rail-restore
@@ -45,3 +45,40 @@ describe('resolveSurfaceDeepLink', () => {
     ).toBe(perms[1]);
   });
 });
+
+/**
+ * objectui#11774 — the capture half's parse: `?surface=` plus the Interfaces
+ * entry id in its own `?nav=` key. A separate key, so every `<type>:<name>`
+ * parser of `?surface=` (each pillar's restore, the app→Studio bridge, the
+ * copilot's surface context) reads the same value it always read.
+ */
+describe('parseSurfaceTarget (objectui#11774)', () => {
+  it('the entry id travels in a key of its own, `nav`', () => {
+    expect(DESIGNER_SURFACE_NAV_PARAM).toBe('nav');
+  });
+
+  it('reads the entry id beside the target', () => {
+    expect(parseSurfaceTarget('object:showcase_task', 'nav_slice_urgent')).toEqual({
+      type: 'object',
+      name: 'showcase_task',
+      navId: 'nav_slice_urgent',
+    });
+  });
+
+  it('BACK-COMPAT: a link with no `nav` parses exactly as `?surface=` alone always did', () => {
+    expect(parseSurfaceTarget('object:showcase_task', null)).toEqual({ type: 'object', name: 'showcase_task' });
+    expect(parseSurfaceTarget('object:showcase_task', '')).toEqual({ type: 'object', name: 'showcase_task' });
+  });
+
+  it('`nav` alone names nothing: it only ever qualifies a target', () => {
+    expect(parseSurfaceTarget(null, 'nav_slice_urgent')).toBeNull();
+    expect(parseSurfaceTarget('object', 'nav_slice_urgent')).toBeNull();
+  });
+
+  it("another pillar's restore ignores the id: it matches on its own type and name", () => {
+    const objects = [{ name: 'showcase_project' }, { name: 'showcase_task' }];
+    expect(
+      resolveSurfaceDeepLink(objects, parseSurfaceTarget('object:showcase_task', 'nav_slice_urgent'), 'object'),
+    ).toBe(objects[1]);
+  });
+});
diff --git a/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.ts b/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.ts
index 7b0cbc8c2b..c3988f4830 100644
--- a/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.ts
+++ b/packages/app-shell/src/views/studio-design/useSurfaceDeepLink.ts
@@ -17,6 +17,12 @@
  *     has no selection yet, and clearing the param there would strip an
  *     incoming deep-link before it is applied.
  *
+ * The Interfaces pillar's surfaces are nav ENTRIES, and several can open one
+ * target, so there both halves also carry the entry's id in a `?nav=` key
+ * beside `?surface=` ({@link DESIGNER_SURFACE_NAV_PARAM}, objectui#11774). A
+ * pillar whose surfaces carry no entry id reads and writes `?surface=` alone,
+ * as before.
+ *
  * InterfacesPillar pioneered the pattern (#code-block-menu-nav); the Data
  * pillar grew the capture half for the app→Studio object bridge (#2446);
  * Automations/Access had neither, so their deep-links snapped back to the
@@ -39,10 +45,30 @@ import {
   formatSurfaceParam,
 } from '../metadata-admin/nav-selection.js';
 
-/** The surface identity carried in the URL param. */
+/**
+ * The nav-entry qualifier of a `?surface=` deep-link (objectui#11774): the
+ * spec `id` of the Interfaces nav entry that is open, `?surface=…&nav=<id>`.
+ *
+ * `?surface=<type>:<name>` names a TARGET, and one app may hold several nav
+ * entries that open one object (data slices, named views), so the Interfaces
+ * pillar adds the entry beside it. A KEY OF ITS OWN, not a `nav:<id>` value of
+ * `?surface=`: every reader of that param parses it as `<type>:<name>` (each
+ * pillar's restore, the app→Studio bridge in `utils/appRoute.ts`, the
+ * copilot's surface context in `StudioAiCopilot`), and a second value grammar
+ * would hand each of them a `nav` "type". With a separate key, `?surface=`
+ * keeps meaning what it meant to all of them, and a link without `nav` — every
+ * link produced before this key existed — resolves exactly as it did.
+ */
+export const DESIGNER_SURFACE_NAV_PARAM = 'nav';
+
+/**
+ * The surface identity carried in the URL: `?surface=` plus, on an Interfaces
+ * nav entry, its id from `?nav=` (absent otherwise).
+ */
 export interface SurfaceTarget {
   type: string;
   name: string;
+  navId?: string;
 }
 
 /**
@@ -54,26 +80,49 @@ export function useSurfaceDeepLink(
   current: SurfaceTarget | null | undefined,
 ): SurfaceTarget | null {
   const [searchParams, setSearchParams] = useSearchParams();
-  const initialRef = React.useRef(parseSurfaceParam(searchParams.get(DESIGNER_SURFACE_PARAM)));
+  const initialRef = React.useRef(
+    parseSurfaceTarget(searchParams.get(DESIGNER_SURFACE_PARAM), searchParams.get(DESIGNER_SURFACE_NAV_PARAM)),
+  );
   // Keyed on the identity, not the object — pillars recreate their Surface
   // objects on list reload, and a same-surface rewrite is a wasted render.
   const type = current?.type;
   const name = current?.name;
+  const navId = current?.navId;
   React.useEffect(() => {
     if (!type || !name) return;
     setSearchParams(
       (prev) => {
         const next = new URLSearchParams(prev);
         next.set(DESIGNER_SURFACE_PARAM, formatSurfaceParam({ type, name }));
+        // objectui#11774 — the entry travels with its target, and a surface
+        // with no entry id clears it, so a `nav` left by an earlier selection
+        // never qualifies a target it was not written for.
+        if (navId) next.set(DESIGNER_SURFACE_NAV_PARAM, navId);
+        else next.delete(DESIGNER_SURFACE_NAV_PARAM);
         return next;
       },
       { replace: true },
     );
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [type, name]);
+  }, [type, name, navId]);
   return initialRef.current;
 }
 
+/**
+ * The deep-link target in a `?surface=` value and a `?nav=` value — the
+ * capture half's parse, pure for the tests. `nav` only ever qualifies a
+ * surface: alone (no parsable `?surface=`) it names nothing, since the mirror
+ * above never writes one without the other.
+ */
+export function parseSurfaceTarget(
+  surface: string | null | undefined,
+  nav: string | null | undefined,
+): SurfaceTarget | null {
+  const parsed = parseSurfaceParam(surface);
+  if (!parsed) return null;
+  return nav ? { ...parsed, navId: nav } : parsed;
+}
+
 /**
  * Resolve a captured deep-link against the pillar's loaded rail: the matching
  * item when the target is of this pillar's surface type AND actually exists in