@@ -0,0 +1,12 @@
+---
+"@pretable-internal/row-model": patch
+---
+
+Grouping-apply insert phase (#500 cycle 2): `sum`/`avg`/`count` columns now
+aggregate through O(1) scalar accumulator cells with exact inverses instead
+of per-row ordered trees, only the selected `aggregateFilteredRows`
+population root is built (the other was write-only), and canonical frozen
+aggregate leaves are no longer copied on every insert. Applying grouping at
+50k rows × 10 `avg` columns drops from ~3.7s / ~800MB of transient heap to
+~0.55s / ~130MB; `min`/`max` and custom aggregators keep the ordered tree and
+their exact fold semantics.
@@ -218,8 +218,15 @@ export function BenchApp({ search, browserVersion }: BenchAppProps) {
       }
 
       const snapshot = grid.rowModel.getState().snapshot;
+      // A grouped model's sorted-first ROOT group is the first visible row,
+      // so a bounded prefix scan finds it. Scanning the ENTIRE still-flat
+      // model (50k `rowAt` calls per frame at target scale) stuffed every
+      // frame with harness work and starved the cooperative transition this
+      // wait exists to await — the setup then blew its frame budget on its
+      // own overhead (#500 cycle 2).
+      const scanLimit = Math.min(snapshot.visibleRowCount, 64);
       let firstGroupRow: BenchGroupRow | null = null;
-      for (let index = 0; index < snapshot.visibleRowCount; index += 1) {
+      for (let index = 0; index < scanLimit; index += 1) {
         const row = snapshot.rowAt(index);
         if (row?.kind === "group") {
           firstGroupRow = row;
@@ -263,7 +270,8 @@ export function BenchApp({ search, browserVersion }: BenchAppProps) {
     // run that says so beats a completed run measuring the wrong thing.
     const snapshot = pretableGridRef.current?.rowModel.getState().snapshot;
     if (!snapshot || countPaintedGroupRows() === 0) return null;
-    for (let index = 0; index < snapshot.visibleRowCount; index += 1) {
+    const limit = Math.min(snapshot.visibleRowCount, 64);
+    for (let index = 0; index < limit; index += 1) {
       const row = snapshot.rowAt(index);
       if (row?.kind === "group") return row;
     }
 
@@ -0,0 +1,107 @@
+# Grouping-Apply Insert Phase (#500 cycle 2) — Design
+
+**Status:** approved direction, specced in full.
+**Parent:** `2026-08-29-grouping-apply-cooperative-cost.md` (cycle 1: seal
+units + clock — merged as PR #518). Cycle 1 fixed the seal phase; this fixes
+the insert phase, which measurement showed dominates: **~2.9s of the ~3.2s**
+at 50k rows × 10 `avg` columns.
+
+## The cost, measured (investigation 2026-08-29; scripts in session scratchpad)
+
+Per row, per grouping level, per aggregated column, the build inserts into
+TWO ordered AVL aggregate trees (`all` + `filtered` roots): ~5.8µs and
+~1.4KB of heap per row·column — perfectly linear at ~289ms/72MB per column on
+a 314ms zero-aggregate base. Three structural facts make this waste, not
+work:
+
+1. **The comparator never reads values.** `compareAggregateLeaves` orders by
+   row sort keys only, so a group's 20 aggregate trees are isomorphic — the
+   engine builds 20 identical AVL shapes per group and shares nothing.
+2. **Scalar kinds don't need order.** `sum`/`avg`/`count` are commutative
+   with **exact inverses** (bigint superaccumulator subtraction; count
+   decrement; ±Infinity as counters), and streaming updates already arrive
+   as remove-then-insert with the originally-inserted value on the removal
+   record. Only `min`/`max` (no inverse) and **custom aggregator specs**
+   (associativity is the only validated law — the fold order is observable)
+   need a removal structure. The real builtin `avg` measures ~0.11µs per
+   scalar accumulate — ~50× under the tree path.
+3. **One population root is write-only.** `aggregateFilteredRows` is a
+   model-lifetime option; `aggregateRecord` finalizes only the selected
+   root. The other root is built and never read (its `firstId` serves only a
+   vestigial error-context path).
+
+## Decisions
+
+1. **(A) Kind-aware aggregation.** `sum`/`avg`/`count` columns get a scalar
+   accumulator cell behind the same root interface
+   (`insertOrReplace`/`remove`/`finalize`/`firstId`): insert = accumulate,
+   remove = exact inverse (bigint units subtraction, count decrement,
+   ±Infinity flags become counters so `Inf + (−Inf) → NaN` finalize
+   semantics survive; NaN admission applied symmetrically on both sides).
+   `min`/`max` and custom specs keep the ordered tree unchanged. Scalar
+   columns charge **no seal units** (accumulate is O(1) inline at insert);
+   the cooperative resumable-unit contract is untouched for the kinds that
+   still seal. `firstId` on a builtin-only scalar group may return
+   undefined — its only consumer is custom-finalizer error context.
+2. **(C1) Build only the selected population root.** The unselected root
+   (`filtered` when `aggregateFilteredRows` is on — the option selects the
+   `all` population — and `all` otherwise) is
+   write-only today; stop building it. Halves the remaining tree cost for
+   min/max/custom AND the scalar-cell writes. `representativeRowId` falls
+   back to the root that exists. The option is model-lifetime, so nothing
+   can request the dropped root later.
+3. **(micro) `normalizedLeaf` stops copying frozen leaves** — it currently
+   allocates a fresh frozen copy of an already-frozen leaf on every insert
+   (~157ms + GC at 50k×10). Return the input when it is already canonical.
+4. **Rejected: bulk tree construction at seal (shape B)** — the O(n)
+   `createOrderStatisticTreeFromSortedEntries` primitive exists, but B keeps
+   the full allocation/GC bill, needs non-resumable per-group sorts inside
+   the cooperative seal, and under A+C1 the residual tree count is too small
+   to repay that; **rejected: multi-measure shared trees (C2)** — mostly
+   redundant once A lands, large typing/instrumentation churn.
+5. **Streaming stays the CONTROL and should strictly improve** — scalar
+   cells make per-touch group updates O(1) where trees were O(log n). The
+   S5 group-updates 20k p95 (10.0ms) must not regress; any improvement is
+   welcome but not claimed in advance.
+
+## Invariants that must be test-pinned (the risk register, made checkable)
+
+- **Inverse exactness**: insert/remove fuzz (randomized adds/removes incl.
+  NaN, ±Infinity, duplicates) comparing the scalar cell against a tree
+  oracle for sum/avg/count — final values identical, intermediate finalize
+  identical at every step.
+- **Remove-then-insert invariant**: streaming updates must keep arriving as
+  remove-then-insert (scalar cells cannot detect replace); pin it with a
+  test that fails if an update path skips the remove.
+- **±Infinity finalize semantics**: `Inf`, `−Inf`, and mixed populations
+  finalize identically to the tree path, including after removals that
+  clear one flag.
+- **Custom specs untouched**: an order-sensitive custom aggregator (one the
+  associativity law permits but commutativity would break) produces the
+  SAME fold as before — proving customs still ride the ordered tree.
+- **C1 twins**: both `aggregateFilteredRows` configs run the full aggregate
+  fixture set; a filter making the two populations differ proves the
+  SELECTED root is the one surviving.
+- **Cycle-1 pins hold**: unit-accounting and slice bounds re-derived for
+  scalar columns charging zero seal units (the existing pins' fixtures use
+  aggregated columns — update the derivations honestly, don't loosen).
+
+## Verification
+
+- The pins above; the full row-model + react suites untouched-green.
+- Node repro (50k×10avg): time-to-grouped from ~3.2s to **≤ 600ms** (target
+  ~400-450ms; the gate at 600 leaves loaded-box headroom), heap Δ from
+  ~780MB to ≤ 200MB.
+- Bench, same-window controls: S2 `group`/`group-expand` at target scale
+  return **`completed`** (the #500 headline); settle reported against the
+  ~400ms pre-#321 number; S5 `group-updates` 20k p95 ≤ 10.0ms (control);
+  3k/750 settles reported. Isolated port, full output to files.
+- Changeset: `@pretable-internal/row-model` patch.
+- #500 closes only if S2 target completes; else it stays open with the
+  residual named.
+
+## Out of scope
+
+The renderer-dom height-index cost (filed, task chip); shape B / C2
+(rejected above, revisit only with new evidence); any change to budget or
+slicing constants; the jsdom setDerivations stall.
@@ -447,8 +447,11 @@ function failingOverrideRoot(): {
     leaves: { size: 1, entryAt: () => ({ rowId: 1 }) },
     filteredCount: 1,
     allCount: 1,
+    // Under C1 (#500 cycle 2) only the SELECTED population root exists —
+    // `filtered` for this root's `aggregateFilteredRows: false` — so the
+    // representative-row fallback must find `firstId` there, not in `all`.
     aggregateRoots: {
-      all: new Map([["score", aggregateTree]]),
+      all: new Map(),
       filtered: new Map([["score", aggregateTree]]),
     },
     aggregates: Object.freeze({ score: 1 }),
 
@@ -116,13 +116,17 @@ function groupAggregates(model: {
 
 describe("grouping-apply cooperative cost (#500)", () => {
   test("the grouped candidate charges O(R) units, not R × columns × roots", () => {
-    // R = 600 rows over 8 aggregated columns and 4 groups. Charged units:
+    // R = 600 rows over 8 aggregated columns and 4 groups. The fixture is
+    // deliberately MIXED — 4 scalar (sum/avg) + 4 tree (min/max) columns —
+    // so both accounting regimes are pinned at once. Charged units:
     //   insert phase: exactly R (one row evaluated per unit), then
-    //   seal phase:   one unit per ROW (all aggregated columns and both
-    //                 population roots sealed together) plus 2 node units
-    //                 per group (finalize + parent/root edge).
-    // The old accounting charged R × 8 columns × 2 roots = 16R seal units,
-    // which cannot fit under R + C for any small constant C.
+    //   seal phase:   one unit per ROW for the TREE-backed columns (all of
+    //                 a node's still-pending trees seal together; #500 cycle
+    //                 2 builds only the selected population root and scalar
+    //                 sum/avg/count columns charge nothing) plus 2 node
+    //                 units per group (finalize + parent/root edge).
+    // The original accounting charged R × 8 columns × 2 roots = 16R seal
+    // units, which cannot fit under R + C for any small constant C.
     const rowCount = 600;
     const scheduler = new ManualScheduler();
     const model = createLocalRowModel({
@@ -166,6 +170,62 @@ describe("grouping-apply cooperative cost (#500)", () => {
     expect(AGGREGATED_COLUMN_COUNT * rowCount).toBeGreaterThan(rowCount + 64);
   });
 
+  test("scalar-only aggregate columns charge zero seal units (#500 cycle 2)", () => {
+    // Every aggregated column here is sum/avg/count — scalar cells that
+    // accumulate inline at insert. The seal phase therefore has ONLY node
+    // structure to do: 2 units per group node (finalize + parent/root edge)
+    // and completion bookkeeping — nothing proportional to R. A scalar
+    // column falling back to the tree path re-adds ~R units and fails the
+    // constant bound.
+    const rowCount = 600;
+    const scheduler = new ManualScheduler();
+    const model = createLocalRowModel({
+      rows: makeRows(rowCount),
+      columns: [
+        helper.accessor("team", { type: "text" }),
+        helper.accessor("score", { type: "number" }),
+        helper.accessor("m0", { type: "number", aggregate: "sum" }),
+        helper.accessor("m1", { type: "number", aggregate: "avg" }),
+        helper.accessor("m2", { type: "number", aggregate: "count" }),
+        helper.accessor("m3", { type: "number", aggregate: "sum" }),
+        helper.accessor("m4", { type: "number", aggregate: "avg" }),
+        helper.accessor("m5", { type: "number", aggregate: "count" }),
+        helper.accessor("m6", { type: "number", aggregate: "sum" }),
+        helper.accessor("m7", { type: "number", aggregate: "avg" }),
+      ] as const,
+      getRowId: (row) => row.id,
+      query: { filters: [], sort: [], rowGroups: [] },
+      transitionScheduler: scheduler,
+      transitionClock: () => 0,
+    });
+    model.setQuery({
+      filters: [],
+      sort: [],
+      rowGroups: [{ columnId: "team", direction: "asc" }],
+    });
+    const candidate = getLocalRowModelActiveTransitionCandidateForTesting(
+      model,
+    ) as { readonly totalRows: number } | undefined;
+    expect(candidate).toBeDefined();
+    let flushed = 0;
+    while (model.getState().status.kind !== "ready") {
+      if (!scheduler.flushOne()) break;
+      flushed += 1;
+      if (flushed > 100_000) throw new Error("Transition did not settle.");
+    }
+    expect(model.getState().status).toEqual({ kind: "ready" });
+    // `totalRows` is monotonic and folds in the builder's charged seal units
+    // when the insert phase ends, so the FINAL reading exposes the full
+    // charge even when sealing itself finishes inside one slice (a
+    // between-slice max can miss it entirely — verified by mutation).
+    // Derivation: 4 groups × 2 node units + completion bookkeeping — the
+    // bound (64) is R-independent; the mixed-fixture test above proves the
+    // same machinery charges ~R when tree columns are present.
+    const sealCharge = candidate!.totalRows - rowCount;
+    expect(sealCharge).toBeGreaterThanOrEqual(0);
+    expect(sealCharge).toBeLessThanOrEqual(64);
+  });
+
   for (const aggregateFilteredRows of [false, true]) {
     test(`aggregates survive the per-row seal (aggregateFilteredRows: ${aggregateFilteredRows})`, async () => {
       // 41 rows (not a multiple of the team count) with per-column-distinct
@@ -238,8 +298,10 @@ describe("grouping-apply cooperative cost (#500)", () => {
   }
 
   test("a full 8k-row grouped rebuild completes within the derived slice bound", () => {
-    // Charged units ≈ R inserts + R row-seals + 2 units per group node +
-    // completion bookkeeping ≈ 2R + small. With the clock frozen, every
+    // Charged units ≈ R inserts + R row-seals (the fixture's min/max
+    // columns keep the ordered tree; its scalar sum/avg columns charge
+    // nothing — #500 cycle 2) + 2 units per group node + completion
+    // bookkeeping ≈ 2R + small. With the clock frozen, every
     // slice runs exactly the 256-unit cap, so slices ≈ ceil((2 × 8_000 +
     // small) / 256) ≈ 63. The bound below allows ~1.5× headroom; the old
     // per-(row × column × root) accounting needed ~530 slices here and