@tscircuit/rectdiff 0.0.40 → 0.0.41

package/benchmark.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+LIMIT=""
+
+default_concurrency() {
+  getconf _NPROCESSORS_ONLN 2>/dev/null || nproc 2>/dev/null || echo 4
+}
+
+CONCURRENT="${BENCHMARK_CONCURRENCY:-$(default_concurrency)}"
+
+print_help() {
+  cat <<'EOF'
+Usage:
+  ./benchmark.sh [--concurrent N] [--limit N]
+
+Options:
+  --concurrent N  Number of Bun worker processes to run, or "auto"
+  --limit N       Run only the first N dataset scenarios
+  -h, --help      Show this help
+
+Examples:
+  ./benchmark.sh
+  ./benchmark.sh --concurrent 8
+  ./benchmark.sh --limit 25
+  ./benchmark.sh --concurrent auto --limit 50
+EOF
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    -h|--help)
+      print_help
+      exit 0
+      ;;
+    --concurrent)
+      CONCURRENT="${2:-}"
+      if [ "$CONCURRENT" = "auto" ]; then
+        CONCURRENT="$(default_concurrency)"
+      fi
+      shift 2
+      ;;
+    --limit)
+      LIMIT="${2:-}"
+      shift 2
+      ;;
+    *)
+      echo "Unknown argument: $1"
+      echo "Run ./benchmark.sh --help for usage"
+      exit 1
+      ;;
+  esac
+done
+
+CMD=(bun "scripts/benchmark/index.ts" "--concurrent" "$CONCURRENT")
+
+if [ -n "$LIMIT" ]; then
+  CMD+=("--limit" "$LIMIT")
+fi
+
+"${CMD[@]}"

package/global.d.ts

@@ -2,3 +2,10 @@ declare module "*.json" {
   const value: any
   export default value
 }
+
+declare module "@tscircuit/autorouting-dataset-01" {
+  import type { SimpleRouteJson } from "./lib/types/srj-types"
+
+  const dataset: Record<string, SimpleRouteJson>
+  export = dataset
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "type": "module",
   "main": "lib/index.ts",
   "types": "lib/index.ts",
@@ -18,6 +18,8 @@
   "devDependencies": {
     "@biomejs/biome": "^2.3.5",
     "@react-hook/resize-observer": "^2.0.2",
+    "@tscircuit/autorouting-dataset-01": "^1.0.32",
+    "@tscircuit/capacity-autorouter": "https://npm-releases.tscircuit.com/npm-tarballs/25314012755-1/tscircuit-capacity-autorouter-0.0.489.tgz",
     "@tscircuit/math-utils": "^0.0.29",
     "@tscircuit/solver-utils": "^0.0.16",
     "@types/bun": "latest",

package/scripts/benchmark/benchmark-child/constants.ts

@@ -0,0 +1,6 @@
+/**
+ * Marks the first phase after port-point pathing completes.
+ * The benchmark uses this as the stop condition for partial solver runs.
+ */
+export const NEXT_PHASE_AFTER_PORT_POINT_PATHING =
+  "uniformPortDistributionSolver"

package/scripts/benchmark/benchmark-child/createSolver.ts

@@ -0,0 +1,34 @@
+import { RectDiffPipeline } from "../../../lib/RectDiffPipeline"
+import type { WorkerTaskMessage } from "../benchmark-types"
+import { getAutorouterPipeline4ModulePath } from "./getAutorouterPipeline4ModulePath"
+import { importRuntimeModule } from "./importRuntimeModule"
+import type { Pipeline4Constructor } from "./types"
+
+/**
+ * Creates the benchmark solver with the repo-local RectDiff pipeline override.
+ * The benchmark imports Pipeline 4 from the published autorouter bundle while
+ * forcing it to instantiate this repo's RectDiff implementation by default.
+ */
+export const createSolver = async (
+  scenario: WorkerTaskMessage["task"]["scenario"],
+  RectDiffPipelineClass: typeof RectDiffPipeline = RectDiffPipeline,
+) => {
+  // Load Pipeline 4 from the installed capacity-autorouter dist bundle, then
+  // inject the RectDiff class explicitly through its runtime override hook.
+  const solverModule = await importRuntimeModule(
+    getAutorouterPipeline4ModulePath(),
+  )
+
+  // TODO: Replace this cast once capacity-autorouter exposes a typed
+  // Pipeline 4 override interface. As of this repo state, the installed
+  // Pipeline 4 constructor only exposes CapacityMeshSolverOptions and does
+  // not type the benchmark's overrides.RectDiffPipelineClass injection.
+  const AutoroutingPipelineSolver4 = (solverModule as any)
+    .AutoroutingPipelineSolver4 as Pipeline4Constructor
+
+  return new AutoroutingPipelineSolver4(scenario, {
+    overrides: {
+      RectDiffPipelineClass,
+    },
+  })
+}

package/scripts/benchmark/benchmark-child/getAutorouterPipeline4ModulePath.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolves the published capacity-autorouter dist entry for benchmarking.
+ * The benchmark relies on the bundled runtime export instead of package-
+ * internal source paths.
+ */
+export const getAutorouterPipeline4ModulePath = () =>
+  import.meta.resolve("@tscircuit/capacity-autorouter")

package/scripts/benchmark/benchmark-child/handleWorkerTaskLine.ts

@@ -0,0 +1,64 @@
+import type { WorkerResult, WorkerTaskMessage } from "../benchmark-types"
+import { NEXT_PHASE_AFTER_PORT_POINT_PATHING } from "./constants"
+import { createSolver } from "./createSolver"
+import { writeWorkerResultMessage } from "./writeWorkerResultMessage"
+
+/**
+ * Handles one benchmark request line from the parent process.
+ * Each line must contain a single JSON-encoded worker task message.
+ */
+export const handleWorkerTaskLine = async (line: string) => {
+  if (!line.trim()) {
+    return
+  }
+
+  let message: WorkerTaskMessage
+  try {
+    message = JSON.parse(line) as WorkerTaskMessage
+  } catch (error) {
+    const result: WorkerResult = {
+      scenarioName: "unknown",
+      elapsedTimeMs: 0,
+      didSolve: false,
+      didTimeout: false,
+      error: `Invalid worker message: ${String(error)}`,
+    }
+    writeWorkerResultMessage(result)
+    return
+  }
+
+  const startedAt = performance.now()
+
+  try {
+    const solver = await createSolver(message.task.scenario)
+
+    while (
+      !solver.failed &&
+      solver.getCurrentPhase() !== NEXT_PHASE_AFTER_PORT_POINT_PATHING
+    ) {
+      solver.step()
+    }
+
+    const result: WorkerResult = {
+      scenarioName: message.task.scenarioName,
+      elapsedTimeMs: Math.max(0, Math.round(performance.now() - startedAt)),
+      didSolve:
+        !solver.failed &&
+        solver.getCurrentPhase() === NEXT_PHASE_AFTER_PORT_POINT_PATHING &&
+        solver.portPointPathingSolver !== undefined,
+      didTimeout: false,
+      error: solver.failed ? solver.error : null,
+    }
+
+    writeWorkerResultMessage(result)
+  } catch (error) {
+    const result: WorkerResult = {
+      scenarioName: message.task.scenarioName,
+      elapsedTimeMs: Math.max(0, Math.round(performance.now() - startedAt)),
+      didSolve: false,
+      didTimeout: false,
+      error: String(error),
+    }
+    writeWorkerResultMessage(result)
+  }
+}

package/scripts/benchmark/benchmark-child/importRuntimeModule.ts

@@ -0,0 +1,8 @@
+/**
+ * Imports a runtime-resolved module path.
+ * This keeps the benchmark loader on a runtime-only import path.
+ */
+export const importRuntimeModule = (modulePath: string) =>
+  new Function("modulePath", "return import(modulePath)")(
+    modulePath,
+  ) as Promise<unknown>

package/scripts/benchmark/benchmark-child/types.ts

@@ -0,0 +1,20 @@
+/**
+ * Describes the subset of solver state the benchmark worker needs.
+ * This keeps the child process decoupled from internal package typings.
+ */
+export type BenchmarkWorkerSolver = {
+  failed: boolean
+  error: string | null
+  portPointPathingSolver?: unknown
+  getCurrentPhase(): string
+  step(): void
+}
+
+/**
+ * Represents the Pipeline 4 constructor shape used by the benchmark.
+ * It allows the worker to inject the local RectDiff override.
+ */
+export type Pipeline4Constructor = new (
+  srj: unknown,
+  opts?: Record<string, unknown>,
+) => BenchmarkWorkerSolver

package/scripts/benchmark/benchmark-child/writeWorkerResultMessage.ts

@@ -0,0 +1,10 @@
+import type { WorkerResult, WorkerResultMessage } from "../benchmark-types"
+
+/**
+ * Writes a worker result message as a single JSON line.
+ * The parent benchmark process reads these messages over stdout.
+ */
+export const writeWorkerResultMessage = (result: WorkerResult) => {
+  const response: WorkerResultMessage = { result }
+  process.stdout.write(`${JSON.stringify(response)}\n`)
+}

package/scripts/benchmark/benchmark-types.ts

@@ -0,0 +1,34 @@
+import type { SimpleRouteJson } from "../../lib/types/srj-types"
+
+/**
+ * Defines one benchmark scenario loaded from the dataset package.
+ */
+export type BenchmarkTask = {
+  scenarioName: string
+  scenario: SimpleRouteJson
+}
+
+/**
+ * Wraps a benchmark task for line-delimited worker communication.
+ */
+export type WorkerTaskMessage = {
+  task: BenchmarkTask
+}
+
+/**
+ * Captures the outcome of a single benchmark worker run.
+ */
+export type WorkerResult = {
+  scenarioName: string
+  elapsedTimeMs: number
+  didSolve: boolean
+  didTimeout: boolean
+  error: string | null
+}
+
+/**
+ * Wraps a worker result for line-delimited stdout transport.
+ */
+export type WorkerResultMessage = {
+  result: WorkerResult
+}

package/scripts/benchmark/benchmark.child.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env bun
+
+import * as readline from "node:readline"
+import { handleWorkerTaskLine } from "./benchmark-child/handleWorkerTaskLine"
+
+const reader = readline.createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity,
+})
+
+reader.on("line", handleWorkerTaskLine)

package/scripts/benchmark/index.ts

@@ -0,0 +1,413 @@
+#!/usr/bin/env bun
+
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process"
+import * as os from "node:os"
+import * as path from "node:path"
+import * as readline from "node:readline"
+import * as dataset from "@tscircuit/autorouting-dataset-01"
+import type { SimpleRouteJson } from "../../lib/types/srj-types"
+import type {
+  BenchmarkTask,
+  WorkerResult,
+  WorkerResultMessage,
+  WorkerTaskMessage,
+} from "./benchmark-types"
+
+type BenchmarkOptions = {
+  concurrency: number
+  limit?: number
+}
+
+type WorkerSlot = {
+  id: number
+  child: ChildProcessWithoutNullStreams
+  stdoutReader: readline.Interface
+  stderrReader: readline.Interface
+}
+
+type WorkerExecutionResult = {
+  result: WorkerResult
+  restartWorker: boolean
+}
+
+const SAMPLE_TIMEOUT_MS = 120_000
+
+const formatDuration = (timeMs: number | null) => {
+  if (timeMs === null) {
+    return "n/a"
+  }
+  if (timeMs < 1000) {
+    return `${timeMs}ms`
+  }
+  return `${(timeMs / 1000).toFixed(1)}s`
+}
+
+const getPercentileMs = (
+  values: number[],
+  percentile: number,
+): number | null => {
+  if (values.length === 0) {
+    return null
+  }
+
+  const sorted = [...values].sort((a, b) => a - b)
+  const index = (sorted.length - 1) * percentile
+  const lower = Math.floor(index)
+  const upper = Math.ceil(index)
+
+  if (lower === upper) {
+    return sorted[lower] ?? null
+  }
+
+  const weight = index - lower
+  const lowerValue = sorted[lower]
+  const upperValue = sorted[upper]
+  if (lowerValue === undefined || upperValue === undefined) {
+    return null
+  }
+  return lowerValue + (upperValue - lowerValue) * weight
+}
+
+const parseArgs = (): BenchmarkOptions => {
+  const args = process.argv.slice(2)
+  const defaultConcurrency =
+    typeof os.availableParallelism === "function"
+      ? os.availableParallelism()
+      : os.cpus().length
+
+  const options: BenchmarkOptions = {
+    concurrency: defaultConcurrency,
+  }
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (arg === "--concurrent") {
+      options.concurrency = Number.parseInt(args[i + 1] ?? "", 10)
+      i += 1
+      continue
+    }
+    if (arg === "--limit") {
+      options.limit = Number.parseInt(args[i + 1] ?? "", 10)
+      i += 1
+      continue
+    }
+    throw new Error(`Unknown argument: ${arg}`)
+  }
+
+  if (!Number.isFinite(options.concurrency) || options.concurrency < 1) {
+    throw new Error("--concurrent must be a positive integer")
+  }
+
+  if (
+    options.limit !== undefined &&
+    (!Number.isFinite(options.limit) || options.limit < 1)
+  ) {
+    throw new Error("--limit must be a positive integer")
+  }
+
+  return options
+}
+
+const loadScenarios = (limit?: number): BenchmarkTask[] => {
+  const scenarios = Object.entries(dataset)
+    .map(([scenarioName, scenario]) => ({
+      scenarioName,
+      scenario: scenario as SimpleRouteJson,
+    }))
+    .sort((a, b) => a.scenarioName.localeCompare(b.scenarioName))
+
+  if (limit === undefined) {
+    return scenarios
+  }
+
+  return scenarios.slice(0, limit)
+}
+
+const createChildProcess = () =>
+  spawn(
+    process.execPath,
+    [path.join("scripts", "benchmark", "benchmark.child.ts")],
+    {
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env,
+    },
+  )
+
+const createWorkerSlot = (id: number): WorkerSlot => {
+  const child = createChildProcess()
+  child.stdout.setEncoding("utf8")
+  child.stderr.setEncoding("utf8")
+
+  return {
+    id,
+    child,
+    stdoutReader: readline.createInterface({
+      input: child.stdout,
+      crlfDelay: Infinity,
+    }),
+    stderrReader: readline.createInterface({
+      input: child.stderr,
+      crlfDelay: Infinity,
+    }),
+  }
+}
+
+const terminateWorker = async (slot: WorkerSlot) => {
+  if (slot.child.killed || slot.child.exitCode !== null) {
+    slot.stdoutReader.close()
+    slot.stderrReader.close()
+    return
+  }
+
+  await new Promise<void>((resolve) => {
+    const finish = () => {
+      slot.stdoutReader.close()
+      slot.stderrReader.close()
+      resolve()
+    }
+
+    slot.child.once("close", finish)
+    try {
+      slot.child.kill("SIGKILL")
+    } catch {
+      finish()
+    }
+  })
+}
+
+const replaceWorker = async (slot: WorkerSlot) => {
+  const previousWorker: WorkerSlot = {
+    id: slot.id,
+    child: slot.child,
+    stdoutReader: slot.stdoutReader,
+    stderrReader: slot.stderrReader,
+  }
+
+  const nextWorker = createWorkerSlot(slot.id)
+  slot.child = nextWorker.child
+  slot.stdoutReader = nextWorker.stdoutReader
+  slot.stderrReader = nextWorker.stderrReader
+  await terminateWorker(previousWorker)
+}
+
+const executeTaskOnWorker = (
+  slot: WorkerSlot,
+  request: WorkerTaskMessage,
+): Promise<WorkerExecutionResult> =>
+  new Promise((resolve) => {
+    const startedAt = performance.now()
+    let settled = false
+    let stderrOutput = ""
+
+    const finish = (result: WorkerResult, restartWorker: boolean) => {
+      if (settled) {
+        return
+      }
+      settled = true
+      clearTimeout(timeout)
+      slot.stdoutReader.removeListener("line", onLine)
+      slot.stderrReader.removeListener("line", onStderrLine)
+      slot.child.removeListener("error", onError)
+      slot.child.removeListener("exit", onExit)
+      resolve({ result, restartWorker })
+    }
+
+    const fail = (
+      error: string,
+      didTimeout: boolean,
+      restartWorker: boolean,
+    ) => {
+      finish(
+        {
+          scenarioName: request.task.scenarioName,
+          elapsedTimeMs: Math.max(0, Math.round(performance.now() - startedAt)),
+          didSolve: false,
+          didTimeout,
+          error,
+        },
+        restartWorker,
+      )
+    }
+
+    const onLine = (line: string) => {
+      let message: WorkerResultMessage
+      try {
+        message = JSON.parse(line) as WorkerResultMessage
+      } catch (error) {
+        fail(`Failed to parse worker output: ${String(error)}`, false, true)
+        return
+      }
+
+      finish(message.result, false)
+    }
+
+    const onStderrLine = (line: string) => {
+      stderrOutput = stderrOutput ? `${stderrOutput}\n${line}` : line
+    }
+
+    const onError = (error: Error) => {
+      fail(`Worker error: ${error.message}`, false, true)
+    }
+
+    const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
+      fail(
+        stderrOutput ||
+          `Worker exited before responding (code=${code}, signal=${signal})`,
+        false,
+        true,
+      )
+    }
+
+    const timeout = setTimeout(() => {
+      fail(`Timed out after ${formatDuration(SAMPLE_TIMEOUT_MS)}`, true, true)
+    }, SAMPLE_TIMEOUT_MS)
+
+    slot.stdoutReader.on("line", onLine)
+    slot.stderrReader.on("line", onStderrLine)
+    slot.child.once("error", onError)
+    slot.child.once("exit", onExit)
+    slot.child.stdin.write(`${JSON.stringify(request)}\n`)
+  })
+
+const formatTable = (
+  scenarioCount: number,
+  solvedCount: number,
+  failedCount: number,
+  timedOutCount: number,
+  avgTimeMs: number,
+  p50TimeMs: number | null,
+  p95TimeMs: number | null,
+  totalTimeMs: number,
+) => {
+  const headers = [
+    "Solver",
+    "Scenarios",
+    "Solved",
+    "Failed",
+    "Timed Out",
+    "Success %",
+    "Avg Time",
+    "P50 Time",
+    "P95 Time",
+    "Total Time",
+  ]
+
+  const rows = [
+    [
+      "Pipeline4->PortPointPathing",
+      String(scenarioCount),
+      String(solvedCount),
+      String(failedCount),
+      String(timedOutCount),
+      `${((solvedCount / scenarioCount) * 100).toFixed(1)}%`,
+      formatDuration(avgTimeMs),
+      formatDuration(p50TimeMs),
+      formatDuration(p95TimeMs),
+      formatDuration(totalTimeMs),
+    ],
+  ]
+
+  const widths = headers.map((header, columnIndex) =>
+    Math.max(
+      header.length,
+      ...rows.map((row) => row[columnIndex]?.length ?? 0),
+    ),
+  )
+  const paddedWidths = widths.map((width) => width ?? 0)
+
+  const separator = `+${paddedWidths.map((width) => "-".repeat(width + 2)).join("+")}+`
+  const headerLine = `| ${headers.map((header, index) => header.padEnd(paddedWidths[index] ?? header.length)).join(" | ")} |`
+  const bodyLines = rows.map(
+    (row) =>
+      `| ${row.map((cell, index) => cell.padEnd(paddedWidths[index] ?? cell.length)).join(" | ")} |`,
+  )
+
+  return [separator, headerLine, separator, ...bodyLines, separator].join("\n")
+}
+
+const main = async () => {
+  const options = parseArgs()
+  const tasks = loadScenarios(options.limit)
+
+  console.log(
+    `Running ${tasks.length} dataset scenarios with concurrency ${options.concurrency}`,
+  )
+
+  const startedAt = performance.now()
+  const results: WorkerResult[] = []
+  const workers = Array.from(
+    { length: Math.min(options.concurrency, tasks.length) },
+    (_, index) => createWorkerSlot(index + 1),
+  )
+
+  let nextTaskIndex = 0
+
+  const runWorkerLoop = async (slot: WorkerSlot) => {
+    while (nextTaskIndex < tasks.length) {
+      const task = tasks[nextTaskIndex]
+      if (!task) {
+        break
+      }
+      nextTaskIndex += 1
+
+      const execution = await executeTaskOnWorker(slot, { task })
+      results.push(execution.result)
+
+      const progressLabel = `[${results.length}/${tasks.length}]`
+      const status = execution.result.didSolve
+        ? "solved"
+        : execution.result.didTimeout
+          ? "timed out"
+          : "failed"
+      console.log(
+        `${progressLabel} ${execution.result.scenarioName} ${status} in ${formatDuration(execution.result.elapsedTimeMs)}`,
+      )
+
+      if (execution.restartWorker) {
+        await replaceWorker(slot)
+      }
+    }
+  }
+
+  await Promise.all(workers.map((slot) => runWorkerLoop(slot)))
+  await Promise.all(workers.map((slot) => terminateWorker(slot)))
+
+  const totalTimeMs = Math.max(0, Math.round(performance.now() - startedAt))
+  const solvedCount = results.filter((result) => result.didSolve).length
+  const failedCount = results.length - solvedCount
+  const timedOutCount = results.filter((result) => result.didTimeout).length
+  const elapsedTimes = results.map((result) => result.elapsedTimeMs)
+  const avgTimeMs =
+    elapsedTimes.reduce((sum, value) => sum + value, 0) / elapsedTimes.length
+
+  console.log("")
+  console.log(
+    formatTable(
+      results.length,
+      solvedCount,
+      failedCount,
+      timedOutCount,
+      Math.round(avgTimeMs),
+      getPercentileMs(elapsedTimes, 0.5),
+      getPercentileMs(elapsedTimes, 0.95),
+      totalTimeMs,
+    ),
+  )
+
+  const failures = results.filter((result) => !result.didSolve)
+  if (failures.length > 0) {
+    console.log("")
+    console.log("Failed scenarios:")
+    for (const failure of failures.slice(0, 20)) {
+      console.log(
+        `- ${failure.scenarioName}: ${failure.error ?? (failure.didTimeout ? "Timed out" : "Unknown failure")}`,
+      )
+    }
+    if (failures.length > 20) {
+      console.log(`- ... and ${failures.length - 20} more`)
+    }
+  }
+}
+
+await main()

package/tests/benchmark-rectdiff-override.test.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test"
+import { RectDiffPipeline } from "../lib/RectDiffPipeline"
+import { createSolver } from "../scripts/benchmark/benchmark-child/createSolver"
+import type { SimpleRouteJson } from "../lib/types/srj-types"
+
+const SENTINEL_ERROR = "FAKE_RECTDIFF_PIPELINE_USED"
+
+class FakeRectDiffPipeline extends RectDiffPipeline {
+  constructor(...args: ConstructorParameters<typeof RectDiffPipeline>) {
+    super(...args)
+    throw new Error(SENTINEL_ERROR)
+  }
+}
+
+test("benchmark createSolver uses an injected fake RectDiff override", async () => {
+  const simpleRouteJson: SimpleRouteJson = {
+    bounds: {
+      minX: 0,
+      maxX: 10,
+      minY: 0,
+      maxY: 10,
+    },
+    obstacles: [],
+    connections: [],
+    layerCount: 2,
+    minTraceWidth: 0.15,
+  }
+
+  const solver = await createSolver(simpleRouteJson, FakeRectDiffPipeline)
+
+  while (!solver.failed && solver.getCurrentPhase() !== "nodeSolver") {
+    solver.step()
+  }
+
+  expect(solver.getCurrentPhase()).toBe("nodeSolver")
+  expect(solver.failed).toBe(false)
+
+  expect(() => solver.step()).toThrow(SENTINEL_ERROR)
+  expect(solver.failed).toBe(true)
+  expect(solver.error).toContain(SENTINEL_ERROR)
+}, 60_000)

package/tests/benchmark-results.test.ts

@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test"
+
+test("benchmark prints result output for one scenario", async () => {
+  const benchmarkProcess = Bun.spawn({
+    cmd: [
+      process.execPath,
+      "scripts/benchmark/index.ts",
+      "--limit",
+      "1",
+      "--concurrent",
+      "1",
+    ],
+    cwd: process.cwd(),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  })
+
+  const [exitCode, stdout, stderr] = await Promise.all([
+    benchmarkProcess.exited,
+    new Response(benchmarkProcess.stdout).text(),
+    new Response(benchmarkProcess.stderr).text(),
+  ])
+
+  expect(stderr).toBe("")
+  expect(exitCode).toBe(0)
+  expect(stdout).toContain("Running 1 dataset scenarios with concurrency 1")
+  expect(stdout).toContain("[1/1]")
+  expect(stdout).toContain("Pipeline4->PortPointPathing")
+}, 180_000)