@@ -0,0 +1,8 @@
+---
+'@object-ui/plugin-kanban': patch
+---
+
+Clause-②: no
+Metadata-protocol: none
+
+A kanban lane no longer reads `0` before its records have arrived. Every lane header that writes a count (the flat board's badge, the swimlane layout's column titles and lane rows) shows a small pending marker instead until the board's records settle, and the lane carries `aria-busy` meanwhile; the lane total waits the same way. Before this, a board opened right after publish under a list view showed the list's footer 「12 条记录」 over lanes reading 0 / 0 / 0 / 0 for as long as its lane queries were in flight. A lane that really holds nothing still reads `0` once its query answers. The signal is the one the board's "No cards" state already waits on (objectui#8827); no new string.
@@ -35,7 +35,7 @@
  */
 import React from 'react';
 import { describe, it, expect, vi, afterEach } from 'vitest';
-import { cleanup, render, screen, waitFor, within } from '@testing-library/react';
+import { act, cleanup, render, screen, waitFor, within } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import { ValueDataSource } from '@object-ui/core';
 import { ActionProvider, SchemaRendererProvider } from '@object-ui/react';
@@ -166,3 +166,93 @@ describe('a kanban under a list view draws every record of the view in its colum
     expect(within(card).queryByText('Close Date')).not.toBeInTheDocument();
   });
 });
+
+/**
+ * objectstack#30431 — under a list view the footer and the lanes answer from
+ * different queries: the list asks its own window and count, the board asks one
+ * query per lane. Walked on cloud's two-plane stack with the card's 客服工单
+ * package (12 tickets, 2 / 4 / 2 / 3 / 1), a board opened right after publish
+ * read footer 「12 条记录」 over lanes 0 / 0 / 0 / 0 while its lane queries were
+ * in flight. Here the lane queries are held open and the list's are not, which
+ * is that ordering.
+ */
+describe('the board under a list view claims no lane count before its lanes answer (objectstack#30431)', () => {
+  const TICKET = 'helpdesk_ticket';
+  const STATUSES = [
+    ['new', '待处理', 2],
+    ['in_progress', '处理中', 4],
+    ['waiting_customer', '等待客户', 2],
+    ['resolved', '已解决', 3],
+    ['closed', '已关闭', 1],
+  ] as const;
+  const TICKETS: Row[] = STATUSES.flatMap(([status, , count]) =>
+    Array.from({ length: count }, (_, i) => ({ id: `${status}-${i}`, subject: `${status} ticket ${i}`, status })),
+  );
+  const TICKET_DEF = {
+    name: TICKET,
+    label: '工单',
+    fields: {
+      subject: { type: 'text', label: '标题' },
+      status: { type: 'select', label: '状态', options: STATUSES.map(([value, label]) => ({ value, label })) },
+    },
+  };
+  const BOARD_VIEW = {
+    type: 'list-view',
+    objectName: TICKET,
+    viewType: 'kanban',
+    columns: [{ field: 'subject' }, { field: 'status' }],
+    kanban: { groupByField: 'status', titleField: 'subject' },
+  };
+
+  /** A lane query is the one that filters on the lane field; the list's never does. */
+  const isLaneQuery = (params: any) => JSON.stringify(params?.$filter ?? null).includes('"status"');
+
+  function heldLanes() {
+    const store = new ValueDataSource<Row>({ items: TICKETS });
+    let release!: () => void;
+    const gate = new Promise<void>((r) => {
+      release = r;
+    });
+    const ds = {
+      find: vi.fn(async (object: string, params: any) => {
+        if (isLaneQuery(params)) await gate;
+        return store.find(object, params);
+      }),
+      findOne: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+      getObjectSchema: vi.fn(async () => TICKET_DEF),
+    } as any;
+    return { ds, release: () => act(async () => release()) };
+  }
+
+  /** The count badge beside a lane title. */
+  const laneBadge = (title: string) => within(lane(title)).getByRole('heading').parentElement!.querySelector('span')!;
+
+  it('the footer may read 12 while the lanes wait, but no lane reads 0 until it has answered', async () => {
+    const { ds, release } = heldLanes();
+    mountBoard(ds, BOARD_VIEW);
+
+    // RIG SELF-CHECK — the state the card reported: the list's count is on
+    // screen and every lane query has left without an answer.
+    await waitFor(() => expect(screen.getByTestId('record-count-bar')).toHaveTextContent('12 records'));
+    await waitFor(() => expect(ds.find.mock.calls.filter((call: any[]) => isLaneQuery(call[1]))).toHaveLength(STATUSES.length + 1));
+    expect(cards()).toHaveLength(0);
+
+    for (const [, title] of STATUSES) {
+      // RED before the fix: '0' on every lane, under a footer reading 12.
+      expect(laneBadge(title).textContent?.trim()).toBe('');
+      expect(lane(title)).toHaveAttribute('aria-busy', 'true');
+    }
+
+    await release();
+
+    await waitFor(() => expect(cards()).toHaveLength(12));
+    for (const [, title, count] of STATUSES) {
+      expect(laneBadge(title).textContent?.trim()).toBe(String(count));
+      expect(lane(title)).not.toHaveAttribute('aria-busy');
+    }
+    expect(screen.getByTestId('record-count-bar')).toHaveTextContent('12 records');
+  });
+});
@@ -675,6 +675,35 @@ function laneCountLabel(count: number, countsAreWindowed?: boolean): string {
   return countsAreWindowed ? `${count}+` : String(count)
 }
 
+/**
+ * What a lane header shows IN PLACE OF its count while the board's records
+ * have not settled (objectstack#30431).
+ *
+ * A lane count is a claim about the data, the same claim "No cards" makes, and
+ * before the records settle the only number this board holds is the length of
+ * an array nothing has filled yet. Drawn, that number is `0` on every lane.
+ * Measured on cloud's two-plane stack: a board opened right after publish,
+ * under a list view whose own count had already answered, showed footer
+ * 「12 条记录」 over lanes reading 0 / 0 / 0 / 0 for as long as its lane
+ * queries were in flight, then 2 / 4 / 2 / 3. "Pending" and "this lane holds
+ * nothing" were the same pixels.
+ *
+ * So the count waits for what the empty state waits for — `recordsSettled`
+ * (objectui#8827) — at every header that writes one. The badge itself stays,
+ * at its size, so the header does not reflow when the number lands. The
+ * marker is decorative (`aria-hidden`); the lane it sits in carries
+ * `aria-busy`, which is what assistive technology reads. No new string.
+ */
+function LaneCountPending() {
+  return (
+    <span
+      aria-hidden="true"
+      data-kanban-lane-count-pending=""
+      className="inline-block h-2 w-2.5 rounded-sm bg-muted-foreground/30 animate-pulse"
+    />
+  )
+}
+
 /**
  * A column's total of the view's `summarizeField`, painted beside its count
  * (objectui#11629). Renders nothing when the board declares no
@@ -796,9 +825,13 @@ function KanbanColumnView({
   const lanePaging = useKanbanLanePaging()
   const lanePage = lanePaging?.pages[String(column.id)]
   const pagedCount = lanePage ? laneCount(lanePage, safeCards.length) : null
-  const laneCountText = pagedCount
-    ? `${pagedCount.count}${pagedCount.atLeast ? '+' : ''}`
-    : laneCountLabel(safeCards.length, countsAreWindowed)
+  // objectstack#30431 — no count before the records settle; see `LaneCountPending`.
+  const countPending = !useKanbanRecordsSettled()
+  const laneCountText = countPending
+    ? <LaneCountPending />
+    : pagedCount
+      ? `${pagedCount.count}${pagedCount.atLeast ? '+' : ''}`
+      : laneCountLabel(safeCards.length, countsAreWindowed)
   // A lane total over a lane that holds more than it drew is a total of what
   // it drew, so it carries the `+` the windowed count carries.
   const laneTotalPartial = countsAreWindowed || lanePage?.hasMore === true
@@ -822,6 +855,7 @@ function KanbanColumnView({
       ref={setNodeRef}
       role="group"
       aria-label={column.title}
+      aria-busy={countPending || undefined}
       aria-disabled={dropBlocked || undefined}
       data-kanban-drop-blocked={dropBlocked ? "" : undefined}
       title={dropBlocked ? dropBlockedReason : undefined}
@@ -869,7 +903,8 @@ function KanbanColumnView({
                 Full
               </Badge>
             )}
-            {!isCollapsed && <LaneTotal cards={safeCards} countsAreWindowed={laneTotalPartial} />}
+            {/* A total over cards that have not arrived is the same false `0`. */}
+            {!isCollapsed && !countPending && <LaneTotal cards={safeCards} countsAreWindowed={laneTotalPartial} />}
           </div>
         </div>
       </div>
@@ -988,9 +1023,12 @@ function KanbanBoardInner({ columns, onCardMove, onCardClick, className, dnd, qu
    * default). It gates the two places below that say "No cards", because both
    * of them are assertions ABOUT THE DATA and this component is reachable —
    * through `KanbanRenderer`'s `React.lazy` boundary — before the data exists.
-   * ⛔ It gates nothing else: lanes, headers, counts and drop targets all keep
-   * rendering while the rows are in flight. The full argument, the measured
-   * reproduction and the settle contract live on the context.
+   * It gates the lane COUNTS for the same reason (objectstack#30431): every
+   * header that writes a count writes `LaneCountPending` instead until the
+   * records settle, since the number it holds before then is a `0` nobody
+   * answered. ⛔ It gates nothing else: lanes, headers, cards and drop targets
+   * all keep rendering while the rows are in flight. The full argument, the
+   * measured reproduction and the settle contract live on the context.
    */
   const recordsSettled = useKanbanRecordsSettled()
 
@@ -1719,10 +1757,14 @@ function KanbanBoardInner({ columns, onCardMove, onCardClick, className, dnd, qu
                     onToggle={() => toggleColumnCollapse(col.id, !collapsed)}
                     className=" text-xs sm:text-sm font-semibold tracking-wider text-primary/90 uppercase"
                   />
+                  {/* objectstack#30431 — the count, and the total, wait for the
+                      records like the flat header's do (`LaneCountPending`). */}
                   {!collapsed && (
-                    <span className="ml-2 text-xs text-muted-foreground">({laneCountLabel(col.cards.length, countsAreWindowed)})</span>
+                    <span className="ml-2 text-xs text-muted-foreground">
+                      {recordsSettled ? `(${laneCountLabel(col.cards.length, countsAreWindowed)})` : <LaneCountPending />}
+                    </span>
                   )}
-                  {!collapsed && (
+                  {!collapsed && recordsSettled && (
                     <LaneTotal cards={col.cards} countsAreWindowed={countsAreWindowed} className="ml-2" />
                   )}
                 </div>
@@ -1748,7 +1790,9 @@ function KanbanBoardInner({ columns, onCardMove, onCardClick, className, dnd, qu
                 >
                   <span className={cn("transition-transform text-xs", isCollapsed ? "" : "rotate-90")}>▶</span>
                   <span className=" text-xs font-semibold text-muted-foreground uppercase tracking-wider">{laneLabel}</span>
-                  <span className=" text-xs text-muted-foreground">({laneCountLabel(laneCardCount, countsAreWindowed)})</span>
+                  <span className=" text-xs text-muted-foreground">
+                    {recordsSettled ? `(${laneCountLabel(laneCardCount, countsAreWindowed)})` : <LaneCountPending />}
+                  </span>
                 </button>
 
                 {/* Lane content */}
 
@@ -33,6 +33,11 @@ import { createContext, useContext } from 'react';
  * ⇒ The only thing hiding the false announcement today is the lazy skeleton
  * happening to be slower than the fetch, and nothing makes it slower.
  *
+ * The lane COUNTS are the same kind of claim and wait on the same signal
+ * (objectstack#30431): before the records settle every header held `0`, which
+ * a board opened right after publish showed under a list footer that already
+ * read 「12 条记录」. See `LaneCountPending` in `KanbanImpl`.
+ *
  * ## Why a tri-state settle and not a `loading` boolean
  *
  * `ObjectKanban` already holds a `loading` boolean — and wiring THAT into the
 
@@ -291,3 +291,95 @@ describe('a card shows its owner\'s avatar when the host names the owner field (
     expect(document.querySelector('[data-kanban-card-owner]')).toBeNull();
   });
 });
+
+/**
+ * objectstack#30431 — a lane count is a claim about the data, so no header
+ * states one before the records settle.
+ *
+ * Measured on cloud's two-plane stack (control plane + runtime): a board opened
+ * right after publish, under a list view whose own count had already answered,
+ * showed footer 「12 条记录」 over lanes reading 0 / 0 / 0 / 0 for as long as
+ * its lane queries were in flight, then 2 / 4 / 2 / 3. Here every query the
+ * board sends is held open until the test lets it go, which is the in-flight
+ * window the stack showed.
+ */
+describe('a board states no lane count while its lane queries are in flight (objectstack#30431)', () => {
+  /** The adapter above, with every `find` held until `release()`. */
+  function heldAdapter(rows: Row[]) {
+    const adapter = makeAdapter(rows);
+    const answer = adapter.find;
+    let release!: () => void;
+    const gate = new Promise<void>((r) => {
+      release = r;
+    });
+    adapter.find = vi.fn(async (object: string, params: any) => {
+      await gate;
+      return answer(object, params);
+    });
+    return { adapter, release: () => act(async () => release()) };
+  }
+
+  const pendingMarker = (columnId: string) =>
+    document.querySelector(`#kanban-col-${columnId}`)?.parentElement?.querySelector('[data-kanban-lane-count-pending]') ?? null;
+
+  it('a lane whose query has not answered shows no count, and its lane says it is busy', async () => {
+    const { adapter, release } = heldAdapter([...deals('open', 2), ...deals('won', 4)]);
+    mount(adapter);
+
+    // RIG SELF-CHECK — every lane's query has left and none has answered, and
+    // the lanes are on screen: the board is not withheld, only the number.
+    await waitFor(() => expect(queries(adapter)).toHaveLength(4));
+    await waitFor(() => expect(lane('Open')).toBeInTheDocument());
+    expect(screen.queryAllByRole('listitem')).toHaveLength(0);
+
+    for (const [id, title] of [['open', 'Open'], ['won', 'Won'], ['lost', 'Lost']] as const) {
+      // RED before the fix: '0' on every lane.
+      expect(laneCountText(id)).toBe('');
+      expect(pendingMarker(id)).not.toBeNull();
+      expect(lane(title)).toHaveAttribute('aria-busy', 'true');
+    }
+
+    await release();
+
+    await waitFor(() => expect(laneCards('Won')).toHaveLength(4));
+    expect(laneCountText('open')).toBe('2');
+    expect(laneCountText('won')).toBe('4');
+    expect(pendingMarker('open')).toBeNull();
+    expect(lane('Open')).not.toHaveAttribute('aria-busy');
+  });
+
+  it('REVERSE: a lane that really holds nothing still reads 0 once its query answers', async () => {
+    const { adapter, release } = heldAdapter([...deals('open', 2), ...deals('won', 4)]);
+    mount(adapter);
+    await waitFor(() => expect(queries(adapter)).toHaveLength(4));
+    await release();
+
+    await waitFor(() => expect(laneCards('Open')).toHaveLength(2));
+    // Withholding the count forever would also pass the test above.
+    expect(laneCountText('lost')).toBe('0');
+    expect(pendingMarker('lost')).toBeNull();
+    expect(lane('Lost')).not.toHaveAttribute('aria-busy');
+  });
+
+  it('the swimlane layout\'s column titles wait the same way', async () => {
+    const { adapter, release } = heldAdapter([...deals('open', 2), ...deals('won', 1)]);
+    mount(adapter, {}, { swimlaneField: 'region' });
+
+    await waitFor(() => expect(queries(adapter)).toHaveLength(1));
+    const titleRow = await waitFor(() => {
+      const row = document.querySelector('[aria-label="Kanban board with swimlanes"] [data-swimlane-scroll-row]');
+      expect(row).not.toBeNull();
+      return row as HTMLElement;
+    });
+    // RED before the fix: '(0)' under every column title.
+    expect(titleRow.textContent).not.toMatch(/\(\d+\+?\)/);
+    expect(titleRow.querySelectorAll('[data-kanban-lane-count-pending]')).toHaveLength(3);
+
+    await release();
+
+    await waitFor(() => expect(titleRow.textContent).toContain('(2)'));
+    expect(titleRow.textContent).toContain('(1)');
+    expect(titleRow.textContent).toContain('(0)');
+    expect(titleRow.querySelectorAll('[data-kanban-lane-count-pending]')).toHaveLength(0);
+  });
+});
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,11 @@ import { createContext, useContext } from 'react';`
`33`	`33`	`* ⇒ The only thing hiding the false announcement today is the lazy skeleton`
`34`	`34`	`* happening to be slower than the fetch, and nothing makes it slower.`
`35`	`35`	`*`
	`36`	`+ * The lane COUNTS are the same kind of claim and wait on the same signal`
	`37`	+ * (objectstack#30431): before the records settle every header held `0`, which
	`38`	`+ * a board opened right after publish showed under a list footer that already`
	`39`	+ * read 「12 条记录」. See `LaneCountPending` in `KanbanImpl`.
	`40`	`+ *`
`36`	`41`	* ## Why a tri-state settle and not a `loading` boolean
`37`	`42`	`*`
`38`	`43`	* `ObjectKanban` already holds a `loading` boolean — and wiring THAT into the