@@ -0,0 +1,21 @@
+---
+'@object-ui/plugin-list': patch
+'@object-ui/components': patch
+'@object-ui/i18n': patch
+---
+
+feat(plugin-list): a list block on a page caps its rows and ends with a "View all N" link; a tabbed list block caps each tab and badges each tab with its count
+
+Clause-②: yes
+Metadata-protocol: none
+
+A `list-view` block in a page region half the page or wider used to draw the whole object list: every row of its query, the toolbar, the `#` column, every column of the view and a horizontal scrollbar. It now draws a capped list:
+
+- **The rows.** At most `dataSource.limit` of them, the key every page element's data binding already declares, and 5 when the block states none. The cap is the query's own window (`$top`), so a capped block never fetches the rest.
+- **The columns.** The view's first four visible columns, in a table fixed to the block's width; the rest are dropped, not scrolled. A view that declares no columns draws the object's `highlightFields` led by its name field, else each record's display name.
+- **No object-list chrome.** No toolbar, view tabs, row-number column, pager or record-count bar. A click on a row opens the record, as a grid row does.
+- **The link.** Under the rows, 「View all N →」 (`list.viewAllCount`, new in all ten language packs) opens the object list on the block's bound view, the same destination the compact list's "View all" link opens.
+
+A region narrower than half the page keeps the compact list, and a list outside any page region (the object list page, a block with no page around it) keeps the full list.
+
+`page:tabs` now badges a tab holding `list-view` blocks with the number of records those blocks' own queries matched, summed with the `record:related_list` counts it already derives. Such a tab is mounted while inactive, hidden, so the badge is there before the tab is opened; a tab with an authored `count` keeps mounting on open only. Nothing an author writes changes. The published surface widens in three places, which is what `Clause-②: yes` declares: the i18n key `list.viewAllCount` in all ten packs; `usePageTabCountReporter`, a new export of `@object-ui/components`, the count channel a `page:tabs` panel opens to the blocks inside it; and `ListView`'s two new optional host props that use it, `capped` and `onTotalChange`.
@@ -368,21 +368,35 @@ by the build* — but with this tier's own primitive: lay out with the blocks'
 structured props (`<flex direction gap>`, `<grid columns>`) and add CSS as a JSON
 `style` object. See *Styling*, above.
 
-## List blocks in a narrow region
+## List blocks in a page region
 
 Region pages (the schema-tree pages above, built from `regions[].components[]`)
 size each block to the region it sits in. A `list-view` block in a region
 narrower than half the page, such as an `aside` rail beside `main`, renders a
 compact list: a header with the title and record count, then two-line rows
 built from the view's first two visible columns. It renders no toolbar, no view
-tabs and no row-number column. A region half the page or wider renders the full
-list.
+tabs and no row-number column.
+
+A region half the page or wider renders a capped list: the first rows only, at
+most the block's `dataSource.limit` and 5 when it sets none, in a short table of
+the view's first four visible columns (the rest are dropped, not scrolled),
+ending with a "View all N" link. It renders no toolbar, no row-number column and
+no pager either. A page block is a summary; the link opens the whole list.
+
+```json
+{ "type": "list-view", "dataSource": { "object": "crm_lead", "view": "my_leads", "limit": 8 } }
+```
 
 The posture is measured from the region's rendered width, never authored, and
 no page or block key sets it. `kind:'html'` and `kind:'react'` pages have no
 regions, so their list blocks always render the full list.
 
-Under its rows the compact list draws a "View all" link. A block bound to a
+A `page:tabs` block whose tabs hold list blocks badges each tab with the number
+of records its list holds, the count the list's own query answered, before the
+tab is opened. A tab item's own `count` still wins.
+
+Under its rows the compact list draws a "View all" link, and the capped list a
+"View all N" link to the same place. A block bound to a
 saved view (`dataSource.view`) links to that view's page in the console
 (`/apps/APP/OBJECT/view/VIEW`); any other block links to the object's list
 (`/apps/APP/OBJECT`). The block's own filter, columns and sort are not carried
 
@@ -0,0 +1,150 @@
+/**
+ * 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.
+ *
+ * objectstack#26613 — a `page:tabs` panel's count channel.
+ *
+ * A tab holding `list-view` blocks is badged with the number of records those
+ * blocks' own queries matched: each block reports through
+ * `usePageTabCountReporter`, and the badge shows the sum. So the tab can be
+ * badged before it is opened, such a tab is mounted while inactive (hidden by
+ * its `data-state`); a tab with an authored `count`, or with no list block,
+ * keeps mounting on open only.
+ *
+ * The `list-view` here is a stand-in that reports the count it is handed, so
+ * this file pins the strip's half of the channel alone; the real block's half
+ * is pinned in plugin-list (`ListViewBlock.cappedPageBlock-26613.test.tsx`).
+ *
+ * What is pinned:
+ *  (a) each tab's badge is its blocks' reported counts, summed, the inactive
+ *      tabs included, which are mounted to report;
+ *  (b) an authored `count` wins, and its tab is not mounted while inactive;
+ *  (c) a tab with no list block is not mounted while inactive;
+ *  (d) a block that unmounts withdraws its count;
+ *  (e) outside a tab panel the reporter is `undefined`.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { render, cleanup, waitFor, act } from '@testing-library/react';
+import React from 'react';
+import { SchemaRenderer } from '@object-ui/react';
+import { ComponentRegistry } from '@object-ui/core';
+import '../renderers';
+import { usePageTabCountReporter } from '../index';
+
+let mounted: string[] = [];
+let reporterSeen: Array<boolean> = [];
+
+/** Reports the count it is handed, once mounted, and records that it mounted. */
+const ReportingList: React.FC<any> = ({ schema }) => {
+  const report = usePageTabCountReporter();
+  reporterSeen.push(report !== undefined);
+  React.useEffect(() => {
+    mounted.push(schema.id);
+    if (typeof schema.reportCount === 'number') report?.(schema.reportCount);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [schema.reportCount]);
+  return <div data-testid={`list-${schema.id}`} />;
+};
+ComponentRegistry.register('list-view', ReportingList, { namespace: 'test', label: 'Reporting list', category: 'view' });
+
+const list = (id: string, reportCount: number) => ({ type: 'list-view', id, properties: { reportCount } });
+
+const triggers = (container: HTMLElement) =>
+  Array.from(container.querySelectorAll('[role="tab"]')).map((t) => t.textContent);
+
+afterEach(() => {
+  cleanup();
+  mounted = [];
+  reporterSeen = [];
+});
+
+describe('page:tabs badges a tab with its list blocks\' counts (objectstack#26613)', () => {
+  it('(a) sums each tab\'s reports, the inactive tabs mounted to report', async () => {
+    const { container } = render(
+      <SchemaRenderer
+        schema={{
+          type: 'page:tabs',
+          id: 'home_tabs',
+          items: [
+            { label: 'Leads', value: 'leads', children: [list('leads', 21)] },
+            { label: 'Work', value: 'work', children: [list('deals', 8), list('tasks', 3)] },
+          ],
+        } as never}
+      />,
+    );
+    await waitFor(() => expect(triggers(container)).toEqual(['Leads21', 'Work11']));
+    expect(mounted.sort()).toEqual(['deals', 'leads', 'tasks']);
+    // The inactive panel is in the tree, marked inactive for its `hidden` class.
+    const work = container.querySelector('[role="tabpanel"][data-state="inactive"]');
+    expect(work?.className).toContain('data-[state=inactive]:hidden');
+  });
+
+  it('(b) an authored count wins, and its tab mounts on open only', async () => {
+    const { container } = render(
+      <SchemaRenderer
+        schema={{
+          type: 'page:tabs',
+          id: 'home_tabs',
+          items: [
+            { label: 'Leads', value: 'leads', children: [list('leads', 21)] },
+            { label: 'Deals', value: 'deals', count: 99, children: [list('deals', 8)] },
+          ],
+        } as never}
+      />,
+    );
+    await waitFor(() => expect(triggers(container)).toEqual(['Leads21', 'Deals99']));
+    expect(mounted).toEqual(['leads']);
+  });
+
+  it('(c) a tab with no list block mounts on open only', async () => {
+    let probes = 0;
+    const Probe: React.FC = () => {
+      React.useEffect(() => {
+        probes += 1;
+      }, []);
+      return null;
+    };
+    ComponentRegistry.register('test-probe-26613', Probe, { namespace: 'test', label: 'Probe', category: 'view' });
+    const { container } = render(
+      <SchemaRenderer
+        schema={{
+          type: 'page:tabs',
+          id: 'home_tabs',
+          items: [
+            { label: 'Leads', value: 'leads', children: [list('leads', 21)] },
+            { label: 'Notes', value: 'notes', children: [{ type: 'test-probe-26613', id: 'probe' }] },
+          ],
+        } as never}
+      />,
+    );
+    await waitFor(() => expect(triggers(container)).toEqual(['Leads21', 'Notes']));
+    expect(probes).toBe(0);
+  });
+
+  it('(d) a block that unmounts withdraws its count', async () => {
+    const schema = (children: unknown[]) => ({
+      type: 'page:tabs',
+      id: 'home_tabs',
+      items: [
+        { label: 'Work', value: 'work', children },
+        { label: 'Other', value: 'other', children: [] },
+      ],
+    });
+    const view = render(<SchemaRenderer schema={schema([list('deals', 8), list('tasks', 3)]) as never} />);
+    await waitFor(() => expect(triggers(view.container)).toEqual(['Work11', 'Other']));
+    act(() => {
+      view.rerender(<SchemaRenderer schema={schema([list('deals', 8)]) as never} />);
+    });
+    await waitFor(() => expect(triggers(view.container)).toEqual(['Work8', 'Other']));
+  });
+
+  it('(e) outside a tab panel the reporter is undefined', () => {
+    render(<SchemaRenderer schema={list('bare', 5) as never} />);
+    expect(reporterSeen.length).toBeGreaterThan(0);
+    expect(reporterSeen.every((seen) => seen === false)).toBe(true);
+  });
+});
@@ -88,6 +88,11 @@ export type { PageBlockSpan } from './renderers/layout/page-block-span';
 export { usePageRegionPosture } from './renderers/layout/page-region-posture';
 export type { PageRegionPosture } from './renderers/layout/page-region-posture';
 
+// The count channel a `page:tabs` panel opens to the blocks inside it
+// (objectstack#26613): the `list-view` block in `@object-ui/plugin-list`
+// reports the records its query matched, and the tab's badge shows the sum.
+export { usePageTabCountReporter } from './renderers/layout/containers';
+
 // `page:header`'s action row: a record's declared `record_header` /
 // `record_more` actions and the host's system actions, through the one
 // resolver `page:header` draws them with (objectui#12906). Exported for the