@effectstream/runtime 0.100.19 → 0.100.22

package/test/reproduction/resume.test.ts

@@ -1,77 +0,0 @@
-/**
- * Resume-marker position over the synthetic `test` chain.
- *
- * Companion to consistency.test.ts (which proves a mid-chunk restart re-fetches
- * uncommitted data instead of skipping it). This file pins down *where* the
- * persisted resume marker lands for a chain whose data is sparse — the property
- * that bounds restart re-scan (see @effectstream/sync CLAUDE.md, design idea #5).
- *
- * The marker is the highest datum merged into the committed block, and because
- * each fetched chunk's boundary page is buffered and consumed even when empty, it
- * tracks the **committed frontier** — NOT the last block that happened to carry
- * data. So a chain that produced one event long ago and has been quiet since
- * still resumes near the frontier, re-fetching at most ~stepSize blocks, never
- * its whole quiet tail. Here: data lives only at block 5, yet the marker must sit
- * at the frontier (height 50 / 60), not stuck back at 5.
- */
-import { afterAll, beforeAll, expect, test } from "bun:test";
-import {
-  countEventRows,
-  type Harness,
-  latestFinalizedHeight,
-  maxPage,
-  setupHarness,
-} from "./harness.ts";
-
-let h: Harness;
-
-beforeAll(async () => {
-  h = await setupHarness();
-});
-
-afterAll(async () => {
-  await h?.teardown();
-});
-
-test(
-  "a sparse chain's resume marker tracks the frontier, not its last data block",
-  async () => {
-    // Data lives ONLY at parallel block 5; everything after is quiet. Block 5 is
-    // the marker a naive "resume from last data" scheme would persist.
-    const events = [{ atBlock: 5, marker: "evt5" }];
-
-    // Phase 1 — sync the main clock to 50 (parallel tip stays ahead so the merge
-    // can finalize). The block-5 event is merged early; the chain is quiet after.
-    await h.runToHeight({
-      events,
-      tips: { mainClock: 50, parallelP: 200 },
-      target: 50,
-      apiPort: 19161,
-    });
-
-    expect(await latestFinalizedHeight(h.pool)).toBe(50);
-    expect(await countEventRows(h.pool, "evt5")).toBe(1);
-
-    // The crux: the parallel marker tracks the committed frontier (50), NOT the
-    // last data block (5). A restart therefore resumes from ~51 and re-scans only
-    // the bounded gap up to the frontier — never blocks 6..50 from scratch.
-    expect(await maxPage(h.pool, "parallelP")).toBe(50);
-    expect(await maxPage(h.pool, "parallelP")).not.toBe(5);
-
-    // Phase 2 (restart) — boot a fresh process against the same DB and sync on to
-    // 60. The parallel chain resumes from the frontier (51), not from block 5.
-    await h.runToHeight({
-      events,
-      tips: { mainClock: 60, parallelP: 200 },
-      target: 60,
-      apiPort: 19162,
-    });
-
-    expect(await latestFinalizedHeight(h.pool)).toBe(60);
-    // Marker advanced with the new frontier...
-    expect(await maxPage(h.pool, "parallelP")).toBe(60);
-    // ...and block 5 was neither re-fetched (resume started past it) nor lost.
-    expect(await countEventRows(h.pool, "evt5")).toBe(1);
-  },
-  120_000,
-);

package/test/reproduction/scenario.ts

@@ -1,126 +0,0 @@
-/**
- * Shared scenario building blocks for the reproduction tests.
- *
- * Both the in-process test files and the out-of-process {@link ./node-runner.ts}
- * subprocess build the *same* synthetic `test`-chain config from these helpers,
- * so a node booted in a child process is identical to one a test would describe.
- * Keeping the config + primitive here (no DB, no cluster imports) lets the
- * subprocess import it cheaply.
- */
-import {
-  ConfigBuilder,
-  ConfigNetworkType,
-  ConfigSyncProtocolType,
-} from "@effectstream/config";
-import { Primitive } from "@effectstream/sm";
-
-/** Fixed wall-clock origin so block timestamps are pure arithmetic. */
-export const START_TIME = 1_700_000_000_000;
-export const BLOCK_TIME_MS = 1000;
-
-export type EventSpec = { atBlock: number; marker: string };
-
-export type ScenarioOpts = {
-  events: EventSpec[];
-  /** Parallel-chain page size. Large (default 1000) => whole tip is one chunk. */
-  parallelStepSize?: number;
-  /** Security namespace; distinct per test keeps databases independent. */
-  securityNamespace?: string;
-};
-
-export function buildConfig(opts: ScenarioOpts) {
-  const stepSize = opts.parallelStepSize ?? 1000;
-  const namespace = opts.securityNamespace ?? "sync-repro";
-  return new ConfigBuilder()
-    .setNamespace((b) => b.setSecurityNamespace(namespace))
-    .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,
-            delayMs: 0,
-            events: opts.events.map((e) => ({
-              atBlock: e.atBlock,
-              payload: { marker: e.marker },
-            })),
-          }),
-        )
-    )
-    .buildPrimitives((b) =>
-      b.addPrimitive(
-        (sp) => (sp as any).parallelP,
-        () => ({
-          name: "testEvt",
-          type: TEST_PRIMITIVE_TYPE,
-          startBlockHeight: 1,
-        }),
-      )
-    )
-    .build();
-}
-
-// ── A minimal user-defined primitive ─────────────────────────────────────────
-// Writes one row to effectstream.primitive_accounting per event (no STF needed:
-// stateMachinePayload is null). Tests assert on that table.
-export const TEST_PRIMITIVE_TYPE = "TEST:EVENT";
-
-export class TestEventPrimitive extends Primitive<any, any> {
-  readonly internalTypeName = TEST_PRIMITIVE_TYPE as any;
-  override grammar = [] as any;
-  constructor(config: any) {
-    super(config);
-  }
-  // deno-lint-ignore require-yield
-  override *getPayload(_height: any, primitiveTransactionData: any): any {
-    const payload = primitiveTransactionData.output.payload;
-    return {
-      isBatched: false,
-      data: [
-        {
-          fromAddressAndType: { type: "none", address: "0x0" },
-          accountingPayload: payload,
-          stateMachinePayload: null,
-        },
-      ],
-    };
-  }
-  override getConfig(): any {
-    return {
-      name: this.instanceName,
-      type: this.internalTypeName,
-      startBlockHeight: this.startBlockHeight,
-      scheduledPrefix: this.stateMachinePrefix,
-    };
-  }
-}