@effectstream/runtime 0.100.19 → 0.100.22

package/test/reproduction/sanity.test.ts

@@ -2,26 +2,90 @@
  * Sanity end-to-end test for the synthetic `test` chain (no fixes required).
  *
  * Proves the foundation this PR adds works: a TEST_MAIN clock + a TEST_PARALLEL
- * chain sync through the real runtime (`start()`), a config-declared event is
- * processed into `effectstream.primitive_accounting`, and committed state
- * survives a restart.
- *
- * Runs on whichever backend `setupHarness` picks: the default in-memory PGLite
- * (no external dependency) or real Postgres when `PGLITE=false`. Either way
- * each node runs in its own subprocess (see harness.ts / node-runner.ts), so a
- * restart is a genuine new OS process booting against the same database.
+ * chain sync through the real runtime (`start()` + PGLite), a config-declared
+ * event is processed into `effectstream.primitive_accounting`, and committed
+ * state survives a restart.
  *
  * (The buffering / resume / fast-catchup reproduction tests land alongside their
  * fixes in follow-up PRs — they assert behaviour that only those fixes provide.)
  */
 import { afterAll, beforeAll, expect, test } from "bun:test";
+import {
+  ConfigBuilder,
+  ConfigNetworkType,
+  ConfigSyncProtocolType,
+} from "@effectstream/config";
+import { TestChainControl } from "@effectstream/sync";
 import {
   countEventRows,
   type Harness,
   latestFinalizedHeight,
   setupHarness,
+  TEST_PRIMITIVE_TYPE,
+  waitForHeight,
+  waitUntilStable,
 } from "./harness.ts";
 
+const START_TIME = 1_700_000_000_000;
+const BLOCK_TIME_MS = 1000;
+
+function buildConfig() {
+  return new ConfigBuilder()
+    .setNamespace((b) => b.setSecurityNamespace("sync-sanity"))
+    .buildNetworks((b) =>
+      b
+        .addNetwork({
+          name: "clock",
+          type: ConfigNetworkType.TEST,
+          startTime: START_TIME,
+          blockTimeMS: BLOCK_TIME_MS,
+        })
+        .addNetwork({
+          name: "chainP",
+          type: ConfigNetworkType.TEST,
+          startTime: START_TIME,
+          blockTimeMS: BLOCK_TIME_MS,
+        })
+    )
+    .buildDeployments((b) => b)
+    .buildSyncProtocols((b) =>
+      b
+        .addMain(
+          (n) => n.clock,
+          () => ({
+            name: "mainClock",
+            type: ConfigSyncProtocolType.TEST_MAIN,
+            startBlockHeight: 1,
+            pollingInterval: 30,
+            stepSize: 1000,
+          }),
+        )
+        .addParallel(
+          (n) => (n as any).chainP,
+          () => ({
+            name: "parallelP",
+            type: ConfigSyncProtocolType.TEST_PARALLEL,
+            startBlockHeight: 1,
+            pollingInterval: 30,
+            stepSize: 1000,
+            delayMs: 0,
+            events: [{ atBlock: 50, payload: { marker: "evt50" } }],
+          }),
+        )
+    )
+    .buildPrimitives((b) =>
+      b.addPrimitive(
+        (sp) => (sp as any).parallelP,
+        () => ({
+          name: "testEvt",
+          type: TEST_PRIMITIVE_TYPE,
+          startBlockHeight: 1,
+        }),
+      )
+    )
+    .build();
+}
+
 let h: Harness;
 
 beforeAll(async () => {
@@ -33,42 +97,29 @@ afterAll(async () => {
 });
 
 test("test chain syncs, processes a configured event, and survives restart", async () => {
-  const events = [{ atBlock: 50, marker: "evt50" }];
-
   // Parallel tip (200) stays ahead of the main clock (100) so the merge is not
   // gated at the chunk boundary.
-  await h.runToHeight({
-    events,
-    tips: { mainClock: 100, parallelP: 200 },
-    target: 100,
-    apiPort: 19131,
-  });
+  TestChainControl.setTip("mainClock", 100);
+  TestChainControl.setTip("parallelP", 200);
+
+  const n1 = await h.runNode({ config: buildConfig(), apiPort: 19131 });
+  await waitForHeight(n1, h.pool, 100);
+  await waitUntilStable(n1, h.pool);
 
-  const height1 = await latestFinalizedHeight(h.pool);
-  const events1 = await countEventRows(h.pool, "evt50");
-  console.log(
-    `[sanity] after sync:    height ${height1} (expect 100), ` +
-      `evt50 rows ${events1} (expect 1)`,
-  );
-  expect(height1).toBe(100);
+  expect(await latestFinalizedHeight(h.pool)).toBe(100);
   // The event declared at block 50 was processed into primitive_accounting.
-  expect(events1).toBe(1);
+  expect(await countEventRows(h.pool, "evt50")).toBe(1);
+  await n1.stop();
+
+  // Restart: committed state must persist (chain already fully caught up).
+  await h.simulateRestart();
+  TestChainControl.setTip("mainClock", 100);
+  TestChainControl.setTip("parallelP", 200);
 
-  // Restart: a new process boots against the same database. Committed state must
-  // persist; the chain is already fully caught up, so nothing new is produced.
-  await h.runToHeight({
-    events,
-    tips: { mainClock: 100, parallelP: 200 },
-    target: 100,
-    apiPort: 19132,
-  });
+  const n2 = await h.runNode({ config: buildConfig(), apiPort: 19132 });
+  await waitUntilStable(n2, h.pool);
 
-  const height2 = await latestFinalizedHeight(h.pool);
-  const events2 = await countEventRows(h.pool, "evt50");
-  console.log(
-    `[sanity] after restart: height ${height2} (expect 100, was ${height1}), ` +
-      `evt50 rows ${events2} (expect 1, was ${events1})`,
-  );
-  expect(height2).toBe(100);
-  expect(events2).toBe(1);
+  expect(await latestFinalizedHeight(h.pool)).toBe(100);
+  expect(await countEventRows(h.pool, "evt50")).toBe(1);
+  await n2.stop();
 }, 60_000);

package/conciseinputhash-determinism.md

@@ -1,114 +0,0 @@
-# Bug Report: non-deterministic `effectstream_tx_hash` (`conciseInputHash`)
-
-**Package:** `@effectstream/node-sdk` — runtime
-**Location:** `runtime/src/process-blocks.ts` (scheduled-input loop, STEP 5)
-**Severity:** Medium — silent cross-node state divergence in a derived column; not (currently) consensus-relevant
-**Status:** Open
-
----
-
-## Summary
-
-When the runtime records the result of a **scheduled** STF input, it fabricates the
-`effectstream_tx_hash` with `Math.random()`. The value is therefore different on every run
-and on every node, so two nodes that replay the exact same source blocks produce **different
-`rollup_input_result.effectstream_tx_hash` values** for the same input. For a framework whose
-core promise is "the database is a pure function of the source blocks," this is a determinism
-hole.
-
-## The code
-
-`runtime/src/process-blocks.ts`, inside the loop over `scheduledData` (STEP 5):
-
-```ts
-const conciseInputHash = `0x${
-  Array(64).fill(0).map(() => Math.floor(Math.random() * 16).toString(16)).join("")
-}`;
-yield* until(
-  insertGameInputResult.run({
-    id: data.id,
-    success,
-    effectstream_tx_hash: Buffer.from(conciseInputHash),
-    index_in_block,
-    block_height: value.blockNumber,
-  }, dbConn),
-);
-```
-
-This runs only for **scheduled** inputs (engine-queued timers / derived inputs that have no
-real on-chain transaction), so the engine has to synthesize a hash. It does so randomly.
-
-## Why it matters / why it's currently masked
-
-- **Block hash is unaffected.** `generateEffectstreamBlockHash` (`@effectstream/crypto`) hashes
-  `blockInfo[].blockHash` (source-chain hashes) + the previous block hash — never
-  `effectstream_tx_hash`. So the block-hash chain stays deterministic; the divergence is
-  confined to the `rollup_input_result.effectstream_tx_hash` column and anything that reads it.
-- **Masked in tests.** The reproduction tests use a no-op STF (`stateMachinePayload: null`),
-  which schedules no STF inputs, so this branch never executes. That is exactly why
-  `consistency-snapshot.ts` lists `effectstream_tx_hash` in `VOLATILE_COLUMNS` and excludes it
-  — the snapshot would otherwise diff on every run once real STFs are involved.
-
-## Two existing quirks to fix alongside
-
-1. **Encoding bug.** `Buffer.from(conciseInputHash)` is given the *string* `"0x" + 64 hex`
-   with no encoding, so it stores 66 **UTF-8** bytes, not the 32 decoded bytes. Whatever
-   derivation replaces `Math.random()`, encode it deliberately (`Buffer.from(hex, "hex")`, or
-   commit to the `0x`-string form consistently).
-
-2. **Ordering prerequisite (the real root).** The hash inputs that give uniqueness
-   (`index_in_block`, and the STF execution order itself) are only deterministic if the
-   `scheduledData` order is deterministic. Today it is not fully:
-   ```ts
-   // TODO What should be the order of the scheduled data - per id?
-   const scheduledData = [...scheduledData1, ...scheduledData2];
-   ```
-   - `scheduledData1` (block-scheduled) is `ORDER BY id ASC` → deterministic given a
-     deterministic scheduling history.
-   - `scheduledData2` (timestamp-scheduled) is `ORDER BY future_ms_timestamp ASC` **only** —
-     **same-timestamp rows have no tiebreak**, so their order is arbitrary.
-
-   This is bigger than the hash: the same order drives **STF execution** and the
-   **`randomGenerator` (Prando) draw sequence**. If it isn't pinned, game state itself can
-   diverge; the random tx-hash is just the most visible symptom.
-
-## Suggested fixes (in order)
-
-### 1. Pin the scheduled-input order (prerequisite, do first)
-Give the queries a total deterministic sort and a deterministic merge:
-- timestamp list → `ORDER BY future_ms_timestamp ASC, id ASC` (break ties by `id`);
-- keep block-scheduled before timestamp-scheduled (or merge both by a single deterministic
-  key). This is required for deterministic STFs regardless of the hash, and it makes
-  `index_in_block` deterministic.
-
-### 2. Derive the hash deterministically (recommended)
-Replace `Math.random()` with a content-addressed hash over the input's identity + position,
-reusing the `sha512` already used for the block hash:
-
-```
-effectstream_tx_hash =
-  sha512(block_height ‖ index_in_block ‖ input_data ‖ from_address ‖ from_address_type)
-```
-
-- `block_height` + `index_in_block` give **uniqueness** (one result per position; needs fix #1).
-- `input_data` + `from_address` + `from_address_type` make it **content-addressed**
-  (tx-hash-like, collision-resistant). All are non-null columns already on the scheduled row.
-
-### Alternatives considered
-- **Reuse the seeded `Prando` (`new Prando(blockHash)`):** smallest change and deterministic,
-  but the shared `randomGenerator` is also consumed by the STFs — drawing hash bytes from it
-  would shift the RNG stream every later STF sees. Would require a *separate*
-  `new Prando(blockHash + ":txhash")`. Produces opaque (non-content) hashes.
-- **`H(data.id, block_height)`:** `id` is a global SERIAL counter — a weaker determinism
-  guarantee than the block-scoped `index_in_block`, and `block_height` adds nothing once `id`
-  is unique. Prefer `index_in_block`.
-- **Provenance: `H(origin_tx_hash, …)`:** ties to the originating real tx, but
-  `origin_tx_hash` is `null` for timestamp-scheduled inputs, so it needs a fallback.
-
-## Verification
-- Add a determinism test with a **real** STF (one that schedules a derived input) and assert
-  two from-scratch syncs produce identical `rollup_input_result.effectstream_tx_hash` —
-  i.e. drop `effectstream_tx_hash` from `VOLATILE_COLUMNS` once fixed and confirm
-  `consistency.test.ts` Test A still passes.
-- Cover the timestamp-tie case explicitly: schedule ≥2 inputs at the same `future_ms_timestamp`
-  and assert identical ordering / hashes across runs.

package/src/api/apply-status.ts

@@ -1,30 +0,0 @@
-/**
- * Apply-stage liveness for /debug/metrics.
- *
- * The serial finalized-block loop in main.ts calls recordAppliedBlock() right
- * after each block COMMITs; the /debug/metrics handler reads `appliedBlockStatus`
- * to report true lag (now − applied block timestamp). Unlike a protocol's `buf`
- * (fetch backlog), this stays high when the node is write/apply-bound.
- *
- * Process-global: one node runs per process, so a module-level singleton keeps
- * main.ts to a single call instead of threading a ref through startHttpServer.
- */
-export type AppliedBlockStatus = {
-  blockNumber: number | null;
-  timestamp: number | null;
-  appliedAtMs: number | null;
-};
-
-export const appliedBlockStatus: AppliedBlockStatus = {
-  blockNumber: null,
-  timestamp: null,
-  appliedAtMs: null,
-};
-
-export function recordAppliedBlock(
-  block: { blockNumber: number | bigint; timestamp: number | bigint },
-): void {
-  appliedBlockStatus.blockNumber = Number(block.blockNumber);
-  appliedBlockStatus.timestamp = Number(block.timestamp);
-  appliedBlockStatus.appliedAtMs = Date.now();
-}

package/test/reproduction/buffering.test.ts

@@ -1,389 +0,0 @@
-/**
- * Verifies the fetch-backpressure feature (Option B′) over the synthetic `test`
- * chain through the real runtime (`start()` + in-process PGLite).
- *
- *  1a — unbounded buffering: with a cap, the fetch loop pauses when the buffer is
- *       full, so it stays bounded (~cap + stepSize) instead of racing to the whole
- *       backlog — while the node keeps applying blocks (liveness).
- *  1b — head-of-line blocking: a stalled slow chain STILL halts block production
- *       (the merge gate is correct), but the fast chain's buffer is now bounded by
- *       the cap instead of ballooning behind the head-of-line block.
- *
- * Before the fix these buffers reached ~49k–50k (see
- * e2e/perf/results/BACKPRESSURE-BASELINE.md); these tests assert they now
- * stay at the cap. Each test also writes a JSON time-series artifact to
- * e2e/perf/results/ whose field names match e2e/perf/metrics.ts `Sample`, so the
- * perf HTML report's Backpressure section can render the same signals.
- */
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import {
-  ConfigBuilder,
-  ConfigNetworkType,
-  ConfigSyncProtocolType,
-} from "@effectstream/config";
-import { TestChainControl } from "@effectstream/sync";
-import fs from "node:fs";
-import path from "node:path";
-import {
-  bufferSize,
-  type Harness,
-  latestFinalizedHeight,
-  type RunningNode,
-  setupHarness,
-  sleep,
-  TEST_PRIMITIVE_TYPE,
-} from "./harness.ts";
-
-const START_TIME = 1_700_000_000_000;
-const BLOCK_TIME_MS = 1000;
-const STEP_SIZE = 1000;
-// A deep backlog the arithmetic fetcher would race through if uncapped (baseline
-// hit ~49k–50k). The slow chain (1b) is pinned low so the merge stalls at its tip.
-const BIG_TIP = 50_000;
-const SLOW_TIP = 50;
-// Explicit small cap so the bound is deterministic and far below the backlog.
-// The fetch pauses at >= CAP; one in-flight chunk can overshoot by ~stepSize, so
-// the buffer settles in [~CAP, CAP + stepSize]. We assert it lands in that band.
-const CAP = 3000;
-const CAP_FLOOR = CAP - STEP_SIZE; // proves backpressure actually engaged
-const BUFFER_BOUND = CAP + STEP_SIZE + 200; // upper bound incl. one overshoot chunk
-
-// e2e/perf/results lives at the repo root: reproduction → test → runtime →
-// node-sdk → packages → <root>/e2e/perf/results.
-const RESULTS_DIR = path.resolve(
-  import.meta.dirname!,
-  "../../../../../e2e/perf/results",
-);
-
-/** One time-series row; field names mirror e2e/perf/metrics.ts `Sample`. */
-type BufSample = {
-  t: number;
-  wall: number;
-  mainBuf: number;
-  evmBuf: number; // the parallel chain's buffer (report labels it "parallel buf")
-  mainOwnBlock: number | null;
-  evmOwnBlock: number | null;
-  rss: number;
-  appliedBlock: number | null;
-};
-
-function ownBlock(node: RunningNode, name: string): number | null {
-  return node.syncProtocols().find((p) => p.name === name)?.lastPage
-    ?.ownBlockNumber ?? null;
-}
-
-/** Backpressure "fired" counter (rising edges) exposed on SyncState / /debug/metrics. */
-function pauses(node: RunningNode, name: string): number {
-  return node.syncProtocols().find((p) => p.name === name)
-    ?.backpressurePauses ?? 0;
-}
-
-/** Side-effect-only artifact write; never throws into the test. */
-function writeArtifact(
-  name: string,
-  samples: BufSample[],
-  meta: Record<string, unknown>,
-): void {
-  try {
-    fs.mkdirSync(RESULTS_DIR, { recursive: true });
-    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const file = path.join(RESULTS_DIR, `${name}-${stamp}.json`);
-    fs.writeFileSync(file, JSON.stringify({ meta, samples }, null, 2));
-    console.log(`buffering artifact: ${file}`);
-  } catch (e) {
-    console.warn(`failed to write buffering artifact: ${String(e)}`);
-  }
-}
-
-let h: Harness;
-beforeEach(async () => {
-  h = await setupHarness();
-});
-afterEach(async () => {
-  await h?.teardown();
-});
-
-// ── 1a — unbounded buffering, now bounded by the cap ────────────────────────────
-
-const MAIN_1A = "mainClock1a";
-const PAR_1A = "parallelP1a";
-
-function buildConfig1a() {
-  return new ConfigBuilder()
-    .setNamespace((b) => b.setSecurityNamespace("sync-buffering-1a"))
-    .buildNetworks((b) =>
-      b
-        .addNetwork({
-          name: "clock",
-          type: ConfigNetworkType.TEST,
-          startTime: START_TIME,
-          blockTimeMS: BLOCK_TIME_MS,
-        })
-        .addNetwork({
-          name: "chainP",
-          type: ConfigNetworkType.TEST,
-          startTime: START_TIME,
-          blockTimeMS: BLOCK_TIME_MS,
-        })
-    )
-    .buildDeployments((b) => b)
-    .buildSyncProtocols((b) =>
-      b
-        .addMain(
-          (n) => n.clock,
-          () => ({
-            name: MAIN_1A,
-            type: ConfigSyncProtocolType.TEST_MAIN,
-            startBlockHeight: 1,
-            pollingInterval: 30,
-            stepSize: STEP_SIZE,
-            maxBufferedPages: CAP,
-          }),
-        )
-        .addParallel(
-          (n) => (n as any).chainP,
-          () => ({
-            name: PAR_1A,
-            type: ConfigSyncProtocolType.TEST_PARALLEL,
-            startBlockHeight: 1,
-            pollingInterval: 30,
-            stepSize: STEP_SIZE,
-            delayMs: 0,
-            events: [],
-            maxBufferedPages: CAP,
-          }),
-        )
-    )
-    .buildPrimitives((b) =>
-      b.addPrimitive(
-        (sp) => (sp as any)[PAR_1A],
-        () => ({ name: "noEvt1a", type: TEST_PRIMITIVE_TYPE, startBlockHeight: 1 }),
-      )
-    )
-    .build();
-}
-
-test("1a: backpressure caps the buffer while the node keeps applying blocks", async () => {
-  // Tips far ahead of where the one-block-per-txn merge can drain to: without a
-  // cap the fetcher would race to ~50k; with the cap it must plateau near CAP.
-  TestChainControl.setTip(MAIN_1A, BIG_TIP);
-  TestChainControl.setTip(PAR_1A, BIG_TIP);
-
-  const node = await h.runNode({ config: buildConfig1a(), apiPort: 19141 });
-  const samples: BufSample[] = [];
-  let peakMain = 0;
-  let peakEvm = 0;
-  let lastApplied = 0;
-  let mainPauses = 0;
-  try {
-    const startMs = Date.now();
-    const deadline = startMs + 6000;
-    while (Date.now() < deadline) {
-      const wall = Date.now();
-      const mainBuf = bufferSize(node, MAIN_1A);
-      const evmBuf = bufferSize(node, PAR_1A);
-      const appliedBlock = await latestFinalizedHeight(h.pool);
-      samples.push({
-        t: wall - startMs,
-        wall,
-        mainBuf,
-        evmBuf,
-        mainOwnBlock: ownBlock(node, MAIN_1A),
-        evmOwnBlock: ownBlock(node, PAR_1A),
-        rss: process.memoryUsage().rss,
-        appliedBlock,
-      });
-      peakMain = Math.max(peakMain, mainBuf);
-      peakEvm = Math.max(peakEvm, evmBuf);
-      lastApplied = appliedBlock ?? lastApplied;
-      // Backpressure engaged (buffer hit the cap) AND the node is still applying
-      // blocks → we've captured the bounded steady state; stop early.
-      if (peakMain >= CAP && lastApplied >= 20) break;
-      await sleep(50);
-    }
-  } finally {
-    mainPauses = pauses(node, MAIN_1A);
-    writeArtifact("buffering-1a", samples, {
-      mode: "1a-bounded-by-cap",
-      stepSize: STEP_SIZE,
-      bigTip: BIG_TIP,
-      cap: CAP,
-      bufferBound: BUFFER_BOUND,
-      peakMainBuf: peakMain,
-      peakEvmBuf: peakEvm,
-      lastApplied,
-      pauses: mainPauses,
-    });
-    await node.stop();
-  }
-
-  // Backpressure engaged: the buffer reached the cap (not starved)...
-  expect(peakMain).toBeGreaterThanOrEqual(CAP_FLOOR);
-  // ...but stayed bounded — nowhere near the uncapped ~49k backlog.
-  expect(Math.max(peakMain, peakEvm)).toBeLessThanOrEqual(BUFFER_BOUND);
-  // ...the node kept producing/applying blocks (no deadlock)...
-  expect(lastApplied).toBeGreaterThanOrEqual(20);
-  // ...and the cap actually fired (the observability metric populated).
-  expect(mainPauses).toBeGreaterThan(0);
-}, 60_000);
-
-// ── 1b — head-of-line blocking, sibling buffer now bounded ──────────────────────
-
-const MAIN_1B = "mainClock1b";
-const FAST_1B = "fastP1b";
-const SLOW_1B = "slowP1b";
-
-function buildConfig1b() {
-  return new ConfigBuilder()
-    .setNamespace((b) => b.setSecurityNamespace("sync-buffering-1b"))
-    .buildNetworks((b) =>
-      b
-        .addNetwork({
-          name: "clock",
-          type: ConfigNetworkType.TEST,
-          startTime: START_TIME,
-          blockTimeMS: BLOCK_TIME_MS,
-        })
-        .addNetwork({
-          name: "chainFast",
-          type: ConfigNetworkType.TEST,
-          startTime: START_TIME,
-          blockTimeMS: BLOCK_TIME_MS,
-        })
-        .addNetwork({
-          name: "chainSlow",
-          type: ConfigNetworkType.TEST,
-          startTime: START_TIME,
-          blockTimeMS: BLOCK_TIME_MS,
-        })
-    )
-    .buildDeployments((b) => b)
-    .buildSyncProtocols((b) =>
-      b
-        .addMain(
-          (n) => n.clock,
-          () => ({
-            name: MAIN_1B,
-            type: ConfigSyncProtocolType.TEST_MAIN,
-            startBlockHeight: 1,
-            pollingInterval: 30,
-            stepSize: STEP_SIZE,
-            maxBufferedPages: CAP,
-          }),
-        )
-        .addParallel(
-          (n) => (n as any).chainFast,
-          () => ({
-            name: FAST_1B,
-            type: ConfigSyncProtocolType.TEST_PARALLEL,
-            startBlockHeight: 1,
-            pollingInterval: 30,
-            stepSize: STEP_SIZE,
-            delayMs: 0,
-            events: [],
-            maxBufferedPages: CAP,
-          }),
-        )
-        .addParallel(
-          (n) => (n as any).chainSlow,
-          () => ({
-            name: SLOW_1B,
-            type: ConfigSyncProtocolType.TEST_PARALLEL,
-            startBlockHeight: 1,
-            pollingInterval: 30,
-            stepSize: STEP_SIZE,
-            delayMs: 0,
-            events: [],
-            maxBufferedPages: CAP,
-          }),
-        )
-    )
-    .buildPrimitives((b) =>
-      b
-        .addPrimitive(
-          (sp) => (sp as any)[FAST_1B],
-          () => ({ name: "noEvtFast", type: TEST_PRIMITIVE_TYPE, startBlockHeight: 1 }),
-        )
-        .addPrimitive(
-          (sp) => (sp as any)[SLOW_1B],
-          () => ({ name: "noEvtSlow", type: TEST_PRIMITIVE_TYPE, startBlockHeight: 1 }),
-        )
-    )
-    .build();
-}
-
-test("1b: a stalled chain still halts production, but the fast chain's buffer stays capped", async () => {
-  // slowP pinned at a low tip → the merge stalls there forever (correct). fastP and
-  // the main clock keep fetching toward their high tips, but the cap now bounds them.
-  TestChainControl.setTip(MAIN_1B, BIG_TIP);
-  TestChainControl.setTip(FAST_1B, BIG_TIP);
-  TestChainControl.setTip(SLOW_1B, SLOW_TIP);
-
-  const node = await h.runNode({ config: buildConfig1b(), apiPort: 19142 });
-  const samples: BufSample[] = [];
-  let peakMain = 0;
-  let peakFast = 0;
-  let stalledHeight = -1;
-  let fastPauses = 0;
-  try {
-    const startMs = Date.now();
-    const deadline = startMs + 15_000;
-    let lastHeight = -1;
-    let lastChange = Date.now();
-    while (Date.now() < deadline) {
-      const wall = Date.now();
-      const mainBuf = bufferSize(node, MAIN_1B);
-      const fastBuf = bufferSize(node, FAST_1B);
-      const appliedBlock = await latestFinalizedHeight(h.pool);
-      samples.push({
-        t: wall - startMs,
-        wall,
-        mainBuf,
-        evmBuf: fastBuf,
-        mainOwnBlock: ownBlock(node, MAIN_1B),
-        evmOwnBlock: ownBlock(node, FAST_1B),
-        rss: process.memoryUsage().rss,
-        appliedBlock,
-      });
-      peakMain = Math.max(peakMain, mainBuf);
-      peakFast = Math.max(peakFast, fastBuf);
-      if (appliedBlock !== lastHeight) {
-        lastHeight = appliedBlock;
-        lastChange = wall;
-      }
-      // Production has stalled (height flat ≥1.5s) AND the fast chain has hit its
-      // cap → the head-of-line block holds while the sibling buffer is bounded.
-      if (wall - lastChange >= 1500 && peakFast >= CAP_FLOOR) {
-        stalledHeight = appliedBlock ?? -1;
-        break;
-      }
-      await sleep(50);
-    }
-  } finally {
-    fastPauses = pauses(node, FAST_1B);
-    writeArtifact("buffering-1b", samples, {
-      mode: "1b-hol-sibling-bounded",
-      stepSize: STEP_SIZE,
-      bigTip: BIG_TIP,
-      slowTip: SLOW_TIP,
-      cap: CAP,
-      bufferBound: BUFFER_BOUND,
-      stalledHeight,
-      peakMainBuf: peakMain,
-      peakFastBuf: peakFast,
-      fastPauses,
-    });
-    await node.stop();
-  }
-
-  // Block production still stalls at ~the slow chain's tip (the merge gate is correct)...
-  expect(stalledHeight).toBeGreaterThanOrEqual(0);
-  expect(stalledHeight).toBeLessThanOrEqual(SLOW_TIP + 10);
-  // ...the fast chain's buffer engaged the cap...
-  expect(peakFast).toBeGreaterThanOrEqual(CAP_FLOOR);
-  // ...but stayed bounded behind the head-of-line block (was ~50k uncapped)...
-  expect(peakFast).toBeLessThanOrEqual(BUFFER_BOUND);
-  expect(peakMain).toBeLessThanOrEqual(BUFFER_BOUND);
-  // ...and the cap actually fired on the fast chain (observability metric populated).
-  expect(fastPauses).toBeGreaterThan(0);
-}, 60_000);