fix(react): the group column is not a data column, and the seams that said it was (#497)

* chore: stop a failing package hiding the rest of the suite, and strike a done roadmap line

pnpm -r bails on the first failing package by default, so one timeout in an
early package silently skipped every package after it — a full run once
never reached core, renderer-dom, react or the apps at all, while the
failure read as a single known flake. --no-bail runs them all and STILL
exits 1 (measured on pnpm 10.12.1; pnpm's own docs claim otherwise). Left
on the build step, where a failure should stop everything.

Residual: the three phases are still chained with &&, so a package-test
failure keeps the apps from running. Fixing that needs exit-code collection,
not a flag.

Roadmap: "public API/documentation gaps + stable row identity" is done.
All four .api.md reports are at zero ae-forgotten-export; getRowId is
required at every entry point with its index parameter removed (#293); and
four fail-closed guards cover API surface (#290), docs tables (#280),
engine reconciliation (#266) and facade forwarding (#301).

* fix(react): the group column is not a data column, and the seams that said it was

Grouping's boundaries with pinning, editing and streaming had no tests at all,
which is where all three prior grouping correctness rounds came from (#259,
#264, #495). Probing those three seams found two live defects, both the #495
shape: a consumer-facing "data column" set that filters only the row-select
checkbox instead of `isSyntheticColumnId`. Ungrouped the two predicates are the
same test, so each site looked correct for as long as nothing was grouped.

1. Announced column counts described a grid one column wider than the artifact.
   Grouped, Cmd+A then Cmd+C put 2 columns on the clipboard and announced 3;
   `exportCsv` wrote a 2-column file and announced 3. `copy.ts`, `csv.ts` and
   `paste.ts` all drop both synthetics, so the announcement — a statement ABOUT
   that clipboard or that file — has to drop them too. `computeSelectionExtent`
   now resolves spans in DATA ordinals with a group-column bound collapsing to
   data column 0, byte-for-byte `resolveRangeBounds`.

2. `onSelectedRowIdChange` went silent while grouped. A range over every real
   data column is a full row, but `singleFullRowSelection` was handed the drawn
   list, whose first entry is the synthetic group column — so the range never
   matched and a consumer's "open the selected record" wiring stopped firing the
   moment the user grouped.

Tests: grouping boundaries added to the three suites that had none —
right-pin (drawn order, pinned insets, grouping BY a right-pinned column,
`groupColumn: {pinned:"left"}`, group-row alignment, drawn `aria-colcount`),
editing (commit inside a group, group rows refuse an editor, an edit cancels
when grouping hides its column or collapses its row, a commit that re-paths
into a collapsed group settles), and streaming (selection/focus survive an
in-place update and a key re-path, expansion and aggregates track, a removed
focused row clears focus, an in-flight editor survives a re-path). Every one
runs a grouped leg against an ungrouped control.

Editing and streaming were probed and found CORRECT — those tests pin
behaviour rather than fix it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(website): the hero's selection summary counts what the clipboard carries

summarizeSelection filtered only the row-select column, so while grouped it
counted the derived group column too — the sidebar claimed one more column
than Cmd+C actually copies. Same defect the library seams had, and it is
directly in the Excel-interop story: 'N x 3 selected' next to a two-column
paste.

Two tests pinned the over-count and are corrected, not weakened:
- selection.test.ts asserted cols: 3 and its comment claimed the group
  column 'is inside the rectangle Cmd+C copies'. Rows and columns are not
  symmetric: group ROWS carry labels and aggregates and do copy; the group
  COLUMN is presentation and was dropped from copy/CSV/paste in #495.
- grouping.spec.ts derived its expectation as headerCells - 1, subtracting
  only the selector. It now counts headers carrying a data-pretable-column-id
  and excludes the group column, so it still fails if a hero column is added.

Negative control: reverting the filter fails selection.test.ts.

* test(react): poll the header assertion that races setQuery's settle

external-filter-authority polled for the rows to settle, then asserted the
header state bare. setQuery settles asynchronously across cooperative slices
(#321), so the rows can be drawn a slice before the header reports — under
load the bare assertion loses that race and reads ariaSort 'none' /
filterActive 'false'.

Not caused by this branch: three full react runs on it produced three
different outcomes (eviction-population-change, then this, then 1457 green),
which is the signature of a load race rather than a regression. Both suspects
pass 3/3 in isolation.

Surfaced now because --no-bail (this branch) stops a failing package hiding
the ones after it, so more of the suite actually runs.

* test(website): drive the stubbed clock inside the wait it gates

HeroGrid's replay test stubs requestAnimationFrame, so the replay only
advances when a frame is flushed by hand. It flushed exactly two, then
waitFor'd for an aggregate to change. If those two did not move THAT
sector's value, the retry loop span against a frozen clock until timeout —
waiting cannot rescue a value nothing is ticking. Each attempt now flushes
another frame, so the loop advances the thing it waits on.

HONEST LIMIT: I could not reproduce the CI failure locally to prove this
fixes it. The old version passes 6/6 at load ~14; the observed failures
were at load 30-50. So this is reasoned, not demonstrated — it removes a
real mechanism that can produce exactly this symptom, and is strictly more
correct given rAF is stubbed, but it is not a verified fix for that run.

NOT caused by this branch, proven structurally rather than statistically:
the failing assertions read summary-nav/summary-pnl, which come from
buildModel(rows) in PortfolioSummary and depend only on rows. This branch
changed summarizeSelection, whose output feeds a sibling SelectionSection.
There is no path from the change to those elements.

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: blove

ROADMAP.md

@@ -37,8 +37,6 @@ See the current [core changelog](packages/core/CHANGELOG.md),
 
 ## Now — harden and measure
 
-- Close remaining public API/documentation gaps and make stable row identity
-  consistent across entry points.
 - Add deterministic PMS and financial-planning benchmark profiles without
   weakening existing 60 Hz, zero-gap, and interaction-continuity gates.
 

apps/website/app/components/__tests__/HeroGrid.test.tsx

@@ -256,21 +256,27 @@ describe("HeroGrid", () => {
     const sidebarBefore = screen.getByTestId("summary-pnl").textContent;
     expect(screen.getByTestId("summary-nav")).toHaveTextContent("$66.1M");
 
-    await act(async () => {
-      flushAnimationFrame(1_000);
-      flushAnimationFrame(1_016);
-    });
-
-    await waitFor(() => {
-      expect(
-        groupRowNamed("Consumer")!.querySelector(
-          '[data-pretable-column-id="dayPnl"]',
-        ),
-      ).not.toHaveTextContent(aggregateBefore ?? "");
-      expect(screen.getByTestId("summary-pnl")).not.toHaveTextContent(
-        sidebarBefore ?? "",
-      );
-    });
+    // `requestAnimationFrame` is stubbed, so the replay only advances when a
+    // frame is flushed by hand — `waitFor` alone cannot rescue a value that has
+    // not been ticked. Two frames were not always enough to move THIS sector's
+    // aggregate, and the retry loop then span against a frozen clock until it
+    // timed out. Drive the clock inside the wait instead: each attempt flushes
+    // another frame, so the loop advances the thing it is waiting on.
+    let frame = 1_000;
+    await waitFor(
+      () => {
+        flushAnimationFrame((frame += 16));
+        expect(
+          groupRowNamed("Consumer")!.querySelector(
+            '[data-pretable-column-id="dayPnl"]',
+          ),
+        ).not.toHaveTextContent(aggregateBefore ?? "");
+        expect(screen.getByTestId("summary-pnl")).not.toHaveTextContent(
+          sidebarBefore ?? "",
+        );
+      },
+      { timeout: 5_000 },
+    );
     expect(panel).toHaveTextContent("Sector");
     expect(
       screen.getByRole("treegrid", { name: /live portfolio positions/i }),

apps/website/app/components/heroGrid/__tests__/selection.test.ts

@@ -96,19 +96,22 @@ describe("summarizeSelection", () => {
       ).toBeNull();
     });
 
-    it("counts the derived group column, and group rows, while grouped", () => {
+    it("counts group rows but NOT the derived group column, while grouped", () => {
       // Grouped by c1: the drawn order loses c1 and gains the group column
       // after the pinned region, and `visibleRows` interleaves group headers
-      // with the leaves. Both are inside the rectangle ⌘C copies, so both count
-      // — a whole-row range here is 3 rows (two leaves and a header) × 3 data
-      // columns (the group column and the two survivors).
+      // with the leaves. They are not symmetric. Group ROWS reach the clipboard
+      // — they carry the label and the aggregates — so they count. The group
+      // COLUMN does not: it is presentation, dropped from copy/CSV/paste so a
+      // block pasted into Excel is the shape Excel expects. Counting it would
+      // make the sidebar claim one more column than ⌘C actually copies.
+      // So: 3 rows (two leaves and a header) × 2 columns (the survivors).
       expect(
         summarizeSelection(
           sel([["g:A", "r2", ROW_SELECT, "c3"]]),
           [ROW_SELECT, GROUP_COLUMN_ID, "c2", "c3"],
           ["g:A", "r1", "r2", "g:B", "r3"],
         ),
-      ).toEqual({ rows: 3, cols: 3 });
+      ).toEqual({ rows: 3, cols: 2 });
     });
   });
 });

apps/website/app/components/heroGrid/selection.ts

@@ -1,4 +1,11 @@
+import { GROUP_COLUMN_ID } from "@pretable/core";
 import { ɵROW_SELECT_COLUMN_ID as ROW_SELECT_COLUMN_ID } from "@pretable/react";
+
+// Both synthetic columns are presentation, and neither reaches the clipboard —
+// mirroring `isSyntheticColumnId` in @pretable/react. Counting either here makes
+// the sidebar claim a wider selection than ⌘C actually copies.
+const isSynthetic = (id: string) =>
+  id === ROW_SELECT_COLUMN_ID || id === GROUP_COLUMN_ID;
 import type { PretableSelectionState } from "@pretable/core";
 
 export interface SelectionSummary {
@@ -35,7 +42,7 @@ export function summarizeSelection(
   rowOrder: readonly string[],
 ): SelectionSummary | null {
   if (!selection.ranges.length) return null;
-  const dataColumns = columnOrder.filter((id) => id !== ROW_SELECT_COLUMN_ID);
+  const dataColumns = columnOrder.filter((id) => !isSynthetic(id));
   if (!dataColumns.length) return null;
   const rowIdx = new Map(rowOrder.map((id, i) => [id, i]));
   const colIdx = new Map(dataColumns.map((id, i) => [id, i]));
@@ -45,8 +52,8 @@ export function summarizeSelection(
     const r0 = rowIdx.get(r.startRowId),
       r1 = rowIdx.get(r.endRowId);
     if (r0 === undefined || r1 === undefined) continue;
-    const startSynth = r.startColumnId === ROW_SELECT_COLUMN_ID;
-    const endSynth = r.endColumnId === ROW_SELECT_COLUMN_ID;
+    const startSynth = isSynthetic(r.startColumnId);
+    const endSynth = isSynthetic(r.endColumnId);
     if (startSynth && endSynth) continue;
     const c0 = startSynth ? 0 : colIdx.get(r.startColumnId);
     const c1 = endSynth ? 0 : colIdx.get(r.endColumnId);

apps/website/e2e/grouping.spec.ts

@@ -1227,10 +1227,16 @@ test("the hero arrives ungrouped and groups when a header is dragged onto the pa
 
   const selection = page.getByRole("region", { name: "Selection" });
   await expect(selection).toContainText(/selected · ⌘C to copy/);
-  // Every drawn column except the selector, derived from the header row rather
-  // than hard-coded so adding a hero column does not silently pass.
-  const drawnDataColumns =
-    (await page.locator("[data-pretable-header-cell]").count()) - 1;
+  // Every drawn column the clipboard actually carries: derived from the header
+  // row rather than hard-coded so adding a hero column does not silently pass,
+  // and excluding BOTH synthetic columns. The selector header carries no
+  // `data-pretable-column-id`; the group column carries its own. Counting
+  // either would pin the sidebar claiming a wider selection than ⌘C copies.
+  const drawnDataColumns = await page
+    .locator(
+      '[data-pretable-header-cell][data-pretable-column-id]:not([data-pretable-column-id="__pretable_group__"])',
+    )
+    .count();
   expect(drawnDataColumns).toBeGreaterThan(1);
   const [rows, cols] = (await selection.innerText())
     .match(/(\d+) × (\d+) selected/)!

package.json

@@ -32,7 +32,7 @@
     "lint": "pnpm -r lint",
     "lint:packaging": "pnpm --filter @pretable/core lint:packaging && pnpm --filter @pretable/react lint:packaging && pnpm --filter @pretable/stream-adapter lint:packaging && pnpm --filter @pretable/ui lint:packaging",
     "publish:preflight": "node ./scripts/publish-preflight.mjs",
-    "test": "node --test scripts/__tests__/analyze-cdp.test.mjs scripts/__tests__/bench-comparator-provenance.test.mjs scripts/__tests__/bench-e2e.test.mjs scripts/__tests__/bench-matrix.test.mjs scripts/__tests__/check-bench-budgets.test.mjs scripts/__tests__/check-prod-deploy.test.mjs scripts/__tests__/check-type-performance.test.mjs scripts/__tests__/public-api-forgotten-exports.test.mjs scripts/__tests__/public-api-symbol-brands.test.mjs scripts/__tests__/publish-preflight.test.mjs scripts/__tests__/publish-public-packages.test.mjs scripts/__tests__/workspace-scripts-own-one-package.test.mjs && pnpm -r --filter './packages/*' build && pnpm -r --filter './packages/*' test && pnpm -r --workspace-concurrency=1 --filter './apps/*' test",
+    "test": "node --test scripts/__tests__/analyze-cdp.test.mjs scripts/__tests__/bench-comparator-provenance.test.mjs scripts/__tests__/bench-e2e.test.mjs scripts/__tests__/bench-matrix.test.mjs scripts/__tests__/check-bench-budgets.test.mjs scripts/__tests__/check-prod-deploy.test.mjs scripts/__tests__/check-type-performance.test.mjs scripts/__tests__/public-api-forgotten-exports.test.mjs scripts/__tests__/public-api-symbol-brands.test.mjs scripts/__tests__/publish-preflight.test.mjs scripts/__tests__/publish-public-packages.test.mjs scripts/__tests__/workspace-scripts-own-one-package.test.mjs && pnpm -r --filter './packages/*' build && pnpm -r --no-bail --filter './packages/*' test && pnpm -r --no-bail --workspace-concurrency=1 --filter './apps/*' test",
     "typecheck": "pnpm -r --filter './packages/*' build && pnpm -r --filter './packages/*' typecheck && pnpm -r --workspace-concurrency=1 --filter './apps/*' typecheck",
     "typecheck:performance": "pnpm --filter '@pretable/core...' build && node ./scripts/check-type-performance.mjs",
     "typecheck:public": "pnpm --filter '@pretable/react...' build && pnpm exec tsc -p type-tests/tsconfig.json --noEmit && pnpm exec tsc -p type-tests/tsconfig.react.json --noEmit"