@tscircuit/rectdiff 0.0.39 → 0.0.41

package/.github/workflows/bun-test.yml

@@ -28,4 +28,4 @@ jobs:
         run: bun install
 
       - name: Run tests
-        run: bun test --timeout 999999
+        run: bun test --timeout 9999

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/lib/RectDiffPipeline.ts

@@ -16,20 +16,17 @@ import { computeInverseRects } from "./solvers/RectDiffSeedingSolver/computeInve
 import { buildZIndexMap } from "./solvers/RectDiffSeedingSolver/layers"
 import { buildObstacleClearanceGraphics } from "./utils/renderObstacleClearance"
 import { mergeGraphics } from "graphics-debug"
-import { SparseMultilayerPromotionSolver } from "./solvers/SparseMultilayerPromotionSolver/SparseMultilayerPromotionSolver"
 
 export interface RectDiffPipelineInput {
   simpleRouteJson: SimpleRouteJson
   gridOptions?: Partial<GridFill3DOptions>
   obstacleClearance?: number
-  sparseMultilayerPromotionTargetShare?: number
 }
 
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
   rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
   outerLayerContainmentMergeSolver?: OuterLayerContainmentMergeSolver
-  sparseMultilayerPromotionSolver?: SparseMultilayerPromotionSolver
   boardVoidRects: XYRect[] | undefined
   zIndexByName?: Map<string, number>
   layerNames?: string[]
@@ -90,25 +87,6 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
         },
       ],
     ),
-    definePipelineStep(
-      "sparseMultilayerPromotionSolver",
-      SparseMultilayerPromotionSolver,
-      (rectDiffPipeline: RectDiffPipeline) => [
-        {
-          meshNodes:
-            rectDiffPipeline.outerLayerContainmentMergeSolver?.getOutput()
-              .outputNodes ??
-            rectDiffPipeline.gapFillSolver?.getOutput().outputNodes ??
-            rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput()
-              .meshNodes ??
-            [],
-          promotionTargetShare:
-            rectDiffPipeline.inputProblem
-              .sparseMultilayerPromotionTargetShare ?? 0.86,
-          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
-        },
-      ],
-    ),
   ]
 
   override _setup(): void {
@@ -142,11 +120,6 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
     const outerLayerMergeOutput =
       this.outerLayerContainmentMergeSolver?.getOutput()
-    const sparseMultilayerOutput =
-      this.sparseMultilayerPromotionSolver?.getOutput()
-    if (sparseMultilayerOutput) {
-      return { meshNodes: sparseMultilayerOutput.outputNodes }
-    }
     if (outerLayerMergeOutput) {
       return { meshNodes: outerLayerMergeOutput.outputNodes }
     }

package/lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts

@@ -29,22 +29,6 @@ const nodeToRect = (node: CapacityMeshNode): XYRect => ({
 
 const rectArea = (rect: XYRect) => rect.width * rect.height
 
-const intersectRects = (a: XYRect, b: XYRect): XYRect | null => {
-  const x0 = Math.max(a.x, b.x)
-  const y0 = Math.max(a.y, b.y)
-  const x1 = Math.min(a.x + a.width, b.x + b.width)
-  const y1 = Math.min(a.y + a.height, b.y + b.height)
-
-  if (x1 <= x0 + EPS || y1 <= y0 + EPS) return null
-
-  return {
-    x: x0,
-    y: y0,
-    width: x1 - x0,
-    height: y1 - y0,
-  }
-}
-
 const cloneNode = (node: CapacityMeshNode): CapacityMeshNode => ({
   ...node,
   center: { ...node.center },
@@ -103,7 +87,6 @@ const isFullyCoveredByRects = (target: XYRect, coveringRects: XYRect[]) => {
 export class OuterLayerContainmentMergeSolver extends BaseSolver {
   private outputNodes: CapacityMeshNode[] = []
   private promotedNodeIds = new Set<string>()
-  private fullyPromotedNodeIds = new Set<string>()
   private residualNodeIds = new Set<string>()
 
   constructor(private input: OuterLayerContainmentMergeSolverInput) {
@@ -113,7 +96,6 @@ export class OuterLayerContainmentMergeSolver extends BaseSolver {
   override _setup() {
     this.outputNodes = this.input.meshNodes.map(cloneNode)
     this.promotedNodeIds.clear()
-    this.fullyPromotedNodeIds.clear()
     this.residualNodeIds.clear()
   }
 
@@ -134,8 +116,6 @@ export class OuterLayerContainmentMergeSolver extends BaseSolver {
     const viaMinSize = Math.max(srj.minViaDiameter ?? 0, srj.minTraceWidth || 0)
     const originalNodes = this.input.meshNodes.map(cloneNode)
     const obstaclesByLayer = this.buildObstaclesByLayer(layerCount)
-    const shouldAllowPartialPromotion =
-      this.getUsableMultilayerVolumeShare(originalNodes) < 0.5
     const mutableOuterNodes = originalNodes.filter(
       (node) =>
         isFreeNode(node) &&
@@ -186,51 +166,23 @@ export class OuterLayerContainmentMergeSolver extends BaseSolver {
         continue
       }
       if (!isFullyCoveredByRects(candidateRect, oppositeSupportRects)) {
-        if (!shouldAllowPartialPromotion) {
-          continue
-        }
-
-        const partialPromotionRects = this.getSupportedPromotionRects({
-          candidateRect,
-          supportRects: oppositeSupportRects,
-          minRectSize: viaMinSize,
-        })
-
-        if (partialPromotionRects.length === 0) {
-          continue
-        }
-
-        for (const partialRect of partialPromotionRects) {
-          const promotedNode = cloneNodeWithRect(
-            candidate,
-            partialRect,
-            `${candidate.capacityMeshNodeId}-outer-partial-${promotedNodes.length}`,
-          )
-          promotedNode.availableZ = [topZ, bottomZ]
-          promotedNode.layer = `z${topZ},${bottomZ}`
-          promotedNodes.push(promotedNode)
-          promotedRects.push(partialRect)
-          this.promotedNodeIds.add(promotedNode.capacityMeshNodeId)
-        }
         continue
       }
 
-      const promotedNode = {
+      promotedNodes.push({
         ...candidate,
         availableZ: [topZ, bottomZ],
         layer: `z${topZ},${bottomZ}`,
-      }
-      promotedNodes.push(promotedNode)
+      })
       promotedRects.push(candidateRect)
-      this.promotedNodeIds.add(promotedNode.capacityMeshNodeId)
-      this.fullyPromotedNodeIds.add(candidate.capacityMeshNodeId)
+      this.promotedNodeIds.add(candidate.capacityMeshNodeId)
     }
 
     let nextResidualId = 0
     const residualNodes: CapacityMeshNode[] = []
 
     for (const node of mutableOuterNodes) {
-      if (this.fullyPromotedNodeIds.has(node.capacityMeshNodeId)) {
+      if (this.promotedNodeIds.has(node.capacityMeshNodeId)) {
         continue
       }
 
@@ -259,62 +211,6 @@ export class OuterLayerContainmentMergeSolver extends BaseSolver {
     return [...immutableNodes, ...promotedNodes, ...residualNodes]
   }
 
-  private getUsableMultilayerVolumeShare(nodes: CapacityMeshNode[]) {
-    let totalVolume = 0
-    let obstacleVolume = 0
-    let multilayerVolume = 0
-
-    for (const node of nodes) {
-      const volume = node.width * node.height * node.availableZ.length
-      totalVolume += volume
-      if (node._containsObstacle) {
-        obstacleVolume += volume
-        continue
-      }
-      if (node.availableZ.length > 1) {
-        multilayerVolume += volume
-      }
-    }
-
-    const usableVolume = totalVolume - obstacleVolume
-    if (usableVolume <= EPS) return 0
-    return multilayerVolume / usableVolume
-  }
-
-  private getSupportedPromotionRects(params: {
-    candidateRect: XYRect
-    supportRects: XYRect[]
-    minRectSize: number
-  }) {
-    const { candidateRect, supportRects, minRectSize } = params
-    const promotedPieces: XYRect[] = []
-
-    for (const supportRect of supportRects) {
-      const overlapRect = intersectRects(candidateRect, supportRect)
-      if (!overlapRect) continue
-
-      let remainingPieces = [overlapRect]
-      for (const existingPiece of promotedPieces) {
-        remainingPieces = remainingPieces.flatMap((piece) =>
-          subtractRect2D(piece, existingPiece),
-        )
-        if (remainingPieces.length === 0) break
-      }
-
-      for (const piece of remainingPieces) {
-        if (
-          piece.width + EPS < minRectSize ||
-          piece.height + EPS < minRectSize
-        ) {
-          continue
-        }
-        promotedPieces.push(piece)
-      }
-    }
-
-    return promotedPieces
-  }
-
   private buildObstaclesByLayer(layerCount: number): ObstacleWithRect[][] {
     const out = Array.from(
       { length: layerCount },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.39",
+  "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)