@tscircuit/autorouting-dataset-01 1.0.24 → 1.0.25

package/dist/cli/index.js

@@ -0,0 +1,1255 @@
+#!/usr/bin/env bun
+
+// lib/cli/main.ts
+import { Command } from "commander";
+
+// lib/cli/run/register.ts
+import { access, mkdir, writeFile } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import kleur from "kleur";
+
+// lib/cli/loadUserAutorouter.ts
+import { pathToFileURL } from "url";
+var loadUserAutorouter = async (autorouterPath, requestedSolverName) => {
+  let exports;
+  try {
+    const fileUrl = pathToFileURL(autorouterPath).href;
+    const module = await import(fileUrl);
+    exports = module;
+  } catch (error) {
+    throw new Error(
+      `Failed to import autorouter from "${autorouterPath}": ${error.message}`
+    );
+  }
+  let displayNameMap = null;
+  for (const [, exportValue] of Object.entries(exports)) {
+    if (exportValue instanceof Map) {
+      const firstEntry = exportValue.entries().next().value;
+      if (firstEntry && typeof firstEntry[0] === "function" && typeof firstEntry[1] === "string") {
+        displayNameMap = exportValue;
+        break;
+      }
+    }
+  }
+  const getDisplayName = (solver, fallback) => {
+    if (displayNameMap) {
+      const name = displayNameMap.get(solver);
+      if (name) return name;
+    }
+    return fallback;
+  };
+  const pipelineExports = [];
+  for (const [exportName, exportValue] of Object.entries(exports)) {
+    if (typeof exportValue === "function" && !exportName.startsWith("_")) {
+      const displayName = getDisplayName(exportValue, exportName);
+      pipelineExports.push({ name: displayName, value: exportValue });
+    } else if (Array.isArray(exportValue)) {
+      for (const item of exportValue) {
+        if (typeof item === "function") {
+          const displayName = getDisplayName(item, item.name || "unknown");
+          pipelineExports.push({ name: displayName, value: item });
+        }
+      }
+    }
+  }
+  if (exports.default) {
+    const defaultExport = exports.default;
+    if (typeof defaultExport === "function") {
+      const fn = defaultExport;
+      const displayName = getDisplayName(defaultExport, fn.name || "default");
+      pipelineExports.push({ name: displayName, value: defaultExport });
+    } else if (Array.isArray(defaultExport)) {
+      for (const item of defaultExport) {
+        if (typeof item === "function") {
+          const fn = item;
+          const displayName = getDisplayName(item, fn.name || "unknown");
+          pipelineExports.push({ name: displayName, value: item });
+        }
+      }
+    }
+  }
+  if (requestedSolverName) {
+    const requestedExport = pipelineExports.find(
+      (e) => e.name === requestedSolverName
+    );
+    if (!requestedExport) {
+      const availableNames = pipelineExports.map((e) => e.name).filter((n) => n !== "default");
+      throw new Error(
+        `Solver "${requestedSolverName}" not found in "${autorouterPath}". Available solvers: ${availableNames.join(", ") || "(none)"}`
+      );
+    }
+    return {
+      solverConstructor: requestedExport.value,
+      solverName: requestedSolverName
+    };
+  }
+  if (pipelineExports.length === 0) {
+    throw new Error(
+      `No autorouter found in "${autorouterPath}". Expected an export containing "Pipeline" in its name (e.g., AutoroutingPipeline, MyPipeline).`
+    );
+  }
+  if (pipelineExports.length > 1) {
+    console.log(
+      `Found ${pipelineExports.length} potential solvers: ${pipelineExports.map((e) => e.name).join(", ")}`
+    );
+    console.log(
+      `Using "${pipelineExports[0].name}". To use a different one, specify it as the second argument.`
+    );
+  }
+  const preferredExport = pipelineExports.find((e) => e.name.toLowerCase().includes("pipeline")) ?? pipelineExports[0];
+  const solverConstructor = preferredExport.value;
+  if (typeof solverConstructor !== "function") {
+    throw new Error(
+      `Export "${preferredExport.name}" is not a class or function. Expected a solver constructor.`
+    );
+  }
+  return {
+    solverConstructor,
+    solverName: preferredExport.name
+  };
+};
+
+// scripts/run-benchmark/buildBenchmarkDetailsJson.ts
+import path from "path";
+var buildBenchmarkDetailsJson = (inputs) => {
+  const { scenarioResultList, scenarioList } = inputs;
+  const detailsByScenarioPath = {};
+  const simpleRouteJsonByScenarioPath = new Map(
+    scenarioList.map((scenario) => [
+      path.basename(scenario.simpleRouteJsonPath),
+      scenario.simpleRouteJson
+    ])
+  );
+  for (const scenarioResult of scenarioResultList) {
+    const scenarioFileName = path.basename(scenarioResult.simpleRouteJsonPath);
+    const simpleRouteJson = simpleRouteJsonByScenarioPath.get(scenarioFileName);
+    if (!simpleRouteJson) {
+      continue;
+    }
+    detailsByScenarioPath[scenarioFileName] = {
+      simpleRouteJson,
+      solverResults: scenarioResult.solverResultBySolverName,
+      circuitPreviewSvg: scenarioResult.circuitPreviewSvg
+    };
+  }
+  return detailsByScenarioPath;
+};
+
+// scripts/run-benchmark/formatTimeSeconds.ts
+var formatTimeSeconds = (timeMs) => {
+  if (timeMs === null) {
+    return "n/a";
+  }
+  return `${(timeMs / 1e3).toFixed(1)}s`;
+};
+
+// scripts/run-benchmark/buildBenchmarkTableRows.ts
+var buildBenchmarkTableRows = (inputs) => {
+  const { resultRowList } = inputs;
+  const tableHeaderList = [
+    "Solver",
+    "Completed %",
+    "Relaxed DRC Pass %",
+    "P50 Time",
+    "P95 Time"
+  ];
+  const tableRowList = resultRowList.map((result) => [
+    result.solverName,
+    `${result.successRatePercent.toFixed(1)}%`,
+    result.relaxedDrcRatePercent === null ? "n/a" : `${result.relaxedDrcRatePercent.toFixed(1)}%`,
+    formatTimeSeconds(result.p50TimeMs),
+    formatTimeSeconds(result.p95TimeMs)
+  ]);
+  return { tableHeaderList, tableRowList };
+};
+
+// scripts/run-benchmark/buildBenchmarkSummaryJson.ts
+var buildBenchmarkSummaryJson = (inputs) => {
+  const { resultRowList, scenarioList } = inputs;
+  const { tableHeaderList, tableRowList } = buildBenchmarkTableRows({
+    resultRowList
+  });
+  return {
+    tableHeaderList,
+    tableRowList,
+    scenarioCount: scenarioList.length
+  };
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateChartConfig.ts
+var generateChartConfig = () => {
+  return `const chart_config = {
+        responsive: true,
+        maintainAspectRatio: true,
+        plugins: {
+            legend: {
+                labels: { color: '#1f2937' }
+            }
+        },
+        scales: {
+            y: {
+                ticks: { color: '#4b5563' },
+                grid: { color: '#e5e7eb' }
+            },
+            x: {
+                ticks: { color: '#4b5563' },
+                grid: { color: '#e5e7eb' }
+            }
+        }
+    };`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateSuccessRateChart.ts
+var generateSuccessRateChart = () => {
+  return `new Chart(document.getElementById('successRateChart'), {
+        type: 'bar',
+        data: {
+            labels: benchmark_data.map(row => row.solverName),
+            datasets: [{
+                label: 'Success Rate (%)',
+                data: benchmark_data.map(row => row.successRatePercent),
+                backgroundColor: 'rgba(59, 130, 246, 0.6)',
+                borderColor: 'rgba(59, 130, 246, 1)',
+                borderWidth: 1
+            }]
+        },
+        options: {
+            ...chart_config,
+            scales: {
+                ...chart_config.scales,
+                y: {
+                    ...chart_config.scales.y,
+                    beginAtZero: true,
+                    max: 100
+                }
+            }
+        }
+    });`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateTimeChart.ts
+var generateTimeChart = () => {
+  return `new Chart(document.getElementById('timeChart'), {
+        type: 'bar',
+        data: {
+            labels: benchmark_data.map(row => row.solverName),
+            datasets: [
+                {
+                    label: 'P50 Time (ms)',
+                    data: benchmark_data.map(row => row.p50TimeMs || 0),
+                    backgroundColor: 'rgba(34, 197, 94, 0.6)',
+                    borderColor: 'rgba(34, 197, 94, 1)',
+                    borderWidth: 1
+                },
+                {
+                    label: 'P95 Time (ms)',
+                    data: benchmark_data.map(row => row.p95TimeMs || 0),
+                    backgroundColor: 'rgba(234, 179, 8, 0.6)',
+                    borderColor: 'rgba(234, 179, 8, 1)',
+                    borderWidth: 1
+                }
+            ]
+        },
+        options: chart_config
+    });`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateChartScripts.ts
+var generateChartScripts = (result_row_list) => {
+  return `<script>
+    const benchmark_data = ${JSON.stringify(result_row_list)};
+    ${generateChartConfig()}
+    ${generateSuccessRateChart()}
+    ${generateTimeChart()}
+</script>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateClientDebuggerScript.ts
+var escapeJsonForHtml = (json) => json.replace(/</g, "\\u003c");
+var generateClientDebuggerScript = (detail_json) => {
+  const detail_json_text = escapeJsonForHtml(JSON.stringify(detail_json));
+  const svgsonShim = encodeURIComponent(
+    [
+      "import * as m from 'https://esm.sh/svgson@5.2.1?target=es2022';",
+      "const stringify = m.stringify ?? m.stringifySync ?? (m.default && (m.default.stringify || m.default.stringifySync));",
+      "export { stringify };",
+      "export * from 'https://esm.sh/svgson@5.2.1?target=es2022';"
+    ].join("")
+  );
+  return `<script>
+    window.__benchmark_details = ${detail_json_text};
+</script>
+<script type="importmap">
+  {
+    "imports": {
+      "react": "https://esm.sh/react@18",
+      "react/jsx-runtime": "https://esm.sh/react@18/jsx-runtime",
+      "react/jsx-dev-runtime": "https://esm.sh/react@18/jsx-dev-runtime",
+      "react-dom": "https://esm.sh/react-dom@18",
+      "react-dom/client": "https://esm.sh/react-dom@18/client",
+      "scheduler": "https://esm.sh/scheduler@0.23.0",
+      "svgson": "data:text/javascript,${svgsonShim}"
+    }
+  }
+</script>
+<script type="module">
+    import React, { useMemo } from "react";
+    import { createRoot } from "react-dom/client";
+    import { GenericSolverDebugger } from "https://esm.sh/@tscircuit/solver-utils@latest/react?external=react,react-dom,svgson";
+    import {
+      AutoroutingPipeline1_OriginalUnravel,
+      AutoroutingPipelineSolver as AutoroutingPipelineSolver2_PortPointPathing
+    } from "https://esm.sh/@tscircuit/capacity-autorouter@latest";
+
+    const solverConstructors = {
+      AutoroutingPipelineSolver2_PortPointPathing,
+      AutoroutingPipeline1_OriginalUnravel
+    };
+
+    const modal = document.getElementById("solver-debugger-modal");
+    const modalTitle = document.getElementById("solver-debugger-title");
+    const rootEl = document.getElementById("solver-debugger-root");
+    const closeBtn = document.getElementById("solver-debugger-close");
+    let root = null;
+
+    const closeModal = () => {
+      if (!modal) return;
+      modal.classList.add("hidden");
+      if (root) {
+        root.unmount();
+        root = null;
+      }
+      if (rootEl) {
+        rootEl.innerHTML = "";
+      }
+    };
+
+    if (closeBtn) {
+      closeBtn.addEventListener("click", closeModal);
+    }
+
+    if (modal) {
+      modal.addEventListener("click", (event) => {
+        if (event.target === modal) {
+          closeModal();
+        }
+      });
+    }
+
+    const DebuggerApp = ({ scenarioKey, solverName }) => {
+      const detail = window.__benchmark_details?.[scenarioKey];
+      const solverCtor = solverConstructors[solverName];
+      const solver = useMemo(() => {
+        if (!detail || !solverCtor) return null;
+        return new solverCtor(detail.simpleRouteJson);
+      }, [scenarioKey, solverName]);
+
+      if (!detail) {
+        return React.createElement(
+          "div",
+          { className: "p-4 text-sm text-red-700" },
+          "Scenario data not found."
+        );
+      }
+
+      if (!solverCtor) {
+        return React.createElement(
+          "div",
+          { className: "p-4 text-sm text-red-700" },
+          "Solver not available in this build."
+        );
+      }
+
+      return React.createElement(GenericSolverDebugger, { solver });
+    };
+
+    const openDebugger = (scenarioKey, solverName) => {
+      if (!modal || !rootEl) return;
+      if (modalTitle) {
+        modalTitle.textContent = \`\${scenarioKey} \u2022 \${solverName}\`;
+      }
+      modal.classList.remove("hidden");
+      if (!root) {
+        root = createRoot(rootEl);
+      }
+      root.render(
+        React.createElement(DebuggerApp, {
+          scenarioKey,
+          solverName,
+          key: scenarioKey + "::" + solverName,
+        })
+      );
+    };
+
+    document.querySelectorAll(".js-open-debugger").forEach((button) => {
+      button.addEventListener("click", () => {
+        const scenarioKey = button.getAttribute("data-scenario");
+        const solverName = button.getAttribute("data-solver");
+        if (scenarioKey && solverName) {
+          openDebugger(scenarioKey, solverName);
+        }
+      });
+    });
+</script>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateHeader.ts
+var generateHeader = (summary_json) => {
+  return `<header class="mb-8">
+    <h1 class="text-4xl font-bold text-blue-600 mb-2">Autorouting Benchmark Results</h1>
+    <p class="text-gray-600">Total Scenarios: ${summary_json.scenarioCount}</p>
+</header>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generatePerformanceOverview.ts
+var generatePerformanceOverview = () => {
+  return `<section class="mb-8">
+    <h2 class="text-2xl font-semibold text-blue-700 mb-4">Performance Overview</h2>
+    <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
+        <benchmark-card title="Success Rate by Solver">
+            <canvas id="successRateChart"></canvas>
+        </benchmark-card>
+        <benchmark-card title="Average Execution Time">
+            <canvas id="timeChart"></canvas>
+        </benchmark-card>
+    </div>
+</section>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateSolverResultCard.ts
+var generateSolverResultCard = (inputs) => {
+  const { solver_name, solver_result, scenario_path } = inputs;
+  const status_badge_class = solver_result.didSolve ? "bg-emerald-100 text-emerald-700 border-emerald-200" : "bg-rose-100 text-rose-700 border-rose-200";
+  const status_text = solver_result.didSolve ? "Solved" : "Failed";
+  const status_icon = solver_result.didSolve ? `<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M5 13l4 4L19 7"/></svg>` : `<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M6 18L18 6M6 6l12 12"/></svg>`;
+  const drc_badge_class = solver_result.relaxedDrcPassed ? "bg-emerald-100 text-emerald-700 border-emerald-200" : "bg-amber-100 text-amber-700 border-amber-200";
+  const drc_text = solver_result.relaxedDrcPassed ? "Passed" : "Failed";
+  const drc_icon = solver_result.relaxedDrcPassed ? `<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M5 13l4 4L19 7"/></svg>` : `<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/></svg>`;
+  return `<div class="bg-white rounded-lg p-4 border border-slate-200 shadow-sm hover:shadow-md transition-shadow">
+    <h4 class="font-semibold text-slate-900 mb-3 text-base">${solver_name}</h4>
+    <div class="space-y-2.5 text-sm">
+        <div class="flex justify-between items-center">
+            <span class="text-slate-600 font-medium">Status</span>
+            <span class="inline-flex items-center gap-1.5 px-2 py-0.5 rounded-md border text-xs font-medium ${status_badge_class}">
+              ${status_icon}
+              <span>${status_text}</span>
+            </span>
+        </div>
+        <div class="flex justify-between items-center">
+            <span class="text-slate-600 font-medium">Time</span>
+            <span class="font-mono text-slate-900 font-semibold">${solver_result.elapsedTimeMs.toFixed(2)}<span class="text-slate-500 font-normal text-xs ml-0.5">ms</span></span>
+        </div>
+        <div class="flex justify-between items-center">
+            <span class="text-slate-600 font-medium">DRC</span>
+            <span class="inline-flex items-center gap-1.5 px-2 py-0.5 rounded-md border text-xs font-medium ${drc_badge_class}">
+              ${drc_icon}
+              <span>${drc_text}</span>
+            </span>
+        </div>
+    </div>
+    <button
+        type="button"
+        class="js-open-debugger mt-4 w-full inline-flex items-center justify-center gap-2 rounded-md border border-slate-300 bg-white px-3 py-2 text-xs font-medium text-slate-700 transition hover:bg-slate-50 hover:border-slate-400 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-1"
+        data-scenario="${scenario_path}"
+        data-solver="${solver_name}"
+    >
+        <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 20l4-16m4 4l4 4-4 4M6 16l-4-4 4-4"/></svg>
+        <span>Open Debugger</span>
+    </button>
+</div>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateScenarioCard.ts
+var generateScenarioCard = (inputs) => {
+  const { scenario_path, solver_results, circuit_preview_svg } = inputs;
+  const solver_preview_html = Object.entries(solver_results).map(([solver_name, solver_result]) => {
+    const badge_class = solver_result.didSolve ? "bg-emerald-100 text-emerald-700 border-emerald-200" : "bg-rose-100 text-rose-700 border-rose-200";
+    const status_text = solver_result.didSolve ? "Solved" : "Failed";
+    return `<span title="${solver_name}" class="inline-flex items-center gap-1.5 px-2.5 py-1 rounded-md border text-xs font-medium ${badge_class}">
+        <span class="font-semibold">${solver_name}</span>
+        <span class="opacity-75">${status_text}</span>
+      </span>`;
+  }).join("");
+  const solver_tag_list = Object.entries(solver_results).map(
+    ([solver_name, solver_result]) => `solver:${solver_name}:${solver_result.didSolve ? "pass" : "fail"}`
+  );
+  const solver_cards_html = Object.entries(solver_results).map(
+    ([solver_name, solver_result]) => generateSolverResultCard({
+      solver_name,
+      solver_result,
+      scenario_path
+    })
+  ).join("");
+  const circuit_preview_section = circuit_preview_svg ? `<div class="px-6 py-4 border-t border-gray-200 bg-white">
+        <h4 class="text-sm font-semibold text-slate-800 mb-3">Circuit Preview</h4>
+        <div class="bg-slate-50 rounded-lg border border-slate-200 p-4 flex items-center justify-center overflow-auto">
+          ${circuit_preview_svg}
+        </div>
+      </div>` : "";
+  return `<details class="js-scenario-card bg-white rounded-lg border border-gray-200 shadow-sm hover:shadow-md transition-shadow" data-tags="${solver_tag_list.join(" ")}">
+    <summary class="px-6 py-4 cursor-pointer hover:bg-slate-50 transition-colors">
+        <div class="flex items-start justify-between gap-4">
+          <span class="font-mono text-sm text-slate-700 break-all pt-1">${scenario_path}</span>
+          <span class="flex flex-wrap items-center gap-2 shrink-0">${solver_preview_html}</span>
+        </div>
+    </summary>
+    ${circuit_preview_section}
+    <div class="px-6 py-4 border-t border-gray-200 bg-slate-50">
+        <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+            ${solver_cards_html}
+        </div>
+    </div>
+</details>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateScenarioDetails.ts
+var generateScenarioDetails = (detail_json) => {
+  const solver_name_list = Array.from(
+    new Set(
+      Object.values(detail_json).flatMap(
+        (scenario_detail) => Object.keys(scenario_detail.solverResults)
+      )
+    )
+  );
+  const tag_filter_html = solver_name_list.map((solver_name) => {
+    const pass_tag = `solver:${solver_name}:pass`;
+    const fail_tag = `solver:${solver_name}:fail`;
+    return `<div class="inline-flex items-center gap-2 px-3 py-2 bg-white rounded-lg border border-gray-200">
+        <span class="text-sm font-medium text-slate-700">${solver_name}:</span>
+        <button type="button" class="js-scenario-tag js-pass-tag inline-flex items-center gap-1.5 rounded-md border border-blue-300 bg-blue-50 px-2.5 py-1 text-xs font-medium text-blue-700 transition hover:bg-blue-100 hover:border-blue-400 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-1" data-tag="${pass_tag}" data-label="${solver_name} solved">
+          <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M5 13l4 4L19 7"/></svg>
+          <span>Solved</span>
+        </button>
+        <button type="button" class="js-scenario-tag js-fail-tag inline-flex items-center gap-1.5 rounded-md border border-rose-300 bg-rose-50 px-2.5 py-1 text-xs font-medium text-rose-700 transition hover:bg-rose-100 hover:border-rose-400 focus:outline-none focus:ring-2 focus:ring-rose-500 focus:ring-offset-1" data-tag="${fail_tag}" data-label="${solver_name} failed">
+          <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M6 18L18 6M6 6l12 12"/></svg>
+          <span>Failed</span>
+        </button>
+      </div>`;
+  }).join("");
+  const scenarios_html = Object.entries(detail_json).map(
+    ([scenario_path, scenario_detail]) => generateScenarioCard({
+      scenario_path,
+      solver_results: scenario_detail.solverResults,
+      circuit_preview_svg: scenario_detail.circuitPreviewSvg
+    })
+  ).join("");
+  return `<section class="mb-8">
+    <h2 class="text-2xl font-bold text-slate-800 mb-4">Scenario Details</h2>
+    <div class="mb-6 rounded-xl border border-slate-200 bg-gradient-to-br from-slate-50 to-white p-5 shadow-sm">
+      <div class="flex flex-wrap items-center gap-3 mb-4">
+        <h3 class="text-sm font-semibold text-slate-900">Filter by Status</h3>
+        <button type="button" class="js-clear-scenario-tags inline-flex items-center gap-1.5 rounded-md border border-slate-300 bg-white px-3 py-1.5 text-xs font-medium text-slate-700 transition hover:bg-slate-50 hover:border-slate-400 focus:outline-none focus:ring-2 focus:ring-slate-500 focus:ring-offset-1">
+          <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/></svg>
+          <span>Clear All</span>
+        </button>
+        <div class="flex-1"></div>
+        <div class="text-xs text-slate-600">
+          <span class="font-medium">Active filters:</span> 
+          <span class="js-scenario-tag-summary font-mono text-slate-800">None</span>
+        </div>
+      </div>
+      <div class="flex flex-wrap gap-3">
+        ${tag_filter_html}
+      </div>
+      <div class="mt-4 pt-4 border-t border-slate-200">
+        <div class="flex items-start gap-2 text-xs text-slate-600">
+          <svg class="w-4 h-4 text-blue-500 mt-0.5 shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/></svg>
+          <p><span class="font-medium">Regression detection:</span> Select "Solved" for one solver and "Failed" for another to identify scenarios that regressed between versions.</p>
+        </div>
+      </div>
+    </div>
+    <div class="space-y-3">${scenarios_html}</div>
+    <script>
+      (() => {
+        const tagButtonList = Array.from(document.querySelectorAll(".js-scenario-tag"))
+        const scenarioCardList = Array.from(document.querySelectorAll(".js-scenario-card"))
+        const summaryEl = document.querySelector(".js-scenario-tag-summary")
+        const clearBtn = document.querySelector(".js-clear-scenario-tags")
+
+        const getActiveTagList = () =>
+          tagButtonList
+            .filter((button) => button.getAttribute("data-selected") === "true")
+            .map((button) => button.getAttribute("data-tag"))
+            .filter(Boolean)
+
+        const updateSummary = (active_tag_list) => {
+          if (!summaryEl) return
+          if (!active_tag_list.length) {
+            summaryEl.textContent = "None"
+            return
+          }
+          const label_list = active_tag_list
+            .map((tag) =>
+              tagButtonList.find((button) => button.getAttribute("data-tag") === tag),
+            )
+            .map((button) => button?.getAttribute("data-label"))
+            .filter(Boolean)
+          summaryEl.textContent = label_list.join(", ")
+        }
+
+        const applyFilter = () => {
+          const active_tag_list = getActiveTagList()
+          updateSummary(active_tag_list)
+          scenarioCardList.forEach((card) => {
+            const tag_list = (card.getAttribute("data-tags") ?? "")
+              .split(" ")
+              .filter(Boolean)
+            const is_match = active_tag_list.every((tag) => tag_list.includes(tag))
+            card.classList.toggle("hidden", !is_match)
+          })
+        }
+
+        tagButtonList.forEach((button) => {
+          button.addEventListener("click", () => {
+            const is_selected = button.getAttribute("data-selected") === "true"
+            const is_pass_tag = button.classList.contains("js-pass-tag")
+            
+            button.setAttribute("data-selected", is_selected ? "false" : "true")
+            
+            if (!is_selected) {
+              // When selecting, change to green
+              button.classList.add("ring-2", "ring-green-500", "ring-offset-2", "shadow-sm", "scale-105")
+              button.classList.remove("border-blue-300", "bg-blue-50", "text-blue-700", "border-rose-300", "bg-rose-50", "text-rose-700")
+              button.classList.add("border-green-500", "bg-green-100", "text-green-800")
+            } else {
+              // When deselecting, restore original color
+              button.classList.remove("ring-2", "ring-green-500", "ring-offset-2", "shadow-sm", "scale-105", "border-green-500", "bg-green-100", "text-green-800")
+              if (is_pass_tag) {
+                button.classList.add("border-blue-300", "bg-blue-50", "text-blue-700")
+              } else {
+                button.classList.add("border-rose-300", "bg-rose-50", "text-rose-700")
+              }
+            }
+            
+            applyFilter()
+          })
+        })
+
+        if (clearBtn) {
+          clearBtn.addEventListener("click", () => {
+            tagButtonList.forEach((button) => {
+              const is_pass_tag = button.classList.contains("js-pass-tag")
+              
+              button.setAttribute("data-selected", "false")
+              button.classList.remove("ring-2", "ring-green-500", "ring-offset-2", "shadow-sm", "scale-105", "border-green-500", "bg-green-100", "text-green-800")
+              
+              if (is_pass_tag) {
+                button.classList.add("border-blue-300", "bg-blue-50", "text-blue-700")
+              } else {
+                button.classList.add("border-rose-300", "bg-rose-50", "text-rose-700")
+              }
+            })
+            applyFilter()
+          })
+        }
+
+        applyFilter()
+      })()
+    </script>
+</section>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateSolverDebuggerModal.ts
+var generateSolverDebuggerModal = () => {
+  return `<div id="solver-debugger-modal" class="fixed inset-0 z-50 flex hidden items-center justify-center bg-black/50 p-4">
+    <div class="w-full max-w-6xl overflow-hidden rounded-lg border border-gray-300 bg-white shadow-2xl">
+        <div class="flex items-center justify-between border-b border-gray-300 px-4 py-3">
+            <h3 id="solver-debugger-title" class="text-sm font-semibold text-blue-800 md:text-base"></h3>
+            <button
+                id="solver-debugger-close"
+                type="button"
+                class="rounded border border-gray-400 px-3 py-1 text-sm text-gray-700 transition hover:border-gray-500 hover:text-gray-900"
+            >
+                Close
+            </button>
+        </div>
+        <div id="solver-debugger-root" class="h-[75vh] overflow-auto"></div>
+    </div>
+</div>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateSummaryTable.ts
+var generateSummaryTable = (summary_json) => {
+  const header_html = summary_json.tableHeaderList.map(
+    (header) => `<th class="px-4 py-3 text-left text-blue-700 font-semibold">${header}</th>`
+  ).join("");
+  const rows_html = summary_json.tableRowList.map(
+    (row) => `
+      <tr class="hover:bg-gray-50 transition-colors">
+          ${row.map((cell) => `<td class="px-4 py-3">${cell}</td>`).join("")}
+      </tr>
+    `
+  ).join("");
+  return `<section class="mb-8">
+    <h2 class="text-2xl font-semibold text-blue-700 mb-4">Summary Table</h2>
+    <benchmark-card>
+        <div class="overflow-x-auto">
+            <table class="w-full text-sm">
+                <thead class="bg-gray-100">
+                    <tr>${header_html}</tr>
+                </thead>
+                <tbody class="divide-y divide-gray-200">${rows_html}</tbody>
+            </table>
+        </div>
+    </benchmark-card>
+</section>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/generateWebComponents.ts
+var generateWebComponents = () => {
+  return `<script>
+    class BenchmarkCard extends HTMLElement {
+        connectedCallback() {
+            const title = this.getAttribute('title');
+            const content = this.innerHTML;
+            this.innerHTML = \`
+                <div class="bg-white rounded-lg p-6 border border-gray-300 shadow-lg">
+                    \${title ? \`<h3 class="text-lg font-semibold text-blue-800 mb-4">\${title}</h3>\` : ''}
+                    <div>\${content}</div>
+                </div>
+            \`;
+        }
+    }
+    customElements.define('benchmark-card', BenchmarkCard);
+</script>`;
+};
+
+// scripts/run-benchmark/generateHtmlVisualization/index.ts
+var generateHtmlVisualization = (inputs) => {
+  const { summary_json, detail_json, result_row_list } = inputs;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Autorouting Benchmark Results</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
+</head>
+<body class="bg-white text-gray-900 min-h-screen p-8">
+    <div class="max-w-7xl mx-auto">
+        ${generateHeader(summary_json)}
+        ${generatePerformanceOverview()}
+        ${generateSummaryTable(summary_json)}
+        ${generateScenarioDetails(detail_json)}
+    </div>
+    ${generateWebComponents()}
+    ${generateSolverDebuggerModal()}
+    ${generateChartScripts(result_row_list)}
+    ${generateClientDebuggerScript(detail_json)}
+</body>
+</html>`;
+};
+
+// scripts/run-benchmark/loadScenarioList.ts
+import { readdir, readFile } from "fs/promises";
+import path2 from "path";
+var loadScenarioList = async (inputs) => {
+  const { datasetDirectory, scenarioCountLimit } = inputs;
+  const datasetFileList = (await readdir(datasetDirectory)).filter((fileName) => fileName.endsWith(".simple-route.json")).sort();
+  const limitedFileList = scenarioCountLimit === null ? datasetFileList : datasetFileList.slice(0, scenarioCountLimit);
+  if (limitedFileList.length === 0) {
+    return [];
+  }
+  const scenarioList = [];
+  for (const fileName of limitedFileList) {
+    const scenarioName = fileName.replace(".simple-route.json", "");
+    const simpleRouteJsonPath = path2.join(datasetDirectory, fileName);
+    const simpleRouteJsonText = await readFile(simpleRouteJsonPath, "utf8");
+    const simpleRouteJson = JSON.parse(simpleRouteJsonText);
+    scenarioList.push({ scenarioName, simpleRouteJsonPath, simpleRouteJson });
+  }
+  return scenarioList;
+};
+
+// scripts/run-benchmark/outputTabled.ts
+var outputTabled = (inputs) => {
+  const { resultRowList, scenarioList } = inputs;
+  const { tableHeaderList, tableRowList } = buildBenchmarkTableRows({
+    resultRowList
+  });
+  const columnWidths = tableHeaderList.map((header, columnIndex) => {
+    let maxWidth = header.length;
+    for (const rowCells of tableRowList) {
+      const cellText = rowCells[columnIndex];
+      if (cellText.length > maxWidth) {
+        maxWidth = cellText.length;
+      }
+    }
+    return maxWidth;
+  });
+  const separator = `+${columnWidths.map((width) => "-".repeat(width + 2)).join("+")}+`;
+  const headerLine = `| ${tableHeaderList.map((header, columnIndex) => header.padEnd(columnWidths[columnIndex])).join(" | ")} |`;
+  const bodyLines = tableRowList.map(
+    (rowCells) => `| ${rowCells.map(
+      (cellText, columnIndex) => cellText.padEnd(columnWidths[columnIndex])
+    ).join(" | ")} |`
+  );
+  const tableText = [
+    separator,
+    headerLine,
+    separator,
+    ...bodyLines,
+    separator
+  ].join("\n");
+  const outputLines = [tableText, "", `Scenarios: ${scenarioList.length}`];
+  return outputLines.join("\n");
+};
+
+// scripts/run-benchmark/runBenchmark.ts
+import { getSvgFromGraphicsObject } from "graphics-debug";
+
+// lib/checks/detectUnfixableRoutingIssues.ts
+import { runAllChecks } from "@tscircuit/checks";
+var detectUnfixableRoutingIssues = async (circuitJson) => {
+  const errorList = await runAllChecks(circuitJson);
+  const traceErrorList = errorList.filter(
+    (error) => "error_type" in error && error.error_type === "pcb_trace_error"
+  );
+  return traceErrorList.length === 0;
+};
+
+// lib/converter/srj-to-circuit-json.ts
+var convertToCircuitJson = (inputs) => {
+  const { srjWithPointPairs, routes } = inputs;
+  const minTraceWidth = inputs.minTraceWidth ?? 0.1;
+  const minViaDiameter = inputs.minViaDiameter ?? 0.6;
+  const circuitJson = [];
+  const pcb_board_id = "pcb_board_0";
+  const boundsWidth = srjWithPointPairs.bounds.maxX - srjWithPointPairs.bounds.minX;
+  const boundsHeight = srjWithPointPairs.bounds.maxY - srjWithPointPairs.bounds.minY;
+  const boardCenterX = (srjWithPointPairs.bounds.minX + srjWithPointPairs.bounds.maxX) / 2;
+  const boardCenterY = (srjWithPointPairs.bounds.minY + srjWithPointPairs.bounds.maxY) / 2;
+  const boardShape = srjWithPointPairs.outline ? "polygon" : "rect";
+  const pcb_board = {
+    type: "pcb_board",
+    pcb_board_id,
+    center: { x: boardCenterX, y: boardCenterY },
+    width: boundsWidth,
+    height: boundsHeight,
+    thickness: 1.6,
+    num_layers: srjWithPointPairs.layerCount,
+    shape: boardShape,
+    outline: srjWithPointPairs.outline,
+    material: "fr4"
+  };
+  circuitJson.push(pcb_board);
+  const connectionNameByConnectionName = /* @__PURE__ */ new Map();
+  for (const connection of srjWithPointPairs.connections) {
+    const connectionFields = connection;
+    const connectionName = connectionFields.netConnectionName ?? connectionFields.rootConnectionName ?? connection.name;
+    connectionNameByConnectionName.set(connection.name, connectionName);
+  }
+  const pcbPortByPcbPortId = /* @__PURE__ */ new Map();
+  const sourceTraceBySourceTraceId = /* @__PURE__ */ new Map();
+  for (const connection of srjWithPointPairs.connections) {
+    const connectionName = connectionNameByConnectionName.get(connection.name) ?? connection.name;
+    const connectedSourcePortIdList = [];
+    for (let pointIndex = 0; pointIndex < connection.pointsToConnect.length; pointIndex += 1) {
+      const point = connection.pointsToConnect[pointIndex];
+      const pcb_port_id = point.pcb_port_id ?? `pcb_port_${connection.name}_${pointIndex}`;
+      connectedSourcePortIdList.push(pcb_port_id);
+      if (!pcbPortByPcbPortId.has(pcb_port_id)) {
+        const pointLayers = Array.isArray(
+          point.layers
+        ) ? point.layers ?? [] : point.layer ? [point.layer] : [];
+        const pcb_port = {
+          type: "pcb_port",
+          pcb_port_id,
+          source_port_id: pcb_port_id,
+          x: point.x,
+          y: point.y,
+          layers: pointLayers
+        };
+        pcbPortByPcbPortId.set(pcb_port_id, pcb_port);
+      }
+    }
+    const existingSourceTrace = sourceTraceBySourceTraceId.get(connectionName);
+    if (existingSourceTrace) {
+      existingSourceTrace.connected_source_port_ids = Array.from(
+        /* @__PURE__ */ new Set([
+          ...existingSourceTrace.connected_source_port_ids,
+          ...connectedSourcePortIdList
+        ])
+      );
+      continue;
+    }
+    sourceTraceBySourceTraceId.set(connectionName, {
+      type: "source_trace",
+      source_trace_id: connectionName,
+      connected_source_port_ids: connectedSourcePortIdList,
+      connected_source_net_ids: []
+    });
+  }
+  circuitJson.push(
+    ...Array.from(sourceTraceBySourceTraceId.values()),
+    ...Array.from(pcbPortByPcbPortId.values())
+  );
+  for (let obstacleIndex = 0; obstacleIndex < srjWithPointPairs.obstacles.length; obstacleIndex += 1) {
+    const obstacle = srjWithPointPairs.obstacles[obstacleIndex];
+    const obstacleType = obstacle.type;
+    const obstacleLayer = obstacle.layers?.[0];
+    if (!obstacleLayer) {
+      continue;
+    }
+    const connectedTo = obstacle.connectedTo ?? [];
+    if (connectedTo.length === 0) {
+      const pcb_keepout_id = `pcb_keepout_${obstacleIndex}`;
+      const pcb_keepout = obstacleType === "oval" ? {
+        type: "pcb_keepout",
+        layers: obstacle.layers,
+        shape: "circle",
+        center: { x: obstacle.center.x, y: obstacle.center.y },
+        pcb_keepout_id,
+        radius: Math.min(obstacle.width, obstacle.height) / 2
+      } : {
+        type: "pcb_keepout",
+        layers: obstacle.layers,
+        shape: "rect",
+        center: { x: obstacle.center.x, y: obstacle.center.y },
+        pcb_keepout_id,
+        width: obstacle.width,
+        height: obstacle.height
+      };
+      circuitJson.push(pcb_keepout);
+      continue;
+    }
+    const pcb_port_id = connectedTo.find((id) => id.startsWith("pcb_port_"));
+    const pcb_smtpad_hint_id = connectedTo.find(
+      (id) => id.startsWith("pcb_smtpad_")
+    );
+    if (!pcb_port_id && !pcb_smtpad_hint_id) {
+      continue;
+    }
+    const pcb_smtpad_id = pcb_smtpad_hint_id ?? `pcb_smtpad_${obstacleIndex}`;
+    const centerX = obstacle.center?.x;
+    const centerY = obstacle.center?.y;
+    if (typeof centerX !== "number" || typeof centerY !== "number") {
+      continue;
+    }
+    const pcb_smtpad = obstacleType === "oval" ? {
+      type: "pcb_smtpad",
+      shape: "circle",
+      pcb_smtpad_id,
+      x: centerX,
+      y: centerY,
+      radius: Math.min(obstacle.width, obstacle.height) / 2,
+      layer: obstacleLayer,
+      pcb_port_id
+    } : {
+      type: "pcb_smtpad",
+      shape: "rect",
+      pcb_smtpad_id,
+      x: centerX,
+      y: centerY,
+      width: obstacle.width,
+      height: obstacle.height,
+      layer: obstacleLayer,
+      pcb_port_id
+    };
+    circuitJson.push(pcb_smtpad);
+  }
+  const viaKeySet = /* @__PURE__ */ new Set();
+  const pcbViaList = [];
+  for (let traceIndex = 0; traceIndex < routes.length; traceIndex += 1) {
+    const trace = routes[traceIndex];
+    const pcbTraceId = trace.pcb_trace_id ?? `pcb_trace_${traceIndex}`;
+    for (const routePoint of trace.route) {
+      if (routePoint.route_type !== "via") {
+        continue;
+      }
+      const fromLayer = routePoint.from_layer;
+      const toLayer = routePoint.to_layer;
+      const viaKey = `${routePoint.x}_${routePoint.y}_${fromLayer}_${toLayer}`;
+      if (viaKeySet.has(viaKey)) {
+        continue;
+      }
+      viaKeySet.add(viaKey);
+      pcbViaList.push({
+        type: "pcb_via",
+        pcb_via_id: `pcb_via_${pcbViaList.length}`,
+        pcb_trace_id: pcbTraceId,
+        x: routePoint.x,
+        y: routePoint.y,
+        outer_diameter: minViaDiameter,
+        hole_diameter: minViaDiameter * 0.5,
+        layers: [fromLayer, toLayer]
+      });
+    }
+  }
+  circuitJson.push(...pcbViaList);
+  for (let traceIndex = 0; traceIndex < routes.length; traceIndex += 1) {
+    const trace = routes[traceIndex];
+    const pcbTraceId = trace.pcb_trace_id ?? `pcb_trace_${traceIndex}`;
+    const traceConnectionName = trace.connection_name ?? trace.connectionName;
+    const sourceTraceId = traceConnectionName ? connectionNameByConnectionName.get(traceConnectionName) ?? traceConnectionName : void 0;
+    const route = trace.route.map((routePoint) => {
+      if (routePoint.route_type === "wire") {
+        return {
+          route_type: "wire",
+          x: routePoint.x,
+          y: routePoint.y,
+          width: routePoint.width ?? minTraceWidth,
+          layer: routePoint.layer,
+          start_pcb_port_id: routePoint.start_pcb_port_id,
+          end_pcb_port_id: routePoint.end_pcb_port_id
+        };
+      }
+      if (routePoint.route_type === "via") {
+        return {
+          route_type: "via",
+          x: routePoint.x,
+          y: routePoint.y,
+          to_layer: routePoint.to_layer,
+          from_layer: routePoint.from_layer
+        };
+      }
+      return null;
+    }).filter(
+      (routePoint) => routePoint !== null
+    );
+    const pcb_trace = {
+      type: "pcb_trace",
+      pcb_trace_id: pcbTraceId,
+      source_trace_id: sourceTraceId,
+      route
+    };
+    circuitJson.push(pcb_trace);
+  }
+  return circuitJson;
+};
+
+// scripts/run-benchmark/getPercentileMs.ts
+var getPercentileMs = (durationMsList, percentile) => {
+  if (durationMsList.length === 0) {
+    return null;
+  }
+  const sorted = [...durationMsList].sort((a, b) => a - b);
+  const clampedPercentile = Math.min(Math.max(percentile, 0), 1);
+  const position = (sorted.length - 1) * clampedPercentile;
+  const lowerIndex = Math.floor(position);
+  const upperIndex = Math.ceil(position);
+  const lowerValue = sorted[lowerIndex];
+  const upperValue = sorted[upperIndex];
+  if (lowerIndex === upperIndex) {
+    return lowerValue;
+  }
+  const weight = position - lowerIndex;
+  return lowerValue + (upperValue - lowerValue) * weight;
+};
+
+// scripts/run-benchmark/solvers.ts
+import {
+  AutoroutingPipeline1_OriginalUnravel,
+  AutoroutingPipelineSolver as AutoroutingPipelineSolver2_PortPointPathing,
+  AutoroutingPipelineSolver3_HgPortPointPathing
+} from "@tscircuit/capacity-autorouter";
+var solverDisplayNameByConstructor = /* @__PURE__ */ new Map([
+  [
+    AutoroutingPipelineSolver2_PortPointPathing,
+    "AutoroutingPipelineSolver2_PortPointPathing"
+  ],
+  [
+    AutoroutingPipelineSolver3_HgPortPointPathing,
+    "AutoroutingPipelineSolver3_HgPortPointPathing"
+  ],
+  [
+    AutoroutingPipeline1_OriginalUnravel,
+    "AutoroutingPipeline1_OriginalUnravel"
+  ]
+]);
+
+// scripts/run-benchmark/runBenchmark.ts
+var runBenchmark = async (inputs) => {
+  const { scenarioList, solverConstructorList } = inputs;
+  const resultRowList = [];
+  const scenarioResultList = scenarioList.map(
+    (scenario) => ({
+      scenarioName: scenario.scenarioName,
+      simpleRouteJsonPath: scenario.simpleRouteJsonPath,
+      solverResultBySolverName: {},
+      circuitPreviewSvg: ""
+    })
+  );
+  const totalRunCount = scenarioList.length * solverConstructorList.length;
+  let completedRunCount = 0;
+  let averageRunTimeMs = 0;
+  for (const solverClass of solverConstructorList) {
+    const solverDisplayName = solverDisplayNameByConstructor.get(solverClass) ?? solverClass.name;
+    let totalTimeMs = 0;
+    let successCount = 0;
+    let relaxedDrcPassedCount = 0;
+    const elapsedTimeMsList = [];
+    for (const [scenarioIndex, scenario] of scenarioList.entries()) {
+      const solver = new solverClass(scenario.simpleRouteJson);
+      const rawSvg = getSvgFromGraphicsObject(solver.visualize());
+      scenarioResultList[scenarioIndex].circuitPreviewSvg = rawSvg;
+      const startMs = Date.now();
+      try {
+        solver.solve();
+      } catch (_error) {
+        solver.solved = false;
+      }
+      const elapsedMs = Date.now() - startMs;
+      const connectionsCount = scenario.simpleRouteJson.connections?.length ?? 0;
+      totalTimeMs += elapsedMs;
+      const solved = solver.solved;
+      if (solved) {
+        successCount += 1;
+        elapsedTimeMsList.push(elapsedMs);
+      }
+      const scenarioStatus = solved ? "Solved" : "Failed";
+      console.log(
+        `[${solverDisplayName}] ${scenarioStatus} ${scenario.scenarioName} in ${formatTimeSeconds(elapsedMs)} (connections: ${connectionsCount})`
+      );
+      completedRunCount += 1;
+      averageRunTimeMs += (elapsedMs - averageRunTimeMs) / Math.max(completedRunCount, 1);
+      const remainingRunCount = Math.max(totalRunCount - completedRunCount, 0);
+      const etaMs = Math.max(averageRunTimeMs * remainingRunCount, 0);
+      const percentComplete = totalRunCount === 0 ? 100 : completedRunCount / totalRunCount * 100;
+      console.log(
+        `[Progress] ${completedRunCount}/${totalRunCount} (${percentComplete.toFixed(1)}%) ETA ${formatTimeSeconds(etaMs)}`
+      );
+      const circuitJson = convertToCircuitJson({
+        srjWithPointPairs: solver.srjWithPointPairs,
+        minTraceWidth: scenario.simpleRouteJson.minTraceWidth,
+        minViaDiameter: scenario.simpleRouteJson.minViaDiameter,
+        routes: !solver.failed ? solver.getOutputSimplifiedPcbTraces() : []
+      });
+      const relaxedDrcPassed = await detectUnfixableRoutingIssues(circuitJson);
+      if (relaxedDrcPassed && solver.solved) {
+        relaxedDrcPassedCount += 1;
+      }
+      scenarioResultList[scenarioIndex].solverResultBySolverName[solverDisplayName] = {
+        didSolve: solved,
+        elapsedTimeMs: elapsedMs,
+        relaxedDrcPassed
+      };
+    }
+    const scenarioCount = scenarioList.length;
+    const successRatePercent = scenarioCount === 0 ? 0 : successCount / scenarioCount * 100;
+    const relaxedDrcRatePercent = relaxedDrcPassedCount === 0 ? null : relaxedDrcPassedCount / scenarioCount * 100;
+    resultRowList.push({
+      solverName: solverDisplayName,
+      totalTimeMs,
+      p50TimeMs: getPercentileMs(elapsedTimeMsList, 0.5),
+      p95TimeMs: getPercentileMs(elapsedTimeMsList, 0.95),
+      successRatePercent,
+      relaxedDrcRatePercent
+    });
+  }
+  return { resultRowList, scenarioResultList };
+};
+
+// lib/cli/run/register.ts
+var findDatasetDirectory = async () => {
+  const possiblePaths = [
+    path3.resolve(process.cwd(), "lib/dataset"),
+    path3.resolve(
+      fileURLToPath(import.meta.url),
+      "..",
+      "..",
+      "..",
+      "..",
+      "lib",
+      "dataset"
+    ),
+    path3.resolve(
+      fileURLToPath(import.meta.url),
+      "..",
+      "..",
+      "..",
+      "lib",
+      "dataset"
+    )
+  ];
+  for (const datasetPath of possiblePaths) {
+    try {
+      await access(datasetPath);
+      return datasetPath;
+    } catch {
+    }
+  }
+  throw new Error(
+    `Could not find dataset directory. Checked: ${possiblePaths.join(", ")}`
+  );
+};
+var registerRun = (program2) => {
+  program2.command("run", { isDefault: true }).description("Run benchmark on an autorouter").argument("<autorouter-path>", "Path to autorouter TypeScript file").argument("[solver-name]", "Specific export name to use as solver").option("-l, --scenario-limit <count>", "Limit number of scenarios to run").option("-o, --output <path>", "Output HTML file path").action(
+    async (autorouterPath, solverName, options) => {
+      try {
+        const absolutePath = path3.resolve(autorouterPath);
+        console.log(
+          `${kleur.cyan("Loading autorouter from:")} ${absolutePath}`
+        );
+        const { solverConstructor, solverName: detectedSolverName } = await loadUserAutorouter(absolutePath, solverName);
+        const finalSolverName = solverName || detectedSolverName;
+        console.log(
+          `${kleur.green("\u2713")} Using autorouter: ${kleur.bold(finalSolverName)}`
+        );
+        solverDisplayNameByConstructor.set(solverConstructor, finalSolverName);
+        const datasetDirectory = await findDatasetDirectory();
+        const scenarioCountLimit = options.scenarioLimit ? Number.parseInt(options.scenarioLimit, 10) : null;
+        const scenarioList = await loadScenarioList({
+          datasetDirectory,
+          scenarioCountLimit
+        });
+        if (scenarioList.length === 0) {
+          console.error(
+            kleur.red(
+              "No dataset files found. Ensure the package is installed correctly."
+            )
+          );
+          process.exit(1);
+        }
+        console.log(
+          `
+${kleur.cyan("Running benchmark with")} ${kleur.bold(String(scenarioList.length))} ${kleur.cyan("scenarios...")}
+`
+        );
+        const { resultRowList, scenarioResultList } = await runBenchmark({
+          scenarioList,
+          solverConstructorList: [solverConstructor]
+        });
+        const outputText = outputTabled({ resultRowList, scenarioList });
+        console.log("");
+        console.log(outputText);
+        const summaryJson = buildBenchmarkSummaryJson({
+          resultRowList,
+          scenarioList
+        });
+        const detailJson = buildBenchmarkDetailsJson({
+          scenarioResultList,
+          scenarioList
+        });
+        const htmlText = generateHtmlVisualization({
+          summary_json: summaryJson,
+          detail_json: detailJson,
+          result_row_list: resultRowList
+        });
+        const outputDir = path3.resolve("results");
+        await mkdir(outputDir, { recursive: true });
+        const outputPath = options.output ? path3.resolve(options.output) : path3.join(outputDir, `${finalSolverName}.html`);
+        await writeFile(outputPath, htmlText);
+        console.log(
+          `
+${kleur.green("\u2713")} HTML results written to: ${kleur.cyan(outputPath)}`
+        );
+        process.exit(0);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`${kleur.red("Error:")} ${message}`);
+        process.exit(1);
+      }
+    }
+  );
+};
+
+// lib/cli/main.ts
+var program = new Command();
+program.name("autorouting-dataset-runner").description(
+  "Benchmark autorouters against the tscircuit autorouting dataset"
+).version("1.0.0");
+registerRun(program);
+program.parse();

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@tscircuit/autorouting-dataset-01",
-  "version": "1.0.24",
+  "version": "1.0.25",
+  "type": "module",
   "main": "lib/dataset/index.ts",
+  "bin": {
+    "autorouting-dataset-runner": "./dist/cli/index.js"
+  },
   "files": [
-    "lib/dataset"
+    "lib/dataset",
+    "dist/cli",
+    "dist/lib",
+    "dist/scripts",
+    "dist/types"
   ],
   "keywords": [
     "tscircuit"
@@ -18,12 +26,20 @@
     "lint:fix": "biome lint --write",
     "check": "biome check",
     "check:write": "biome check --write --unsafe",
-    "build": "tsci build --disable-parts-engine --ignore-errors"
+    "build": "tsci build --disable-parts-engine --ignore-errors",
+    "build:cli": "tsup",
+    "setup": "bun run build:cli && npm install -g .",
+    "prepublishOnly": "bun run build:cli"
   },
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "kleur": "^4.1.5"
+  },
   "devDependencies": {
+    "tsup": "^8.2.4",
     "@biomejs/biome": "^2.3.13",
     "@tsci/imrishabh18.TB6612FNG": "^0.1.0",
     "@tsci/seveibar.PICO": "^0.1.0",