envio 3.3.0-alpha.11 → 3.3.0-alpha.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.3.0-alpha.11",
+  "version": "3.3.0-alpha.12",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -70,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.3.0-alpha.11",
-    "envio-linux-x64-musl": "3.3.0-alpha.11",
-    "envio-linux-arm64": "3.3.0-alpha.11",
-    "envio-darwin-x64": "3.3.0-alpha.11",
-    "envio-darwin-arm64": "3.3.0-alpha.11"
+    "envio-linux-x64": "3.3.0-alpha.12",
+    "envio-linux-x64-musl": "3.3.0-alpha.12",
+    "envio-linux-arm64": "3.3.0-alpha.12",
+    "envio-darwin-x64": "3.3.0-alpha.12",
+    "envio-darwin-arm64": "3.3.0-alpha.12"
   }
 }

package/src/ChainFetching.res

@@ -149,19 +149,28 @@ let rec onQueryResponse = async (
 
     let numContractRegisterEvents = parsedQueueItems->Array.reduce(0, (count, item) => {
       let eventItem = item->Internal.castUnsafeEventItem
-      eventItem.onEventRegistration.contractRegister !== None
-        ? count + 1
-        : count
-    })
-    Logging.trace({
-      "msg": "Finished querying",
-      "chainId": chain->ChainMap.Chain.toChainId,
-      "partitionId": query.partitionId,
-      "fromBlock": fromBlockQueried,
-      "toBlock": latestFetchedBlockNumber,
-      "numEvents": parsedQueueItems->Array.length,
-      "numContractRegisterEvents": numContractRegisterEvents,
+      eventItem.onEventRegistration.contractRegister !== None ? count + 1 : count
     })
+    if numContractRegisterEvents === 0 {
+      Logging.trace({
+        "msg": "Finished querying",
+        "chainId": chain->ChainMap.Chain.toChainId,
+        "partitionId": query.partitionId,
+        "fromBlock": fromBlockQueried,
+        "toBlock": latestFetchedBlockNumber,
+        "numEvents": parsedQueueItems->Array.length,
+      })
+    } else {
+      Logging.trace({
+        "msg": "Finished querying",
+        "chainId": chain->ChainMap.Chain.toChainId,
+        "partitionId": query.partitionId,
+        "fromBlock": fromBlockQueried,
+        "toBlock": latestFetchedBlockNumber,
+        "numEvents": parsedQueueItems->Array.length,
+        "numContractRegisterEvents": numContractRegisterEvents,
+      })
+    }
 
     let reorgResult = chainState->ChainState.registerReorgGuard(~blockHashes, ~knownHeight)
 

package/src/ChainFetching.res.mjs

@@ -111,15 +111,26 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
       return count;
     }
   });
-  Logging.trace({
-    msg: "Finished querying",
-    chainId: chain,
-    partitionId: query.partitionId,
-    fromBlock: fromBlockQueried,
-    toBlock: latestFetchedBlockNumber,
-    numEvents: parsedQueueItems.length,
-    numContractRegisterEvents: numContractRegisterEvents
-  });
+  if (numContractRegisterEvents === 0) {
+    Logging.trace({
+      msg: "Finished querying",
+      chainId: chain,
+      partitionId: query.partitionId,
+      fromBlock: fromBlockQueried,
+      toBlock: latestFetchedBlockNumber,
+      numEvents: parsedQueueItems.length
+    });
+  } else {
+    Logging.trace({
+      msg: "Finished querying",
+      chainId: chain,
+      partitionId: query.partitionId,
+      fromBlock: fromBlockQueried,
+      toBlock: latestFetchedBlockNumber,
+      numEvents: parsedQueueItems.length,
+      numContractRegisterEvents: numContractRegisterEvents
+    });
+  }
   let reorgResult = ChainState.registerReorgGuard(chainState, response.blockHashes, knownHeight);
   let rollbackWithReorgDetectedBlockNumber;
   if (typeof reorgResult !== "object") {

package/src/CrossChainState.res

@@ -170,7 +170,7 @@ let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampNa
 // --- Fetch control. ---
 
 // Chains ordered furthest-behind first, so the shared buffer pool goes to the
-// chains with the most backfill work before the rest.
+// chains with the most fetchable backfill work before the rest.
 let priorityOrder = (crossChainState: t) =>
   crossChainState.chainStates
   ->Dict.valuesToArray
@@ -198,29 +198,37 @@ let totalReservedSize = (crossChainState: t) => {
 // chain-density-derived target block, then subtract what it actually used
 // before moving to the next chain. So a chain that can only use a little
 // (density too low, or already caught up) leaves the rest for the others
-// automatically. A chain visited after the budget ran out simply doesn't
-// query this round — the leader's reservations release as its responses land,
-// so the next tick redistributes. Chains that do get budget are additionally
-// capped at the most-behind chain's target progress mapped onto their own
-// range, so no chain runs further ahead than the chain the pool is
-// prioritizing.
+// automatically. Starting a new query requires at least 10% of the target pool
+// to be free. A chain visited after the budget falls below that admission unit
+// doesn't query this round — reservations release as responses land, so the
+// next tick redistributes. Chains that do get budget are additionally capped
+// at the first querying chain's target progress mapped onto their own range, so
+// no chain runs further ahead than the chain currently using the pool. Waiting
+// and idle chains do not establish this alignment line.
 let checkAndFetch = async (
   crossChainState: t,
   ~dispatchChain: (~chain: ChainMap.Chain.t, ~action: FetchState.nextQuery) => promise<unit>,
 ) => {
+  let targetBudget = crossChainState.targetBufferSize->Int.toFloat
   let remaining = ref(
     Pervasives.max(
       0.,
-      crossChainState.targetBufferSize->Int.toFloat -.
+      targetBudget -.
       crossChainState->totalReadyCount->Int.toFloat -.
       crossChainState->totalReservedSize,
     ),
   )
 
+  // New fetch work is admitted in units of 10% of the target pool. Waiting
+  // below this floor avoids spending the last few free items on undersized
+  // queries; response and batch completion schedule another tick after they
+  // release enough budget.
+  let minimumAdmissionBudget = targetBudget *. 0.1
+
   // A chain with no density signal probes blind, so it only gets a bounded
   // slice of the pool — one unknown chain shouldn't hold the whole budget
-  // while it takes its first measurements.
-  let coldChainBudget = Pervasives.min(5_000., crossChainState.targetBufferSize->Int.toFloat)
+  // while it takes its first measurements. Its probe is one admission unit.
+  let coldChainBudget = minimumAdmissionBudget
 
   // Chunk reservations get headroom over the density estimate so a
   // denser-than-expected range doesn't truncate at the server cap; realtime
@@ -233,30 +241,33 @@ let checkAndFetch = async (
   ->priorityOrder
   ->Array.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
-    if cs->ChainState.knownHeight == 0 {
-      // No height yet — nothing to size a budget or an alignment line
-      // against. Skip without consuming budget or claiming leadership, so a
-      // chain whose source hasn't reported doesn't unconstrain everyone else.
-      actionByChain->Utils.Dict.setByInt(chainId, FetchState.WaitingForNewBlock)
+    if remaining.contents < minimumAdmissionBudget {
+      // More than 90% of the target pool is ready or reserved. Do not attempt
+      // any chain action until a full admission unit becomes free.
+      actionByChain->Utils.Dict.setByInt(chainId, FetchState.NothingToQuery)
+    } else if cs->ChainState.knownHeight == 0 {
+      // Let getNextQuery own the waiting decision without trying to size work
+      // against an unknown height.
+      actionByChain->Utils.Dict.setByInt(
+        chainId,
+        cs->ChainState.getNextQuery(~chainTargetItems=0., ~chunkItemsMultiplier),
+      )
     } else {
       let isCold = cs->ChainState.effectiveDensity === None
       let chainTargetItems =
         (isCold ? Pervasives.min(remaining.contents, coldChainBudget) : remaining.contents) +.
         cs->ChainState.pendingBudget
+      let candidateProgress = switch maxProgress.contents {
+      | None if !isCold =>
+        Some(
+          cs->ChainState.progressAtBlock(
+            ~blockNumber=cs->ChainState.targetBlock(~chainTargetItems),
+          ),
+        )
+      | _ => None
+      }
       let maxTargetBlock = switch maxProgress.contents {
-      | None if isCold =>
-        // A cold chain's target is a guess — it doesn't set the alignment
-        // line; the first density-bearing chain after it does.
-        None
-      | None =>
-        // The most-behind chain sets the alignment line for everyone after it.
-        maxProgress :=
-          Some(
-            cs->ChainState.progressAtBlock(
-              ~blockNumber=cs->ChainState.targetBlock(~chainTargetItems),
-            ),
-          )
-        None
+      | None => None
       // 5% margin past the leader's line: chains whose progress tracks the
       // leader closely would otherwise flap in and out of the clamp as
       // leadership alternates, stalling their pipeline every other tick.
@@ -274,8 +285,7 @@ let checkAndFetch = async (
         // range to nothing — and has nothing else to wake it must keep polling
         // for new blocks instead of going silent. NothingToQuery isn't
         // dispatched, so such a chain would never be re-scheduled and its head
-        // tracking would freeze (the knownHeight == 0 branch above forces a poll
-        // for the same reason). A chain is genuinely idle — and correctly left
+        // tracking would freeze. A chain is genuinely idle — and correctly left
         // undispatched — when it is caught up to its head/endblock, still
         // draining in-flight queries, or holding ready items that batch
         // processing will drain and re-schedule from.
@@ -287,6 +297,14 @@ let checkAndFetch = async (
             : FetchState.WaitingForNewBlock
         actionByChain->Utils.Dict.setByInt(chainId, action)
       | Ready(queries) => {
+          // A density-bearing chain establishes the alignment line only after
+          // proving that it can use the pool. Waiting and idle chains leave it
+          // open for the next chain; cold-chain targets remain guesses and do
+          // not lead, as before.
+          switch candidateProgress {
+          | Some(progress) => maxProgress := Some(progress)
+          | None => ()
+          }
           let consumed =
             queries->Array.reduce(0., (acc, query: FetchState.query) =>
               acc +. query.itemsEst->Int.toFloat

package/src/CrossChainState.res.mjs

@@ -134,10 +134,11 @@ function totalReservedSize(crossChainState) {
 }
 
 async function checkAndFetch(crossChainState, dispatchChain) {
+  let targetBudget = crossChainState.targetBufferSize;
   let remaining = {
-    contents: Primitive_float.max(0, crossChainState.targetBufferSize - totalReadyCount(crossChainState) - totalReservedSize(crossChainState))
+    contents: Primitive_float.max(0, targetBudget - totalReadyCount(crossChainState) - totalReservedSize(crossChainState))
   };
-  let coldChainBudget = Primitive_float.min(5000, crossChainState.targetBufferSize);
+  let minimumAdmissionBudget = targetBudget * 0.1;
   let chunkItemsMultiplier = crossChainState.isRealtime ? 3 : 1.5;
   let actionByChain = {};
   let maxProgress = {
@@ -145,18 +146,22 @@ async function checkAndFetch(crossChainState, dispatchChain) {
   };
   priorityOrder(crossChainState).forEach(cs => {
     let chainId = ChainState.chainConfig(cs).id;
+    if (remaining.contents < minimumAdmissionBudget) {
+      actionByChain[chainId] = "NothingToQuery";
+      return;
+    }
     if (ChainState.knownHeight(cs) === 0) {
-      actionByChain[chainId] = "WaitingForNewBlock";
+      actionByChain[chainId] = ChainState.getNextQuery(cs, 0, chunkItemsMultiplier, undefined);
       return;
     }
     let isCold = ChainState.effectiveDensity(cs) === undefined;
     let chainTargetItems = (
-      isCold ? Primitive_float.min(remaining.contents, coldChainBudget) : remaining.contents
+      isCold ? Primitive_float.min(remaining.contents, minimumAdmissionBudget) : remaining.contents
     ) + ChainState.pendingBudget(cs);
+    let match = maxProgress.contents;
+    let candidateProgress = match !== undefined || isCold ? undefined : ChainState.progressAtBlock(cs, ChainState.targetBlock(cs, chainTargetItems));
     let progress = maxProgress.contents;
-    let maxTargetBlock = progress !== undefined ? ChainState.blockAtProgress(cs, progress + 0.05) : (
-        isCold ? undefined : (maxProgress.contents = ChainState.progressAtBlock(cs, ChainState.targetBlock(cs, chainTargetItems)), undefined)
-      );
+    let maxTargetBlock = progress !== undefined ? ChainState.blockAtProgress(cs, progress + 0.05) : undefined;
     let action = ChainState.getNextQuery(cs, chainTargetItems, chunkItemsMultiplier, maxTargetBlock);
     if (typeof action !== "object") {
       if (action === "WaitingForNewBlock") {
@@ -168,6 +173,9 @@ async function checkAndFetch(crossChainState, dispatchChain) {
       return;
     } else {
       let queries = action._0;
+      if (candidateProgress !== undefined) {
+        maxProgress.contents = candidateProgress;
+      }
       let consumed = Stdlib_Array.reduce(queries, 0, (acc, query) => acc + query.itemsEst);
       let partitions = {};
       queries.forEach(query => {

package/src/FetchState.res

@@ -47,17 +47,19 @@ type partition = {
   dynamicContract: option<string>,
   // Mutable array for SourceManager sync - queries exist only while being fetched
   mutPendingQueries: array<pendingQuery>,
-  // Track last 3 successful query ranges for chunking heuristic (0 means no data)
-  prevQueryRange: int,
-  prevPrevQueryRange: int,
-  // Item count of the response that set prevQueryRange. Paired with it to derive
-  // the partition's event density (prevRangeSize / prevQueryRange) for sizing
-  // queries against the buffer budget.
-  prevRangeSize: int,
+  // The last two ranges that measured how many blocks the source could return.
+  // Both must be non-zero before the minimum is trusted for chunk sizing.
+  sourceRangeCapacity: int,
+  prevSourceRangeCapacity: int,
+  // Smoothed items/block observed in responses. This is independent from the
+  // source's range capacity: even a response truncated by our own itemsTarget
+  // cap is useful density evidence while saying nothing about source capacity.
+  // None distinguishes a new partition from a real zero-density observation.
+  eventDensity: option<float>,
   // Tracks the latestFetchedBlock.blockNumber of the most recent response
-  // that updated prevQueryRange. Prevents degradation of the chunking heuristic
-  // when parallel query responses arrive out of order.
-  latestBlockRangeUpdateBlock: int,
+  // that updated sourceRangeCapacity. Prevents degradation of the chunking
+  // heuristic when parallel query responses arrive out of order.
+  latestSourceRangeCapacityUpdateBlock: int,
 }
 
 type query = {
@@ -111,22 +113,17 @@ let densityItemsTarget = (~density, ~fromBlock, ~toBlock, ~chainTargetBlock) =>
   )
 }
 
-// Calculate the chunk range from history using min-of-last-3-ranges heuristic
+// Calculate the chunk range from the last two source-capacity observations.
 let getMinHistoryRange = (p: partition) => {
-  switch (p.prevQueryRange, p.prevPrevQueryRange) {
+  switch (p.sourceRangeCapacity, p.prevSourceRangeCapacity) {
   | (0, _) | (_, 0) => None
   | (a, b) => Some(a < b ? a : b)
   }
 }
 
-// Density (items/block) from the last response, trusted only after two
-// responses — a single sample is too noisy to size the next query by.
-let getTrustedDensity = (p: partition) => {
-  switch (p.prevQueryRange, p.prevPrevQueryRange) {
-  | (0, _) | (_, 0) => None
-  | (prevQueryRange, _) => Some(p.prevRangeSize->Int.toFloat /. prevQueryRange->Int.toFloat)
-  }
-}
+// Density has its own initialization signal and is useful independently from
+// source-capacity history, including when an itemsTarget cap truncates a response.
+let getTrustedDensity = (p: partition) => p.eventDensity
 
 let getMinQueryRange = (partitions: array<partition>) => {
   let min = ref(0)
@@ -134,8 +131,8 @@ let getMinQueryRange = (partitions: array<partition>) => {
     let p = partitions->Array.getUnsafe(i)
 
     // Even if it's fetching, set dynamicContract field
-    let a = p.prevQueryRange
-    let b = p.prevPrevQueryRange
+    let a = p.sourceRangeCapacity
+    let b = p.prevSourceRangeCapacity
     if a > 0 && (min.contents == 0 || a < min.contents) {
       min := a
     }
@@ -208,11 +205,14 @@ module OptimizedPartitions = {
       nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
       let minRange = getMinQueryRange([p1, p2])
       // The merged partition indexes both parents' addresses, so its expected
-      // event rate is the sum of their densities. Parents without a trusted
-      // density contribute 0; if none has one, prevRangeSize stays 0 and the
-      // partition probes for a fresh signal instead of chunking.
-      let inheritedDensity =
-        p1->getTrustedDensity->Option.getOr(0.) +. p2->getTrustedDensity->Option.getOr(0.)
+      // event rate is the sum of their densities. If neither parent has a
+      // trusted density, the merged partition probes for a fresh signal
+      // instead of treating zero as an observed density.
+      let inheritedDensity = switch (p1->getTrustedDensity, p2->getTrustedDensity) {
+      | (Some(p1Density), Some(p2Density)) => Some(p1Density +. p2Density)
+      | (Some(density), None) | (None, Some(density)) => Some(density)
+      | (None, None) => None
+      }
       {
         id: newId,
         dynamicContract: Some(contractName),
@@ -221,10 +221,10 @@ module OptimizedPartitions = {
         mergeBlock: None,
         addressesByContractName: Dict.make(), // set below
         mutPendingQueries: [],
-        prevQueryRange: minRange,
-        prevPrevQueryRange: minRange,
-        prevRangeSize: (inheritedDensity *. minRange->Int.toFloat)->Math.ceil->Float.toInt,
-        latestBlockRangeUpdateBlock: 0,
+        sourceRangeCapacity: minRange,
+        prevSourceRangeCapacity: minRange,
+        eventDensity: inheritedDensity,
+        latestSourceRangeCapacityUpdateBlock: 0,
       }
     }
 
@@ -472,14 +472,28 @@ module OptimizedPartitions = {
     pendingQuery.fetchedBlock = Some(latestFetchedBlock)
 
     let blockRange = latestFetchedBlock.blockNumber - query.fromBlock + 1
-    // Skip updating block range if a later response already updated it.
+    // Update density for every response, independently from whether this range
+    // is valid evidence of source capacity. A cap hit is still useful density
+    // evidence because it reports items returned across the scanned range.
+    let observedEventDensity = itemsCount->Int.toFloat /. blockRange->Int.toFloat
+    // Seed from the first observation, then smooth every later observation
+    // with a 1:1 moving average. Keeping initialization explicit is important:
+    // zero is valid density evidence and must participate in the next blend.
+    let updatedEventDensity = switch p.eventDensity {
+    | None => Some(observedEventDensity)
+    | Some(eventDensity) => Some((eventDensity +. observedEventDensity) /. 2.)
+    }
+
+    // Skip updating source capacity if a later response already updated it.
     // Prevents degradation of the chunking heuristic when parallel query
     // responses arrive out of order (e.g. earlier query with smaller range
     // arriving after a later query with bigger range).
-    let shouldUpdateBlockRange =
-      latestFetchedBlock.blockNumber > p.latestBlockRangeUpdateBlock &&
+    let shouldUpdateSourceRangeCapacity =
+      latestFetchedBlock.blockNumber > p.latestSourceRangeCapacityUpdateBlock &&
         switch query.toBlock {
-        | None => latestFetchedBlock.blockNumber < knownHeight - 10 // Don't update block range when very close to the head
+        | None =>
+          // Don't update source capacity when very close to the head.
+          latestFetchedBlock.blockNumber < knownHeight - 10
         | Some(queryToBlock) =>
           if latestFetchedBlock.blockNumber < queryToBlock {
             // Partial response is direct capacity evidence — unless it was
@@ -497,9 +511,12 @@ module OptimizedPartitions = {
             }
           }
         }
-    let updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p.prevQueryRange
-    let updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p.prevQueryRange : p.prevPrevQueryRange
-    let updatedPrevRangeSize = shouldUpdateBlockRange ? itemsCount : p.prevRangeSize
+    let updatedSourceRangeCapacity = shouldUpdateSourceRangeCapacity
+      ? blockRange
+      : p.sourceRangeCapacity
+    let updatedPrevSourceRangeCapacity = shouldUpdateSourceRangeCapacity
+      ? p.sourceRangeCapacity
+      : p.prevSourceRangeCapacity
 
     // Process fetched queries from front of queue for main partition
     let updatedLatestFetchedBlock = consumeFetchedQueries(
@@ -519,12 +536,12 @@ module OptimizedPartitions = {
       let updatedMainPartition = {
         ...p,
         latestFetchedBlock: updatedLatestFetchedBlock,
-        prevQueryRange: updatedPrevQueryRange,
-        prevPrevQueryRange: updatedPrevPrevQueryRange,
-        prevRangeSize: updatedPrevRangeSize,
-        latestBlockRangeUpdateBlock: shouldUpdateBlockRange
+        sourceRangeCapacity: updatedSourceRangeCapacity,
+        prevSourceRangeCapacity: updatedPrevSourceRangeCapacity,
+        eventDensity: updatedEventDensity,
+        latestSourceRangeCapacityUpdateBlock: shouldUpdateSourceRangeCapacity
           ? latestFetchedBlock.blockNumber
-          : p.latestBlockRangeUpdateBlock,
+          : p.latestSourceRangeCapacityUpdateBlock,
       }
 
       mutEntities->Dict.set(p.id, updatedMainPartition)
@@ -986,10 +1003,10 @@ OptimizedPartitions.t => {
             addressesByContractName,
             mergeBlock: None,
             mutPendingQueries: [],
-            prevQueryRange: 0,
-            prevPrevQueryRange: 0,
-            prevRangeSize: 0,
-            latestBlockRangeUpdateBlock: 0,
+            sourceRangeCapacity: 0,
+            prevSourceRangeCapacity: 0,
+            eventDensity: None,
+            latestSourceRangeCapacityUpdateBlock: 0,
           })
           nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
         }
@@ -1322,10 +1339,10 @@ let registerDynamicContracts = (
                         addressesByContractName,
                         mergeBlock: None,
                         mutPendingQueries: p.mutPendingQueries,
-                        prevQueryRange: p.prevQueryRange,
-                        prevPrevQueryRange: p.prevPrevQueryRange,
-                        prevRangeSize: p.prevRangeSize,
-                        latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock,
+                        sourceRangeCapacity: p.sourceRangeCapacity,
+                        prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                        eventDensity: p.eventDensity,
+                        latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock,
                       })
                     }
                   }
@@ -1582,24 +1599,25 @@ type partitionFillState = {
 // query with no other ceiling: the true hard bounds stay
 // endBlock/mergeBlock/the lagged head.
 //
-// The tick's budget is chainTargetItems minus what's already in flight. Every
-// candidate query — gap-fill holes, plus each in-range partition's chunks or
-// open-ended probe toward the target — is generated with no budget check, then
-// the candidates are sorted by fromBlock and accepted in that order while the
-// budget stays positive. The query that tips it negative is still accepted (a
-// single overshoot); everything after it waits for a tick with more budget.
+// The tick's budget is chainTargetItems minus what's already in flight. A
+// non-positive budget only resolves the wait action and generates no query
+// candidates. With a positive budget, every candidate query — gap-fill holes,
+// plus each in-range partition's chunks or open-ended probe toward the target —
+// is generated with no budget check, then the candidates are sorted by
+// fromBlock and accepted in that order while the budget stays positive. The
+// query that tips it negative is still accepted (a single overshoot);
+// everything after it waits for a tick with more budget.
 // Sorting by fromBlock spends the budget on the earliest blocks across all
 // partitions first, so no partition is starved by generation order and the
 // frontier advances evenly. In-flight reservations release as responses land,
 // so acceptance redistributes across ticks.
 //
-// A partition with a trusted positive density (two or more responses — see
-// getMinHistoryRange) generates real, density-sized chunks toward the target.
-// Any other partition (no signal, one noisy sample, or a density-0 estimate)
-// generates one open-ended probe sized to the events its range to the target is
-// expected to hold — rangeTargetDensity × (chainTargetBlock − fromBlock + 1) /
-// inRangeCount — so several unknown-density partitions probe in parallel within
-// one budget, each scaled by how much of the range it still has to cover.
+// A partition with source-capacity history and a positive density generates
+// density-sized chunks toward the target. Any other partition (no signal, no
+// capacity history, or a density-0 estimate) generates one open-ended probe
+// sized to the events its range to the target is expected to hold —
+// rangeTargetDensity × (chainTargetBlock − fromBlock + 1) / inRangeCount — so
+// unknown-density partitions probe in parallel within one budget.
 let getNextQuery = (
   {optimizedPartitions, blockLag, latestOnBlockBlockNumber, knownHeight, endBlock}: t,
   ~chainTargetBlock: int,
@@ -1639,6 +1657,12 @@ let getNextQuery = (
       }
     }
 
+    // A zero budget is an admission check: preserve the wait-state scan above,
+    // but make every query-generation pass below empty. Caught-up chains also
+    // skip those passes because their action is already known.
+    let partitionsCount =
+      chainTargetItems <= 0. || shouldWaitForNewBlock.contents ? 0 : partitionsCount
+
     // One bucket per partition, in idsInAscOrder order — gap-fill and the
     // budget pass both push into a partition's own bucket, so flattening at
     // the end (see below) reproduces idsInAscOrder without a sort.
@@ -1788,10 +1812,9 @@ let getNextQuery = (
       inRangeCount > 0 && rangeToTarget > 0 ? freshBudget /. rangeToTarget->Int.toFloat : 0.
 
     // Phase B: generate each in-range partition's candidates — strict chunks
-    // toward the target sized by real density (up to the pending-chunk cap), or,
-    // for a partition without a trusted positive density, a single open-ended
-    // probe at its even share of the budget. No budget check here; the
-    // acceptance pass below decides which candidates make the cut.
+    // when both source-capacity history and density are known, or an open-ended
+    // budget probe otherwise. No budget check here; the acceptance pass below
+    // decides which candidates make the cut.
     //
     // Chunks require a POSITIVE trusted density: density 0 prices every chunk at
     // ~nothing, so an open-ended probe (full server scan range in one response)
@@ -2022,10 +2045,10 @@ let make = (
       mergeBlock: None,
       dynamicContract: None,
       mutPendingQueries: [],
-      prevQueryRange: 0,
-      prevPrevQueryRange: 0,
-      prevRangeSize: 0,
-      latestBlockRangeUpdateBlock: 0,
+      sourceRangeCapacity: 0,
+      prevSourceRangeCapacity: 0,
+      eventDensity: None,
+      latestSourceRangeCapacityUpdateBlock: 0,
     })
   }
 
@@ -2345,13 +2368,15 @@ let isReadyToEnterReorgThreshold = ({endBlock, blockLag, buffer, knownHeight} as
   buffer->Utils.Array.isEmpty
 }
 
-// Lower progress percentage = further behind = higher priority. Shared by the
-// batch ordering and the cross-chain fetch priority.
+// Lower progress percentage = further behind = higher priority. Progress is
+// relative to the head this chain can actually fetch, so a chain at its lagged
+// head does not look behind relative to unavailable blocks. Shared by the batch
+// ordering and the cross-chain fetch priority.
 let getProgressPercentage = (fetchState: t) => {
   switch fetchState.firstEventBlock {
   | None => 0.
   | Some(firstEventBlock) =>
-    let totalRange = fetchState.knownHeight - firstEventBlock
+    let totalRange = fetchState.knownHeight - fetchState.blockLag - firstEventBlock
     if totalRange <= 0 {
       0.
     } else {

package/src/FetchState.res.mjs

@@ -28,27 +28,23 @@ function densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock) {
 }
 
 function getMinHistoryRange(p) {
-  let match = p.prevQueryRange;
-  let match$1 = p.prevPrevQueryRange;
+  let match = p.sourceRangeCapacity;
+  let match$1 = p.prevSourceRangeCapacity;
   if (match !== 0 && match$1 !== 0) {
     return match < match$1 ? match : match$1;
   }
 }
 
 function getTrustedDensity(p) {
-  let match = p.prevQueryRange;
-  let match$1 = p.prevPrevQueryRange;
-  if (match !== 0 && match$1 !== 0) {
-    return p.prevRangeSize / match;
-  }
+  return p.eventDensity;
 }
 
 function getMinQueryRange(partitions) {
   let min = 0;
   for (let i = 0, i_finish = partitions.length; i < i_finish; ++i) {
     let p = partitions[i];
-    let a = p.prevQueryRange;
-    let b = p.prevPrevQueryRange;
+    let a = p.sourceRangeCapacity;
+    let b = p.prevSourceRangeCapacity;
     if (a > 0 && (min === 0 || a < min)) {
       min = a;
     }
@@ -88,10 +84,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
-        prevQueryRange: p1.prevQueryRange,
-        prevPrevQueryRange: p1.prevPrevQueryRange,
-        prevRangeSize: p1.prevRangeSize,
-        latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p1.sourceRangeCapacity,
+        prevSourceRangeCapacity: p1.prevSourceRangeCapacity,
+        eventDensity: p1.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p1.latestSourceRangeCapacityUpdateBlock
       });
       completed.push({
         id: p2.id,
@@ -101,10 +97,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: potentialMergeBlock,
         dynamicContract: p2.dynamicContract,
         mutPendingQueries: p2.mutPendingQueries,
-        prevQueryRange: p2.prevQueryRange,
-        prevPrevQueryRange: p2.prevPrevQueryRange,
-        prevRangeSize: p2.prevRangeSize,
-        latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p2.sourceRangeCapacity,
+        prevSourceRangeCapacity: p2.prevSourceRangeCapacity,
+        eventDensity: p2.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p2.latestSourceRangeCapacityUpdateBlock
       });
       let newId = nextPartitionIndexRef.contents.toString();
       nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
@@ -112,7 +108,13 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         p1,
         p2
       ]);
-      let inheritedDensity = Stdlib_Option.getOr(getTrustedDensity(p1), 0) + Stdlib_Option.getOr(getTrustedDensity(p2), 0);
+      let match = p1.eventDensity;
+      let match$1 = p2.eventDensity;
+      let inheritedDensity = match !== undefined ? (
+          match$1 !== undefined ? match + match$1 : match
+        ) : (
+          match$1 !== undefined ? match$1 : undefined
+        );
       continuingBase = {
         id: newId,
         latestFetchedBlock: {
@@ -124,10 +126,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: undefined,
         dynamicContract: contractName,
         mutPendingQueries: [],
-        prevQueryRange: minRange,
-        prevPrevQueryRange: minRange,
-        prevRangeSize: Math.ceil(inheritedDensity * minRange) | 0,
-        latestBlockRangeUpdateBlock: 0
+        sourceRangeCapacity: minRange,
+        prevSourceRangeCapacity: minRange,
+        eventDensity: inheritedDensity,
+        latestSourceRangeCapacityUpdateBlock: 0
       };
     } else {
       completed.push({
@@ -138,10 +140,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
-        prevQueryRange: p1.prevQueryRange,
-        prevPrevQueryRange: p1.prevPrevQueryRange,
-        prevRangeSize: p1.prevRangeSize,
-        latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p1.sourceRangeCapacity,
+        prevSourceRangeCapacity: p1.prevSourceRangeCapacity,
+        eventDensity: p1.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p1.latestSourceRangeCapacityUpdateBlock
       });
       continuingBase = p2;
     }
@@ -154,10 +156,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mergeBlock: potentialMergeBlock,
       dynamicContract: p2.dynamicContract,
       mutPendingQueries: p2.mutPendingQueries,
-      prevQueryRange: p2.prevQueryRange,
-      prevPrevQueryRange: p2.prevPrevQueryRange,
-      prevRangeSize: p2.prevRangeSize,
-      latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+      sourceRangeCapacity: p2.sourceRangeCapacity,
+      prevSourceRangeCapacity: p2.prevSourceRangeCapacity,
+      eventDensity: p2.eventDensity,
+      latestSourceRangeCapacityUpdateBlock: p2.latestSourceRangeCapacityUpdateBlock
     });
     continuingBase = p1;
   } else {
@@ -178,10 +180,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mergeBlock: continuingBase.mergeBlock,
       dynamicContract: continuingBase.dynamicContract,
       mutPendingQueries: continuingBase.mutPendingQueries,
-      prevQueryRange: continuingBase.prevQueryRange,
-      prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-      prevRangeSize: continuingBase.prevRangeSize,
-      latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+      sourceRangeCapacity: continuingBase.sourceRangeCapacity,
+      prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
+      eventDensity: continuingBase.eventDensity,
+      latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
     });
     let restId = nextPartitionIndexRef.contents.toString();
     nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
@@ -193,10 +195,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mergeBlock: continuingBase.mergeBlock,
       dynamicContract: continuingBase.dynamicContract,
       mutPendingQueries: [],
-      prevQueryRange: continuingBase.prevQueryRange,
-      prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-      prevRangeSize: continuingBase.prevRangeSize,
-      latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+      sourceRangeCapacity: continuingBase.sourceRangeCapacity,
+      prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
+      eventDensity: continuingBase.eventDensity,
+      latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
     });
     return completed;
   }
@@ -210,10 +212,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
     mergeBlock: continuingBase.mergeBlock,
     dynamicContract: continuingBase.dynamicContract,
     mutPendingQueries: continuingBase.mutPendingQueries,
-    prevQueryRange: continuingBase.prevQueryRange,
-    prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-    prevRangeSize: continuingBase.prevRangeSize,
-    latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+    sourceRangeCapacity: continuingBase.sourceRangeCapacity,
+    prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
+    eventDensity: continuingBase.eventDensity,
+    latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
   });
   return completed;
 }
@@ -358,8 +360,11 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
   let pendingQuery = getPendingQueryOrThrow(p$1, query.fromBlock);
   pendingQuery.fetchedBlock = latestFetchedBlock;
   let blockRange = (latestFetchedBlock.blockNumber - query.fromBlock | 0) + 1 | 0;
-  let shouldUpdateBlockRange = false;
-  if (latestFetchedBlock.blockNumber > p$1.latestBlockRangeUpdateBlock) {
+  let observedEventDensity = itemsCount / blockRange;
+  let eventDensity = p$1.eventDensity;
+  let updatedEventDensity = eventDensity !== undefined ? (eventDensity + observedEventDensity) / 2 : observedEventDensity;
+  let shouldUpdateSourceRangeCapacity = false;
+  if (latestFetchedBlock.blockNumber > p$1.latestSourceRangeCapacityUpdateBlock) {
     let queryToBlock = query.toBlock;
     let tmp;
     if (queryToBlock !== undefined) {
@@ -372,11 +377,10 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     } else {
       tmp = latestFetchedBlock.blockNumber < (knownHeight - 10 | 0);
     }
-    shouldUpdateBlockRange = tmp;
+    shouldUpdateSourceRangeCapacity = tmp;
   }
-  let updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p$1.prevQueryRange;
-  let updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p$1.prevQueryRange : p$1.prevPrevQueryRange;
-  let updatedPrevRangeSize = shouldUpdateBlockRange ? itemsCount : p$1.prevRangeSize;
+  let updatedSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? blockRange : p$1.sourceRangeCapacity;
+  let updatedPrevSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? p$1.sourceRangeCapacity : p$1.prevSourceRangeCapacity;
   let mutPendingQueries = p$1.mutPendingQueries;
   let latestFetchedBlock$1 = p$1.latestFetchedBlock;
   while ((() => {
@@ -402,7 +406,7 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     let updatedMainPartition_mergeBlock = p$1.mergeBlock;
     let updatedMainPartition_dynamicContract = p$1.dynamicContract;
     let updatedMainPartition_mutPendingQueries = p$1.mutPendingQueries;
-    let updatedMainPartition_latestBlockRangeUpdateBlock = shouldUpdateBlockRange ? latestFetchedBlock.blockNumber : p$1.latestBlockRangeUpdateBlock;
+    let updatedMainPartition_latestSourceRangeCapacityUpdateBlock = shouldUpdateSourceRangeCapacity ? latestFetchedBlock.blockNumber : p$1.latestSourceRangeCapacityUpdateBlock;
     let updatedMainPartition = {
       id: updatedMainPartition_id,
       latestFetchedBlock: updatedLatestFetchedBlock,
@@ -411,10 +415,10 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
       mergeBlock: updatedMainPartition_mergeBlock,
       dynamicContract: updatedMainPartition_dynamicContract,
       mutPendingQueries: updatedMainPartition_mutPendingQueries,
-      prevQueryRange: updatedPrevQueryRange,
-      prevPrevQueryRange: updatedPrevPrevQueryRange,
-      prevRangeSize: updatedPrevRangeSize,
-      latestBlockRangeUpdateBlock: updatedMainPartition_latestBlockRangeUpdateBlock
+      sourceRangeCapacity: updatedSourceRangeCapacity,
+      prevSourceRangeCapacity: updatedPrevSourceRangeCapacity,
+      eventDensity: updatedEventDensity,
+      latestSourceRangeCapacityUpdateBlock: updatedMainPartition_latestSourceRangeCapacityUpdateBlock
     };
     mutEntities[p$1.id] = updatedMainPartition;
   }
@@ -739,10 +743,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: undefined,
             dynamicContract: isDynamic ? contractName : undefined,
             mutPendingQueries: [],
-            prevQueryRange: 0,
-            prevPrevQueryRange: 0,
-            prevRangeSize: 0,
-            latestBlockRangeUpdateBlock: 0
+            sourceRangeCapacity: 0,
+            prevSourceRangeCapacity: 0,
+            eventDensity: undefined,
+            latestSourceRangeCapacityUpdateBlock: 0
           });
           nextPartitionIndexRef = nextPartitionIndexRef + 1 | 0;
         };
@@ -790,10 +794,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: currentPBlock < nextPBlock ? nextPBlock : undefined,
             dynamicContract: currentP.dynamicContract,
             mutPendingQueries: currentP.mutPendingQueries,
-            prevQueryRange: currentP.prevQueryRange,
-            prevPrevQueryRange: currentP.prevPrevQueryRange,
-            prevRangeSize: currentP.prevRangeSize,
-            latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: currentP.sourceRangeCapacity,
+            prevSourceRangeCapacity: currentP.prevSourceRangeCapacity,
+            eventDensity: currentP.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: currentP.latestSourceRangeCapacityUpdateBlock
           });
           currentPRef = {
             id: nextP.id,
@@ -803,10 +807,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: nextP.mergeBlock,
             dynamicContract: nextP.dynamicContract,
             mutPendingQueries: nextP.mutPendingQueries,
-            prevQueryRange: nextP.prevQueryRange,
-            prevPrevQueryRange: nextP.prevPrevQueryRange,
-            prevRangeSize: nextP.prevRangeSize,
-            latestBlockRangeUpdateBlock: nextP.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: nextP.sourceRangeCapacity,
+            prevSourceRangeCapacity: nextP.prevSourceRangeCapacity,
+            eventDensity: nextP.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: nextP.latestSourceRangeCapacityUpdateBlock
           };
         } else {
           currentPRef = {
@@ -817,10 +821,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: currentP.mergeBlock,
             dynamicContract: currentP.dynamicContract,
             mutPendingQueries: currentP.mutPendingQueries,
-            prevQueryRange: currentP.prevQueryRange,
-            prevPrevQueryRange: currentP.prevPrevQueryRange,
-            prevRangeSize: currentP.prevRangeSize,
-            latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: currentP.sourceRangeCapacity,
+            prevSourceRangeCapacity: currentP.prevSourceRangeCapacity,
+            eventDensity: currentP.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: currentP.latestSourceRangeCapacityUpdateBlock
           };
         }
       }
@@ -967,10 +971,10 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
                 mergeBlock: p.mergeBlock,
                 dynamicContract: p.dynamicContract,
                 mutPendingQueries: p.mutPendingQueries,
-                prevQueryRange: p.prevQueryRange,
-                prevPrevQueryRange: p.prevPrevQueryRange,
-                prevRangeSize: p.prevRangeSize,
-                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
               };
               let addressesByContractName = {};
               addressesByContractName[contractName] = addresses;
@@ -982,10 +986,10 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
                 mergeBlock: undefined,
                 dynamicContract: contractName,
                 mutPendingQueries: p.mutPendingQueries,
-                prevQueryRange: p.prevQueryRange,
-                prevPrevQueryRange: p.prevPrevQueryRange,
-                prevRangeSize: p.prevRangeSize,
-                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
               });
             }
           } else {
@@ -997,10 +1001,10 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
               mergeBlock: p.mergeBlock,
               dynamicContract: contractName,
               mutPendingQueries: p.mutPendingQueries,
-              prevQueryRange: p.prevQueryRange,
-              prevPrevQueryRange: p.prevPrevQueryRange,
-              prevRangeSize: p.prevRangeSize,
-              latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+              sourceRangeCapacity: p.sourceRangeCapacity,
+              prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+              eventDensity: p.eventDensity,
+              latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
             };
           }
         }
@@ -1072,7 +1076,7 @@ function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock,
       exit = 1;
     }
     if (exit === 1) {
-      let trustedDensity = getTrustedDensity(partition);
+      let trustedDensity = partition.eventDensity;
       let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : chainTargetBlock;
       let pushSingleQuery = (density, isChunk) => {
         let itemsTarget = densityItemsTarget(density * chunkItemsMultiplier, rangeFromBlock, rangeEndBlock, chainTargetBlock);
@@ -1150,7 +1154,8 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
       shouldWaitForNewBlock = false;
     }
   }
-  let queriesByPartitionIndex = Stdlib_Array.fromInitializer(partitionsCount, param => []);
+  let partitionsCount$1 = chainTargetItems <= 0 || shouldWaitForNewBlock ? 0 : partitionsCount;
+  let queriesByPartitionIndex = Stdlib_Array.fromInitializer(partitionsCount$1, param => []);
   let computeQueryEndBlock = p => {
     let queryEndBlock = Utils.$$Math.minOptInt(endBlock, p.mergeBlock);
     if (blockLag !== 0) {
@@ -1164,7 +1169,7 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
   let partitionIndexById = {};
   let candidates = [];
   let fillStates = [];
-  for (let idx$1 = 0; idx$1 < partitionsCount; ++idx$1) {
+  for (let idx$1 = 0; idx$1 < partitionsCount$1; ++idx$1) {
     let partitionId$1 = optimizedPartitions.idsInAscOrder[idx$1];
     let p$1 = optimizedPartitions.entities[partitionId$1];
     partitionIndexById[partitionId$1] = idx$1;
@@ -1189,7 +1194,7 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
       let pq$1 = p$1.mutPendingQueries[pqIdx$1];
       if (pq$1.fromBlock > cursor) {
         let beforeLen = candidates.length;
-        pushGapFillQueries(candidates, partitionId$1, cursor, Utils.$$Math.minOptInt(pq$1.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (12 - pendingCount | 0) - chunksUsedThisCall | 0, p$1, chainTargetItems / partitionsCount, chunkItemsMultiplier, p$1.selection, p$1.addressesByContractName);
+        pushGapFillQueries(candidates, partitionId$1, cursor, Utils.$$Math.minOptInt(pq$1.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (12 - pendingCount | 0) - chunksUsedThisCall | 0, p$1, chainTargetItems / partitionsCount$1, chunkItemsMultiplier, p$1.selection, p$1.addressesByContractName);
         chunksUsedThisCall = chunksUsedThisCall + (candidates.length - beforeLen | 0) | 0;
       }
       let toBlock = pq$1.toBlock;
@@ -1248,7 +1253,7 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
     let eb = fs.queryEndBlock;
     let maxBlock = eb !== undefined ? eb : chainTargetBlock;
     let match = fs.maybeChunkRange;
-    let match$1 = getTrustedDensity(p);
+    let match$1 = p.eventDensity;
     if (match !== undefined && match$1 !== undefined && match$1 > 0) {
       let chunkSize = Js_math.ceil_int(match * 1.8);
       let maxChunksRemaining = (12 - fs.pendingCount | 0) - fs.chunksUsedThisCall | 0;
@@ -1416,10 +1421,10 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
       mergeBlock: undefined,
       dynamicContract: undefined,
       mutPendingQueries: [],
-      prevQueryRange: 0,
-      prevPrevQueryRange: 0,
-      prevRangeSize: 0,
-      latestBlockRangeUpdateBlock: 0
+      sourceRangeCapacity: 0,
+      prevSourceRangeCapacity: 0,
+      eventDensity: undefined,
+      latestSourceRangeCapacityUpdateBlock: 0
     });
   }
   let normalSelection = {
@@ -1554,10 +1559,10 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
             mergeBlock: mergeBlock$1,
             dynamicContract: p.dynamicContract,
             mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
-            prevQueryRange: p.prevQueryRange,
-            prevPrevQueryRange: p.prevPrevQueryRange,
-            prevRangeSize: p.prevRangeSize,
-            latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: p.sourceRangeCapacity,
+            prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+            eventDensity: p.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
           });
         }
       }
@@ -1575,10 +1580,10 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
         mergeBlock: p.mergeBlock,
         dynamicContract: p.dynamicContract,
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
-        prevQueryRange: p.prevQueryRange,
-        prevPrevQueryRange: p.prevPrevQueryRange,
-        prevRangeSize: p.prevRangeSize,
-        latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p.sourceRangeCapacity,
+        prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+        eventDensity: p.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
       });
     }
   }
@@ -1619,10 +1624,10 @@ function resetPendingQueries(fetchState) {
         mergeBlock: partition.mergeBlock,
         dynamicContract: partition.dynamicContract,
         mutPendingQueries: kept,
-        prevQueryRange: partition.prevQueryRange,
-        prevPrevQueryRange: partition.prevPrevQueryRange,
-        prevRangeSize: partition.prevRangeSize,
-        latestBlockRangeUpdateBlock: partition.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: partition.sourceRangeCapacity,
+        prevSourceRangeCapacity: partition.prevSourceRangeCapacity,
+        eventDensity: partition.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: partition.latestSourceRangeCapacityUpdateBlock
       };
     }
   }
@@ -1698,7 +1703,7 @@ function getProgressPercentage(fetchState) {
   if (firstEventBlock === undefined) {
     return 0;
   }
-  let totalRange = fetchState.knownHeight - firstEventBlock | 0;
+  let totalRange = (fetchState.knownHeight - fetchState.blockLag | 0) - firstEventBlock | 0;
   if (totalRange <= 0) {
     return 0;
   }

package/src/Rollback.res

@@ -72,7 +72,7 @@ let rec rollback = async (
     // found yet. Wait for the ReorgDetected branch above to find it and re-kick.
     | FindingReorgDepth => ()
     | FoundReorgDepth(_) if state->IndexerState.isProcessing =>
-      Logging.info("Waiting for batch to finish processing before executing rollback")
+      Logging.trace("Waiting for batch to finish processing before executing rollback")
     | FoundReorgDepth({chain: reorgChain, rollbackTargetBlockNumber}) =>
       await executeRollback(
         state,
@@ -96,10 +96,10 @@ and executeRollback = async (
 ) => {
   let startTime = Performance.now()
 
-  let chainState = state->IndexerState.getChainState(~chain=reorgChain)
-
-  let logger = Logging.createChildFrom(
-    ~logger=chainState->ChainState.logger,
+  // Not derived from the reorg chain's logger: that would bind its chainId onto
+  // every line, colliding with the per-chain chainId on the "Rollbacked" logs.
+  // The reorg chain is identified by the reorgChain param instead.
+  let logger = Logging.createChild(
     ~params={
       "action": "Rollback",
       "reorgChain": reorgChain,
@@ -161,10 +161,12 @@ and executeRollback = async (
     }
   }
 
+  let rolledBackChains = []
   state
   ->IndexerState.chainStates
   ->Utils.Dict.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
+    let fromBlock = cs->ChainState.committedProgressBlockNumber
     cs->ChainState.rollback(
       ~newProgressBlockNumber=newProgressBlockNumberPerChain->Utils.Dict.dangerouslyGetByIntNonOption(
         chainId,
@@ -175,6 +177,19 @@ and executeRollback = async (
       ~rollbackTargetBlockNumber,
       ~isReorgChain=chainId === reorgChainId,
     )
+    let toBlock = cs->ChainState.committedProgressBlockNumber
+    if fromBlock !== toBlock {
+      rolledBackChains
+      ->Array.push({
+        "chainId": chainId,
+        "fromBlock": fromBlock,
+        "toBlock": toBlock,
+        "rollbackedEvents": eventsProcessedDiffByChain
+        ->Utils.Dict.dangerouslyGetByIntNonOption(chainId)
+        ->Option.getOr(0.),
+      })
+      ->ignore
+    }
   })
 
   let diff = await state->InMemoryStore.prepareRollbackDiff(
@@ -183,15 +198,19 @@ and executeRollback = async (
     ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
   )
 
+  rolledBackChains->Array.forEach(chain => {
+    logger->Logging.childInfo({
+      "msg": "Rollbacked",
+      "chainId": chain["chainId"],
+      "fromBlock": chain["fromBlock"],
+      "toBlock": chain["toBlock"],
+      "rollbackedEvents": chain["rollbackedEvents"],
+    })
+  })
   logger->Logging.childTrace({
-    "msg": "Finished rollback on reorg",
-    "entityChanges": {
-      "deleted": diff["deletedEntities"],
-      "upserted": diff["setEntities"],
-    },
-    "rollbackedEvents": rollbackedProcessedEvents.contents,
-    "beforeCheckpointId": state->IndexerState.committedCheckpointId,
-    "targetCheckpointId": rollbackTargetCheckpointId,
+    "msg": "Rollback entity changes",
+    "deleted": diff["deletedEntities"],
+    "upserted": diff["setEntities"],
   })
   Prometheus.RollbackSuccess.increment(
     ~timeSeconds=Performance.secondsSince(startTime),

package/src/Rollback.res.mjs

@@ -33,8 +33,7 @@ async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime)
 
 async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
   let startTime = Performance.now();
-  let chainState = IndexerState.getChainState(state, reorgChain);
-  let logger = Logging.createChildFrom(ChainState.logger(chainState), {
+  let logger = Logging.createChild({
     action: "Rollback",
     reorgChain: reorgChain,
     targetBlockNumber: rollbackTargetBlockNumber
@@ -55,20 +54,34 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
     newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
   }
+  let rolledBackChains = [];
   Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
     let chainId = ChainState.chainConfig(cs).id;
+    let fromBlock = ChainState.committedProgressBlockNumber(cs);
     ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+    let toBlock = ChainState.committedProgressBlockNumber(cs);
+    if (fromBlock !== toBlock) {
+      rolledBackChains.push({
+        chainId: chainId,
+        fromBlock: fromBlock,
+        toBlock: toBlock,
+        rollbackedEvents: Stdlib_Option.getOr(eventsProcessedDiffByChain[chainId], 0)
+      });
+      return;
+    }
   });
   let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain);
+  rolledBackChains.forEach(chain => Logging.childInfo(logger, {
+    msg: "Rollbacked",
+    chainId: chain.chainId,
+    fromBlock: chain.fromBlock,
+    toBlock: chain.toBlock,
+    rollbackedEvents: chain.rollbackedEvents
+  }));
   Logging.childTrace(logger, {
-    msg: "Finished rollback on reorg",
-    entityChanges: {
-      deleted: diff$1.deletedEntities,
-      upserted: diff$1.setEntities
-    },
-    rollbackedEvents: rollbackedProcessedEvents,
-    beforeCheckpointId: IndexerState.committedCheckpointId(state),
-    targetCheckpointId: rollbackTargetCheckpointId
+    msg: "Rollback entity changes",
+    deleted: diff$1.deletedEntities,
+    upserted: diff$1.setEntities
   });
   Prometheus.RollbackSuccess.increment(Performance.secondsSince(startTime), rollbackedProcessedEvents);
   IndexerState.completeRollback(state, eventsProcessedDiffByChain);
@@ -97,7 +110,7 @@ async function rollback(state, scheduleFetch, scheduleProcessing, scheduleRollba
         return scheduleRollback();
       case "FoundReorgDepth" :
         if (IndexerState.isProcessing(state)) {
-          return Logging.info("Waiting for batch to finish processing before executing rollback");
+          return Logging.trace("Waiting for batch to finish processing before executing rollback");
         } else {
           return await executeRollback(state, match.chain, match.rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing);
         }

package/src/sources/SvmHyperSyncSource.res

@@ -488,6 +488,16 @@ let make = (
 
       switch maybeConfig {
       | None => ()
+      // Exclude instructions from failed transactions. HyperSync has no
+      // server-side predicate to filter instructions by parent-transaction
+      // success (`InstructionSelection` only exposes `is_inner`, and
+      // instruction/transaction selections union at block level rather than
+      // joining), so we filter client-side on the `isCommitted` flag HyperSync
+      // already delivers on every instruction row (a required column, zero extra
+      // bandwidth). When HyperSync adds a server-side `is_committed` predicate the
+      // query can push this down and the client-side check becomes a redundant
+      // safety net.
+      | Some(_) if !instr.isCommitted => ()
       | Some(onEventRegistration) =>
         let eventConfig =
           onEventRegistration.eventConfig->(

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -415,7 +415,7 @@ function make(param) {
       let byteLengths = Stdlib_Option.getOr(orderingByProgram[instr.programId], []);
       let contractAddress = instr.programId;
       let maybeConfig = probeRouter(eventRouter, programId, instr, byteLengths, contractAddress, contractNameByAddress);
-      if (maybeConfig !== undefined) {
+      if (maybeConfig !== undefined && instr.isCommitted) {
         let eventConfig = maybeConfig.eventConfig;
         let logKey = instr.slot.toString() + ":" + instr.transactionIndex.toString() + ":" + serializeInstructionAddress(instr.instructionAddress);
         let maybeLogs = Stdlib_Option.map(logsByKey[logKey], logs => logs.map(log => ({