@tscircuit/rectdiff 0.0.23 → 0.0.25

package/lib/buildFinalRectDiffVisualization.ts

@@ -0,0 +1,46 @@
+import { mergeGraphics, type GraphicsObject } from "graphics-debug"
+import type { CapacityMeshNode } from "./types/capacity-mesh-types"
+import type { SimpleRouteJson } from "./types/srj-types"
+import { getColorForZLayer } from "./utils/getColorForZLayer"
+import { buildOutlineGraphics } from "./utils/buildOutlineGraphics"
+import { buildObstacleClearanceGraphics } from "./utils/renderObstacleClearance"
+
+type BuildFinalVisualizationParams = {
+  srj: SimpleRouteJson
+  meshNodes: CapacityMeshNode[]
+  obstacleClearance?: number
+}
+
+export const buildFinalRectDiffVisualization = ({
+  srj,
+  meshNodes,
+  obstacleClearance,
+}: BuildFinalVisualizationParams): GraphicsObject => {
+  const outline = buildOutlineGraphics({ srj })
+  const clearance = buildObstacleClearanceGraphics({
+    srj,
+    clearance: obstacleClearance,
+  })
+  const rects = meshNodes.map((node) => ({
+    center: node.center,
+    width: node.width,
+    height: node.height,
+    stroke: getColorForZLayer(node.availableZ).stroke,
+    fill: node._containsObstacle
+      ? "#fca5a5"
+      : getColorForZLayer(node.availableZ).fill,
+    layer: `z${node.availableZ.join(",")}`,
+    label: `node ${node.capacityMeshNodeId}\nz:${node.availableZ.join(",")}`,
+  }))
+
+  const nodesGraphic: GraphicsObject = {
+    title: "RectDiffPipeline - Final",
+    coordinateSystem: "cartesian",
+    rects,
+    lines: [],
+    points: [],
+    texts: [],
+  }
+
+  return mergeGraphics(mergeGraphics(nodesGraphic, outline), clearance)
+}

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -57,6 +57,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
   private candidates!: Candidate3D[]
   private placed!: Placed3D[]
   private placedIndexByLayer!: Array<RBush<RTreeRect>>
+  private hardPlacedByLayer!: XYRect[][]
   private expansionIndex!: number
   private edgeAnalysisDone!: boolean
   private totalSeedsThisGrid!: number
@@ -131,6 +132,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       { length: layerCount },
       () => new RBush<RTreeRect>(),
     )
+    this.hardPlacedByLayer = Array.from({ length: layerCount }, () => [])
     this.expansionIndex = 0
     this.edgeAnalysisDone = false
     this.totalSeedsThisGrid = 0
@@ -164,19 +166,13 @@ export class RectDiffSeedingSolver extends BaseSolver {
     } = this.options
     const grid = gridSizes[this.gridIndex]!
 
-    // Build hard-placed map once per micro-step (cheap)
-    const hardPlacedByLayer = allLayerNode({
-      layerCount: this.layerCount,
-      placed: this.placed,
-    })
-
     // Ensure candidates exist for this grid
     if (this.candidates.length === 0 && this.consumedSeedsThisGrid === 0) {
       this.candidates = computeCandidates3D({
         bounds: this.bounds,
         gridSize: grid,
         layerCount: this.layerCount,
-        hardPlacedByLayer,
+        hardPlacedByLayer: this.hardPlacedByLayer,
         obstacleIndexByLayer: this.input.obstacleIndexByLayer,
         placedIndexByLayer: this.placedIndexByLayer,
       })
@@ -185,9 +181,10 @@ export class RectDiffSeedingSolver extends BaseSolver {
     }
 
     // If no candidates remain, advance grid or run edge pass or switch phase
-    if (this.candidates.length === 0) {
+    if (this.consumedSeedsThisGrid >= this.candidates.length) {
       if (this.gridIndex + 1 < gridSizes.length) {
         this.gridIndex += 1
+        this.candidates = []
         this.totalSeedsThisGrid = 0
         this.consumedSeedsThisGrid = 0
         return
@@ -200,13 +197,14 @@ export class RectDiffSeedingSolver extends BaseSolver {
             layerCount: this.layerCount,
             obstacleIndexByLayer: this.input.obstacleIndexByLayer,
             placedIndexByLayer: this.placedIndexByLayer,
-            hardPlacedByLayer,
+            hardPlacedByLayer: this.hardPlacedByLayer,
           })
           this.edgeAnalysisDone = true
           this.totalSeedsThisGrid = this.candidates.length
           this.consumedSeedsThisGrid = 0
           return
         }
+        this.candidates = []
         this.solved = true
         this.expansionIndex = 0
         return
@@ -214,8 +212,17 @@ export class RectDiffSeedingSolver extends BaseSolver {
     }
 
     // Consume exactly one candidate
-    const cand = this.candidates.shift()!
-    this.consumedSeedsThisGrid += 1
+    const cand = this.candidates[this.consumedSeedsThisGrid++]!
+    if (
+      isFullyOccupiedAtPoint({
+        layerCount: this.layerCount,
+        obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer,
+        point: { x: cand.x, y: cand.y },
+      })
+    ) {
+      return
+    }
 
     // Evaluate attempts — multi-layer span first (computed ignoring soft nodes)
     const span = longestFreeSpanAroundZ({
@@ -226,7 +233,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       minSpan: minMulti.minLayers,
       maxSpan: maxMultiLayerSpan,
       obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-      additionalBlockersByLayer: hardPlacedByLayer,
+      additionalBlockersByLayer: this.hardPlacedByLayer,
     })
 
     const attempts: Array<{
@@ -285,17 +292,10 @@ export class RectDiffSeedingSolver extends BaseSolver {
         },
         newIndex,
       )
-
-      // New: relax candidate culling — only drop seeds that became fully occupied
-      this.candidates = this.candidates.filter(
-        (c) =>
-          !isFullyOccupiedAtPoint({
-            layerCount: this.layerCount,
-            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-            placedIndexByLayer: this.placedIndexByLayer,
-            point: { x: c.x, y: c.y },
-          }),
-      )
+      this.hardPlacedByLayer = allLayerNode({
+        layerCount: this.layerCount,
+        placed: this.placed,
+      })
 
       return // processed one candidate
     }
@@ -392,31 +392,6 @@ export class RectDiffSeedingSolver extends BaseSolver {
       }
     }
 
-    // obstacle clearance visualization (expanded)
-    if (this.input.obstacleClearance && this.input.obstacleClearance > 0) {
-      for (const obstacle of srj.obstacles ?? []) {
-        const pad = this.input.obstacleClearance
-        const expanded = {
-          x: obstacle.center.x - obstacle.width / 2 - pad,
-          y: obstacle.center.y - obstacle.height / 2 - pad,
-          width: obstacle.width + 2 * pad,
-          height: obstacle.height + 2 * pad,
-        }
-        rects.push({
-          center: {
-            x: expanded.x + expanded.width / 2,
-            y: expanded.y + expanded.height / 2,
-          },
-          width: expanded.width,
-          height: expanded.height,
-          fill: "rgba(234, 179, 8, 0.15)",
-          stroke: "rgba(202, 138, 4, 0.9)",
-          layer: "obstacle-clearance",
-          label: "clearance",
-        })
-      }
-    }
-
     // board void rects (early visualization of mask)
     if (this.boardVoidRects) {
       let outlineBBox: {

package/lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts

@@ -4,6 +4,8 @@ import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 import type RBush from "rbush"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+const quantize = (value: number, precision = 1e-6) =>
+  Math.round(value / precision) * precision
 
 /**
  * Compute candidate seed points for a given grid size.
@@ -25,6 +27,10 @@ export function computeCandidates3D(params: {
     hardPlacedByLayer,
   } = params
   const out = new Map<string, Candidate3D>() // key by (x,y)
+  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) => [
+    ...(obstacleIndexByLayer[z]?.all() ?? []),
+    ...(hardPlacedByLayer[z] ?? []),
+  ])
 
   for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
     for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
@@ -73,23 +79,19 @@ export function computeCandidates3D(params: {
         : bestZ
 
       // Distance heuristic against hard blockers only (obstacles + full-stack)
-      const hardAtZ = [
-        ...(obstacleIndexByLayer[anchorZ]?.all() ?? []),
-        ...(hardPlacedByLayer[anchorZ] ?? []),
-      ]
-      const d = Math.min(
-        distancePointToRectEdges({ x, y }, bounds),
-        ...(hardAtZ.length
-          ? hardAtZ.map((b) => distancePointToRectEdges({ x, y }, b))
-          : [Infinity]),
-      )
+      const hardAtZ = hardRectsByLayer[anchorZ] ?? []
+      let d = distancePointToRectEdges({ x, y }, bounds)
+      for (const blocker of hardAtZ) {
+        d = Math.min(d, distancePointToRectEdges({ x, y }, blocker))
+      }
+      const distance = quantize(d)
 
       const k = `${x.toFixed(6)}|${y.toFixed(6)}`
       const cand: Candidate3D = {
         x,
         y,
         z: anchorZ,
-        distance: d,
+        distance,
         zSpanLen: bestSpan.length,
       }
       const prev = out.get(k)
@@ -104,6 +106,13 @@ export function computeCandidates3D(params: {
   }
 
   const arr = Array.from(out.values())
-  arr.sort((a, b) => b.zSpanLen! - a.zSpanLen! || b.distance - a.distance)
+  arr.sort(
+    (a, b) =>
+      b.zSpanLen! - a.zSpanLen! ||
+      b.distance - a.distance ||
+      a.z - b.z ||
+      a.x - b.x ||
+      a.y - b.y,
+  )
   return arr
 }

package/lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts

@@ -4,6 +4,18 @@ import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 import type RBush from "rbush"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+const quantize = (value: number, precision = 1e-6) =>
+  Math.round(value / precision) * precision
+
+const toRect = (rect: XYRect | RTreeRect): XYRect =>
+  "minX" in rect
+    ? {
+        x: rect.minX,
+        y: rect.minY,
+        width: rect.maxX - rect.minX,
+        height: rect.maxY - rect.minY,
+      }
+    : rect
 
 /**
  * Compute exact uncovered segments along a 1D line.
@@ -15,14 +27,23 @@ function computeUncoveredSegments(params: {
   minSegmentLength: number
 }): Array<{ start: number; end: number; center: number }> {
   const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params
+  const lineStartQ = quantize(lineStart)
+  const lineEndQ = quantize(lineEnd)
+  const normalizedIntervals = coveringIntervals
+    .map((i) => {
+      const s = quantize(i.start)
+      const e = quantize(i.end)
+      return { start: Math.min(s, e), end: Math.max(s, e) }
+    })
+    .filter((i) => i.end > i.start + EPS)
 
-  if (coveringIntervals.length === 0) {
-    const center = (lineStart + lineEnd) / 2
-    return [{ start: lineStart, end: lineEnd, center }]
+  if (normalizedIntervals.length === 0) {
+    const center = (lineStartQ + lineEndQ) / 2
+    return [{ start: lineStartQ, end: lineEndQ, center }]
   }
 
   // Sort intervals by start position
-  const sorted = [...coveringIntervals].sort((a, b) => a.start - b.start)
+  const sorted = [...normalizedIntervals].sort((a, b) => a.start - b.start)
 
   // Merge overlapping intervals
   const merged: Array<{ start: number; end: number }> = []
@@ -45,8 +66,8 @@ function computeUncoveredSegments(params: {
   const uncovered: Array<{ start: number; end: number; center: number }> = []
 
   // Check gap before first interval
-  if (merged[0]!.start > lineStart + EPS) {
-    const start = lineStart
+  if (merged[0]!.start > lineStartQ + EPS) {
+    const start = lineStartQ
     const end = merged[0]!.start
     if (end - start >= minSegmentLength) {
       uncovered.push({ start, end, center: (start + end) / 2 })
@@ -63,9 +84,9 @@ function computeUncoveredSegments(params: {
   }
 
   // Check gap after last interval
-  if (merged[merged.length - 1]!.end < lineEnd - EPS) {
+  if (merged[merged.length - 1]!.end < lineEndQ - EPS) {
     const start = merged[merged.length - 1]!.end
-    const end = lineEnd
+    const end = lineEndQ
     if (end - start >= minSegmentLength) {
       uncovered.push({ start, end, center: (start + end) / 2 })
     }
@@ -98,6 +119,12 @@ export function computeEdgeCandidates3D(params: {
   // Use small inset from edges for placement
   const δ = Math.max(minSize * 0.15, EPS * 3)
   const dedup = new Set<string>()
+  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) =>
+    [
+      ...(obstacleIndexByLayer[z]?.all() ?? []),
+      ...(hardPlacedByLayer[z] ?? []),
+    ].map(toRect),
+  )
   const key = (p: { x: number; y: number; z: number }) =>
     `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`
 
@@ -111,7 +138,11 @@ export function computeEdgeCandidates3D(params: {
   }
 
   function pushIfFree(p: { x: number; y: number; z: number }) {
-    const { x, y, z } = p
+    const qx = quantize(p.x)
+    const qy = quantize(p.y)
+    const { z } = p
+    const x = qx
+    const y = qy
     if (
       x < bounds.x + EPS ||
       y < bounds.y + EPS ||
@@ -122,16 +153,12 @@ export function computeEdgeCandidates3D(params: {
     if (fullyOcc({ x, y })) return // new rule: only drop if truly impossible
 
     // Distance uses obstacles + hard nodes (soft nodes ignored for ranking)
-    const hard = [
-      ...(obstacleIndexByLayer[z]?.all() ?? []),
-      ...(hardPlacedByLayer[z] ?? []),
-    ]
-    const d = Math.min(
-      distancePointToRectEdges({ x, y }, bounds),
-      ...(hard.length
-        ? hard.map((b) => distancePointToRectEdges({ x, y }, b))
-        : [Infinity]),
-    )
+    const hard = hardRectsByLayer[z] ?? []
+    let d = distancePointToRectEdges({ x, y }, bounds)
+    for (const blocker of hard) {
+      d = Math.min(d, distancePointToRectEdges({ x, y }, blocker))
+    }
+    const distance = quantize(d)
 
     const k = key({ x, y, z })
     if (dedup.has(k)) return
@@ -148,14 +175,23 @@ export function computeEdgeCandidates3D(params: {
       obstacleIndexByLayer,
       additionalBlockersByLayer: hardPlacedByLayer,
     })
-    out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true })
+    out.push({
+      x,
+      y,
+      z,
+      distance,
+      zSpanLen: span.length,
+      isEdgeSeed: true,
+    })
   }
 
   for (let z = 0; z < layerCount; z++) {
-    const blockers = [
-      ...(obstacleIndexByLayer[z]?.all() ?? []),
-      ...(hardPlacedByLayer[z] ?? []),
-    ]
+    const blockers = (hardRectsByLayer[z] ?? []).map((b) => ({
+      x: quantize(b.x),
+      y: quantize(b.y),
+      width: quantize(b.width),
+      height: quantize(b.height),
+    }))
 
     // 1) Board edges — find exact uncovered segments along each edge
 
@@ -372,6 +408,13 @@ export function computeEdgeCandidates3D(params: {
   }
 
   // Strong multi-layer preference then distance.
-  out.sort((a, b) => b.zSpanLen! - a.zSpanLen! || b.distance - a.distance)
+  out.sort(
+    (a, b) =>
+      b.zSpanLen! - a.zSpanLen! ||
+      b.distance - a.distance ||
+      a.z - b.z ||
+      a.x - b.x ||
+      a.y - b.y,
+  )
   return out
 }

package/lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts

@@ -35,7 +35,7 @@ export function longestFreeSpanAroundZ(params: {
       maxY: y,
     }
     const obstacleIdx = obstacleIndexByLayer[layer]
-    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false
+    if (obstacleIdx && obstacleIdx.collides(query)) return false
 
     const extras = additionalBlockersByLayer?.[layer] ?? []
     return !extras.some((b) => containsPoint(b, { x, y }))

package/lib/utils/buildOutlineGraphics.ts

@@ -0,0 +1,39 @@
+import type { GraphicsObject, Line } from "graphics-debug"
+import type { SimpleRouteJson } from "../types/srj-types"
+
+export type BuildOutlineParams = { srj: SimpleRouteJson }
+
+export const buildOutlineGraphics = ({
+  srj,
+}: BuildOutlineParams): GraphicsObject => {
+  const hasOutline = srj.outline && srj.outline.length > 1
+  const lines: NonNullable<Line[]> = hasOutline
+    ? [
+        {
+          points: [...srj.outline!, srj.outline![0]!],
+          strokeColor: "#111827",
+          strokeWidth: 0.1,
+          label: "outline",
+        },
+      ]
+    : [
+        {
+          points: [
+            { x: srj.bounds.minX, y: srj.bounds.minY },
+            { x: srj.bounds.maxX, y: srj.bounds.minY },
+            { x: srj.bounds.maxX, y: srj.bounds.maxY },
+            { x: srj.bounds.minX, y: srj.bounds.maxY },
+            { x: srj.bounds.minX, y: srj.bounds.minY },
+          ],
+          strokeColor: "#111827",
+          strokeWidth: 0.1,
+          label: "bounds",
+        },
+      ]
+
+  return {
+    title: "SimpleRoute Outline",
+    coordinateSystem: "cartesian",
+    lines,
+  }
+}

package/lib/utils/expandRectFromSeed.ts

@@ -17,6 +17,16 @@ type ExpandDirectionParams = {
   maxAspect: number | null | undefined
 }
 
+const quantize = (value: number, precision = 1e-6) =>
+  Math.round(value / precision) * precision
+
+const quantizeRect = (rect: XYRect): XYRect => ({
+  x: quantize(rect.x),
+  y: quantize(rect.y),
+  width: quantize(rect.width),
+  height: quantize(rect.height),
+})
+
 function maxExpandRight(params: ExpandDirectionParams) {
   const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
@@ -165,14 +175,13 @@ const toRect = (tree: RTreeRect): XYRect => ({
 })
 
 const addBlocker = (params: {
-  rect: XYRect
-  seen: Set<string>
+  rect: RTreeRect
+  seen: Set<RTreeRect>
   blockers: XYRect[]
 }) => {
   const { rect, seen, blockers } = params
-  const key = `${rect.x}|${rect.y}|${rect.width}|${rect.height}`
-  if (seen.has(key)) return
-  seen.add(key)
+  if (seen.has(rect)) return
+  seen.add(rect)
   blockers.push(rect)
 }
 
@@ -215,7 +224,7 @@ export function expandRectFromSeed(params: {
   const initialW = Math.max(minSide, minReq.width)
   const initialH = Math.max(minSide, minReq.height)
   const blockers: XYRect[] = []
-  const seen = new Set<string>()
+  const seen = new Set<RTreeRect>()
   const totalLayers = placedIndexByLayer.length
 
   // Ignore the existing placement we are expanding so it doesn't self-block.
@@ -227,7 +236,7 @@ export function expandRectFromSeed(params: {
       const blockersIndex = obsticalIndexByLayer[z]
       if (blockersIndex) {
         for (const entry of blockersIndex.search(query))
-          addBlocker({ rect: toRect(entry), seen, blockers })
+          addBlocker({ rect: entry, seen, blockers })
       }
 
       const placedLayer = placedIndexByLayer[z]
@@ -235,10 +244,9 @@ export function expandRectFromSeed(params: {
         for (const entry of placedLayer.search(query)) {
           const isFullStack = entry.zLayers.length >= totalLayers
           if (!isFullStack) continue
-          const rect = toRect(entry)
           if (
             isSelfRect({
-              rect,
+              rect: entry,
               startX,
               startY,
               initialW,
@@ -246,7 +254,7 @@ export function expandRectFromSeed(params: {
             })
           )
             continue
-          addBlocker({ rect, seen, blockers })
+          addBlocker({ rect: entry, seen, blockers })
         }
       }
     }
@@ -333,7 +341,7 @@ export function expandRectFromSeed(params: {
     if (r.width + EPS >= minReq.width && r.height + EPS >= minReq.height) {
       const area = r.width * r.height
       if (area > bestArea) {
-        best = r
+        best = quantizeRect(r)
         bestArea = area
       }
     }

package/lib/utils/isFullyOccupiedAtPoint.ts

@@ -17,10 +17,10 @@ export function isFullyOccupiedAtPoint(params: OccupancyParams): boolean {
   }
   for (let z = 0; z < params.layerCount; z++) {
     const obstacleIdx = params.obstacleIndexByLayer[z]
-    const hasObstacle = !!obstacleIdx && obstacleIdx.search(query).length > 0
+    const hasObstacle = !!obstacleIdx && obstacleIdx.collides(query)
 
     const placedIdx = params.placedIndexByLayer[z]
-    const hasPlaced = !!placedIdx && placedIdx.search(query).length > 0
+    const hasPlaced = !!placedIdx && placedIdx.collides(query)
 
     if (!hasObstacle && !hasPlaced) return false
   }

package/lib/utils/rectdiff-geometry.ts

@@ -30,27 +30,20 @@ export function distancePointToRectEdges(
   p: { x: number; y: number },
   r: XYRect,
 ) {
-  const edges: [number, number, number, number][] = [
-    [r.x, r.y, r.x + r.width, r.y],
-    [r.x + r.width, r.y, r.x + r.width, r.y + r.height],
-    [r.x + r.width, r.y + r.height, r.x, r.y + r.height],
-    [r.x, r.y + r.height, r.x, r.y],
-  ]
-  let best = Infinity
-  for (const [x1, y1, x2, y2] of edges) {
-    const A = p.x - x1,
-      B = p.y - y1,
-      C = x2 - x1,
-      D = y2 - y1
-    const dot = A * C + B * D
-    const lenSq = C * C + D * D
-    let t = lenSq !== 0 ? dot / lenSq : 0
-    t = clamp(t, 0, 1)
-    const xx = x1 + t * C
-    const yy = y1 + t * D
-    best = Math.min(best, Math.hypot(p.x - xx, p.y - yy))
+  const minX = r.x
+  const maxX = r.x + r.width
+  const minY = r.y
+  const maxY = r.y + r.height
+
+  if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
+    return Math.min(p.x - minX, maxX - p.x, p.y - minY, maxY - p.y)
   }
-  return best
+
+  const dx = p.x < minX ? minX - p.x : p.x > maxX ? p.x - maxX : 0
+  const dy = p.y < minY ? minY - p.y : p.y > maxY ? p.y - maxY : 0
+  if (dx === 0) return dy
+  if (dy === 0) return dx
+  return Math.hypot(dx, dy)
 }
 
 /** Find the intersection of two 1D intervals, or null if they don't overlap. */

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {
     "start": "cosmos",
     "build": "tsup-node ./lib/index.ts --format esm --dts",
     "build:site": "cosmos-export",
+    "benchmark:slow-problem": "bun scripts/benchmark-slow-problem.ts test-assets/keyboard4.json",
     "format": "biome format --write .",
     "format:check": "biome format ."
   },