@@ -0,0 +1,13 @@
+---
+'@object-ui/app-shell': patch
+---
+
+perf(app-shell): a packaged app's object route asks its lookup targets without views
+
+Clause-②: no
+Metadata-protocol: none
+
+An object route in an app that ships in a package read the route object's lookup targets through the package scope's with-views read. A target outside the app bundle, such as `sys_user` behind an `owner` lookup, then had its views composed from the whole `/meta/view` list.
+
+- **Now.** The lookup targets are asked by name without views, as an app without a package already asked them. They join the route's object scope as their definitions land, so lookup cells link and name their targets as before.
+- **Unchanged.** The route's object, the app's `requiresObject` entries and the navigation's objects keep their views. A lookup target the package already holds asks nothing more.
@@ -16,14 +16,20 @@
  * id asks the route's object and its lookup targets by name, never the whole
  * registry (objectstack#29416). A record drawer (`?recordId=`) asks the scope of the list under it,
  * as `AppContent` does (objectstack#27626).
+ *
+ * objectstack#29551 — inside a packaged app whose bundle is in hand, the route
+ * object's lookup targets are asked without views: a target outside the bundle
+ * (`sys_user`) joins the scope as a served definition and reads no
+ * `/meta/view` list, while the route's object keeps the bundle's views.
+ * CONTROL: a target the bundle holds reads nothing more and keeps its views.
  */
 
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { cleanup, render, waitFor } from '@testing-library/react';
-import { MemoryRouter } from 'react-router-dom';
+import { MemoryRouter, useLocation } from 'react-router-dom';
 import { AdapterCtx } from '@object-ui/react';
-import { MetadataProvider } from '../../providers/MetadataProvider';
-import { enterAppBundle, useAppObjectScopePrefetch } from '../appObjectScope';
+import { MetadataProvider, useMetadata } from '../../providers/MetadataProvider';
+import { enterAppBundle, readAppObjectScope, useAppObjectScopePrefetch } from '../appObjectScope';
 
 const CRM = 'app.crm';
 const OBJECTS = [
@@ -143,3 +149,105 @@ describe('the console root starts the app object scope (objectui#12811)', () =>
     expect([...objectCalls(noPackage)].sort()).toEqual(['object/crm_account', 'object/sys_user']);
   });
 });
+
+describe('objectstack#29551 — a packaged app asks its lookup targets without views', () => {
+  type Doc = { name: string; [key: string]: unknown };
+  const BUNDLED: Doc[] = [
+    { name: 'crm_account', _packageId: CRM, fields: { owner: { type: 'lookup', reference: 'sys_user' } } },
+    { name: 'crm_contact', _packageId: CRM, fields: { account: { type: 'lookup', reference: 'crm_account' } } },
+  ];
+  const ALL: Doc[] = [...BUNDLED, { name: 'sys_user', _packageId: 'plugin.auth', fields: {} }];
+  const VIEWS: Doc[] = [
+    { name: 'crm_account.all', object: 'crm_account', viewKind: 'list', label: 'All accounts', isDefault: true, config: { type: 'grid', columns: [] } },
+    { name: 'crm_contact.all', object: 'crm_contact', viewKind: 'list', label: 'All contacts', isDefault: true, config: { type: 'grid', columns: [] } },
+    { name: 'sys_user.all', object: 'sys_user', viewKind: 'list', label: 'All users', isDefault: true, config: { type: 'grid', columns: [] } },
+  ];
+
+  /** The crm app's bundle, as the adapter's `peekAppBundle` answers once the app was entered: its two objects and their views. */
+  function bundle() {
+    const items = new Map<string, Map<string, { item: unknown; envelope: Record<string, unknown> }>>();
+    const put = (type: string, docs: Doc[]) => {
+      const byName = new Map();
+      for (const doc of docs) byName.set(doc.name, { item: structuredClone(doc), envelope: { type, name: doc.name, item: doc } });
+      items.set(type, byName);
+    };
+    put('object', BUNDLED);
+    put('view', VIEWS.slice(0, 2));
+    return { status: 'ready', items };
+  }
+
+  function makeBundledAdapter(calls: string[]) {
+    const held = bundle();
+    return {
+      clearCache: vi.fn(),
+      invalidateCache: vi.fn(),
+      peekAppBundle: () => held,
+      getObjectSchema(this: { getClient(): any }, name: string) {
+        return this.getClient()
+          .meta.getItem('object', name)
+          .then((res: any) => (res && typeof res === 'object' && 'item' in res ? res.item : res));
+      },
+      getClient: () => ({
+        meta: {
+          getItems: (type: string, options?: { packageId?: string }) => {
+            calls.push(options?.packageId ? `${type}?package=${options.packageId}` : type);
+            const all = type === 'object' ? ALL : type === 'view' ? VIEWS : type === 'app' ? APPS : [];
+            const items = options?.packageId ? all.filter((o: any) => o._packageId === options.packageId) : all;
+            return Promise.resolve({ type, items: structuredClone(items) });
+          },
+          getItem: (type: string, name: string) => {
+            calls.push(`${type}/${name}`);
+            const item = (type === 'object' ? ALL : []).find((o) => o.name === name);
+            return item ? Promise.resolve({ item: structuredClone(item) }) : Promise.reject(new Error('404'));
+          },
+        },
+      }),
+    } as unknown as Parameters<typeof MetadataProvider>[0]['adapter'];
+  }
+
+  /** What `AppContent` reads on the route: each scope object with the list views it composed. */
+  function ScopeProbe() {
+    useAppObjectScopePrefetch();
+    const { apps, readObjectScope } = useMetadata();
+    const { pathname, search } = useLocation();
+    const app = apps.find((a: any) => a?.name === 'crm');
+    const read = app && readObjectScope ? readAppObjectScope(readObjectScope, app, pathname.split('/').slice(3).join('/'), search) : undefined;
+    const objects: any[] = read?.scope?.objects ?? [];
+    const text = objects
+      .map((o) => `${o.name}[${Object.keys(o.listViews ?? {}).join('+')}]`)
+      .sort()
+      .join(',');
+    return <div data-testid="scope">{text}</div>;
+  }
+
+  function mountBundled(url: string) {
+    sessionStorage.clear();
+    const calls: string[] = [];
+    const view = render(
+      <MetadataProvider adapter={makeBundledAdapter(calls)}>
+        <MemoryRouter initialEntries={[url]}>
+          <ScopeProbe />
+        </MemoryRouter>
+      </MetadataProvider>,
+    );
+    return { calls, scope: () => view.getByTestId('scope').textContent };
+  }
+
+  const reads = (calls: string[]) => calls.filter((c) => c !== 'app');
+
+  it('a lookup target outside the bundle is asked by name without views: no /meta/view list, and the route object keeps its views', async () => {
+    const { calls, scope } = mountBundled('/apps/crm/crm_account');
+    await waitFor(() => expect(scope()).toContain('sys_user['));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(reads(calls)).toEqual([`object?package=${CRM}`, 'object/sys_user']);
+    expect(scope()).toBe('crm_account[crm_account.all],crm_contact[crm_contact.all],sys_user[]');
+  });
+
+  it('CONTROL: a lookup target the bundle holds asks nothing more and keeps its views', async () => {
+    const { calls, scope } = mountBundled('/apps/crm/crm_contact');
+    await waitFor(() => expect(scope()).toContain('crm_contact['));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(reads(calls)).toEqual([`object?package=${CRM}`]);
+    expect(scope()).toBe('crm_account[crm_account.all],crm_contact[crm_contact.all]');
+  });
+});
@@ -7,9 +7,9 @@
  * the chrome around it read the app's object scope instead
  * (`MetadataContextValue.readObjectScope`): the package's objects, plus by
  * name the route's object and its lookup targets when the package does not
- * hold them, the objects the app's navigation and area entries require
- * (`requiresObject`), and the navigation's objects while the command palette
- * is open.
+ * hold them (the lookup targets without views, objectstack#29551), the objects
+ * the app's navigation and area entries require (`requiresObject`), and the
+ * navigation's objects while the command palette is open.
  *
  * A page (`page/:pageName`, objectui#12980) reads only the objects its page
  * definition binds ({@link pageObjectNames}), by name, beside the app's
@@ -565,13 +565,14 @@ function readObjectRouteNames(
   const routeDef = objectName ? first.objects.find((o: any) => o?.name === objectName) : undefined;
   const lookups = routeDef ? lookupTargetNames(routeDef) : [];
   if (lookups.length === 0) return { scope: first, ready, ...routeOutcome };
-  if (packageId) return { scope: read([...names, ...lookups]), ready, ...routeOutcome };
-  // In an app with no package the lookup targets are asked without views: a
-  // lookup cell links and names its target and reads none of its views, and a
-  // target outside the app bundle (`sys_user`) composed with them read the
-  // whole `/meta/view` list. They join the names-only scope's objects as they
-  // land.
-  (readObjectScope as ReadNamesWithoutViews)({ names: lookups, views: false });
+  // The lookup targets are asked without views, through the same scope as the
+  // route's names: a lookup cell links and names its target and reads none of
+  // its views, and a target outside the app bundle (`sys_user`) composed with
+  // them read the whole `/meta/view` list (objectstack#29551). They join the
+  // scope's objects as they land; the route's names keep their views.
+  const readWithoutViews = readObjectScope as ReadNamesWithoutViews;
+  if (packageId) readWithoutViews({ packageId, names: lookups, views: false });
+  else readWithoutViews({ names: lookups, views: false });
   return { scope: first, ready, ...routeOutcome };
 }