envio 3.3.0-alpha.8 → 3.3.0-alpha.9

package/package.json

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

package/src/ChainState.res

@@ -136,25 +136,6 @@ let makeInternal = (
     }
   })
 
-  // TODO: Move it to the HandlerRegister module
-  // so the error is thrown with better stack trace
-  onBlockRegistrations->Array.forEach(onBlockRegistration => {
-    if onBlockRegistration.startBlock->Option.getOr(startBlock) < startBlock {
-      JsError.throwWithMessage(
-        `The start block for onBlock handler "${onBlockRegistration.name}" is less than the chain start block (${startBlock->Int.toString}). This is not supported yet.`,
-      )
-    }
-    switch endBlock {
-    | Some(chainEndBlock) =>
-      if onBlockRegistration.endBlock->Option.getOr(chainEndBlock) > chainEndBlock {
-        JsError.throwWithMessage(
-          `The end block for onBlock handler "${onBlockRegistration.name}" is greater than the chain end block (${chainEndBlock->Int.toString}). This is not supported yet.`,
-        )
-      }
-    | None => ()
-    }
-  })
-
   let contractConfigs = IndexingAddresses.makeContractConfigs(~onEventRegistrations)
   let indexingAddressIndex = IndexingAddresses.make(~contractConfigs, ~addresses=indexingAddresses)
 
@@ -385,7 +366,8 @@ let isReadyToEnterReorgThreshold = (cs: t) => cs.fetchState->FetchState.isReadyT
 let startFetchingQueries = (cs: t, ~queries: array<FetchState.query>) => {
   cs.fetchState->FetchState.startFetchingQueries(~queries)
   cs.pendingBudget =
-    cs.pendingBudget +. queries->Array.reduce(0., (acc, query) => acc +. query.itemsTarget)
+    cs.pendingBudget +.
+    queries->Array.reduce(0., (acc, query) => acc +. query.itemsTarget->Int.toFloat)
 }
 
 // Drop every in-flight query and release their reservations together, keeping
@@ -395,24 +377,108 @@ let resetPendingQueries = (cs: t) => {
   cs.pendingBudget = 0.
 }
 
-// Turn this chain's share of the indexer-wide buffer budget into a soft
-// target block (via chain density, or knownHeight when density isn't known
-// yet), then propose queries sized against it. Called by CrossChainState's
-// waterfall, furthest-behind chain first, with chainTargetItems set to
-// whatever budget remains at that point in the waterfall.
-let getNextQuery = (cs: t, ~chainTargetItems: float) => {
+let isReady = (cs: t) => cs.timestampCaughtUpToHeadOrEndblock !== None
+
+// Block span over which a batch fully replaces the chain density estimate;
+// smaller batches blend in proportionally, so a few sparse/dense blocks only
+// nudge it.
+let densityBlendWindow = 100.
+
+// The last block this chain can fetch right now: the head, or endBlock when
+// it's below the head.
+let fetchCeiling = (cs: t) => {
+  let fetchState = cs.fetchState
+  switch fetchState.endBlock {
+  | Some(endBlock) => Pervasives.min(endBlock, fetchState.knownHeight)
+  | None => fetchState.knownHeight
+  }
+}
+
+// This chain's share of the indexer-wide buffer budget turned into a soft
+// target block: via chain density, or the fetch ceiling when density isn't
+// known yet.
+let targetBlock = (cs: t, ~chainTargetItems: float) => {
   let fetchState = cs.fetchState
-  let knownHeight = fetchState.knownHeight
+  let fetchCeiling = cs->fetchCeiling
   let bufferBlockNumber = fetchState->FetchState.bufferBlockNumber
-  let chainTargetBlock = switch cs.chainDensity {
+  switch cs.chainDensity {
   | Some(density) if density > 0. =>
     Pervasives.min(
-      knownHeight,
+      fetchCeiling,
       bufferBlockNumber + Math.ceil(chainTargetItems /. density)->Float.toInt,
     )
-  | _ => knownHeight
+  | _ => fetchCeiling
   }
-  fetchState->FetchState.getNextQuery(~chainTargetBlock, ~chainTargetItems)
+}
+
+// Block range that cross-chain progress alignment maps fractions over: from
+// the first block that can hold this chain's events to the last block it will
+// fetch.
+let progressRange = (cs: t) => {
+  let fetchState = cs.fetchState
+  let lower = fetchState.firstEventBlock->Option.getOr(fetchState.startBlock)
+  let upper = switch fetchState.endBlock {
+  | Some(endBlock) => endBlock
+  | None => fetchState.knownHeight
+  }
+  (lower, upper)
+}
+
+// A degenerate range (chain already at or past its last block) maps to 1 so it
+// never constrains the other chains. Clamped at 0 for the initial -1 fetch
+// frontier — the only possible blockNumber below the range's lower bound.
+let progressAtBlock = (cs: t, ~blockNumber) => {
+  let (lower, upper) = cs->progressRange
+  upper <= lower
+    ? 1.
+    : Pervasives.max(
+        0.,
+        Pervasives.min(1., (blockNumber - lower)->Int.toFloat /. (upper - lower)->Int.toFloat),
+      )
+}
+
+let blockAtProgress = (cs: t, ~progress) => {
+  let (lower, upper) = cs->progressRange
+  lower + Math.ceil(progress *. (upper - lower)->Int.toFloat)->Float.toInt
+}
+
+// Propose queries sized against this chain's target block. Called by
+// CrossChainState's waterfall, furthest-behind chain first, with
+// chainTargetItems set to whatever budget remains at that point and
+// maxTargetBlock set to the most-behind chain's progress mapped onto this
+// chain, so a chain with budget can't run further ahead than the chain the
+// whole pool is prioritizing.
+let getNextQuery = (cs: t, ~chainTargetItems: float, ~maxTargetBlock=?) => {
+  let chainTargetBlock = cs->targetBlock(~chainTargetItems)
+  let chainTargetBlock = switch maxTargetBlock {
+  | Some(maxTargetBlock) => Pervasives.min(chainTargetBlock, maxTargetBlock)
+  | None => chainTargetBlock
+  }
+  // When the target block is clamped (head/endBlock/cross-chain alignment) a
+  // known-density chain can't use the whole handed budget — cap the fresh part
+  // at what the clamped range actually costs (in-flight reservations stay on
+  // top: they're already accounted and shouldn't crowd out new partitions), so
+  // the waterfall's leftover flows to the next chain in the same tick instead
+  // of being held by an oversized probe.
+  let chainTargetItems = switch cs.chainDensity {
+  | Some(density) if density > 0. =>
+    let rangeCost =
+      density *. (chainTargetBlock - cs.fetchState->FetchState.bufferBlockNumber)->Int.toFloat
+    // 3x headroom only for a chain already caught up once and polling the
+    // head: there a single query covers the whole remaining range, and a
+    // slightly denser-than-expected range would otherwise truncate at the
+    // server cap and force an immediate catch-up query for the last blocks.
+    // During backfill the range never fits one query anyway, so headroom
+    // would just hold budget away from other chains.
+    let rangeCost =
+      chainTargetBlock >= cs->fetchCeiling && cs->isReady ? rangeCost *. 3. : rangeCost
+    Pervasives.min(chainTargetItems, Math.ceil(rangeCost) +. cs.pendingBudget)
+  | _ =>
+    // No density signal yet: bound the probe so one unknown chain doesn't
+    // hold the whole pool while it takes its first measurements.
+    Pervasives.min(chainTargetItems, 5_000. +. cs.pendingBudget)
+  }
+  cs.fetchState->FetchState.getNextQuery(~chainTargetBlock, ~chainTargetItems)
 }
 
 // Run a fetch tick for this chain against its sources, feeding the owned fetch
@@ -451,8 +517,6 @@ let getHighestBlockBelowThreshold = (cs: t): int => {
 
 let isActivelyIndexing = (cs: t) => cs.fetchState->FetchState.isActivelyIndexing
 
-let isReady = (cs: t) => cs.timestampCaughtUpToHeadOrEndblock !== None
-
 // True once the fetch frontier has reached the head/endBlock for this chain.
 let isFetchingAtHead = (cs: t) => cs.fetchState->FetchState.isFetchingAtHead
 
@@ -689,7 +753,7 @@ let handleQueryResult = (
     ->FetchState.updateKnownHeight(~knownHeight)
 
   // The query is no longer in flight, so release its reservation.
-  cs.pendingBudget = Pervasives.max(0., cs.pendingBudget -. query.itemsTarget)
+  cs.pendingBudget = Pervasives.max(0., cs.pendingBudget -. query.itemsTarget->Int.toFloat)
 }
 
 // Run reorg detection against a fetch response and commit the updated guard.
@@ -852,8 +916,9 @@ let applyBatchProgress = (cs: t, ~batch: Batch.t, ~blockTimestampName: string) =
       }
 
       // Chain-wide density update: seed with the batch's own events/block on
-      // the first update, then smooth incrementally so a run of a few
-      // sparse/dense blocks doesn't swing the target block estimate.
+      // the first update, then blend weighted by the batch's block span — a
+      // few sparse/dense blocks barely nudge the estimate, while a
+      // window-sized batch replaces it.
       let deltaBlocks = chainAfterBatch.progressBlockNumber - cs.committedProgressBlockNumber
       if deltaBlocks > 0 {
         let deltaEvents = chainAfterBatch.totalEventsProcessed -. cs.numEventsProcessed
@@ -866,7 +931,9 @@ let applyBatchProgress = (cs: t, ~batch: Batch.t, ~blockTimestampName: string) =
           cs.chainDensity = Some(
             switch cs.chainDensity {
             | None => batchDensity
-            | Some(oldDensity) => (oldDensity +. batchDensity) /. 2.
+            | Some(oldDensity) =>
+              let alpha = Pervasives.min(1., deltaBlocks->Int.toFloat /. densityBlendWindow)
+              oldDensity *. (1. -. alpha) +. batchDensity *. alpha
             },
           )
         }

package/src/ChainState.res.mjs

@@ -74,7 +74,6 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
     onEventRegistrations: [],
     onBlockRegistrations: []
   });
-  let onBlockRegistrations = match.onBlockRegistrations;
   let onEventRegistrations = match.onEventRegistrations;
   chainConfig.contracts.forEach(contract => {
     let startBlock = contract.startBlock;
@@ -82,17 +81,9 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       return Stdlib_JsError.throwWithMessage(`The start block for contract "` + contract.name + `" is less than the chain start block. This is not supported yet.`);
     }
   });
-  onBlockRegistrations.forEach(onBlockRegistration => {
-    if (Stdlib_Option.getOr(onBlockRegistration.startBlock, startBlock) < startBlock) {
-      Stdlib_JsError.throwWithMessage(`The start block for onBlock handler "` + onBlockRegistration.name + `" is less than the chain start block (` + startBlock.toString() + `). This is not supported yet.`);
-    }
-    if (endBlock !== undefined && Stdlib_Option.getOr(onBlockRegistration.endBlock, endBlock) > endBlock) {
-      return Stdlib_JsError.throwWithMessage(`The end block for onBlock handler "` + onBlockRegistration.name + `" is greater than the chain end block (` + endBlock.toString() + `). This is not supported yet.`);
-    }
-  });
   let contractConfigs = IndexingAddresses.makeContractConfigs(onEventRegistrations);
   let indexingAddressIndex = IndexingAddresses.make(contractConfigs, indexingAddresses);
-  let fetchState = FetchState.make(startBlock, endBlock, onEventRegistrations, contractConfigs, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, onBlockRegistrations, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock));
+  let fetchState = FetchState.make(startBlock, endBlock, onEventRegistrations, contractConfigs, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, match.onBlockRegistrations, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock));
   let chainReorgCheckpoints = Stdlib_Array.filterMap(reorgCheckpoints, reorgCheckpoint => {
     if (reorgCheckpoint.chain_id === chainConfig.id) {
       return reorgCheckpoint;
@@ -245,13 +236,77 @@ function startFetchingQueries(cs, queries) {
   cs.pendingBudget = cs.pendingBudget + Stdlib_Array.reduce(queries, 0, (acc, query) => acc + query.itemsTarget);
 }
 
-function getNextQuery(cs, chainTargetItems) {
+function isReady(cs) {
+  return cs.timestampCaughtUpToHeadOrEndblock !== undefined;
+}
+
+function fetchCeiling(cs) {
   let fetchState = cs.fetchState;
-  let knownHeight = fetchState.knownHeight;
+  let endBlock = fetchState.endBlock;
+  if (endBlock !== undefined) {
+    return Primitive_int.min(endBlock, fetchState.knownHeight);
+  } else {
+    return fetchState.knownHeight;
+  }
+}
+
+function targetBlock(cs, chainTargetItems) {
+  let fetchState = cs.fetchState;
+  let fetchCeiling$1 = fetchCeiling(cs);
   let bufferBlockNumber = FetchState.bufferBlockNumber(fetchState);
   let density = cs.chainDensity;
-  let chainTargetBlock = density !== undefined && density > 0 ? Primitive_int.min(knownHeight, bufferBlockNumber + (Math.ceil(chainTargetItems / density) | 0) | 0) : knownHeight;
-  return FetchState.getNextQuery(fetchState, chainTargetBlock, chainTargetItems);
+  if (density !== undefined && density > 0) {
+    return Primitive_int.min(fetchCeiling$1, bufferBlockNumber + (Math.ceil(chainTargetItems / density) | 0) | 0);
+  } else {
+    return fetchCeiling$1;
+  }
+}
+
+function progressRange(cs) {
+  let fetchState = cs.fetchState;
+  let lower = Stdlib_Option.getOr(fetchState.firstEventBlock, fetchState.startBlock);
+  let endBlock = fetchState.endBlock;
+  let upper = endBlock !== undefined ? endBlock : fetchState.knownHeight;
+  return [
+    lower,
+    upper
+  ];
+}
+
+function progressAtBlock(cs, blockNumber) {
+  let match = progressRange(cs);
+  let upper = match[1];
+  let lower = match[0];
+  if (upper <= lower) {
+    return 1;
+  } else {
+    return Primitive_float.max(0, Primitive_float.min(1, (blockNumber - lower | 0) / (upper - lower | 0)));
+  }
+}
+
+function blockAtProgress(cs, progress) {
+  let match = progressRange(cs);
+  let lower = match[0];
+  return lower + (Math.ceil(progress * (match[1] - lower | 0)) | 0) | 0;
+}
+
+function getNextQuery(cs, chainTargetItems, maxTargetBlock) {
+  let chainTargetBlock = targetBlock(cs, chainTargetItems);
+  let chainTargetBlock$1 = maxTargetBlock !== undefined ? Primitive_int.min(chainTargetBlock, maxTargetBlock) : chainTargetBlock;
+  let density = cs.chainDensity;
+  let chainTargetItems$1;
+  if (density !== undefined) {
+    if (density > 0) {
+      let rangeCost = density * (chainTargetBlock$1 - FetchState.bufferBlockNumber(cs.fetchState) | 0);
+      let rangeCost$1 = chainTargetBlock$1 >= fetchCeiling(cs) && cs.timestampCaughtUpToHeadOrEndblock !== undefined ? rangeCost * 3 : rangeCost;
+      chainTargetItems$1 = Primitive_float.min(chainTargetItems, Math.ceil(rangeCost$1) + cs.pendingBudget);
+    } else {
+      chainTargetItems$1 = Primitive_float.min(chainTargetItems, 5000 + cs.pendingBudget);
+    }
+  } else {
+    chainTargetItems$1 = Primitive_float.min(chainTargetItems, 5000 + cs.pendingBudget);
+  }
+  return FetchState.getNextQuery(cs.fetchState, chainTargetBlock$1, chainTargetItems$1);
 }
 
 function dispatch(cs, executeQuery, waitForNewBlock, onNewBlock, action, stateId) {
@@ -282,10 +337,6 @@ function isActivelyIndexing(cs) {
   return FetchState.isActivelyIndexing(cs.fetchState);
 }
 
-function isReady(cs) {
-  return cs.timestampCaughtUpToHeadOrEndblock !== undefined;
-}
-
 function isFetchingAtHead(cs) {
   return FetchState.isFetchingAtHead(cs.fetchState);
 }
@@ -603,7 +654,14 @@ function applyBatchProgress(cs, batch, blockTimestampName) {
     if (exit === 1) {
       let batchDensity = deltaEvents / deltaBlocks;
       let oldDensity = cs.chainDensity;
-      cs.chainDensity = oldDensity !== undefined ? (oldDensity + batchDensity) / 2 : batchDensity;
+      let tmp;
+      if (oldDensity !== undefined) {
+        let alpha = Primitive_float.min(1, deltaBlocks / 100);
+        tmp = oldDensity * (1 - alpha) + batchDensity * alpha;
+      } else {
+        tmp = batchDensity;
+      }
+      cs.chainDensity = tmp;
     }
   }
   cs.committedProgressBlockNumber = chainAfterBatch.progressBlockNumber;
@@ -684,6 +742,9 @@ export {
   chainDensity,
   hasReadyItem,
   isReadyToEnterReorgThreshold,
+  targetBlock,
+  progressAtBlock,
+  blockAtProgress,
   getNextQuery,
   dispatch,
   toChainData,

package/src/ChainState.resi

@@ -64,7 +64,10 @@ let hasReadyItem: t => bool
 let isReadyToEnterReorgThreshold: t => bool
 
 // Fetch control.
-let getNextQuery: (t, ~chainTargetItems: float) => FetchState.nextQuery
+let targetBlock: (t, ~chainTargetItems: float) => int
+let progressAtBlock: (t, ~blockNumber: int) => float
+let blockAtProgress: (t, ~progress: float) => int
+let getNextQuery: (t, ~chainTargetItems: float, ~maxTargetBlock: int=?) => FetchState.nextQuery
 let dispatch: (
   t,
   ~executeQuery: FetchState.query => promise<unit>,

package/src/CrossChainState.res

@@ -198,8 +198,12 @@ 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 — unlike a per-query pool, this can starve a near-head chain
-// while an earlier one is deep in backfill, which is the intended tradeoff.
+// 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.
 let checkAndFetch = async (
   crossChainState: t,
   ~dispatchChain: (~chain: ChainMap.Chain.t, ~action: FetchState.nextQuery) => promise<unit>,
@@ -214,40 +218,63 @@ let checkAndFetch = async (
   )
 
   let actionByChain = Dict.make()
+  let maxProgress = ref(None)
   crossChainState
   ->priorityOrder
   ->Array.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
-    let chainTargetItems = remaining.contents +. cs->ChainState.pendingBudget
-    switch cs->ChainState.getNextQuery(~chainTargetItems) {
-    | (WaitingForNewBlock | NothingToQuery) as action =>
-      actionByChain->Utils.Dict.setByInt(chainId, action)
-    | Ready(queries) => {
-        let consumed =
-          queries->Array.reduce(0., (acc, query: FetchState.query) => acc +. query.itemsTarget)
+    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)
+    } else {
+      let chainTargetItems = remaining.contents +. cs->ChainState.pendingBudget
+      let maxTargetBlock = switch maxProgress.contents {
+      | None =>
+        // The most-behind chain sets the alignment line for everyone after it.
+        maxProgress :=
+          Some(
+            cs->ChainState.progressAtBlock(
+              ~blockNumber=cs->ChainState.targetBlock(~chainTargetItems),
+            ),
+          )
+        None
+      | Some(progress) => Some(cs->ChainState.blockAtProgress(~progress))
+      }
+      switch cs->ChainState.getNextQuery(~chainTargetItems, ~maxTargetBlock?) {
+      | (WaitingForNewBlock | NothingToQuery) as action =>
+        actionByChain->Utils.Dict.setByInt(chainId, action)
+      | Ready(queries) => {
+          let consumed =
+            queries->Array.reduce(0., (acc, query: FetchState.query) =>
+              acc +. query.itemsTarget->Int.toFloat
+            )
 
-        let partitions = Dict.make()
-        queries->Array.forEach((query: FetchState.query) =>
-          partitions->Dict.set(
-            query.partitionId,
-            {
-              "fromBlock": query.fromBlock,
-              "targetBlock": query.toBlock,
-              "targetEvents": query.itemsTarget->Math.round->Float.toInt,
-            },
+          let partitions = Dict.make()
+          queries->Array.forEach((query: FetchState.query) =>
+            partitions->Dict.set(
+              query.partitionId,
+              {
+                "fromBlock": query.fromBlock,
+                "targetBlock": query.toBlock,
+                "targetEvents": query.itemsTarget,
+              },
+            )
           )
-        )
-        Logging.trace({
-          "msg": "Started querying",
-          "chainId": chainId,
-          "partitions": partitions,
-        })
+          Logging.trace({
+            "msg": "Started querying",
+            "chainId": chainId,
+            "partitions": partitions,
+          })
 
-        actionByChain->Utils.Dict.setByInt(chainId, FetchState.Ready(queries))
-        // Mark the queries in flight and reserve their size against the shared
-        // budget; released as each response lands in handleQueryResult.
-        cs->ChainState.startFetchingQueries(~queries)
-        remaining := Pervasives.max(0., remaining.contents -. consumed)
+          actionByChain->Utils.Dict.setByInt(chainId, FetchState.Ready(queries))
+          // Mark the queries in flight and reserve their size against the
+          // shared budget; released as each response lands in
+          // handleQueryResult.
+          cs->ChainState.startFetchingQueries(~queries)
+          remaining := Pervasives.max(0., remaining.contents -. consumed)
+        }
       }
     }
   })

package/src/CrossChainState.res.mjs

@@ -138,10 +138,19 @@ async function checkAndFetch(crossChainState, dispatchChain) {
     contents: Primitive_float.max(0, crossChainState.targetBufferSize - totalReadyCount(crossChainState) - totalReservedSize(crossChainState))
   };
   let actionByChain = {};
+  let maxProgress = {
+    contents: undefined
+  };
   priorityOrder(crossChainState).forEach(cs => {
     let chainId = ChainState.chainConfig(cs).id;
+    if (ChainState.knownHeight(cs) === 0) {
+      actionByChain[chainId] = "WaitingForNewBlock";
+      return;
+    }
     let chainTargetItems = remaining.contents + ChainState.pendingBudget(cs);
-    let action = ChainState.getNextQuery(cs, chainTargetItems);
+    let progress = maxProgress.contents;
+    let maxTargetBlock = progress !== undefined ? ChainState.blockAtProgress(cs, progress) : (maxProgress.contents = ChainState.progressAtBlock(cs, ChainState.targetBlock(cs, chainTargetItems)), undefined);
+    let action = ChainState.getNextQuery(cs, chainTargetItems, maxTargetBlock);
     if (typeof action !== "object") {
       if (action === "WaitingForNewBlock") {
         actionByChain[chainId] = action;
@@ -157,7 +166,7 @@ async function checkAndFetch(crossChainState, dispatchChain) {
         partitions[query.partitionId] = {
           fromBlock: query.fromBlock,
           targetBlock: query.toBlock,
-          targetEvents: Math.round(query.itemsTarget) | 0
+          targetEvents: query.itemsTarget
         };
       });
       Logging.trace({

package/src/EnvioGlobal.res

@@ -0,0 +1,53 @@
+// The single process-wide mutable state record, stashed on `globalThis` so a
+// duplicate envio module instance — e.g. when the CLI's `bin.mjs` resolves
+// envio from one path but the user's handlers resolve it from
+// `node_modules/envio` — shares one state. Without this, each copy keeps its
+// own module-level state: registration would read an empty registry and the
+// `indexer.chains` getters would silently fall back to static config values.
+//
+// Slots are opaque (`unknown`) so this module stays at the bottom of the
+// dependency graph; each owning module casts its slot to the real type once
+// (`HandlerRegister` for the registration slots, `Main` for the runtime
+// slots, `RollbackCommit` for its callbacks).
+//
+// Version-gated: the slot shapes can evolve between envio versions, so the
+// guard uses strict full-version equality. On mismatch we throw with a
+// deduplication hint instead of silently mixing shapes across builds.
+type t = {
+  version: string,
+  eventRegistrations: dict<unknown>,
+  mutable activeRegistration: option<unknown>,
+  preRegistered: array<unknown>,
+  rollbackCommitCallbacks: array<unknown>,
+  mutable indexerState: option<unknown>,
+  mutable persistence: option<unknown>,
+}
+
+// Record type with `mutable` so assignment typechecks; ReScript keeps the
+// field name verbatim in the generated JS so the globalThis slot is
+// `__envioGlobal`.
+type globalThis = {mutable __envioGlobal: Nullable.t<t>}
+@val external globalThis: globalThis = "globalThis"
+
+let value: t = {
+  let version = Utils.EnvioPackage.value.version
+  switch globalThis.__envioGlobal->Nullable.toOption {
+  | Some(existing) if existing.version === version => existing
+  | Some(existing) =>
+    JsError.throwWithMessage(
+      `Multiple incompatible envio versions loaded in the same process: ${existing.version} and ${version}. Deduplicate the 'envio' dependency in your project.`,
+    )
+  | None =>
+    let fresh = {
+      version,
+      eventRegistrations: Dict.make(),
+      activeRegistration: None,
+      preRegistered: [],
+      rollbackCommitCallbacks: [],
+      indexerState: None,
+      persistence: None,
+    }
+    globalThis.__envioGlobal = Nullable.make(fresh)
+    fresh
+  }
+}

package/src/EnvioGlobal.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+let version = Utils.EnvioPackage.value.version;
+
+let existing = globalThis.__envioGlobal;
+
+let value;
+
+if (existing == null) {
+  let fresh = {
+    version: version,
+    eventRegistrations: {},
+    activeRegistration: undefined,
+    preRegistered: [],
+    rollbackCommitCallbacks: [],
+    indexerState: undefined,
+    persistence: undefined
+  };
+  globalThis.__envioGlobal = fresh;
+  value = fresh;
+} else {
+  value = existing.version === version ? existing : Stdlib_JsError.throwWithMessage(`Multiple incompatible envio versions loaded in the same process: ` + existing.version + ` and ` + version + `. Deduplicate the 'envio' dependency in your project.`);
+}
+
+export {
+  value,
+}
+/* existing Not a pure module */