okengine 0.17.2 → 0.18.4

package/src/bench/g08-store-sql.bench.ts

@@ -0,0 +1,178 @@
+/**
+ * G8a — store.sql sustained insert/update (live Postgres via pgdog).
+ *
+ * Drives `createStoreRuntime` → `sharedSqlConn` through the public
+ * `runtime.open()` path (same connection the fx layer uses), then hammers:
+ *   1. sustained single-row INSERTs,
+ *   2. sustained point UPDATEs,
+ *   3. mixed insert+update interleave.
+ *
+ * Run: OKE_BENCH=1 OKE_TEST_POSTGRES=1 DATABASE_URL=… bun test ./src/bench/g08-store-sql.bench.ts --timeout 300000
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { postgresDriver } from "../drivers/postgres.ts";
+import { sql } from "../elements/store/declare.ts";
+import { defineTable } from "../elements/store/table.ts";
+import { createSqlStoreHandle, type SqlStoreHandle } from "../elements/store/sql-session.ts";
+import { createStoreRuntime } from "../elements/store/runtime.ts";
+import { okid } from "../okid.ts";
+import { LIVE_PG } from "./lib/infra.ts";
+import { DISCLAIMER, HARDWARE, percentile, writeArtifact } from "./lib/report.ts";
+
+const CAL = process.env.OKE_BENCH_CAL === "1";
+/** Ops per phase — sized so each full run is ~30–60 s against pgdog. */
+const OPS = CAL ? 200 : 2_000;
+
+const db = sql("g8sql");
+const rows = defineTable("oke_bench_g8_rows", {
+  id: true,
+  n: true,
+  at: true,
+});
+
+let handle: SqlStoreHandle;
+let runtime: ReturnType<typeof createStoreRuntime>;
+
+beforeAll(async () => {
+  if (!LIVE_PG) throw new Error("G8 needs live Postgres: set OKE_TEST_POSTGRES=1 + DATABASE_URL");
+  runtime = createStoreRuntime({
+    drivers: { sql: postgresDriver },
+    sql: { g8sql: { name: "g8sql", primary: { url: LIVE_PG } } },
+    now: () => Date.now(),
+  });
+  runtime.register(db);
+  const conn = await runtime.primarySql();
+  if (!conn) throw new Error("G8: runtime.primarySql() returned undefined");
+  await conn.exec(`
+    CREATE TABLE IF NOT EXISTS oke_bench_g8_rows (
+      id TEXT PRIMARY KEY,
+      n BIGINT NOT NULL DEFAULT 0,
+      at BIGINT NOT NULL DEFAULT 0
+    )
+  `);
+  await conn.exec(`DELETE FROM oke_bench_g8_rows WHERE id LIKE 'bench-g8-%'`);
+  // Same session shape the fx layer builds: shared conn, no PII classes.
+  handle = createSqlStoreHandle(db.ref, {
+    connection: conn,
+    classifications: new Map(),
+    routedRole: "primary",
+    domainDdl: "off",
+  });
+}, 20_000);
+
+afterAll(async () => {
+  try {
+    const conn = await runtime?.primarySql();
+    await conn?.exec(`DELETE FROM oke_bench_g8_rows WHERE id LIKE 'bench-g8-%'`);
+  } catch {
+    /* best-effort cleanup */
+  }
+  await runtime?.close();
+});
+
+async function timedPhase(
+  name: string,
+  op: (i: number) => Promise<unknown>,
+): Promise<{
+  latencies: number[];
+}> {
+  const latencies: number[] = [];
+  for (let i = 0; i < OPS; i++) {
+    const t0 = performance.now();
+    await op(i);
+    latencies.push(performance.now() - t0);
+  }
+  latencies.sort((a, b) => a - b);
+  console.log(
+    `[G8a] ${name}: ops=${OPS} p50=${percentile(latencies, 50).toFixed(3)}ms ` +
+      `p99=${percentile(latencies, 99).toFixed(3)}ms`,
+  );
+  return { latencies };
+}
+
+function metricsFor(label: string, latencies: number[], wallS: number): Record<string, number> {
+  return {
+    [`${label}.ops`]: latencies.length,
+    [`${label}.p50Ms`]: Number(percentile(latencies, 50).toFixed(3)),
+    [`${label}.p99Ms`]: Number(percentile(latencies, 99).toFixed(3)),
+    [`${label}.opsPerSec`]: Number((latencies.length / wallS).toFixed(1)),
+  };
+}
+
+describe.skipIf(!process.env.OKE_BENCH || !LIVE_PG)("G8a — store.sql sustained", () => {
+  test(
+    "sustained insert / update / mixed against live postgres",
+    async () => {
+      const ids = Array.from({ length: OPS }, () => `bench-g8-${okid()}`);
+      const metrics: Record<string, number> = {};
+
+      // 1. Sustained inserts.
+      let t0 = performance.now();
+      const ins = await timedPhase("insert", (i) =>
+        handle.insert(rows).values({ id: ids[i]!, n: i, at: Date.now() }).execute(),
+      );
+      let wallS = (performance.now() - t0) / 1000;
+      Object.assign(metrics, metricsFor("insert", ins.latencies, wallS));
+
+      // 2. Sustained point updates.
+      t0 = performance.now();
+      const upd = await timedPhase("update", (i) =>
+        handle
+          .update(rows)
+          .set({ n: i + 1 })
+          .where({ id: ids[i]! }),
+      );
+      wallS = (performance.now() - t0) / 1000;
+      Object.assign(metrics, metricsFor("update", upd.latencies, wallS));
+
+      // 3. Mixed interleave — read-modify-write pairs.
+      t0 = performance.now();
+      const mixLatencies: number[] = [];
+      for (let i = 0; i < OPS; i++) {
+        const s = performance.now();
+        const found = await handle.select().from(rows).where({ id: ids[i]! }).limit(1);
+        if (found.length !== 1) throw new Error(`G8a mixed: row ${ids[i]} missing`);
+        await handle
+          .update(rows)
+          .set({ n: i + 2 })
+          .where({ id: ids[i]! });
+        mixLatencies.push(performance.now() - s);
+      }
+      wallS = (performance.now() - t0) / 1000;
+      Object.assign(metrics, metricsFor("mixed", mixLatencies, wallS));
+      Object.assign(metrics, { mixedReadThenWritePairs: OPS });
+
+      // Sanity: last update landed.
+      const check = await handle
+        .select()
+        .from(rows)
+        .where({ id: ids[OPS - 1]! })
+        .limit(1);
+      expect(Number(check[0]?.n)).toBe(OPS + 1);
+
+      console.log("[G8a] metrics:", JSON.stringify(metrics));
+      const issues: string[] = [];
+      if (metrics["update.opsPerSec"]! < metrics["insert.opsPerSec"]! * 0.3) {
+        issues.push(
+          `update throughput collapsed vs insert: ${metrics["update.opsPerSec"]} < 30% of ${metrics["insert.opsPerSec"]}`,
+        );
+      }
+
+      const path = await writeArtifact({
+        group: "G8a",
+        hardware: HARDWARE,
+        disclaimer: DISCLAIMER,
+        command:
+          "OKE_BENCH=1 OKE_TEST_POSTGRES=1 DATABASE_URL=$DATABASE_URL bun test ./src/bench/g08-store-sql.bench.ts --timeout 300000",
+        metrics,
+        issues,
+        fixes: [],
+        remeasured: null,
+      });
+      console.log(`[G8a] artifact: ${path}`);
+      expect(issues.length).toBe(0);
+    },
+    CAL ? 90_000 : 300_000,
+  );
+});

package/src/bench/g09-journal-sustained.bench.ts

@@ -0,0 +1,203 @@
+/**
+ * G9 — durable journal / fx.step sustained (live Postgres via pgdog).
+ *
+ * Boots a real `oke()` app whose journal runtime is `createPostgresJournalStore`
+ * (the SKIP LOCKED claim/lease path), then drives parallel durable flow
+ * executions closed-loop for `OKE_BENCH_DURATION_S` seconds (default 300).
+ * Every run records 3 journaled steps; `store.put` is wrapped with a counter
+ * so journal write rate is exact. A background sampler tracks backlog depth
+ * (`running`/`sleeping` runs) every 5 s.
+ *
+ * Run: OKE_BENCH=1 OKE_TEST_POSTGRES=1 DATABASE_URL=… bun test ./src/bench/g09-journal-sustained.bench.ts --timeout 420000
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createPostgresJournalStore } from "../drivers/journal-postgres.ts";
+import { oke, type OkeApp } from "../kernel/app.ts";
+import type { JournalRuntime } from "../kernel/boot-bind/journal.ts";
+import { flow, type AnyFlowDef } from "../kernel/flow.ts";
+import type { Binding } from "../kernel/on.ts";
+import { http } from "../kernel/triggers.ts";
+import type { JournalRun, JournalStore } from "../kernel/journal.ts";
+import { LIVE_PG } from "./lib/infra.ts";
+import { DISCLAIMER, HARDWARE, percentile, writeArtifact } from "./lib/report.ts";
+
+const CAL = process.env.OKE_BENCH_CAL === "1";
+const DURATION_S = CAL ? 15 : Math.max(10, Number(process.env.OKE_BENCH_DURATION_S ?? "300"));
+/** Closed-loop workers — each awaits run completion before firing again. */
+const CONCURRENCY = CAL ? 4 : 16;
+const FLOW_PREFIX = "g9sustained";
+
+let app: OkeApp;
+let journal: Awaited<ReturnType<typeof createPostgresJournalStore>>;
+let putsCount = 0;
+let stepRuns = 0;
+let failedRuns = 0;
+
+beforeAll(async () => {
+  if (!LIVE_PG) throw new Error("G9 needs live Postgres: set OKE_TEST_POSTGRES=1 + DATABASE_URL");
+  journal = await createPostgresJournalStore({ url: LIVE_PG });
+  await journal.sql.exec(`DELETE FROM oke_journal_runs WHERE flow LIKE '${FLOW_PREFIX}%'`);
+
+  // Exact journal write accounting: wrap put().
+  const counted = {
+    ...journal,
+    put: async (run: JournalRun) => {
+      putsCount += 1;
+      await journal.put(run);
+    },
+  } as JournalStore & NonNullable<JournalRuntime["store"]>;
+  const jrt: JournalRuntime = {
+    store: counted,
+    instanceId: "g9-bench",
+    leaseMs: 30_000,
+    driverId: "postgres",
+  };
+
+  // Three lightweight fx.steps per run — replay never re-runs them.
+  const work = flow(`${FLOW_PREFIX}.work`, {
+    durable: true,
+    do: async (input, fx) => {
+      const n = Number((input as { n?: number }).n ?? 0);
+      const a = await fx.step("step-a", () => n + 1);
+      const b = await fx.step("step-b", async () => a * 2);
+      await fx.step("step-c", () => ({ b, at: Date.now() }));
+      stepRuns += 3;
+      return { ok: true as const, b };
+    },
+  });
+  const bindings: Binding[] = [
+    { trigger: http.post("/g9/work").public(), flow: work as AnyFlowDef },
+  ];
+  app = oke({
+    name: "g9-journal-sustained",
+    env: "test",
+    startScheduler: false,
+    gate: { unguardedHttp: "allow" },
+    bindings,
+    elements: { journal: jrt },
+  });
+  await app.boot();
+}, 30_000);
+
+afterAll(async () => {
+  try {
+    await journal?.sql.exec(`DELETE FROM oke_journal_runs WHERE flow LIKE '${FLOW_PREFIX}%'`);
+    await journal?.close();
+  } catch {
+    /* best-effort cleanup */
+  }
+});
+
+interface BacklogSample {
+  tS: number;
+  backlog: number;
+}
+
+describe.skipIf(!process.env.OKE_BENCH || !LIVE_PG)("G9 — journal sustained", () => {
+  test(
+    `${DURATION_S}s of parallel durable flows — steps/sec, write rate, backlog depth`,
+    async () => {
+      const samples: BacklogSample[] = [];
+      let sampling = true;
+      const t0 = performance.now();
+      const sampler = (async () => {
+        while (sampling) {
+          try {
+            const rows = await journal.sql.query(
+              `SELECT COUNT(*) AS c FROM oke_journal_runs
+               WHERE flow LIKE ? AND status IN ('running','sleeping','compensating')`,
+              [`${FLOW_PREFIX}%`],
+            );
+            samples.push({
+              tS: Number(((performance.now() - t0) / 1000).toFixed(1)),
+              backlog: Number((rows[0] as { c: number }).c),
+            });
+          } catch {
+            /* sampler is best-effort */
+          }
+          await Bun.sleep(5_000);
+        }
+      })();
+
+      const latencies: number[] = [];
+      let done = 0;
+      const deadlineMs = DURATION_S * 1000;
+
+      const worker = async (): Promise<void> => {
+        for (;;) {
+          if (performance.now() - t0 >= deadlineMs) return;
+          const s = performance.now();
+          try {
+            const res = await app.fetch(
+              new Request("http://localhost/g9/work", {
+                method: "POST",
+                body: JSON.stringify({ n: done }),
+                headers: { "content-type": "application/json" },
+              }),
+            );
+            if (!res.ok) throw new Error(`g9 work HTTP ${res.status}`);
+          } catch {
+            failedRuns += 1;
+            continue;
+          }
+          latencies.push(performance.now() - s);
+          done += 1;
+        }
+      };
+
+      await Promise.all(Array.from({ length: CONCURRENCY }, worker));
+      const wallS = (performance.now() - t0) / 1000;
+      sampling = false;
+      await sampler;
+
+      const metrics: Record<string, number> = {
+        durationS: Number(wallS.toFixed(1)),
+        concurrency: CONCURRENCY,
+        runsCompleted: done,
+        runsPerSec: Number((done / wallS).toFixed(2)),
+        stepsExecuted: stepRuns,
+        stepsPerSec: Number((stepRuns / wallS).toFixed(2)),
+        journalPuts: putsCount,
+        journalWritesPerSec: Number((putsCount / wallS).toFixed(2)),
+        runP50Ms: Number(percentile(latencies, 50).toFixed(3)),
+        runP99Ms: Number(percentile(latencies, 99).toFixed(3)),
+        runMaxMs: latencies.length ? Number(Math.max(...latencies).toFixed(3)) : 0,
+        failedRuns,
+        backlogMax: samples.length ? Math.max(...samples.map((x) => x.backlog)) : -1,
+        backlogAvg:
+          samples.length > 0
+            ? Number((samples.reduce((a, x) => a + x.backlog, 0) / samples.length).toFixed(2))
+            : -1,
+        backlogFinal: samples.length ? samples[samples.length - 1]!.backlog : -1,
+      };
+
+      console.log("[G9] metrics:", JSON.stringify(metrics));
+      const issues: string[] = [];
+      if (failedRuns > 0) issues.push(`failed durable runs under sustained load: ${failedRuns}`);
+      if (metrics.backlogFinal! > CONCURRENCY * 2) {
+        issues.push(
+          `backlog did not drain: final=${metrics.backlogFinal} vs concurrency=${CONCURRENCY}`,
+        );
+      }
+
+      const path = await writeArtifact({
+        group: "G9",
+        hardware: HARDWARE,
+        disclaimer: DISCLAIMER,
+        command:
+          "OKE_BENCH=1 OKE_TEST_POSTGRES=1 DATABASE_URL=$DATABASE_URL bun test ./src/bench/g09-journal-sustained.bench.ts --timeout 420000",
+        metrics,
+        issues,
+        fixes: [],
+        remeasured: null,
+      });
+      console.log(`[G9] artifact: ${path}`);
+
+      expect(failedRuns).toBe(0);
+      expect(done).toBeGreaterThan(0);
+      expect(stepRuns).toBe(done * 3);
+    },
+    CAL ? 120_000 : Math.min(600_000, DURATION_S * 1000 + 120_000),
+  );
+});

package/src/bench/g10-observability-contention.bench.ts

@@ -0,0 +1,246 @@
+/**
+ * G10 — observability contention: same load twice, app alone vs app +
+ * Console signals-panel queries (`projectSignalsList`,
+ * `src/console/server/signals.ts`) hammering the same Postgres pool.
+ *
+ * Each arm boots a fresh `load-child serve` and runs an identical G5-shaped
+ * closed-loop (30× /ping + 10× durable journal flow + 10× store insert) for
+ * `OKE_BENCH_G10_ARM_S` seconds. Arm B adds 3 concurrent
+ * `projectSignalsList()` loops whose `bus.inspect()` COUNT queries run on the
+ * same DATABASE_URL pool. Metric: req/sec delta between arms.
+ *
+ * Run: OKE_BENCH=1 OKE_TEST_POSTGRES=1 DATABASE_URL=… OKE_TEST_REDIS_URL=… bun test ./src/bench/g10-observability-contention.bench.ts --timeout 600000
+ */
+
+import { describe, expect, test } from "bun:test";
+import { openPostgresSignal } from "../drivers/signal-postgres.ts";
+import type { SignalBus } from "../drivers/signal-types.ts";
+import { createMemorySignalConfigStore } from "../elements/signal/reconcile.ts";
+import { signal } from "../elements/signal/declare.ts";
+import { projectSignalsList } from "../console/server/signals.ts";
+import { LIVE_PG } from "./lib/infra.ts";
+import { createBunSignalSql } from "./lib/signal-pg.ts";
+import { DISCLAIMER, HARDWARE, percentile, writeArtifact } from "./lib/report.ts";
+
+const CAL = process.env.OKE_BENCH_CAL === "1";
+const ARM_S = CAL ? 15 : Math.max(30, Number(process.env.OKE_BENCH_G10_ARM_S ?? "120"));
+const PING_WORKERS = 30;
+const DURABLE_WORKERS = 10;
+const STORE_WORKERS = 10;
+const OBSERVER_LOOPS = 3;
+
+type Server = Bun.Subprocess<"ignore", "pipe", "ignore">;
+
+function spawnServe(port: number): Server {
+  return Bun.spawn(["bun", "run", "src/bench/load-child.ts", "serve", String(port)], {
+    stdout: "pipe",
+    stderr: "ignore",
+    env: process.env,
+  });
+}
+
+async function readReadyPid(proc: Server): Promise<number> {
+  const reader = proc.stdout.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) throw new Error("server died before ready");
+    buf += dec.decode(value, { stream: true });
+    const nl = buf.indexOf("\n");
+    if (nl >= 0) {
+      const line = buf.slice(0, nl).trim();
+      if (line.startsWith("{")) {
+        void (async () => {
+          try {
+            for (;;) {
+              const r = await reader.read();
+              if (r.done) break;
+            }
+          } catch {
+            /* closed */
+          }
+        })();
+        return (JSON.parse(line) as { pid: number }).pid;
+      }
+    }
+  }
+}
+
+/** One arm: identical closed-loop shape; optional concurrent console queries. */
+async function runArm(
+  port: number,
+  observers: boolean,
+  sql: ReturnType<typeof createBunSignalSql> | null,
+): Promise<{
+  pingRps: number;
+  durableRps: number;
+  storeRps: number;
+  totalRps: number;
+  errors: number;
+  obsRps: number;
+  obsP50Ms: number;
+  obsP99Ms: number;
+}> {
+  const server = spawnServe(port);
+  try {
+    await readReadyPid(server);
+    const base = `http://127.0.0.1:${port}`;
+    await Bun.sleep(CAL ? 2_000 : 4_000); // warm-up
+
+    let stop = false;
+    const c = { ping: 0, durable: 0, store: 0, errors: 0 };
+
+    const loop = async (
+      path: string,
+      body: Record<string, unknown>,
+      counter: keyof typeof c,
+    ): Promise<void> => {
+      while (!stop) {
+        try {
+          const res = await fetch(`${base}${path}`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+          });
+          await res.arrayBuffer();
+          if (!res.ok) c.errors++;
+        } catch {
+          c.errors++;
+          continue;
+        }
+        c[counter]++;
+      }
+    };
+    // /ping is GET — separate worker shape.
+    const pingLoop = async (): Promise<void> => {
+      while (!stop) {
+        try {
+          const res = await fetch(`${base}/ping`);
+          await res.arrayBuffer();
+          if (!res.ok) c.errors++;
+        } catch {
+          c.errors++;
+          continue;
+        }
+        c.ping++;
+      }
+    };
+
+    const workers = [
+      ...Array.from({ length: PING_WORKERS }, pingLoop),
+      ...Array.from({ length: DURABLE_WORKERS }, () => loop("/_/bench/durable", {}, "durable")),
+      ...Array.from({ length: STORE_WORKERS }, () => loop("/_/bench/rls", { n: 1 }, "store")),
+    ];
+    const running = Promise.all(workers);
+
+    const obsLats: number[] = [];
+    let obsQueries = 0;
+    if (observers && sql) {
+      const decl = signal("g10-watch", { delivery: "once", optional: true });
+      const consoleBus: SignalBus = await openPostgresSignal({
+        signals: new Map([[decl.name, decl]]),
+        sql,
+        leaseMs: 5_000,
+      });
+      const config = createMemorySignalConfigStore();
+      const observerLoop = async (): Promise<void> => {
+        while (!stop) {
+          const s = performance.now();
+          try {
+            await projectSignalsList({ manifest: null, config, bus: consoleBus });
+          } catch {
+            /* observability panel is read-only; never fail the load arm */
+          }
+          obsLats.push(performance.now() - s);
+          obsQueries++;
+        }
+      };
+      for (let i = 0; i < OBSERVER_LOOPS; i++) void observerLoop();
+    }
+
+    await Bun.sleep(ARM_S * 1000);
+    stop = true;
+    await running;
+
+    const wallS = ARM_S;
+    return {
+      pingRps: Number((c.ping / wallS).toFixed(1)),
+      durableRps: Number((c.durable / wallS).toFixed(1)),
+      storeRps: Number((c.store / wallS).toFixed(1)),
+      totalRps: Number(((c.ping + c.durable + c.store) / wallS).toFixed(1)),
+      errors: c.errors,
+      obsRps: Number((obsQueries / wallS).toFixed(2)),
+      obsP50Ms: Number(percentile(obsLats, 50).toFixed(1)),
+      obsP99Ms: Number(percentile(obsLats, 99).toFixed(1)),
+    };
+  } finally {
+    server.kill();
+    await server.exited.catch(() => {});
+  }
+}
+
+describe.skipIf(!process.env.OKE_BENCH || !LIVE_PG)("G10 — observability contention", () => {
+  test(
+    `app alone vs app + console signals queries × ${ARM_S}s/arm — req/sec delta`,
+    async () => {
+      // Arm A: load only.
+      const a = await runArm(6677, false, null);
+      // Arm B: identical load + observability panel queries.
+      const sql = createBunSignalSql(LIVE_PG!);
+      const b = await runArm(6678, true, sql);
+      await sql.close().catch(() => {});
+
+      const deltaPct = (x: number, y: number): number =>
+        x > 0 ? Number((((y - x) / x) * 100).toFixed(1)) : -1;
+
+      const metrics: Record<string, number> = {
+        armSeconds: ARM_S,
+        armATotalRps: a.totalRps,
+        armAPingRps: a.pingRps,
+        armADurableRps: a.durableRps,
+        armAStoreRps: a.storeRps,
+        armBTotalRps: b.totalRps,
+        armBPingRps: b.pingRps,
+        armBDurableRps: b.durableRps,
+        armBStoreRps: b.storeRps,
+        totalDeltaPct: deltaPct(a.totalRps, b.totalRps),
+        pingDeltaPct: deltaPct(a.pingRps, b.pingRps),
+        durableDeltaPct: deltaPct(a.durableRps, b.durableRps),
+        storeDeltaPct: deltaPct(a.storeRps, b.storeRps),
+        consoleQueriesPerSec: b.obsRps,
+        consoleQueryP50Ms: b.obsP50Ms,
+        consoleQueryP99Ms: b.obsP99Ms,
+        errorsA: a.errors,
+        errorsB: b.errors,
+      };
+
+      const issues: string[] = [];
+      if (a.errors + b.errors > 0) issues.push(`errors: armA=${a.errors} armB=${b.errors}`);
+      if (metrics.totalDeltaPct! < -25) {
+        issues.push(
+          `observability panel costs ${Math.abs(metrics.totalDeltaPct!)}% of throughput on the shared pool`,
+        );
+      }
+
+      console.log("[G10] metrics:", JSON.stringify(metrics));
+      const path = await writeArtifact({
+        group: "G10-observability-contention",
+        hardware: HARDWARE,
+        disclaimer: DISCLAIMER,
+        command:
+          "OKE_BENCH=1 OKE_TEST_POSTGRES=1 DATABASE_URL=$DATABASE_URL OKE_TEST_REDIS_URL=$OKE_TEST_REDIS_URL bun test ./src/bench/g10-observability-contention.bench.ts --timeout 600000",
+        metrics,
+        issues,
+        fixes: [],
+        remeasured: null,
+      });
+      console.log(`[G10] artifact: ${path}`);
+
+      expect(a.errors).toBeLessThan(10);
+      expect(b.errors).toBeLessThan(10);
+      expect(b.totalRps).toBeGreaterThan(0);
+    },
+    CAL ? 120_000 : 500_000,
+  );
+});