@effectstream/runtime 0.100.22 → 0.100.24

package/src/finalized-stream.ts

@@ -0,0 +1,73 @@
+/**
+ * Bounded hand-off queue between the merge (producer) and the apply loop (consumer).
+ *
+ * The merge sends finalized blocks into an effection channel; the apply loop drains
+ * them. effection channel subscribers buffer unbounded, so during deep catch-up the
+ * merge (no I/O) outpaces the apply loop and the queue grows toward the whole backlog
+ * → OOM (sync/CLAUDE.md Finding #1) — especially with empty-block coalescing removing
+ * the per-block apply brake.
+ *
+ * This wraps the channel with backpressure: the producer blocks once `cap` produced
+ * blocks are still unconsumed, and the consumer wakes it as it drains. The cap only
+ * ever throttles the producer (the consumer always keeps pulling), so it can't
+ * deadlock. `inFlight = produced − consumed` is the live queue depth, surfaced on
+ * /debug/metrics.
+ */
+import { type Channel, createChannel, type Operation } from "effection";
+import { conditionVariable } from "@effectstream/utils";
+import type { ChainBlock } from "@effectstream/sync";
+import {
+  finalizedStreamStatus,
+  recordConsumed,
+  recordProduced,
+} from "./api/stream-status.ts";
+import type { FinalizedBlockSubscription } from "./coalesce.ts";
+
+export type BoundedFinalizedStream = {
+  /** Send side — hand to `startMerge`. `send` blocks the producer at the cap. */
+  stream: Channel<ChainBlock, void>;
+  /** Read side — hand to the coalescer / apply loop. Counts drains and wakes the producer. */
+  subscription: FinalizedBlockSubscription;
+};
+
+export function* createBoundedFinalizedStream(
+  cap: number,
+): Operation<BoundedFinalizedStream> {
+  const channel = createChannel<ChainBlock>();
+  // Subscribe BEFORE the caller spawns the merge: effection channels drop sends
+  // with no subscriber, so a fast restart could emit blocks before we subscribe
+  // and stall at the pre-restart height.
+  const subscription = yield* channel;
+
+  const drained = conditionVariable<void>();
+  const inFlight = () =>
+    finalizedStreamStatus.produced - finalizedStreamStatus.consumed;
+
+  // `startMerge` only uses `.send`; gate it. check-then-wait is atomic under
+  // effection's cooperative scheduling, so there's no lost wakeup.
+  const stream: Channel<ChainBlock, void> = {
+    ...channel,
+    *send(block: ChainBlock) {
+      while (inFlight() >= cap) {
+        yield* drained.wait();
+      }
+      recordProduced();
+      yield* channel.send(block);
+    },
+  };
+
+  // Count consumed at the pull point (exact channel depth, decoupled from the
+  // coalescer's run length) and wake the merge once the queue drops below cap.
+  const countedSubscription: FinalizedBlockSubscription = {
+    *next() {
+      const result = yield* subscription.next();
+      if (!result.done) {
+        recordConsumed(1);
+        if (inFlight() < cap) drained.wake();
+      }
+      return result;
+    },
+  };
+
+  return { stream, subscription: countedSubscription };
+}

package/src/main.ts

@@ -23,16 +23,21 @@ import {
 import { startMerge, startSync } from "@effectstream/sync";
 import { ComponentNames, log, SeverityNumber } from "@effectstream/log";
 import {
-  createChannel,
-  each,
   type Operation,
   sleep,
   spawn,
   until,
 } from "effection";
 import { initTelemetry } from "./telemetry.ts";
-import { type PendingEvent, processFinalizedBlock } from "./process-blocks.ts";
+import {
+  type PendingEvent,
+  processFinalizedBlockWithRetry,
+} from "./process-blocks.ts";
+import { createEmptyBlockCoalescer } from "./coalesce.ts";
 import { startHttpServer } from "./api/http-server.ts";
+import { recordAppliedBlock } from "./api/apply-status.ts";
+import { recordCoalesced } from "./api/stream-status.ts";
+import { createBoundedFinalizedStream } from "./finalized-stream.ts";
 import type { StartConfig } from "./types.ts";
 import type { Client } from "pg";
 import type { EffectstreamBlockHash } from "@effectstream/utils";
@@ -91,13 +96,20 @@ export function* start(config: StartConfig): Operation<void> {
     );
   });
 
+  // 10× main clock block time (NTP if present, else protocol 0). Undefined disables lag gating.
   const ntpConfig = syncInfo.find(s => s.networkType === ConfigNetworkType.NTP);
-  const ntpBlockTimeMS = (ntpConfig?.network as { blockTimeMS: number } | undefined)?.blockTimeMS;
-  const lagThresholdMs = ntpBlockTimeMS != null ? ntpBlockTimeMS * 10 : undefined;
+  const clockBlockTimeMS =
+    (ntpConfig?.network as { blockTimeMS?: number } | undefined)?.blockTimeMS ??
+    (syncInfo[0]?.network as { blockTimeMS?: number } | undefined)?.blockTimeMS;
+  const lagThresholdMs = clockBlockTimeMS != null ? clockBlockTimeMS * 10 : undefined;
 
-  const finalizedBlockStream = createChannel<ChainBlock>();
+  // Bounded hand-off queue between the merge and the apply loop. Backpressure caps
+  // the in-memory queue so deep catch-up can't grow it toward the whole backlog
+  // (see finalized-stream.ts / sync/CLAUDE.md Finding #1).
+  const { stream: finalizedStream, subscription: finalizedBlocks } =
+    yield* createBoundedFinalizedStream(ENV.EFFECTSTREAM_FINALIZED_STREAM_CAP);
 
-  yield* spawn(() => startMerge(syncProtocols, finalizedBlockStream));
+  yield* spawn(() => startMerge(syncProtocols, finalizedStream));
 
   const heartbeatIntervalMs = 60_000;
   yield* spawn(function* () {
@@ -139,55 +151,66 @@ export function* start(config: StartConfig): Operation<void> {
     yield* spawn(() => runSnapshotLoop(config.snapshotConfig!));
   }
 
-  for (const value of yield* each(finalizedBlockStream)) {
-    // We request a dbClient for a non-shared dbConn object.
-    // For PGLite, this is not enough, as the can only be one connection at a time.
-    // So we request a DBMutex as well.
-    let dbClient: Client | undefined;
-    // Custom app events emitted by STFs during this block. Collected by
-    // processFinalizedBlock and flushed below ONLY after it returns — i.e.
-    // strictly after the block's COMMIT. See plan invariant I1.
-    let blockAppEvents: PendingEvent[] = [];
-    try {
-      yield* acquireDBMutex(`processing-blocks:${value.blockNumber}`);
-      dbClient = yield* until((dbConn as any).connect()); // Client,
-
-      const result = yield* processFinalizedBlock(
-        value,
-        config,
-        dbClient as any, // Client,
-        blockHash,
+  const coalescer = createEmptyBlockCoalescer({
+    enabled: ENV.EFFECTSTREAM_COALESCE_EMPTY_BLOCKS,
+    subscription: finalizedBlocks,
+    pool: dbConn as any, // Pool,
+    migrations: config.migrations,
+    lagThresholdMs,
+    getPreviousBlockHash: () => blockHash,
+    onFlush: (endpoint, length) => {
+      // `consumed` is counted at the subscription pull point (above), not here, so
+      // it reflects the channel depth regardless of how many blocks a run folds.
+      recordCoalesced(length);
+      recordAppliedBlock(endpoint);
+      emitLatestBlocks(
+        endpoint.blockNumber,
+        endpoint.timestamp,
+        getRangesForSyncProtocols(endpoint),
+      );
+      log.local(
+        ComponentNames.EFFECTSTREAM_SYNC,
+        "block-merge",
+        SeverityNumber.INFO,
+        (l) =>
+          l(
+            `coalesced ${length} empty block(s) → block ${endpoint.blockNumber}`,
+          ),
       );
-      const resultHash = result.blockHash;
-      blockAppEvents = result.events;
-      if (resultHash !== "0x0") {
-        blockHash = resultHash;
-      }
-    } finally {
-      releaseDBMutex(`processing-blocks:${value.blockNumber}`);
-      if (dbClient) {
-        (dbClient as any).release(); // Client,
-      }
+    },
+  });
+
+  while (true) {
+    const value = yield* coalescer.advance();
+    if (value === undefined) break;
+
+    // Owns connection checkout, the per-block DB mutex (PGLite), and
+    // transient-pg retry/backoff. App events flush below only after it
+    // returns — strictly after the block's COMMIT.
+    const result = yield* processFinalizedBlockWithRetry(
+      value,
+      config,
+      dbConn as any, // Pool,
+      blockHash,
+    );
+    const blockAppEvents: PendingEvent[] = result.events;
+    if (result.blockHash !== "0x0") {
+      blockHash = result.blockHash;
     }
 
+    recordAppliedBlock(value); // apply-stage liveness for /debug/metrics
+
     // Used to emit & log the block range for each protocol.
     const contentBlocksForProtocol = getRangesForSyncProtocols(value);
 
-    // Fire-and-forget: do not stall the sync loop on broker acks.
+    // Fire-and-forget: don't stall the sync loop on broker acks. Ordering is
+    // safe without a wrapper queue — Opifex assigns packet IDs synchronously in
+    // publish() and net.Socket serializes writes in call order, so MQTT 3.1.1
+    // §4.6 in-order delivery holds per (publisher, topic, QoS).
     //
-    // Opifex's TcpClient assigns packet IDs synchronously in client.publish()
-    // and writes to the socket via Node's net.Socket, which has its own write
-    // queue — so concurrent publish() calls land on the wire in call order.
-    // MQTT 3.1.1 §4.6 then guarantees in-order delivery to each subscriber
-    // per (publisher, topic, QoS). We don't need a wrapper queue.
-    //
-    // TODO(scaling): the broker runs in-process (see `new EventBroker(...)`
-    // above). Fan-out to N subscribers consumes the same event loop as block
-    // processing. At ~thousands of subscribers, consider:
-    //   1) moving the broker to a worker / separate process,
-    //   2) a publisher-side circuit breaker if ctx.unresolvedPublish.size > N
-    //      (drop events with a counter for observability).
-    // Today: localhost, in-process, expected O(10²) subscribers — non-issue.
+    // TODO(scaling): the broker is in-process, so fan-out shares this event
+    // loop. At ~thousands of subscribers, move it to a worker and/or add a
+    // publisher-side circuit breaker. Today: localhost, O(10²) subs — non-issue.
     emitLatestBlocks(
       value.blockNumber,
       value.timestamp,
@@ -220,7 +243,7 @@ export function* start(config: StartConfig): Operation<void> {
           }...${lagSuffix} | ${JSON.stringify(contentBlocksForProtocol)}`,
         ),
     );
-    yield* each.next();
+    if (config.dev?.applyDelayMs) yield* sleep(config.dev.applyDelayMs);
   }
 }
 
@@ -239,13 +262,9 @@ function getRangesForSyncProtocols(value: ChainBlock): Record<string, [number, n
 }
 
 /**
- * Publish built-in block-level events.
- *
- * Fire-and-forget for the same reasons as the app-event flush above
- * (do not stall the sync loop; ordering preserved by Opifex + MQTT 3.1.1).
- *
- * Errors are caught locally so they don't escape to the global
- * `unhandledrejection` handler without context.
+ * Publish built-in block-level events. Fire-and-forget like the app-event flush
+ * above (don't stall the sync loop; ordering held by Opifex + MQTT 3.1.1).
+ * Errors are caught locally so they don't reach the global handler contextless.
  */
 function emitLatestBlocks(
   rollUpBlockHeight: number,
@@ -296,45 +315,48 @@ function* startup(
     });
   });
 
-  
   yield* acquireDBMutex(`startup-node`);
+  // `finally` releases the mutex on error/cancellation too; a throw in any step
+  // below would otherwise leak it and deadlock every later DB operation.
+  try {
+    // Dev-only reset of user-owned public tables
+    if (config.dev?.resetPublicData) {
+      yield* resetPublicTables(dbConn as any); // Client,
+    }
 
-  // Dev-only reset of user-owned public tables
-  if (config.dev?.resetPublicData) {
-    yield* resetPublicTables(dbConn as any); // Client,
-  }
-
-  // When the node is started, we apply system migrations.
-  // Either system initial migrations, or migrations given a Paima Engine Update.
-  yield* applySystemMigrations(
-    config.appVersion,
-    versionInfo,
-    lastBlockHeight,
-    dbConn,
-    config.migrations,
-  );
+    // When the node is started, we apply system migrations.
+    // Either system initial migrations, or migrations given a Paima Engine Update.
+    yield* applySystemMigrations(
+      config.appVersion,
+      versionInfo,
+      lastBlockHeight,
+      dbConn,
+      config.migrations,
+    );
 
-  // Validate that immutable config fields (e.g. NTP startTime, startBlockHeight)
-  // have not changed since the last run. Persists a snapshot on first start.
-  // Must run after system migrations so the snapshot table exists.
-  yield* validateAndSnapshotConfig(syncInfo, dbConn);
+    // Validate that immutable config fields (e.g. NTP startTime, startBlockHeight)
+    // have not changed since the last run. Persists a snapshot on first start.
+    // Must run after system migrations so the snapshot table exists.
+    yield* validateAndSnapshotConfig(syncInfo, dbConn);
 
-  const syncProtocols = yield* genSyncProtocols(dbConn as any, // Client,
-    syncInfo);
+    const syncProtocols = yield* genSyncProtocols(dbConn as any, // Client,
+      syncInfo);
 
-  const capabilities = yield* until(detectCapabilities(dbConn as any));
-  const viewStrategy = selectViewStrategy(capabilities);
+    const capabilities = yield* until(detectCapabilities(dbConn as any));
+    const viewStrategy = selectViewStrategy(capabilities);
 
-  yield* createDynamicTables(
-    versionInfo,
-    lastBlockHeight,
-    dbConn as any, // Client,
-    syncProtocols,
-    viewStrategy,
-  );
+    yield* createDynamicTables(
+      versionInfo,
+      lastBlockHeight,
+      dbConn as any, // Client,
+      syncProtocols,
+      viewStrategy,
+    );
 
-  releaseDBMutex(`startup-node`);
-  return syncProtocols;
+    return syncProtocols;
+  } finally {
+    releaseDBMutex(`startup-node`);
+  }
 }
 
 // Convert the primitive config to the final primitive instance

package/src/process-blocks.ts

@@ -1,6 +1,6 @@
 import type { ChainBlock } from "@effectstream/sync";
-import { call, type Operation, until } from "effection";
-import type { Pool } from "pg";
+import { call, type Operation, sleep, until } from "effection";
+import type { Pool, PoolClient } from "pg";
 import { type BaseStfInput, type EmitFn, primitiveTransitionFunction } from "@effectstream/sm";
 import { PreparedQuery } from "@pgtyped/runtime";
 import type {
@@ -9,19 +9,24 @@ import type {
   SyncStateUpdateStream,
 } from "@effectstream/coroutine";
 import {
+  acquireDBMutex,
   blockHeightDone,
   deleteEmptyBlocks,
   deleteScheduled,
   getFutureGameInputByBlockHeight,
   getFutureGameInputByMaxTimestamp,
   insertGameInputResult,
+  isTransientPgError,
+  poolErrors,
+  releaseDBMutex,
   removePages,
   saveLastBlock,
+  upsertPage,
 } from "@effectstream/db";
 import { Buffer } from "node:buffer";
 import { ComponentNames, log, SeverityNumber } from "@effectstream/log";
 import type { StartConfig } from "./types.ts";
-import type { BlockNumber, EffectstreamBlockHash } from "@effectstream/utils";
+import type { EffectstreamBlockHash } from "@effectstream/utils";
 import { generateEffectstreamBlockHash, Prando } from "@effectstream/crypto";
 import { applyUserMigrations } from "./version-migrations.ts";
 import type { EventPathAndDef } from "@effectstream/event-client";
@@ -308,36 +313,53 @@ export function* processFinalizedBlock(
       }, dbConn)
     );
 
-    /* STEP 7: Update page state for all sync protocols consumed
-    *          This is to mark what blocks where consumed by this specific
-    *          block, to avoid re-processing the same blocks more than once
-    *          if the sync protocol is restarted.
+    /* STEP 7: Persist the block-accurate resume marker per protocol, inside this
+    *          block's transaction (the runtime is the sole writer of the resume
+    *          position). Upsert at page_number = ownBlockNumber, then prune
+    *          everything below → one row per protocol = the committed watermark.
+    *          Full mechanism: @effectstream/sync CLAUDE.md, design idea #5.
     */
-
-    // Get latest block for each sync protocol.
-    const latestBlocks: Record<string, BlockNumber> = {};
-    for (const blockInfo of value.blockInfo) {
-      if (
-        !latestBlocks[blockInfo.protocol_name] ||
-        latestBlocks[blockInfo.protocol_name] < blockInfo.block_number
-      ) {
-        latestBlocks[blockInfo.protocol_name] = blockInfo.block_number;
-      }
-    }
-
-    for (const [protocolName, blockNumber] of Object.entries(latestBlocks)) {
+    for (const { protocol_name, lastPage } of value.resumePages) {
+      yield* until(
+        upsertPage.run({
+          protocol_name,
+          page_number: lastPage.ownBlockNumber,
+          page: JSON.stringify(lastPage),
+        }, dbConn),
+      );
       yield* until(
         removePages.run({
-          protocol_name: protocolName,
-          page_number: blockNumber,
+          protocol_name,
+          page_number: lastPage.ownBlockNumber,
         }, dbConn),
       );
     }
 
     /* STEP 8: Commit the transaction. */
     yield* until(dbConn.query("COMMIT"));
+    // A successful COMMIT proves the DB is reachable end-to-end — reset the
+    // pool failure clock so the write path also feeds the health tracker
+    // (it otherwise only sees floating pool errors and the read-side API).
+    poolErrors.markHealthy();
   } catch (err) {
-    yield* until(dbConn.query("ROLLBACK"));
+    // Best-effort rollback. If the socket is dead the ROLLBACK throws too;
+    // swallow that so it doesn't mask the original error — the caller's retry
+    // loop keys off the original (transient) error, not a rollback failure.
+    try {
+      yield* until(dbConn.query("ROLLBACK"));
+    } catch (rollbackErr) {
+      log.remote(
+        ComponentNames.EFFECTSTREAM_SYNC,
+        "block-processing",
+        SeverityNumber.WARN,
+        (log) =>
+          log(
+            `ROLLBACK failed for block ${value.blockNumber} (connection likely dead): ${
+              String(rollbackErr)
+            }`,
+          ),
+      );
+    }
     log.remote(
       ComponentNames.EFFECTSTREAM_SYNC,
       "block-processing",
@@ -345,12 +367,89 @@ export function* processFinalizedBlock(
       (log) =>
         log(`Error processing block ${value.blockNumber}: ${String(err)}`),
     );
-    // We cannot recover from this error.
+    // Re-throw: `processFinalizedBlockWithRetry` decides whether this is a
+    // retryable transient pg failure or a fatal bug.
     throw err;
   }
 
-  return { 
-    blockHash: hasOperations ? blockHash : "0x0" as PaimaBlockHash, 
-    events: blockEvents 
+  return {
+    blockHash: hasOperations ? blockHash : "0x0" as PaimaBlockHash,
+    events: blockEvents
   };
 }
+
+/** Caps the exponential backoff between block-retry attempts. */
+const MAX_RETRY_BACKOFF_MS = 5_000;
+
+/**
+ * Run {@link processFinalizedBlock} against a freshly checked-out pool client,
+ * retrying the whole block on transient pg failures (Neon cold-starts,
+ * idle-socket evictions, TLS blips).
+ *
+ * The previous socket is dead after such a failure, so each attempt
+ * re-acquires a client and reprocesses the block from `BEGIN` — safe because
+ * the failed tx never committed and the caller only advances the block stream
+ * after this returns.
+ *
+ * `poolErrors` governs escalation: it logs WARN→ERROR as the outage persists
+ * and calls `process.exit(1)` once it crosses the fatal threshold, letting the
+ * orchestrator restart us. A non-transient error (a real SQL/logic bug) is
+ * re-thrown and crashes, as before.
+ *
+ * Owns the per-block DB mutex (for PGLite) and client lifecycle so the caller
+ * doesn't have to.
+ */
+export function* processFinalizedBlockWithRetry(
+  value: ChainBlock,
+  config: StartConfig,
+  pool: Pool,
+  previousBlockHash: EffectstreamBlockHash | null,
+): Operation<ProcessFinalizedBlockResult> {
+  const lockName = `processing-blocks:${value.blockNumber}`;
+  let attempt = 0;
+  while (true) {
+    let dbClient: PoolClient | undefined;
+    let transientErr: unknown;
+    try {
+      yield* acquireDBMutex(lockName);
+      dbClient = yield* until(pool.connect());
+      return yield* processFinalizedBlock(
+        value,
+        config,
+        dbClient as unknown as Pool, // a checked-out client, used as the tx conn
+        previousBlockHash,
+      );
+    } catch (err) {
+      if (!isTransientPgError(err)) throw err;
+      transientErr = err;
+    } finally {
+      releaseDBMutex(lockName);
+      if (dbClient) {
+        // Passing the error destroys the client instead of recycling it, so
+        // the pool never hands the dead socket back out. On success
+        // `transientErr` is undefined and the client returns to the pool.
+        try {
+          dbClient.release(transientErr as Error | undefined);
+        } catch {
+          /* already released/destroyed */
+        }
+      }
+    }
+
+    attempt++;
+    poolErrors.log(transientErr, ["sync-write"]);
+    const backoffMs = Math.min(500 * 2 ** (attempt - 1), MAX_RETRY_BACKOFF_MS);
+    log.local(
+      ComponentNames.EFFECTSTREAM_SYNC,
+      "block-processing",
+      SeverityNumber.WARN,
+      (l) =>
+        l(
+          `transient db error on block ${value.blockNumber}; retry #${attempt} in ${backoffMs}ms: ${
+            String(transientErr)
+          }`,
+        ),
+    );
+    yield* sleep(backoffMs);
+  }
+}

package/src/types.ts

@@ -79,5 +79,12 @@ export type StartConfig = {
      * state such as `bufferedData.size()`. No effect in production.
      */
     onStarted?: (ctx: { syncProtocols: AllSyncProtocols[] }) => void;
+    /**
+     * Test/diagnostic only: sleep this many ms after each applied block, slowing
+     * the drain so the per-chain fetch buffers fill to their cap and the
+     * backpressure fix becomes observable (otherwise drain ≈ fetch and the buffer
+     * never grows). No effect in production (leave unset / 0).
+     */
+    applyDelayMs?: number;
   };
 };

package/test/coalesce.unit.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import {
+  type EmptyRunBoundaries,
+  isCoalescableEmptyBlock,
+} from "../src/coalesce.ts";
+
+const NO_BOUNDARIES: EmptyRunBoundaries = {
+  minScheduledBlockHeight: null,
+  minScheduledTimestampMs: null,
+};
+
+function block(
+  blockNumber: number,
+  timestamp: number,
+  primitives: unknown[] = [],
+): any {
+  return { blockNumber, timestamp, blockInfo: [], resumePages: [], primitives };
+}
+
+test("empty block with no boundaries is coalescable", () => {
+  expect(isCoalescableEmptyBlock(block(10, 10_000), NO_BOUNDARIES, undefined))
+    .toBe(true);
+});
+
+test("block with on-chain content is NOT coalescable", () => {
+  expect(
+    isCoalescableEmptyBlock(block(10, 10_000, [{}]), NO_BOUNDARIES, undefined),
+  ).toBe(false);
+});
+
+test("block where a migration fires is NOT coalescable", () => {
+  const migrations = [{ name: "m1", sql: "", blockHeight: 10 }];
+  expect(isCoalescableEmptyBlock(block(10, 10_000), NO_BOUNDARIES, migrations))
+    .toBe(false);
+  expect(isCoalescableEmptyBlock(block(9, 9_000), NO_BOUNDARIES, migrations))
+    .toBe(true);
+});
+
+test("block at/after a pending block-height-scheduled input is NOT coalescable", () => {
+  const boundaries: EmptyRunBoundaries = {
+    minScheduledBlockHeight: 10,
+    minScheduledTimestampMs: null,
+  };
+  expect(isCoalescableEmptyBlock(block(9, 9_000), boundaries, undefined)).toBe(
+    true,
+  );
+  expect(isCoalescableEmptyBlock(block(10, 10_000), boundaries, undefined)).toBe(
+    false,
+  );
+  expect(isCoalescableEmptyBlock(block(11, 11_000), boundaries, undefined)).toBe(
+    false,
+  );
+});
+
+test("block at/after a due timestamp-scheduled input is NOT coalescable", () => {
+  const boundaries: EmptyRunBoundaries = {
+    minScheduledBlockHeight: null,
+    minScheduledTimestampMs: 10_000,
+  };
+  expect(isCoalescableEmptyBlock(block(9, 9_999), boundaries, undefined)).toBe(
+    true,
+  );
+  expect(isCoalescableEmptyBlock(block(10, 10_000), boundaries, undefined)).toBe(
+    false,
+  );
+  expect(isCoalescableEmptyBlock(block(11, 10_001), boundaries, undefined)).toBe(
+    false,
+  );
+});