feat(sync): add balanced subtree resync benchmarks

Author: marcus-pousette

docs/BENCHMARKS.md

@@ -35,6 +35,7 @@ pnpm benchmark:postgres
 
 - First view on a new device, structure only: `benchmark:sync:*` with `sync-balanced-children-cold-start`
 - First view on a new device, with payloads: `benchmark:sync:*` with `sync-balanced-children-payloads-cold-start`
+- Re-sync the same subtree on a restarted client that already has that scope locally: `benchmark:sync:*` with `sync-balanced-children-resync` or `sync-balanced-children-payloads-resync`
 - Single end-to-end time-to-first-visible-page number: `benchmark:sync:*` with the same balanced workloads plus `--first-view`
 - One-time bootstrap/discovery tax before opening the regional websocket: `benchmark:sync:bootstrap`
 - Local render cost after the data is already present: `benchmark:sqlite-node:note-paths -- --benches=read-children-payloads`
@@ -78,6 +79,25 @@ pnpm benchmark:sync:remote -- \
 
 Use `--fanout=20` when you want to model a broader notebook tree.
 
+### Re-Sync The Same Subtree
+
+Balanced-tree re-sync is the closest current benchmark to "restart a client that
+already has this subtree locally, then reconcile that same scope again".
+
+```sh
+pnpm sync-server:postgres:db:start
+pnpm benchmark:sync:local -- \
+  --workloads=sync-balanced-children-resync,sync-balanced-children-payloads-resync \
+  --counts=10000,100000 \
+  --fanout=10
+pnpm sync-server:postgres:db:stop
+```
+
+These workloads keep the same balanced immediate-subtree shape as the first-view
+benchmarks, but the receiver already has the current scoped result. That means
+they measure the normal non-empty scoped reconcile path instead of the
+empty-receiver direct-send shortcut.
+
 ### Prime Sync Server Fixtures
 
 Use this when you want to prebuild sync-server fixtures before running the actual sync benchmarks.
@@ -411,6 +431,8 @@ Product-facing defaults:
 - `sync-one-missing`: narrow protocol baseline for a tiny delta
 - `sync-balanced-children-cold-start`: new device already knows the scope root and pulls the immediate children of a node from a balanced tree
 - `sync-balanced-children-payloads-cold-start`: same balanced-tree cold-start path, plus payloads
+- `sync-balanced-children-resync`: same balanced immediate-subtree shape, but the client already has that scoped result locally and re-runs scoped reconcile
+- `sync-balanced-children-payloads-resync`: same balanced re-sync path, plus payloads for the scope root and those immediate children
 
 Specialized or synthetic workloads:
 

packages/sync/server/postgres-node/src/server.ts

@@ -95,6 +95,9 @@ type DocContext = {
 
 type PostgresNodeDocStore = {
   provider: WebSocketSyncServerDocProvider<Operation>;
+  // When the exact applied ops are available in-process, peers can use the
+  // fast delta path. Cross-process invalidation only knows "this doc changed",
+  // so callers may omit ops and force peers to rescan their subscriptions.
   notifyDocUpdate: (docId: string, ops?: readonly Operation[]) => void;
   closeAll: () => Promise<void>;
 };
@@ -482,6 +485,10 @@ export function createPostgresNodeDocStore(
   let closing = false;
   let closeAllPromise: Promise<void> | undefined;
 
+  // `ops` is optional because not every update source can provide the exact
+  // applied batch. Local applyOps calls can forward precise ops to in-process
+  // peers, while pg_notify-style cross-process invalidation only reports the
+  // doc id and falls back to subscription rescans.
   const notifyDocUpdate = (docId: string, ops?: readonly Operation[]): void => {
     const ctx = docs.get(docId);
     if (!ctx) return;

packages/treecrdt-benchmark/src/sync.ts

@@ -6,7 +6,9 @@ import { benchTiming } from './timing.js';
 export type SyncBenchWorkload =
   | 'sync-all'
   | 'sync-balanced-children-cold-start'
+  | 'sync-balanced-children-resync'
   | 'sync-balanced-children-payloads-cold-start'
+  | 'sync-balanced-children-payloads-resync'
   | 'sync-children'
   | 'sync-children-cold-start'
   | 'sync-children-payloads'
@@ -25,6 +27,10 @@ export const DEFAULT_SYNC_BENCH_WORKLOADS = [
   'sync-balanced-children-cold-start',
   'sync-balanced-children-payloads-cold-start',
 ] as const satisfies readonly SyncBenchWorkload[];
+export const PRODUCT_RESYNC_SYNC_BENCH_WORKLOADS = [
+  'sync-balanced-children-resync',
+  'sync-balanced-children-payloads-resync',
+] as const satisfies readonly SyncBenchWorkload[];
 export const SYNTHETIC_SYNC_BENCH_WORKLOADS = [
   'sync-all',
   'sync-children',
@@ -34,6 +40,7 @@ export const SYNTHETIC_SYNC_BENCH_WORKLOADS = [
 ] as const satisfies readonly SyncBenchWorkload[];
 export const ALL_SYNC_BENCH_WORKLOADS = [
   ...DEFAULT_SYNC_BENCH_WORKLOADS,
+  ...PRODUCT_RESYNC_SYNC_BENCH_WORKLOADS,
   ...SYNTHETIC_SYNC_BENCH_WORKLOADS,
 ] as const satisfies readonly SyncBenchWorkload[];
 export const DEFAULT_SYNC_BENCH_ROOT_CHILDREN_WORKLOADS = [
@@ -252,6 +259,89 @@ function buildBalancedChildrenColdStartCase(opts: {
   };
 }
 
+function buildBalancedChildrenResyncCase(opts: {
+  size: number;
+  fanout: number;
+  replicas: { s: ReplicaId; p: ReplicaId };
+  root: string;
+  payloadBytes: number;
+  withPayloads: boolean;
+}): SyncBenchCase {
+  const treeSize = opts.size;
+  if (!Number.isInteger(treeSize) || treeSize <= opts.fanout) {
+    throw new Error(`balanced children re-sync requires size > fanout (${opts.fanout})`);
+  }
+
+  const sharedOps = buildFanoutInsertTreeOps({
+    replica: opts.replicas.s,
+    size: treeSize,
+    fanout: opts.fanout,
+    root: opts.root,
+  });
+  const scopeRootInsert = sharedOps[0];
+  if (!scopeRootInsert || scopeRootInsert.kind.type !== 'insert') {
+    throw new Error('expected balanced tree seed to start with scope root insert');
+  }
+
+  const targetParent = scopeRootInsert.kind.node;
+  const targetChildren = targetChildrenForFirstChild(treeSize, opts.fanout);
+  const scopedNodes = new Set([targetParent, ...targetChildren]);
+  const opsB: Operation[] = [...sharedOps];
+
+  if (opts.withPayloads) {
+    let counter = 0;
+    let lamport = maxLamport(sharedOps);
+    for (let i = 0; i < sharedOps.length; i += 1) {
+      const op = sharedOps[i];
+      if (op?.kind.type !== 'insert') continue;
+      opsB.push(
+        makeOp(opts.replicas.p, ++counter, ++lamport, {
+          type: 'payload',
+          node: op.kind.node,
+          payload: payloadBytesFromSeed(i + 1, opts.payloadBytes),
+        }),
+      );
+    }
+  }
+
+  // Re-sync benchmarks model a client that already has the exact scoped result
+  // from an earlier session, so reconcile should confirm "already in sync"
+  // instead of transferring the subtree again.
+  const opsA = opsB.filter((op) => {
+    if (op.kind.type === 'insert') {
+      return op.kind.node === targetParent || op.kind.parent === targetParent;
+    }
+    if (op.kind.type === 'payload') {
+      return scopedNodes.has(op.kind.node);
+    }
+    return false;
+  });
+
+  return {
+    name: `sync-balanced-children${opts.withPayloads ? '-payloads' : ''}-resync-fanout${opts.fanout}-${treeSize}`,
+    opsA,
+    opsB,
+    filter: { children: { parent: nodeIdToBytes16(targetParent) } },
+    totalOps: 0,
+    extra: {
+      treeSize,
+      fanout: opts.fanout,
+      targetParent,
+      targetDepth: 1,
+      targetChildren: targetChildren.length,
+      coldStart: false,
+      balancedTree: true,
+      knownScopeRoot: true,
+      nonEmptyLocalResult: true,
+      payloadBytes: opts.withPayloads ? opts.payloadBytes : 0,
+      payloadsEverywhere: opts.withPayloads,
+      pageSize: Math.min(DEFAULT_SYNC_BENCH_PAGE_SIZE, targetChildren.length),
+    },
+    expectedFinalOpsA: opsA.length,
+    expectedFinalOpsB: opsB.length,
+  };
+}
+
 export function buildSyncBenchCase(opts: {
   workload: SyncBenchWorkload;
   size: number;
@@ -328,6 +418,28 @@ export function buildSyncBenchCase(opts: {
     });
   }
 
+  if (workload === 'sync-balanced-children-resync') {
+    return buildBalancedChildrenResyncCase({
+      size,
+      fanout,
+      replicas: { s: replicas.s, p: replicas.p },
+      root,
+      payloadBytes,
+      withPayloads: false,
+    });
+  }
+
+  if (workload === 'sync-balanced-children-payloads-resync') {
+    return buildBalancedChildrenResyncCase({
+      size,
+      fanout,
+      replicas: { s: replicas.s, p: replicas.p },
+      root,
+      payloadBytes,
+      withPayloads: true,
+    });
+  }
+
   if (workload === 'sync-root-children-fanout10') {
     const treeSize = size;
     if (treeSize < fanout)