Bump attribution CHUNK_SIZE from 50 to 500

Author: shikokuchuo

hub-client/src/services/attribution.test.ts

@@ -468,9 +468,10 @@ describe('updateAttributionMap — incremental update', () => {
 
 describe('buildAttributionMap — chunked processing', () => {
   it('processes large history in chunks via requestIdleCallback', async () => {
-    // Create 120 history entries, each inserting one character
+    // Create CHUNK_SIZE+20 history entries to force more than one chunk.
+    const N = CHUNK_SIZE + 20;
     const entries: MockHistoryEntry[] = [];
-    for (let i = 0; i < 120; i++) {
+    for (let i = 0; i < N; i++) {
       entries.push({
         heads: [`h${i}`],
         actor: `actor${i % 2}`,
@@ -485,11 +486,9 @@ describe('buildAttributionMap — chunked processing', () => {
     const result = await buildAttributionMap(handle as any, 'text');
 
     expect(result).not.toBeNull();
-    expect(result!.entries).toHaveLength(120);
-    // requestIdleCallback should have been called for chunking
-    // 120 entries / CHUNK_SIZE chunks, plus potentially the initial call
+    expect(result!.entries).toHaveLength(N);
     expect(mockRequestIdleCallback.mock.calls.length).toBeGreaterThanOrEqual(
-      Math.ceil(120 / CHUNK_SIZE)
+      Math.ceil(N / CHUNK_SIZE),
     );
   });
 
@@ -507,15 +506,14 @@ describe('buildAttributionMap — chunked processing', () => {
     mockDiff.mockImplementation(createMockDiff(entries));
 
     const controller = new AbortController();
-    controller.abort(); // Abort before calling
+    controller.abort();
 
     const result = await buildAttributionMap(handle as any, 'text', controller.signal);
 
     expect(result).toBeNull();
   });
 
   it('returns null when signal is aborted between chunks', async () => {
-    // Create enough entries to span multiple chunks
     const entries: MockHistoryEntry[] = [];
     for (let i = 0; i < CHUNK_SIZE + 10; i++) {
       entries.push({
@@ -531,12 +529,10 @@ describe('buildAttributionMap — chunked processing', () => {
 
     const controller = new AbortController();
 
-    // Abort after the first chunk's requestIdleCallback fires
     let callCount = 0;
     mockRequestIdleCallback.mockImplementation((cb: IdleRequestCallback) => {
       callCount++;
       if (callCount === 1) {
-        // Let first chunk complete, then abort
         cb({ didTimeout: false, timeRemaining: () => 50 } as IdleDeadline);
         controller.abort();
       } else {

hub-client/src/services/attribution.ts

@@ -66,8 +66,15 @@ export class HistoryCompactedError extends Error {
   }
 }
 
-/** Number of history entries processed per idle callback chunk. */
-export const CHUNK_SIZE = 50;
+/**
+ * History entries processed between idle-callback yields. Tuning knob:
+ * larger values reduce the number of rIC round trips (faster
+ * time-to-attribution) but make each slice's CPU block bigger (more frame
+ * jank risk). 500 gives ~2.5 ms of CPU per slice at bench-measured
+ * ~5 µs/entry, comfortably under one 60 Hz frame even when real Automerge
+ * diffs push per-entry cost an order of magnitude higher.
+ */
+export const CHUNK_SIZE = 500;
 
 // ---------------------------------------------------------------------------
 // Internal: patch application
@@ -186,14 +193,14 @@ export async function buildAttributionMap(
   let prevHeads: unknown = null;
   let lastHeads: unknown[] = [];
 
-  // Process history in chunks, yielding to the event loop between each
+  // Process history in fixed-count chunks, yielding between each. Chunk
+  // size is the frame-impact vs. time-to-attribution tuning knob — see
+  // CHUNK_SIZE docs.
   for (let chunkStart = 0; chunkStart < history.length; chunkStart += CHUNK_SIZE) {
-    // Yield before each chunk to avoid blocking the main thread
     await waitForIdle();
     if (signal?.aborted) return null;
 
     const chunkEnd = Math.min(chunkStart + CHUNK_SIZE, history.length);
-
     for (let i = chunkStart; i < chunkEnd; i++) {
       const currHeads = history[i];
       const changeHash = extractChangeHash(currHeads);
@@ -202,10 +209,8 @@ export async function buildAttributionMap(
       const time = meta?.time ?? 0;
       const attribution: CharAttribution = { actor, time };
 
-      // Get patches from diff
       const decodedCurr = decodeHeads(currHeads as Parameters<typeof decodeHeads>[0]);
       let patches: unknown[];
-
       if (prevHeads === null) {
         patches = diff(
           viewable.doc() as Parameters<typeof diff>[0],