@peerbit/shared-log 13.2.24 → 13.2.26

package/dist/src/sync/simple.js

@@ -39,7 +39,10 @@ import { Entry, Log } from "@peerbit/log";
 import { CONVERGENCE_MESSAGE_PRIORITY, SilentDelivery, } from "@peerbit/stream-interface";
 import { EntryWithRefs, createExchangeHeadsMessages, createRawExchangeHeadsMessages, } from "../exchange-heads.js";
 import { TransportMessage } from "../message.js";
+import { DispatchLifecycleRegistry } from "./dispatch-lifecycle.js";
+import { PendingSyncStore, QUEUED_SYNC_ALIAS_REFRESH_PENDING, } from "./pending-sync-store.js";
 import { emitSyncProfileDuration, syncProfileStart } from "./profile.js";
+import { SyncPeerSlotRegistry, } from "./sync-peer-state.js";
 let RequestMaybeSync = (() => {
     let _classDecorators = [variant([0, 1])];
     let _classDescriptor;
@@ -429,14 +432,10 @@ export const MAX_PENDING_SIMPLE_SYNC_LOOKUPS_GLOBAL = 32;
 // Retry scanning can touch persistent indexes. Bound each pass so a full
 // adversarial queue cannot force 40,000 lookups in one event-loop turn.
 export const MAX_SIMPLE_SYNC_RETRY_KEYS_PER_TICK = 4_096;
-// Late coordinate-to-hash cache fills are discovered incrementally. Keep this
-// independent of retained queue size so an empty or repeated request cannot
-// force an O(global pending keys) reverse-alias rebuild.
-const MAX_PENDING_SIMPLE_SYNC_ALIAS_REFRESH_PER_MESSAGE = 128;
-const QUEUED_SYNC_ALIAS_REFRESH_PENDING = Symbol("queued-sync-alias-refresh-pending");
-// This is an absolute first-seen lifetime. Repeated claims and additional peers
-// deliberately do not slide the deadline.
-export const PENDING_SIMPLE_SYNC_KEY_TTL_MS = 60_000;
+// The pending-claim TTL, alias-refresh bound and pending-refresh sentinel
+// moved into ./pending-sync-store.ts with the record store (stage-4 sync
+// unification). Re-exported here for compatibility.
+export { PENDING_SIMPLE_SYNC_KEY_TTL_MS } from "./pending-sync-store.js";
 // Bound retained request/response associations globally. Ten thousand hashes
 // covers several full default-size request batches while keeping adversarial or
 // abandoned requests to a small, predictable amount of heap.
@@ -455,38 +454,35 @@ const createDeferred = () => {
     return { promise, resolve, reject };
 };
 export class SimpleSyncronizer {
-    // map of hash to public keys that we can ask for entries
-    syncInFlightQueue;
-    syncInFlightQueueInverted;
-    syncInFlightQueueExpiresAt;
-    syncInFlightQueueExpiryTimer;
-    pendingSyncExpiryHeap;
-    pendingSyncKeyExpiryNodes;
-    pendingSyncAdmissionExpiryNodes;
+    // The pending-sync record store owns the claim/admission state. The
+    // legacy public map instances (syncInFlightQueue, syncInFlightQueueInverted,
+    // syncInFlight, ...) live inside it and are exposed through the accessors
+    // below under their historical names.
+    pendingSync;
     syncInFlightRetryIterator;
     syncInFlightRetryRemaining = 0;
-    syncInFlightQueueClaimants;
-    syncInFlightQueueClaimantIndexes;
-    syncInFlightQueueRoundRobinCursor;
-    syncInFlightQueuedCoordinates;
-    syncInFlightQueuedHashByCoordinate;
-    syncInFlightQueuedCoordinatesByHash;
-    syncInFlightQueuedCoordinateRefreshIterator;
-    pendingSyncClaimCount;
-    pendingSyncAdmissionCount;
-    pendingSyncActiveAdmissionReservations;
-    pendingSyncAdmissionCountByPeer;
-    pendingSyncAdmissionIdentitiesByPeer;
-    pendingSyncAdmissionReservations;
-    pendingSyncAdmissionReservationsByPeer;
-    pendingSyncAdmissionReservationsByIdentity;
     pendingCoordinateLookupCount;
     pendingCoordinateLookupCountByPeer;
     pendingCoordinateResponseCount;
     pendingCoordinateResponseCountByPeer;
+    // Per-peer slot rows for coordinate lookups, coordinate responses and
+    // active maybe-sync responses (shared registry; see sync-peer-state.ts
+    // for the lifetime policy). Release closures capture the row object:
+    // once a disconnect detaches the row, the peer's slots return to the
+    // aggregate quota immediately, and a late release only settles the
+    // detached row — it never touches a reconnected successor's quota.
+    peerSlotRows;
+    // map of hash to public keys that we can ask for entries
+    get syncInFlightQueue() {
+        return this.pendingSync.syncInFlightQueue;
+    }
+    get syncInFlightQueueInverted() {
+        return this.pendingSync.syncInFlightQueueInverted;
+    }
     // map of hash to public keys that we have asked for entries
-    syncInFlight;
-    syncInFlightTargetsByKey;
+    get syncInFlight() {
+        return this.pendingSync.syncInFlight;
+    }
     rpc;
     log;
     entryIndex;
@@ -515,39 +511,22 @@ export class SimpleSyncronizer {
     syncDispatchLifecycleController;
     syncDispatchTargetEpochCounter;
     syncDispatchTargetEpochs;
-    syncDispatchTargets;
+    syncDispatchRegistry;
     repairSessionCounter;
     repairSessions;
     // Syncing and dedeplucation work
     syncMoreInterval;
     closed;
     constructor(properties) {
-        this.syncInFlightQueue = new Map();
-        this.syncInFlightQueueInverted = new Map();
-        this.syncInFlightQueueExpiresAt = new Map();
-        this.pendingSyncExpiryHeap = [];
-        this.pendingSyncKeyExpiryNodes = new Map();
-        this.pendingSyncAdmissionExpiryNodes = new Map();
-        this.syncInFlightQueueClaimants = new Map();
-        this.syncInFlightQueueClaimantIndexes = new Map();
-        this.syncInFlightQueueRoundRobinCursor = new Map();
-        this.syncInFlightQueuedCoordinates = new Set();
-        this.syncInFlightQueuedHashByCoordinate = new Map();
-        this.syncInFlightQueuedCoordinatesByHash = new Map();
-        this.pendingSyncClaimCount = 0;
-        this.pendingSyncAdmissionCount = 0;
-        this.pendingSyncActiveAdmissionReservations = 0;
-        this.pendingSyncAdmissionCountByPeer = new Map();
-        this.pendingSyncAdmissionIdentitiesByPeer = new Map();
-        this.pendingSyncAdmissionReservations = new Set();
-        this.pendingSyncAdmissionReservationsByPeer = new Map();
-        this.pendingSyncAdmissionReservationsByIdentity = new Map();
+        this.pendingSync = new PendingSyncStore({
+            coordinateToHash: properties.coordinateToHash,
+            isDispatchEpochCurrent: (peer, epoch) => this.syncDispatchTargetEpochs.get(peer) === epoch,
+        });
         this.pendingCoordinateLookupCount = 0;
         this.pendingCoordinateLookupCountByPeer = new Map();
         this.pendingCoordinateResponseCount = 0;
         this.pendingCoordinateResponseCountByPeer = new Map();
-        this.syncInFlight = new Map();
-        this.syncInFlightTargetsByKey = new Map();
+        this.peerSlotRows = new SyncPeerSlotRegistry();
         this.rpc = properties.rpc;
         this.log = properties.log;
         this.entryIndex = properties.entryIndex;
@@ -575,7 +554,19 @@ export class SimpleSyncronizer {
         this.syncDispatchLifecycleController = new AbortController();
         this.syncDispatchTargetEpochCounter = 0;
         this.syncDispatchTargetEpochs = new Map();
-        this.syncDispatchTargets = new Map();
+        this.syncDispatchRegistry = new DispatchLifecycleRegistry({
+            isClosed: () => this.closed === true,
+            currentOwnershipLifecycleController: () => this.syncDispatchLifecycleController,
+            hasRetainedWork: (lifecycle) => lifecycle.retainedWork > 0,
+            // Target-activity strategy: dispatch-epoch identity.
+            isTargetCurrent: (targetLifecycle) => this.syncDispatchTargetEpochs.get(targetLifecycle.target) ===
+                targetLifecycle.epoch,
+            onTargetAborted: (targetLifecycle) => {
+                for (const batch of [...targetLifecycle.batches]) {
+                    this.removePendingMaybeSyncResponseBatch(batch);
+                }
+            },
+        });
         this.repairSessionCounter = 0;
         this.repairSessions = new Map();
     }
@@ -708,7 +699,7 @@ export class SimpleSyncronizer {
             disposed: false,
             abortAllOnTargetDisconnect: options?.abortAllOnTargetDisconnect === true,
         };
-        for (const target of [...new Set(targets)]) {
+        this.syncDispatchRegistry.register(lifecycle, targets, (forLifecycle, target) => {
             const expectedEpoch = options?.targetEpochs?.get(target);
             const currentEpoch = this.syncDispatchTargetEpochs.get(target);
             const epoch = expectedEpoch ??
@@ -717,10 +708,10 @@ export class SimpleSyncronizer {
                     ? undefined
                     : this.getOrCreateSyncDispatchTargetEpoch(target));
             if (!epoch) {
-                continue;
+                return undefined;
             }
-            const targetLifecycle = {
-                lifecycle,
+            return {
+                lifecycle: forLifecycle,
                 target,
                 epoch,
                 controller: new AbortController(),
@@ -728,94 +719,31 @@ export class SimpleSyncronizer {
                 responseLeases: 0,
                 activeWaiters: 0,
             };
-            lifecycle.targets.set(target, targetLifecycle);
-            let activeForTarget = this.syncDispatchTargets.get(target);
-            if (!activeForTarget) {
-                activeForTarget = new Set();
-                this.syncDispatchTargets.set(target, activeForTarget);
-            }
-            activeForTarget.add(targetLifecycle);
-            if (this.syncDispatchTargetEpochs.get(target) !== epoch) {
+        }, (targetLifecycle) => {
+            if (this.syncDispatchTargetEpochs.get(targetLifecycle.target) !==
+                targetLifecycle.epoch) {
                 this.abortSyncDispatchTarget(targetLifecycle, new Error("sync target lifecycle is stale"));
             }
-        }
-        ownershipLifecycleController.signal.addEventListener("abort", lifecycle.onOwnerOrCallerAbort, { once: true });
-        if (callerSignal && callerSignal !== ownershipLifecycleController.signal) {
-            callerSignal.addEventListener("abort", lifecycle.onOwnerOrCallerAbort, {
-                once: true,
-            });
-        }
-        if (this.closed === true ||
-            ownershipLifecycleController !== this.syncDispatchLifecycleController ||
-            ownershipLifecycleController.signal.aborted ||
-            callerSignal?.aborted) {
-            lifecycle.onOwnerOrCallerAbort();
-        }
+        });
         return lifecycle;
     }
     abortSyncDispatchTarget(targetLifecycle, reason) {
-        if (!targetLifecycle.controller.signal.aborted) {
-            targetLifecycle.controller.abort(reason);
-        }
-        for (const batch of [...targetLifecycle.batches]) {
-            this.removePendingMaybeSyncResponseBatch(batch);
-        }
-        this.maybeDisposeSyncDispatchLifecycle(targetLifecycle.lifecycle);
+        this.syncDispatchRegistry.abortTarget(targetLifecycle, reason);
     }
     abortSyncDispatchLifecycle(lifecycle, reason) {
-        if (!lifecycle.controller.signal.aborted) {
-            lifecycle.controller.abort(reason);
-        }
-        for (const targetLifecycle of lifecycle.targets.values()) {
-            this.abortSyncDispatchTarget(targetLifecycle, reason);
-        }
-        this.maybeDisposeSyncDispatchLifecycle(lifecycle);
+        this.syncDispatchRegistry.abortLifecycle(lifecycle, reason);
     }
     finishSyncDispatchLifecycle(lifecycle) {
-        lifecycle.dispatchFinished = true;
-        this.maybeDisposeSyncDispatchLifecycle(lifecycle);
+        this.syncDispatchRegistry.finish(lifecycle);
     }
     maybeDisposeSyncDispatchLifecycle(lifecycle) {
-        if (lifecycle.disposed ||
-            !lifecycle.dispatchFinished ||
-            lifecycle.retainedWork > 0) {
-            return;
-        }
-        lifecycle.disposed = true;
-        lifecycle.ownershipLifecycleController.signal.removeEventListener("abort", lifecycle.onOwnerOrCallerAbort);
-        if (lifecycle.callerSignal &&
-            lifecycle.callerSignal !== lifecycle.ownershipLifecycleController.signal) {
-            lifecycle.callerSignal.removeEventListener("abort", lifecycle.onOwnerOrCallerAbort);
-        }
-        for (const targetLifecycle of lifecycle.targets.values()) {
-            const activeForTarget = this.syncDispatchTargets.get(targetLifecycle.target);
-            activeForTarget?.delete(targetLifecycle);
-            if (activeForTarget?.size === 0) {
-                this.syncDispatchTargets.delete(targetLifecycle.target);
-            }
-        }
+        this.syncDispatchRegistry.maybeDispose(lifecycle);
     }
     isSyncDispatchLifecycleActive(lifecycle, target) {
-        if (this.closed === true ||
-            lifecycle.disposed ||
-            lifecycle.ownershipLifecycleController !==
-                this.syncDispatchLifecycleController ||
-            lifecycle.ownershipLifecycleController.signal.aborted ||
-            lifecycle.callerSignal?.aborted ||
-            lifecycle.controller.signal.aborted) {
-            return false;
-        }
-        if (target === undefined) {
-            return true;
-        }
-        const targetLifecycle = lifecycle.targets.get(target);
-        return (targetLifecycle !== undefined &&
-            !targetLifecycle.controller.signal.aborted &&
-            this.syncDispatchTargetEpochs.get(target) === targetLifecycle.epoch);
+        return this.syncDispatchRegistry.isLifecycleActive(lifecycle, target);
     }
     getSyncDispatchSignal(lifecycle, target) {
-        return (lifecycle.targets.get(target)?.controller.signal ??
-            lifecycle.controller.signal);
+        return this.syncDispatchRegistry.getSignal(lifecycle, target);
     }
     pendingMaybeSyncResponseWaiterBefore(left, right) {
         return left.order < right.order;
@@ -1336,6 +1264,14 @@ export class SimpleSyncronizer {
                 beginDelivery: () => {
                     for (const authorization of addedAuthorizations) {
                         if (!authorization.settled) {
+                            if (authorization.deliveryInFlight !== true &&
+                                authorization.active === true &&
+                                authorization.slotRow?.attached === true) {
+                                // The response was accepted before the request send began:
+                                // custody of the hash-budget unit moves from the slot row to
+                                // finishDelivery for the duration of the send.
+                                authorization.slotRow.pendingResponseHashes -= 1;
+                            }
                             authorization.deliveryInFlight = true;
                         }
                     }
@@ -1353,6 +1289,13 @@ export class SimpleSyncronizer {
                                 ?.get(authorization.hash) !== authorization) {
                             releasedCount += 1;
                         }
+                        else if (authorization.active === true &&
+                            authorization.slotRow?.attached === true) {
+                            // The response was accepted while the request send was in
+                            // flight; custody of the hash-budget unit returns to the
+                            // active lease's slot row.
+                            authorization.slotRow.pendingResponseHashes += 1;
+                        }
                     }
                     if (releasedCount > 0) {
                         this.pendingMaybeSyncResponseCount -= releasedCount;
@@ -1609,35 +1552,65 @@ export class SimpleSyncronizer {
         if (acceptedByLifecycle.size === 0) {
             return [];
         }
+        const slotRow = this.getOrCreateSyncResponseSlotRow(fromHash);
+        slotRow.active += 1;
         this.activeMaybeSyncResponseCount += 1;
         this.activeMaybeSyncResponseCountByPeer.set(fromHash, (this.activeMaybeSyncResponseCountByPeer.get(fromHash) ?? 0) + 1);
-        let remainingLeases = acceptedByLifecycle.size;
+        // Accepted authorizations leave their batch (above) but stay charged
+        // against the global hash budget. Move that charge into row custody so a
+        // disconnect can return it even when the response ship never settles;
+        // units currently owned by finishDelivery (deliveryInFlight) stay out.
+        for (const { authorizations } of acceptedByLifecycle.values()) {
+            for (const authorization of authorizations) {
+                authorization.slotRow = slotRow;
+                if (authorization.deliveryInFlight !== true) {
+                    slotRow.pendingResponseHashes += 1;
+                }
+            }
+        }
+        let remainingPhysicalLeases = acceptedByLifecycle.size;
         return [...acceptedByLifecycle].map(([targetLifecycle, { hashes: acceptedHashes, authorizations }]) => {
-            let released = false;
-            return {
-                hashes: acceptedHashes,
-                signal: targetLifecycle.controller.signal,
-                release: (options) => {
-                    if (released) {
-                        return;
-                    }
-                    released = true;
-                    const pendingForTarget = this.pendingMaybeSyncResponses.get(fromHash);
-                    for (const authorization of authorizations) {
-                        this.settlePendingMaybeSyncResponseAuthorization(authorization, options?.fulfilled === true);
-                        if (pendingForTarget?.get(authorization.hash) === authorization) {
-                            pendingForTarget.delete(authorization.hash);
-                        }
-                    }
-                    if (pendingForTarget?.size === 0) {
-                        this.pendingMaybeSyncResponses.delete(fromHash);
+            let logicalReleased = false;
+            let physicalReleased = false;
+            const releaseLogical = (options) => {
+                if (logicalReleased) {
+                    return;
+                }
+                logicalReleased = true;
+                slotRow.activeReleases.delete(releaseLogical);
+                const pendingForTarget = this.pendingMaybeSyncResponses.get(fromHash);
+                for (const authorization of authorizations) {
+                    this.settlePendingMaybeSyncResponseAuthorization(authorization, options?.fulfilled === true);
+                    if (pendingForTarget?.get(authorization.hash) === authorization) {
+                        pendingForTarget.delete(authorization.hash);
                     }
-                    this.pendingMaybeSyncResponseCount -= authorizations.filter((authorization) => authorization.deliveryInFlight !== true).length;
-                    targetLifecycle.responseLeases -= 1;
-                    targetLifecycle.lifecycle.retainedWork -= 1;
-                    remainingLeases -= 1;
-                    if (remainingLeases === 0) {
-                        this.activeMaybeSyncResponseCount -= 1;
+                }
+                if (pendingForTarget?.size === 0) {
+                    this.pendingMaybeSyncResponses.delete(fromHash);
+                }
+                const chargedToRow = authorizations.filter((authorization) => authorization.deliveryInFlight !== true).length;
+                if (slotRow.attached) {
+                    this.pendingMaybeSyncResponseCount -= chargedToRow;
+                    slotRow.pendingResponseHashes -= chargedToRow;
+                }
+                // else: the hash budget already returned in aggregate when the row
+                // detached; only the deliveryInFlight units (owned by
+                // finishDelivery) remain charged.
+                targetLifecycle.responseLeases -= 1;
+                targetLifecycle.lifecycle.retainedWork -= 1;
+                this.schedulePendingMaybeSyncResponseWaiter();
+                this.maybeDisposeSyncDispatchLifecycle(targetLifecycle.lifecycle);
+            };
+            const releasePhysical = () => {
+                if (physicalReleased) {
+                    return;
+                }
+                physicalReleased = true;
+                remainingPhysicalLeases -= 1;
+                if (remainingPhysicalLeases === 0) {
+                    slotRow.active -= 1;
+                    this.activeMaybeSyncResponseCount -= 1;
+                    if (slotRow.attached) {
                         const activeForPeer = (this.activeMaybeSyncResponseCountByPeer.get(fromHash) ?? 1) -
                             1;
                         if (activeForPeer === 0) {
@@ -1646,9 +1619,21 @@ export class SimpleSyncronizer {
                         else {
                             this.activeMaybeSyncResponseCountByPeer.set(fromHash, activeForPeer);
                         }
+                        this.maybeDropIdleSyncResponseSlotRow(slotRow);
+                    }
+                }
+            };
+            slotRow.activeReleases.add(releaseLogical);
+            return {
+                hashes: acceptedHashes,
+                signal: targetLifecycle.controller.signal,
+                release: (options) => {
+                    try {
+                        releaseLogical(options);
+                    }
+                    finally {
+                        releasePhysical();
                     }
-                    this.schedulePendingMaybeSyncResponseWaiter();
-                    this.maybeDisposeSyncDispatchLifecycle(targetLifecycle.lifecycle);
                 },
             };
         });
@@ -2164,11 +2149,26 @@ export class SimpleSyncronizer {
                 return true;
             }
             const target = from.hashcode();
-            const releaseLookup = this.tryAcquireCoordinateLookup(target);
-            if (!releaseLookup) {
+            const lookupPermit = this.tryAcquireCoordinateLookup(target);
+            if (!lookupPermit) {
                 return true;
             }
+            const { release: releaseLookup, row: slotRow } = lookupPermit;
             const lifecycle = this.captureSyncDispatchLifecycle([target]);
+            let lifecycleFinished = false;
+            const finishLifecycle = () => {
+                if (lifecycleFinished) {
+                    return;
+                }
+                lifecycleFinished = true;
+                slotRow.activeReleases.delete(finishLifecycle);
+                this.finishSyncDispatchLifecycle(lifecycle);
+                this.maybeDropIdleSyncResponseSlotRow(slotRow);
+            };
+            // Dispatch completion is logical ownership. A disconnected peer must
+            // not retain this lifecycle/listeners while a non-abortable lookup or
+            // shipment keeps only its global physical permit alive.
+            slotRow.activeReleases.add(finishLifecycle);
             let lookupReleased = false;
             const finishLookup = () => {
                 if (lookupReleased) {
@@ -2228,7 +2228,7 @@ export class SimpleSyncronizer {
             }
             finally {
                 finishLookup();
-                this.finishSyncDispatchLifecycle(lifecycle);
+                finishLifecycle();
             }
         }
         else {
@@ -2246,284 +2246,86 @@ export class SimpleSyncronizer {
         this.markRepairSessionResolvedHashes(properties.hashes);
     }
     getPendingSyncKeyIdentity(key) {
-        if (typeof key === "string") {
-            return key;
-        }
-        const hash = this.coordinateToHash.get(key);
-        return hash ?? key;
-    }
-    removeQueuedSyncCoordinateAlias(key) {
-        this.syncInFlightQueuedCoordinates.delete(key);
-        if (this.syncInFlightQueuedCoordinates.size === 0) {
-            this.syncInFlightQueuedCoordinateRefreshIterator = undefined;
-        }
-        const previousHash = this.syncInFlightQueuedHashByCoordinate.get(key);
-        this.syncInFlightQueuedHashByCoordinate.delete(key);
-        if (previousHash != null) {
-            const coordinates = this.syncInFlightQueuedCoordinatesByHash.get(previousHash);
-            coordinates?.delete(key);
-            if (coordinates?.size === 0) {
-                this.syncInFlightQueuedCoordinatesByHash.delete(previousHash);
-            }
-        }
-    }
-    refreshQueuedSyncCoordinateAlias(key) {
-        if (!this.syncInFlightQueue.has(key)) {
-            this.removeQueuedSyncCoordinateAlias(key);
-            return;
-        }
-        this.syncInFlightQueuedCoordinates.add(key);
-        const hash = this.coordinateToHash.get(key) ?? undefined;
-        const previousHash = this.syncInFlightQueuedHashByCoordinate.get(key);
-        if (previousHash !== hash) {
-            if (previousHash != null) {
-                const coordinates = this.syncInFlightQueuedCoordinatesByHash.get(previousHash);
-                coordinates?.delete(key);
-                if (coordinates?.size === 0) {
-                    this.syncInFlightQueuedCoordinatesByHash.delete(previousHash);
-                }
-            }
-            if (hash == null) {
-                this.syncInFlightQueuedHashByCoordinate.delete(key);
-            }
-            else {
-                this.syncInFlightQueuedHashByCoordinate.set(key, hash);
-            }
-        }
-        if (hash != null) {
-            let coordinates = this.syncInFlightQueuedCoordinatesByHash.get(hash);
-            if (!coordinates) {
-                coordinates = new Set();
-                this.syncInFlightQueuedCoordinatesByHash.set(hash, coordinates);
-            }
-            coordinates.add(key);
-            this.reconcileQueuedSyncCoordinateAlias(key, hash);
-        }
-    }
-    reconcileQueuedSyncCoordinateAlias(coordinate, hash) {
-        const now = Date.now();
-        const coordinateExpiresAt = this.syncInFlightQueueExpiresAt.get(coordinate);
-        if (coordinateExpiresAt != null && coordinateExpiresAt <= now) {
-            this.clearSyncProcessKey(coordinate);
-            return;
-        }
-        const hashExpiresAt = this.syncInFlightQueueExpiresAt.get(hash);
-        if (hashExpiresAt != null && hashExpiresAt <= now) {
-            this.clearSyncProcessKey(hash);
-            return;
-        }
-        const hashClaimants = this.syncInFlightQueue.get(hash);
-        if (!hashClaimants || !this.syncInFlightQueue.has(coordinate)) {
-            return;
-        }
-        const expiresAt = Math.min(this.syncInFlightQueueExpiresAt.get(coordinate) ?? Infinity, this.syncInFlightQueueExpiresAt.get(hash) ?? Infinity);
-        for (const claimant of [...hashClaimants]) {
-            this.addPendingSyncClaim(coordinate, claimant, expiresAt);
-        }
-        if (Number.isFinite(expiresAt)) {
-            this.movePendingSyncKeyExpiryEarlier(coordinate, expiresAt);
-        }
-        for (const target of [...(this.syncInFlightTargetsByKey.get(hash) ?? [])]) {
-            const state = this.syncInFlight.get(target)?.get(hash);
-            if (state) {
-                this.setSyncInFlightTargetKey(target, coordinate, state.timestamp);
-            }
-        }
-        this.clearSyncProcessKey(hash);
+        return this.pendingSync.getPendingSyncKeyIdentity(key);
     }
     refreshQueuedSyncCoordinateAliases() {
-        if (this.syncInFlightQueuedCoordinates.size === 0 &&
-            this.syncInFlightQueueClaimants.size < this.syncInFlightQueue.size) {
-            // Defensive compatibility for callers/tests that seed the public queue
-            // directly. Keep hydration bounded; internal writes register coordinates
-            // when the key is first admitted.
-            let inspected = 0;
-            for (const key of this.syncInFlightQueue.keys()) {
-                if (typeof key === "bigint") {
-                    this.syncInFlightQueuedCoordinates.add(key);
-                }
-                inspected += 1;
-                if (inspected >= MAX_PENDING_SIMPLE_SYNC_ALIAS_REFRESH_PER_MESSAGE) {
-                    break;
-                }
-            }
-        }
-        if (this.syncInFlightQueuedCoordinates.size === 0) {
-            this.syncInFlightQueuedCoordinateRefreshIterator = undefined;
-            return;
-        }
-        this.syncInFlightQueuedCoordinateRefreshIterator ??=
-            this.syncInFlightQueuedCoordinates.values();
-        for (let refreshed = 0; refreshed < MAX_PENDING_SIMPLE_SYNC_ALIAS_REFRESH_PER_MESSAGE; refreshed += 1) {
-            const next = this.syncInFlightQueuedCoordinateRefreshIterator.next();
-            if (next.done) {
-                this.syncInFlightQueuedCoordinateRefreshIterator = undefined;
-                break;
-            }
-            this.refreshQueuedSyncCoordinateAlias(next.value);
-        }
+        this.pendingSync.refreshQueuedSyncCoordinateAliases();
     }
     getQueuedSyncKeyForAdmission(key) {
-        const getValidQueuedKey = (candidate) => {
-            if (!this.syncInFlightQueue.has(candidate)) {
-                return undefined;
-            }
-            const expiresAt = this.syncInFlightQueueExpiresAt.get(candidate);
-            if (expiresAt != null && expiresAt <= Date.now()) {
-                this.clearSyncProcessKey(candidate);
-                return undefined;
-            }
-            return candidate;
-        };
-        if (getValidQueuedKey(key) != null) {
-            if (typeof key === "bigint") {
-                this.refreshQueuedSyncCoordinateAlias(key);
-                return getValidQueuedKey(key);
-            }
-            return key;
-        }
-        if (typeof key === "string") {
-            const aliases = this.syncInFlightQueuedCoordinatesByHash.get(key);
-            if (aliases) {
-                let inspected = 0;
-                for (const alias of aliases) {
-                    if (inspected >= MAX_PENDING_SIMPLE_SYNC_ALIAS_REFRESH_PER_MESSAGE) {
-                        return QUEUED_SYNC_ALIAS_REFRESH_PENDING;
-                    }
-                    inspected += 1;
-                    this.refreshQueuedSyncCoordinateAlias(alias);
-                    if (this.syncInFlightQueuedCoordinatesByHash.get(key)?.has(alias) ===
-                        true) {
-                        const validAlias = getValidQueuedKey(alias);
-                        if (validAlias != null) {
-                            return validAlias;
-                        }
-                    }
-                }
-                if ((this.syncInFlightQueuedCoordinatesByHash.get(key)?.size ?? 0) > 0) {
-                    return QUEUED_SYNC_ALIAS_REFRESH_PENDING;
-                }
-            }
-            return undefined;
-        }
-        const hash = this.coordinateToHash.get(key);
-        return hash != null ? getValidQueuedKey(hash) : undefined;
+        return this.pendingSync.getQueuedSyncKeyForAdmission(key);
     }
     addPendingSyncClaim(key, from, expiresAt) {
-        const fromHash = from.hashcode();
-        let peers = this.syncInFlightQueue.get(key);
-        let claimants = this.syncInFlightQueueClaimants.get(key);
-        let claimantIndexes = this.syncInFlightQueueClaimantIndexes.get(key);
-        if (!peers) {
-            peers = [];
-            this.syncInFlightQueue.set(key, peers);
-            claimants = new Set();
-            this.syncInFlightQueueClaimants.set(key, claimants);
-            claimantIndexes = new Map();
-            this.syncInFlightQueueClaimantIndexes.set(key, claimantIndexes);
-            const deadline = expiresAt ?? Date.now() + PENDING_SIMPLE_SYNC_KEY_TTL_MS;
-            this.syncInFlightQueueExpiresAt.set(key, deadline);
-            const expiryNode = {
-                kind: "key",
-                key,
-                expiresAt: deadline,
-                heapIndex: -1,
-            };
-            this.pendingSyncKeyExpiryNodes.set(key, expiryNode);
-            this.pushPendingSyncExpiry(expiryNode);
-            if (typeof key === "bigint") {
-                this.refreshQueuedSyncCoordinateAlias(key);
-            }
-        }
-        else if (!claimants) {
-            // Defensive compatibility for callers/tests that seed the public queue
-            // maps directly. Internally every retained key gets this set at creation.
-            claimants = new Set(peers.map((peer) => peer.hashcode()));
-            this.syncInFlightQueueClaimants.set(key, claimants);
-            this.pendingSyncClaimCount += claimants.size;
-        }
-        if (!claimantIndexes) {
-            claimantIndexes = new Map();
-            for (let index = 0; index < peers.length; index += 1) {
-                claimantIndexes.set(peers[index].hashcode(), index);
-            }
-            this.syncInFlightQueueClaimantIndexes.set(key, claimantIndexes);
-        }
-        if (claimants.has(fromHash)) {
-            return false;
-        }
-        claimantIndexes.set(fromHash, peers.length);
-        peers.push(from);
-        claimants.add(fromHash);
-        let inverted = this.syncInFlightQueueInverted.get(fromHash);
-        if (!inverted) {
-            inverted = new Set();
-            this.syncInFlightQueueInverted.set(fromHash, inverted);
-        }
-        inverted.add(key);
-        this.pendingSyncClaimCount += 1;
-        this.schedulePendingSyncKeyExpiry();
-        return true;
+        return this.pendingSync.addPendingSyncClaim(key, from, expiresAt);
     }
     hasPendingSyncClaim(key, peer) {
-        const claimants = this.syncInFlightQueueClaimants.get(key);
-        if (claimants) {
-            return claimants.has(peer);
-        }
-        const peers = this.syncInFlightQueue.get(key);
-        if (!peers) {
-            return false;
-        }
-        const hydrated = new Set(peers.map((candidate) => candidate.hashcode()));
-        this.syncInFlightQueueClaimants.set(key, hydrated);
-        const indexes = new Map();
-        for (let index = 0; index < peers.length; index += 1) {
-            indexes.set(peers[index].hashcode(), index);
-        }
-        this.syncInFlightQueueClaimantIndexes.set(key, indexes);
-        this.pendingSyncClaimCount += hydrated.size;
-        return hydrated.has(peer);
+        return this.pendingSync.hasPendingSyncClaim(key, peer);
     }
     filterDispatchablePendingSyncClaims(keys, peer, epoch) {
-        if (this.syncDispatchTargetEpochs.get(peer) !== epoch) {
-            return [];
-        }
-        const now = Date.now();
-        const dispatchable = [];
-        for (const key of keys) {
-            const expiresAt = this.syncInFlightQueueExpiresAt.get(key);
-            if (expiresAt != null && expiresAt <= now) {
-                this.clearSyncProcessKey(key);
-                continue;
-            }
-            if (this.syncInFlightQueue.has(key) &&
-                this.hasPendingSyncClaim(key, peer)) {
-                dispatchable.push(key);
-            }
-        }
-        return dispatchable;
+        return this.pendingSync.filterDispatchablePendingSyncClaims(keys, peer, epoch);
     }
     canStartPendingSyncLookup(peer) {
-        return (this.pendingSyncAdmissionReservations.size +
+        return (this.pendingSync.pendingSyncAdmissionReservations.size +
             this.pendingCoordinateLookupCount <
             MAX_PENDING_SIMPLE_SYNC_LOOKUPS_GLOBAL &&
-            (this.pendingSyncAdmissionReservationsByPeer.get(peer)?.size ?? 0) +
+            (this.pendingSync.pendingSyncAdmissionReservationsByPeer.get(peer)
+                ?.size ?? 0) +
                 (this.pendingCoordinateLookupCountByPeer.get(peer) ?? 0) <
                 MAX_PENDING_SIMPLE_SYNC_LOOKUPS_PER_PEER);
     }
+    getOrCreateSyncResponseSlotRow(peer) {
+        return this.peerSlotRows.ensure(peer);
+    }
+    detachSyncResponseSlotRow(peer) {
+        const row = this.peerSlotRows.detach(peer);
+        if (!row) {
+            return;
+        }
+        // Disconnect returns only the current peer generation's quota. The
+        // global counters represent physically live, potentially non-abortable
+        // work and remain charged until each captured release actually settles.
+        this.pendingCoordinateLookupCountByPeer.delete(peer);
+        this.pendingCoordinateResponseCountByPeer.delete(peer);
+        this.activeMaybeSyncResponseCountByPeer.delete(peer);
+        if (row.pendingResponseHashes > 0) {
+            // Active authorizations' hash budget returns in aggregate with the
+            // row. The settled releases below (and any late ship-side release)
+            // see the detached row and skip the global budget.
+            this.pendingMaybeSyncResponseCount -= row.pendingResponseHashes;
+            row.pendingResponseHashes = 0;
+            this.schedulePendingMaybeSyncResponseWaiter();
+        }
+        // Settle only logical active-response ownership so authorizations leave
+        // pendingMaybeSyncResponses and responseLeases/retainedWork drain. The
+        // eventual ship-side release still returns its global physical permit.
+        // Closures capture THIS row (identity, not peer hash), so a reconnected
+        // successor's row is never touched.
+        for (const release of [...row.activeReleases]) {
+            release();
+        }
+    }
+    maybeDropIdleSyncResponseSlotRow(row) {
+        this.peerSlotRows.maybeDropIdle(row);
+    }
     tryAcquireCoordinateLookup(peer) {
         if (!this.canStartPendingSyncLookup(peer)) {
             return undefined;
         }
+        const row = this.getOrCreateSyncResponseSlotRow(peer);
+        row.lookups += 1;
         this.pendingCoordinateLookupCount += 1;
         this.pendingCoordinateLookupCountByPeer.set(peer, (this.pendingCoordinateLookupCountByPeer.get(peer) ?? 0) + 1);
         let released = false;
-        return () => {
+        const release = () => {
             if (released) {
                 return;
             }
             released = true;
+            row.lookups -= 1;
             this.pendingCoordinateLookupCount -= 1;
+            if (!row.attached) {
+                // Per-peer quota returned when this generation detached.
+                return;
+            }
             const remaining = (this.pendingCoordinateLookupCountByPeer.get(peer) ?? 1) - 1;
             if (remaining === 0) {
                 this.pendingCoordinateLookupCountByPeer.delete(peer);
@@ -2531,7 +2333,9 @@ export class SimpleSyncronizer {
             else {
                 this.pendingCoordinateLookupCountByPeer.set(peer, remaining);
             }
+            this.maybeDropIdleSyncResponseSlotRow(row);
         };
+        return { row, release };
     }
     tryAcquireCoordinateResponse(peer) {
         if (this.pendingCoordinateResponseCount >=
@@ -2540,6 +2344,8 @@ export class SimpleSyncronizer {
                 MAX_PENDING_SIMPLE_COORDINATE_RESPONSES_PER_PEER) {
             return undefined;
         }
+        const row = this.getOrCreateSyncResponseSlotRow(peer);
+        row.responses += 1;
         this.pendingCoordinateResponseCount += 1;
         this.pendingCoordinateResponseCountByPeer.set(peer, (this.pendingCoordinateResponseCountByPeer.get(peer) ?? 0) + 1);
         let released = false;
@@ -2548,7 +2354,12 @@ export class SimpleSyncronizer {
                 return;
             }
             released = true;
+            row.responses -= 1;
             this.pendingCoordinateResponseCount -= 1;
+            if (!row.attached) {
+                // Per-peer quota returned when this generation detached.
+                return;
+            }
             const remaining = (this.pendingCoordinateResponseCountByPeer.get(peer) ?? 1) - 1;
             if (remaining === 0) {
                 this.pendingCoordinateResponseCountByPeer.delete(peer);
@@ -2556,347 +2367,35 @@ export class SimpleSyncronizer {
             else {
                 this.pendingCoordinateResponseCountByPeer.set(peer, remaining);
             }
+            this.maybeDropIdleSyncResponseSlotRow(row);
         };
     }
     reservePendingSyncAdmission(peer, identities) {
-        const count = identities.length;
-        if (count <= 0) {
-            return undefined;
-        }
-        const reservation = {
-            peer,
-            remaining: count,
-            active: true,
-            released: false,
-            expiresAt: Date.now() + PENDING_SIMPLE_SYNC_KEY_TTL_MS,
-            identities: new Set(identities),
-            retainedSettled: 0,
-        };
-        this.pendingSyncAdmissionReservations.add(reservation);
-        let peerReservations = this.pendingSyncAdmissionReservationsByPeer.get(peer);
-        if (!peerReservations) {
-            peerReservations = new Set();
-            this.pendingSyncAdmissionReservationsByPeer.set(peer, peerReservations);
-        }
-        peerReservations.add(reservation);
-        this.pendingSyncActiveAdmissionReservations += 1;
-        this.pendingSyncAdmissionCount += count;
-        this.pendingSyncAdmissionCountByPeer.set(peer, (this.pendingSyncAdmissionCountByPeer.get(peer) ?? 0) + count);
-        let reservedIdentities = this.pendingSyncAdmissionIdentitiesByPeer.get(peer);
-        if (!reservedIdentities) {
-            reservedIdentities = new Set();
-            this.pendingSyncAdmissionIdentitiesByPeer.set(peer, reservedIdentities);
-        }
-        for (const identity of identities) {
-            reservedIdentities.add(identity);
-            let reservationsForIdentity = this.pendingSyncAdmissionReservationsByIdentity.get(identity);
-            if (!reservationsForIdentity) {
-                reservationsForIdentity = new Set();
-                this.pendingSyncAdmissionReservationsByIdentity.set(identity, reservationsForIdentity);
-            }
-            reservationsForIdentity.add(reservation);
-        }
-        const expiryNode = {
-            kind: "admission",
-            reservation,
-            expiresAt: reservation.expiresAt,
-            heapIndex: -1,
-        };
-        this.pendingSyncAdmissionExpiryNodes.set(reservation, expiryNode);
-        this.pushPendingSyncExpiry(expiryNode);
-        this.schedulePendingSyncKeyExpiry();
-        return reservation;
-    }
-    removePendingSyncAdmissionIdentity(reservation, identity, options) {
-        if (!reservation.identities.delete(identity)) {
-            return false;
-        }
-        if (options?.retainQuota === true) {
-            reservation.retainedSettled += 1;
-        }
-        else {
-            reservation.remaining -= 1;
-            this.pendingSyncAdmissionCount -= 1;
-            const peerCount = (this.pendingSyncAdmissionCountByPeer.get(reservation.peer) ?? 0) - 1;
-            if (peerCount === 0) {
-                this.pendingSyncAdmissionCountByPeer.delete(reservation.peer);
-            }
-            else {
-                this.pendingSyncAdmissionCountByPeer.set(reservation.peer, peerCount);
-            }
-        }
-        const reservedIdentities = this.pendingSyncAdmissionIdentitiesByPeer.get(reservation.peer);
-        reservedIdentities?.delete(identity);
-        if (reservedIdentities?.size === 0) {
-            this.pendingSyncAdmissionIdentitiesByPeer.delete(reservation.peer);
-        }
-        const reservationsForIdentity = this.pendingSyncAdmissionReservationsByIdentity.get(identity);
-        reservationsForIdentity?.delete(reservation);
-        if (reservationsForIdentity?.size === 0) {
-            this.pendingSyncAdmissionReservationsByIdentity.delete(identity);
-        }
-        return true;
+        return this.pendingSync.reservePendingSyncAdmission(peer, identities);
     }
     clearPendingSyncAdmissionIdentity(identity) {
-        const reservations = this.pendingSyncAdmissionReservationsByIdentity.get(identity);
-        if (!reservations) {
-            return;
-        }
-        for (const reservation of [...reservations]) {
-            this.removePendingSyncAdmissionIdentity(reservation, identity, {
-                retainQuota: true,
-            });
-        }
+        this.pendingSync.clearPendingSyncAdmissionIdentity(identity);
     }
     consumePendingSyncAdmission(reservation, identity) {
-        if (!reservation.active || reservation.expiresAt <= Date.now()) {
-            if (reservation.expiresAt <= Date.now()) {
-                this.invalidatePendingSyncAdmission(reservation);
-            }
-            return "invalid";
-        }
-        if (!reservation.identities.has(identity)) {
-            return "settled";
-        }
-        this.removePendingSyncAdmissionIdentity(reservation, identity);
-        if (reservation.remaining === 0) {
-            this.removePendingSyncAdmissionExpiry(reservation);
-            reservation.active = false;
-            reservation.released = true;
-            this.pendingSyncActiveAdmissionReservations -= 1;
-            this.pendingSyncAdmissionReservations.delete(reservation);
-            const peerReservations = this.pendingSyncAdmissionReservationsByPeer.get(reservation.peer);
-            peerReservations?.delete(reservation);
-            if (peerReservations?.size === 0) {
-                this.pendingSyncAdmissionReservationsByPeer.delete(reservation.peer);
-            }
-            this.clearPendingSyncExpiryTimerIfIdle();
-        }
-        return "consumed";
+        return this.pendingSync.consumePendingSyncAdmission(reservation, identity);
     }
     transferPendingSyncAdmissionIdentity(peer, identity) {
-        const reservations = this.pendingSyncAdmissionReservationsByIdentity.get(identity);
-        if (!reservations) {
-            return undefined;
-        }
-        for (const reservation of reservations) {
-            if (reservation.peer !== peer ||
-                reservation.released ||
-                reservation.expiresAt <= Date.now() ||
-                !this.removePendingSyncAdmissionIdentity(reservation, identity, {
-                    retainQuota: true,
-                })) {
-                continue;
-            }
-            // The original resolver may be non-abortable and still retains its input
-            // arrays. Keep that reservation charged until its queueSync finally
-            // settles; the queued claim is counted separately and can disappear
-            // without returning the resolver's quota early.
-            return reservation.expiresAt;
-        }
-        return undefined;
-    }
-    invalidatePendingSyncAdmission(reservation) {
-        if (!reservation || reservation.released || !reservation.active) {
-            return;
-        }
-        // Expiry/disconnect invalidates late lookup results, but it must not return
-        // the quota slot while the underlying storage/index work is still alive.
-        // Those lookups are not generally abortable; only queueSync's finally block
-        // may release their active-work accounting.
-        this.removePendingSyncAdmissionExpiry(reservation);
-        reservation.active = false;
-        this.pendingSyncActiveAdmissionReservations -= 1;
-        this.clearPendingSyncExpiryTimerIfIdle();
+        return this.pendingSync.transferPendingSyncAdmissionIdentity(peer, identity);
     }
     releasePendingSyncAdmission(reservation) {
-        if (!reservation || reservation.released) {
-            return;
-        }
-        this.removePendingSyncAdmissionExpiry(reservation);
-        for (const identity of [...reservation.identities]) {
-            this.removePendingSyncAdmissionIdentity(reservation, identity);
-        }
-        if (reservation.retainedSettled > 0) {
-            const retainedSettled = reservation.retainedSettled;
-            reservation.retainedSettled = 0;
-            reservation.remaining -= retainedSettled;
-            this.pendingSyncAdmissionCount -= retainedSettled;
-            const peerCount = (this.pendingSyncAdmissionCountByPeer.get(reservation.peer) ?? 0) -
-                retainedSettled;
-            if (peerCount === 0) {
-                this.pendingSyncAdmissionCountByPeer.delete(reservation.peer);
-            }
-            else {
-                this.pendingSyncAdmissionCountByPeer.set(reservation.peer, peerCount);
-            }
-        }
-        if (reservation.active) {
-            this.pendingSyncActiveAdmissionReservations -= 1;
-        }
-        reservation.active = false;
-        reservation.released = true;
-        this.pendingSyncAdmissionReservations.delete(reservation);
-        const peerReservations = this.pendingSyncAdmissionReservationsByPeer.get(reservation.peer);
-        peerReservations?.delete(reservation);
-        if (peerReservations?.size === 0) {
-            this.pendingSyncAdmissionReservationsByPeer.delete(reservation.peer);
-        }
-        this.clearPendingSyncExpiryTimerIfIdle();
+        this.pendingSync.releasePendingSyncAdmission(reservation);
     }
     clearPendingSyncAdmissions(peer) {
-        const reservations = peer == null
-            ? this.pendingSyncAdmissionReservations
-            : this.pendingSyncAdmissionReservationsByPeer.get(peer);
-        if (!reservations) {
-            return;
-        }
-        for (const reservation of [...reservations]) {
-            this.invalidatePendingSyncAdmission(reservation);
-        }
-    }
-    swapPendingSyncExpiry(left, right) {
-        const leftNode = this.pendingSyncExpiryHeap[left];
-        const rightNode = this.pendingSyncExpiryHeap[right];
-        this.pendingSyncExpiryHeap[left] = rightNode;
-        this.pendingSyncExpiryHeap[right] = leftNode;
-        rightNode.heapIndex = left;
-        leftNode.heapIndex = right;
-    }
-    pushPendingSyncExpiry(node) {
-        node.heapIndex = this.pendingSyncExpiryHeap.length;
-        this.pendingSyncExpiryHeap.push(node);
-        let index = node.heapIndex;
-        while (index > 0) {
-            const parent = Math.floor((index - 1) / 2);
-            if (this.pendingSyncExpiryHeap[parent].expiresAt <=
-                this.pendingSyncExpiryHeap[index].expiresAt) {
-                break;
-            }
-            this.swapPendingSyncExpiry(parent, index);
-            index = parent;
-        }
-    }
-    removePendingSyncExpiry(node) {
-        const index = node.heapIndex;
-        if (index < 0 ||
-            index >= this.pendingSyncExpiryHeap.length ||
-            this.pendingSyncExpiryHeap[index] !== node) {
-            return;
-        }
-        const last = this.pendingSyncExpiryHeap.pop();
-        node.heapIndex = -1;
-        if (index >= this.pendingSyncExpiryHeap.length) {
-            return;
-        }
-        this.pendingSyncExpiryHeap[index] = last;
-        last.heapIndex = index;
-        let current = index;
-        while (current > 0) {
-            const parent = Math.floor((current - 1) / 2);
-            if (this.pendingSyncExpiryHeap[parent].expiresAt <=
-                this.pendingSyncExpiryHeap[current].expiresAt) {
-                break;
-            }
-            this.swapPendingSyncExpiry(parent, current);
-            current = parent;
-        }
-        for (;;) {
-            const left = current * 2 + 1;
-            const right = left + 1;
-            let smallest = current;
-            if (left < this.pendingSyncExpiryHeap.length &&
-                this.pendingSyncExpiryHeap[left].expiresAt <
-                    this.pendingSyncExpiryHeap[smallest].expiresAt) {
-                smallest = left;
-            }
-            if (right < this.pendingSyncExpiryHeap.length &&
-                this.pendingSyncExpiryHeap[right].expiresAt <
-                    this.pendingSyncExpiryHeap[smallest].expiresAt) {
-                smallest = right;
-            }
-            if (smallest === current) {
-                break;
-            }
-            this.swapPendingSyncExpiry(current, smallest);
-            current = smallest;
-        }
-    }
-    removePendingSyncKeyExpiry(key) {
-        const node = this.pendingSyncKeyExpiryNodes.get(key);
-        if (!node) {
-            return;
-        }
-        this.pendingSyncKeyExpiryNodes.delete(key);
-        this.removePendingSyncExpiry(node);
+        this.pendingSync.clearPendingSyncAdmissions(peer);
     }
     movePendingSyncKeyExpiryEarlier(key, expiresAt) {
-        const current = this.syncInFlightQueueExpiresAt.get(key);
-        if (current == null || current <= expiresAt) {
-            return;
-        }
-        this.removePendingSyncKeyExpiry(key);
-        this.syncInFlightQueueExpiresAt.set(key, expiresAt);
-        const node = {
-            kind: "key",
-            key,
-            expiresAt,
-            heapIndex: -1,
-        };
-        this.pendingSyncKeyExpiryNodes.set(key, node);
-        this.pushPendingSyncExpiry(node);
-        this.schedulePendingSyncKeyExpiry();
-    }
-    removePendingSyncAdmissionExpiry(reservation) {
-        const node = this.pendingSyncAdmissionExpiryNodes.get(reservation);
-        if (!node) {
-            return;
-        }
-        this.pendingSyncAdmissionExpiryNodes.delete(reservation);
-        this.removePendingSyncExpiry(node);
+        this.pendingSync.movePendingSyncKeyExpiryEarlier(key, expiresAt);
     }
     expirePendingSyncKeys(now = Date.now()) {
-        for (;;) {
-            const node = this.pendingSyncExpiryHeap[0];
-            if (!node || node.expiresAt > now) {
-                break;
-            }
-            this.removePendingSyncExpiry(node);
-            if (node.kind === "key") {
-                if (this.pendingSyncKeyExpiryNodes.get(node.key) !== node) {
-                    continue;
-                }
-                this.pendingSyncKeyExpiryNodes.delete(node.key);
-                this.clearSyncProcessKey(node.key);
-            }
-            else {
-                if (this.pendingSyncAdmissionExpiryNodes.get(node.reservation) !== node) {
-                    continue;
-                }
-                this.pendingSyncAdmissionExpiryNodes.delete(node.reservation);
-                this.invalidatePendingSyncAdmission(node.reservation);
-            }
-        }
+        this.pendingSync.expirePendingSyncKeys(now);
     }
     clearPendingSyncExpiryTimerIfIdle() {
-        if (this.pendingSyncExpiryHeap.length === 0 &&
-            this.syncInFlightQueueExpiryTimer != null) {
-            clearTimeout(this.syncInFlightQueueExpiryTimer);
-            this.syncInFlightQueueExpiryTimer = undefined;
-        }
-    }
-    schedulePendingSyncKeyExpiry() {
-        if (this.syncInFlightQueueExpiryTimer != null ||
-            this.pendingSyncExpiryHeap.length === 0) {
-            return;
-        }
-        const expiresAt = this.pendingSyncExpiryHeap[0].expiresAt;
-        this.syncInFlightQueueExpiryTimer = setTimeout(() => {
-            this.syncInFlightQueueExpiryTimer = undefined;
-            this.expirePendingSyncKeys();
-            this.schedulePendingSyncKeyExpiry();
-        }, Math.max(0, expiresAt - Date.now()));
-        this.syncInFlightQueueExpiryTimer.unref?.();
+        this.pendingSync.clearPendingSyncExpiryTimerIfIdle();
     }
     async queueSync(keys, from, options) {
         if (this.closed === true || keys.length === 0) {
@@ -2911,9 +2410,9 @@ export class SimpleSyncronizer {
         const peerClaimCount = this.syncInFlightQueueInverted.get(fromHash)?.size ?? 0;
         let availableClaims = Math.max(0, Math.min(MAX_PENDING_SIMPLE_SYNC_KEYS_PER_PEER -
             peerClaimCount -
-            (this.pendingSyncAdmissionCountByPeer.get(fromHash) ?? 0), MAX_PENDING_SIMPLE_SYNC_KEYS_GLOBAL -
-            this.pendingSyncClaimCount -
-            this.pendingSyncAdmissionCount));
+            (this.pendingSync.pendingSyncAdmissionCountByPeer.get(fromHash) ?? 0), MAX_PENDING_SIMPLE_SYNC_KEYS_GLOBAL -
+            this.pendingSync.pendingSyncClaimCount -
+            this.pendingSync.pendingSyncAdmissionCount));
         const targetEpoch = this.getOrCreateSyncDispatchTargetEpoch(fromHash);
         const ownershipLifecycleController = this.syncDispatchLifecycleController;
         const isCapturedLifecycleActive = () => this.closed !== true &&
@@ -2934,7 +2433,7 @@ export class SimpleSyncronizer {
         const keysToCheck = [];
         const identitiesToCheck = [];
         const seen = new Set();
-        const pendingAdmissionIdentities = this.pendingSyncAdmissionIdentitiesByPeer.get(fromHash);
+        const pendingAdmissionIdentities = this.pendingSync.pendingSyncAdmissionIdentitiesByPeer.get(fromHash);
         // Default senders use 1,024-key messages. Capping examined input at the
         // entire per-peer allowance prevents a duplicate-filled oversized vector
         // from turning admission itself into unbounded work.
@@ -3351,7 +2850,7 @@ export class SimpleSyncronizer {
                     if (!isOpenLifecycleActive()) {
                         return;
                     }
-                    const expiresAt = this.syncInFlightQueueExpiresAt.get(key);
+                    const expiresAt = this.pendingSync.syncInFlightQueueExpiresAt.get(key);
                     if (expiresAt != null && expiresAt <= Date.now()) {
                         this.clearSyncProcessKey(key);
                         continue;
@@ -3364,7 +2863,7 @@ export class SimpleSyncronizer {
                     if (!value) {
                         continue;
                     }
-                    const currentExpiresAt = this.syncInFlightQueueExpiresAt.get(key);
+                    const currentExpiresAt = this.pendingSync.syncInFlightQueueExpiresAt.get(key);
                     if (currentExpiresAt != null && currentExpiresAt <= Date.now()) {
                         this.clearSyncProcessKey(key);
                         continue;
@@ -3374,8 +2873,7 @@ export class SimpleSyncronizer {
                             this.clearSyncProcessKey(key);
                             continue;
                         }
-                        const cursor = (this.syncInFlightQueueRoundRobinCursor.get(key) ?? 0) %
-                            value.length;
+                        const cursor = this.pendingSync.getRoundRobinCursor(key) % value.length;
                         const candidate = value[cursor];
                         const publicKeyHash = candidate.hashcode();
                         const inflightTimestamp = this.syncInFlight
@@ -3394,7 +2892,7 @@ export class SimpleSyncronizer {
                             }
                             request.hashes.push(key);
                             if (value.length > 1) {
-                                this.syncInFlightQueueRoundRobinCursor.set(key, (cursor + 1) % value.length);
+                                this.pendingSync.setRoundRobinCursor(key, (cursor + 1) % value.length);
                             }
                         }
                     }
@@ -3463,28 +2961,9 @@ export class SimpleSyncronizer {
         this.syncDispatchLifecycleController.abort();
         this.syncDispatchTargetEpochs.clear();
         this.clearPendingSyncAdmissions();
-        this.syncInFlightQueue.clear();
-        this.syncInFlightQueueInverted.clear();
         this.syncInFlightRetryIterator = undefined;
         this.syncInFlightRetryRemaining = 0;
-        this.syncInFlightQueueExpiresAt.clear();
-        this.pendingSyncExpiryHeap.length = 0;
-        this.pendingSyncKeyExpiryNodes.clear();
-        this.pendingSyncAdmissionExpiryNodes.clear();
-        this.syncInFlightQueueClaimants.clear();
-        this.syncInFlightQueueClaimantIndexes.clear();
-        this.syncInFlightQueueRoundRobinCursor.clear();
-        this.syncInFlightQueuedCoordinates.clear();
-        this.syncInFlightQueuedHashByCoordinate.clear();
-        this.syncInFlightQueuedCoordinatesByHash.clear();
-        this.syncInFlightQueuedCoordinateRefreshIterator = undefined;
-        this.pendingSyncClaimCount = 0;
-        if (this.syncInFlightQueueExpiryTimer != null) {
-            clearTimeout(this.syncInFlightQueueExpiryTimer);
-            this.syncInFlightQueueExpiryTimer = undefined;
-        }
-        this.syncInFlight.clear();
-        this.syncInFlightTargetsByKey.clear();
+        this.pendingSync.clearForClose();
         this.recentlySentExchangeHeads.clear();
         this.clearPendingMaybeSyncResponses();
         for (const sessionId of [...this.repairSessions.keys()]) {
@@ -3529,202 +3008,31 @@ export class SimpleSyncronizer {
         return this.hasSyncProcessState() || this.repairSessions.size > 0;
     }
     hasSyncProcessState() {
-        return (this.syncInFlightQueue.size > 0 ||
-            this.syncInFlightQueueInverted.size > 0 ||
-            this.pendingSyncAdmissionCount > 0 ||
-            this.syncInFlight.size > 0);
+        return this.pendingSync.hasSyncProcessState();
     }
     clearSyncProcessKey(key) {
-        const inflight = this.syncInFlightQueue.get(key);
-        if (inflight) {
-            for (const peer of inflight) {
-                const map = this.syncInFlightQueueInverted.get(peer.hashcode());
-                if (map) {
-                    map.delete(key);
-                    if (map.size === 0) {
-                        this.syncInFlightQueueInverted.delete(peer.hashcode());
-                    }
-                }
-            }
-            const trackedClaimants = this.syncInFlightQueueClaimants.get(key);
-            this.pendingSyncClaimCount = Math.max(0, this.pendingSyncClaimCount -
-                (trackedClaimants?.size ?? inflight.length));
-            this.syncInFlightQueue.delete(key);
-        }
-        this.syncInFlightQueueClaimants.delete(key);
-        this.syncInFlightQueueClaimantIndexes.delete(key);
-        this.syncInFlightQueueRoundRobinCursor.delete(key);
-        if (typeof key === "bigint") {
-            this.removeQueuedSyncCoordinateAlias(key);
-        }
-        this.removePendingSyncKeyExpiry(key);
-        this.syncInFlightQueueExpiresAt.delete(key);
-        this.clearPendingSyncExpiryTimerIfIdle();
-        this.clearSyncInFlightKey(key);
+        this.pendingSync.clearSyncProcessKey(key);
     }
     removePendingSyncClaim(key, peer) {
-        const inflight = this.syncInFlightQueue.get(key);
-        if (!inflight) {
-            return;
-        }
-        let claimants = this.syncInFlightQueueClaimants.get(key);
-        let claimantIndexes = this.syncInFlightQueueClaimantIndexes.get(key);
-        if (!claimants || !claimantIndexes) {
-            claimants = new Set();
-            claimantIndexes = new Map();
-            for (let index = 0; index < inflight.length; index += 1) {
-                const claimant = inflight[index].hashcode();
-                claimants.add(claimant);
-                claimantIndexes.set(claimant, index);
-            }
-            if (!this.syncInFlightQueueClaimants.has(key)) {
-                this.pendingSyncClaimCount += claimants.size;
-            }
-            this.syncInFlightQueueClaimants.set(key, claimants);
-            this.syncInFlightQueueClaimantIndexes.set(key, claimantIndexes);
-        }
-        const index = claimantIndexes.get(peer);
-        if (index == null) {
-            return;
-        }
-        const lastIndex = inflight.length - 1;
-        if (index !== lastIndex) {
-            const lastClaimant = inflight[lastIndex];
-            const lastClaimantHash = lastClaimant.hashcode();
-            inflight[index] = lastClaimant;
-            claimantIndexes.set(lastClaimantHash, index);
-        }
-        inflight.pop();
-        claimantIndexes.delete(peer);
-        claimants.delete(peer);
-        this.pendingSyncClaimCount = Math.max(0, this.pendingSyncClaimCount - 1);
-        const inverted = this.syncInFlightQueueInverted.get(peer);
-        inverted?.delete(key);
-        if (inverted?.size === 0) {
-            this.syncInFlightQueueInverted.delete(peer);
-        }
-        if (inflight.length > 0) {
-            const cursor = this.syncInFlightQueueRoundRobinCursor.get(key) ?? 0;
-            this.syncInFlightQueueRoundRobinCursor.set(key, cursor === lastIndex
-                ? index % inflight.length
-                : cursor % inflight.length);
-            return;
-        }
-        this.syncInFlightQueue.delete(key);
-        this.syncInFlightQueueClaimants.delete(key);
-        this.syncInFlightQueueClaimantIndexes.delete(key);
-        this.syncInFlightQueueRoundRobinCursor.delete(key);
-        if (typeof key === "bigint") {
-            this.removeQueuedSyncCoordinateAlias(key);
-        }
-        this.removePendingSyncKeyExpiry(key);
-        this.syncInFlightQueueExpiresAt.delete(key);
-        this.clearSyncInFlightKey(key);
-        this.clearPendingSyncExpiryTimerIfIdle();
+        this.pendingSync.removePendingSyncClaim(key, peer);
     }
     removeSyncInFlightTargetKey(peer, key) {
-        const map = this.syncInFlight.get(peer);
-        if (!map?.delete(key)) {
-            return;
-        }
-        if (map.size === 0) {
-            this.syncInFlight.delete(peer);
-        }
-        const targets = this.syncInFlightTargetsByKey.get(key);
-        targets?.delete(peer);
-        if (targets?.size === 0) {
-            this.syncInFlightTargetsByKey.delete(key);
-        }
+        this.pendingSync.removeSyncInFlightTargetKey(peer, key);
     }
     setSyncInFlightTargetKey(peer, key, timestamp) {
-        let map = this.syncInFlight.get(peer);
-        if (!map) {
-            map = new Map();
-            this.syncInFlight.set(peer, map);
-        }
-        const existing = map.get(key);
-        if (!existing || existing.timestamp < timestamp) {
-            map.set(key, { timestamp });
-        }
-        let targets = this.syncInFlightTargetsByKey.get(key);
-        if (!targets) {
-            targets = new Set();
-            this.syncInFlightTargetsByKey.set(key, targets);
-        }
-        targets.add(peer);
+        this.pendingSync.setSyncInFlightTargetKey(peer, key, timestamp);
     }
     clearSyncInFlightTarget(peer) {
-        const map = this.syncInFlight.get(peer);
-        if (!map) {
-            return;
-        }
-        for (const key of map.keys()) {
-            const targets = this.syncInFlightTargetsByKey.get(key);
-            targets?.delete(peer);
-            if (targets?.size === 0) {
-                this.syncInFlightTargetsByKey.delete(key);
-            }
-        }
-        this.syncInFlight.delete(peer);
-    }
-    clearSyncInFlightKey(key) {
-        const targets = this.syncInFlightTargetsByKey.get(key);
-        if (!targets) {
-            // Defensive compatibility for tests or integrations that seed the public
-            // syncInFlight map directly. Internal writes always populate the index.
-            for (const [peer, map] of this.syncInFlight) {
-                if (map.has(key)) {
-                    this.removeSyncInFlightTargetKey(peer, key);
-                }
-            }
-            return;
-        }
-        for (const peer of [...targets]) {
-            this.removeSyncInFlightTargetKey(peer, key);
-        }
-    }
-    forEachKnownAlias(hash, callback) {
-        callback(hash);
-        for (const coordinate of [
-            ...(this.syncInFlightQueuedCoordinatesByHash.get(hash) ?? []),
-        ]) {
-            callback(coordinate);
-        }
-    }
-    clearSyncInFlightForPeer(publicKeyHash, hash) {
-        const map = this.syncInFlight.get(publicKeyHash);
-        if (!map) {
-            return;
-        }
-        this.refreshQueuedSyncCoordinateAliases();
-        this.forEachKnownAlias(hash, (key) => this.removeSyncInFlightTargetKey(publicKeyHash, key));
+        this.pendingSync.clearSyncInFlightTarget(peer);
     }
     clearSyncInFlightForPeerHashes(publicKeyHash, hashes) {
-        const map = this.syncInFlight.get(publicKeyHash);
-        if (!map || hashes.length === 0) {
-            return;
-        }
-        this.refreshQueuedSyncCoordinateAliases();
-        for (const hash of hashes) {
-            this.forEachKnownAlias(hash, (key) => this.removeSyncInFlightTargetKey(publicKeyHash, key));
-        }
+        this.pendingSync.clearSyncInFlightForPeerHashes(publicKeyHash, hashes);
     }
     clearSyncProcess(hash) {
-        this.refreshQueuedSyncCoordinateAliases();
-        this.forEachKnownAlias(hash, (key) => this.clearSyncProcessKey(key));
+        this.pendingSync.clearSyncProcess(hash);
     }
     clearSyncProcesses(hashes) {
-        if (hashes.length === 0) {
-            return;
-        }
-        this.refreshQueuedSyncCoordinateAliases();
-        const keys = new Set();
-        for (const hash of hashes) {
-            this.forEachKnownAlias(hash, (key) => keys.add(key));
-        }
-        for (const key of keys) {
-            this.clearSyncProcessKey(key);
-        }
+        this.pendingSync.clearSyncProcesses(hashes);
     }
     onPeerDisconnected(key) {
         const publicKeyHash = typeof key === "string" ? key : key.hashcode();
@@ -3734,7 +3042,7 @@ export class SimpleSyncronizer {
         this.syncDispatchTargetEpochs.delete(publicKeyHash);
         this.clearPendingSyncAdmissions(publicKeyHash);
         for (const targetLifecycle of [
-            ...(this.syncDispatchTargets.get(publicKeyHash) ?? []),
+            ...(this.syncDispatchRegistry.activeTargets.get(publicKeyHash) ?? []),
         ]) {
             if (targetLifecycle.lifecycle.abortAllOnTargetDisconnect) {
                 this.abortSyncDispatchLifecycle(targetLifecycle.lifecycle, new Error("sync target disconnected"));
@@ -3746,13 +3054,12 @@ export class SimpleSyncronizer {
         this.clearSyncInFlightTarget(publicKeyHash);
         this.recentlySentExchangeHeads.delete(publicKeyHash);
         this.clearPendingMaybeSyncResponses(publicKeyHash);
-        const map = this.syncInFlightQueueInverted.get(publicKeyHash);
-        if (map) {
-            for (const hash of [...map]) {
-                this.removePendingSyncClaim(hash, publicKeyHash);
-            }
-            this.syncInFlightQueueInverted.delete(publicKeyHash);
-        }
+        this.pendingSync.removeClaimsForPeer(publicKeyHash);
+        // Storage lookups and response ships for this peer may never settle
+        // (the resolvers are not universally abortable). Detach the slot row so
+        // the peer's quota returns immediately; the captured closures settle
+        // against the detached row without touching a successor's quota.
+        this.detachSyncResponseSlotRow(publicKeyHash);
     }
     get pending() {
         return this.syncInFlightQueue.size;