@tscircuit/schematic-trace-solver 0.0.32 → 0.0.33

package/lib/index.ts

@@ -1,2 +1,3 @@
 export * from "./solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 export * from "./types/InputProblem"
+export { SchematicTraceSingleLineSolver2 } from "./solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -1,8 +1,14 @@
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
-import type { InputChip, InputPin, InputProblem } from "lib/types/InputProblem"
+import type {
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
 import { ConnectivityMap } from "connectivity-map"
 import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
+import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
 import type { GraphicsObject } from "graphics-debug"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
@@ -104,6 +110,22 @@ export class MspConnectionPairSolver extends BaseSolver {
         // Too far apart; skip creating an MSP pair for this net
         return
       }
+      // Avoid pairs that would cross restricted center lines
+      const pinIdMap = new Map(Object.entries(this.pinMap)) as Map<
+        PinId,
+        InputPin & { chipId: string }
+      >
+      if (
+        doesPairCrossRestrictedCenterLines({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pinIdMap,
+          p1,
+          p2,
+        })
+      ) {
+        return
+      }
 
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1!)!
       const userNetId =
@@ -122,12 +144,41 @@ export class MspConnectionPairSolver extends BaseSolver {
 
     // There are more than 3 pins, so we need to run MSP to find the best pairs
 
+    const pinIdMap = new Map(Object.entries(this.pinMap)) as Map<
+      PinId,
+      InputPin & { chipId: string }
+    >
     const msp = getOrthogonalMinimumSpanningTree(
       directlyConnectedPins.map((p) => this.pinMap[p]!).filter(Boolean),
-      { maxDistance: this.maxMspPairDistance },
+      {
+        maxDistance: this.maxMspPairDistance,
+        forbidEdge: (a, b) =>
+          doesPairCrossRestrictedCenterLines({
+            inputProblem: this.inputProblem,
+            chipMap: this.chipMap,
+            pinIdMap,
+            p1: a as InputPin & { chipId: string },
+            p2: b as InputPin & { chipId: string },
+          }),
+      },
     )
 
     for (const [pin1, pin2] of msp) {
+      const p1Obj = this.pinMap[pin1!]!
+      const p2Obj = this.pinMap[pin2!]!
+      // Skip any edge that would cross a restricted center line (safety filter)
+      if (
+        doesPairCrossRestrictedCenterLines({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pinIdMap,
+          p1: p1Obj,
+          p2: p2Obj,
+        })
+      ) {
+        continue
+      }
+
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1!)!
       const userNetId =
         this.userNetIdByPinId[pin1!] ?? this.userNetIdByPinId[pin2!]
@@ -136,7 +187,7 @@ export class MspConnectionPairSolver extends BaseSolver {
         dcConnNetId: dcNetId,
         globalConnNetId,
         userNetId,
-        pins: [this.pinMap[pin1!]!, this.pinMap[pin2!]!],
+        pins: [p1Obj, p2Obj],
       })
     }
   }

package/lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines.ts

@@ -0,0 +1,62 @@
+import type {
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import { getRestrictedCenterLines } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines"
+
+export const doesPairCrossRestrictedCenterLines = (params: {
+  inputProblem: InputProblem
+  chipMap: Record<string, InputChip>
+  pinIdMap: Map<PinId, InputPin & { chipId: string }>
+  p1: InputPin & { chipId: string }
+  p2: InputPin & { chipId: string }
+}): boolean => {
+  const { inputProblem, chipMap, pinIdMap, p1, p2 } = params
+
+  const restrictedCenterLines = getRestrictedCenterLines({
+    pins: [p1, p2],
+    inputProblem,
+    pinIdMap,
+    chipMap,
+  })
+
+  if (restrictedCenterLines.size === 0) return false
+
+  const EPS = 1e-9
+
+  const crossesSegment = (
+    a: { x: number; y: number },
+    b: { x: number; y: number },
+  ): boolean => {
+    for (const [, rcl] of restrictedCenterLines) {
+      if (rcl.axes.has("x") && typeof rcl.x === "number") {
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS) return true
+      }
+      if (rcl.axes.has("y") && typeof rcl.y === "number") {
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS) return true
+      }
+    }
+    return false
+  }
+
+  // If already aligned on one axis, just check that single segment
+  if (Math.abs(p1.x - p2.x) < EPS || Math.abs(p1.y - p2.y) < EPS) {
+    return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y })
+  }
+
+  // Two L-shape possibilities: horizontal-then-vertical or vertical-then-horizontal
+  const elbowHV = { x: p2.x, y: p1.y }
+  const elbowVH = { x: p1.x, y: p2.y }
+
+  const hvCrosses =
+    crossesSegment({ x: p1.x, y: p1.y }, elbowHV) ||
+    crossesSegment(elbowHV, { x: p2.x, y: p2.y })
+  const vhCrosses =
+    crossesSegment({ x: p1.x, y: p1.y }, elbowVH) ||
+    crossesSegment(elbowVH, { x: p2.x, y: p2.y })
+
+  // Forbid the pair only if both L-shape routes would cross a restricted center line
+  return hvCrosses && vhCrosses
+}

package/lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts

@@ -18,7 +18,10 @@ import type { InputPin, PinId } from "lib/types/InputProblem"
  */
 export function getOrthogonalMinimumSpanningTree(
   pins: InputPin[],
-  opts: { maxDistance?: number } = {},
+  opts: {
+    maxDistance?: number
+    forbidEdge?: (a: InputPin, b: InputPin) => boolean
+  } = {},
 ): Array<[PinId, PinId]> {
   const n = pins.length
   const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY
@@ -82,7 +85,9 @@ export function getOrthogonalMinimumSpanningTree(
     for (let v = 0; v < n; v++) {
       if (!inTree[v]) {
         const d0 = manhattan(pins[u], pins[v])
-        const d = d0 > maxDistance ? Number.POSITIVE_INFINITY : d0
+        const isForbidden = opts?.forbidEdge?.(pins[u], pins[v]) ?? false
+        const d =
+          d0 > maxDistance || isForbidden ? Number.POSITIVE_INFINITY : d0
         if (
           d < bestDist[v] ||
           (d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId)

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -7,7 +7,7 @@ import type {
   MspConnectionPairId,
 } from "../MspConnectionPairSolver/MspConnectionPairSolver"
 import type { ConnectivityMap } from "connectivity-map"
-import { SchematicTraceSingleLineSolver } from "./SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver"
+import { SchematicTraceSingleLineSolver2 } from "./SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
 import type { Guideline } from "../GuidelinesSolver/GuidelinesSolver"
 import { visualizeGuidelines } from "../GuidelinesSolver/visualizeGuidelines"
 import type { Point } from "@tscircuit/math-utils"
@@ -20,7 +20,6 @@ export interface SolvedTracePath extends MspConnectionPair {
 
 export class SchematicTraceLinesSolver extends BaseSolver {
   inputProblem: InputProblem
-  guidelines: Guideline[]
   mspConnectionPairs: MspConnectionPair[]
 
   dcConnMap: ConnectivityMap
@@ -34,7 +33,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
   solvedTracePaths: Array<SolvedTracePath> = []
   failedConnectionPairs: Array<MspConnectionPair & { error?: string }> = []
 
-  declare activeSubSolver: SchematicTraceSingleLineSolver | null
+  declare activeSubSolver: SchematicTraceSingleLineSolver2 | null
 
   constructor(params: {
     mspConnectionPairs: MspConnectionPair[]
@@ -42,14 +41,12 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     dcConnMap: ConnectivityMap
     globalConnMap: ConnectivityMap
     inputProblem: InputProblem
-    guidelines: Guideline[]
   }) {
     super()
     this.inputProblem = params.inputProblem
     this.mspConnectionPairs = params.mspConnectionPairs
     this.dcConnMap = params.dcConnMap
     this.globalConnMap = params.globalConnMap
-    this.guidelines = params.guidelines
     this.chipMap = params.chipMap
 
     this.queuedConnectionPairs = [...this.mspConnectionPairs]
@@ -64,7 +61,6 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       mspConnectionPairs: this.mspConnectionPairs,
       dcConnMap: this.dcConnMap,
       globalConnMap: this.globalConnMap,
-      guidelines: this.guidelines,
     }
   }
 
@@ -111,11 +107,10 @@ export class SchematicTraceLinesSolver extends BaseSolver {
 
     const { pins } = connectionPair
 
-    this.activeSubSolver = new SchematicTraceSingleLineSolver({
+    this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,
       pins,
       chipMap: this.chipMap,
-      guidelines: this.guidelines,
     })
   }
 
@@ -128,8 +123,6 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       connectionAlpha: 0.1,
     })
 
-    visualizeGuidelines({ guidelines: this.guidelines, graphics })
-
     for (const { mspPairId, tracePath } of this.solvedTracePaths) {
       graphics.lines!.push({
         points: tracePath,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -0,0 +1,239 @@
+import type { GraphicsObject } from "graphics-debug"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type {
+  ChipId,
+  InputChip,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import type { Point } from "@tscircuit/math-utils"
+import { calculateElbow } from "calculate-elbow"
+import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
+import { getObstacleRects, type ChipWithBounds } from "./rect"
+import { findFirstCollision, isHorizontal, isVertical } from "./collisions"
+import {
+  aabbFromPoints,
+  candidateMidsFromSet,
+  midBetweenPointAndRect,
+  type Axis,
+} from "./mid"
+import { pathKey, shiftSegmentOrth } from "./pathOps"
+
+type PathKey = string
+
+export class SchematicTraceSingleLineSolver2 extends BaseSolver {
+  pins: MspConnectionPair["pins"]
+  inputProblem: InputProblem
+  chipMap: Record<string, InputChip>
+
+  obstacles: ChipWithBounds[]
+  rectById: Map<string, ChipWithBounds>
+  aabb: { minX: number; maxX: number; minY: number; maxY: number }
+
+  baseElbow: Point[]
+
+  solvedTracePath: Point[] | null = null
+
+  private queue: Array<{ path: Point[]; collisionChipIds: Set<ChipId> }> = []
+  private visited: Set<PathKey> = new Set()
+
+  constructor(params: {
+    pins: MspConnectionPair["pins"]
+    inputProblem: InputProblem
+    chipMap: Record<string, InputChip>
+  }) {
+    super()
+    this.pins = params.pins
+    this.inputProblem = params.inputProblem
+    this.chipMap = params.chipMap
+
+    // Ensure facing directions are present
+    for (const pin of this.pins) {
+      if (!pin._facingDirection) {
+        const chip = this.chipMap[pin.chipId]
+        pin._facingDirection = getPinDirection(pin, chip)
+      }
+    }
+
+    // Build obstacle rects from chips
+    this.obstacles = getObstacleRects(this.inputProblem)
+    this.rectById = new Map(this.obstacles.map((r) => [r.chipId, r]))
+
+    // Build initial elbow path
+    const [pin1, pin2] = this.pins
+    this.baseElbow = calculateElbow(
+      {
+        x: pin1.x,
+        y: pin1.y,
+        facingDirection: pin1._facingDirection!,
+      },
+      {
+        x: pin2.x,
+        y: pin2.y,
+        facingDirection: pin2._facingDirection!,
+      },
+      { overshoot: 0.2 },
+    )
+
+    // Bounds defined by PA and PB
+    this.aabb = aabbFromPoints(
+      { x: pin1.x, y: pin1.y },
+      { x: pin2.x, y: pin2.y },
+    )
+
+    // Seed search
+    this.queue.push({ path: this.baseElbow, collisionChipIds: new Set() })
+    this.visited.add(pathKey(this.baseElbow))
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof SchematicTraceSingleLineSolver2
+  >[0] {
+    return {
+      chipMap: this.chipMap,
+      pins: this.pins,
+      inputProblem: this.inputProblem,
+    }
+  }
+
+  private axisOfSegment(a: Point, b: Point): Axis | null {
+    if (isVertical(a, b)) return "x"
+    if (isHorizontal(a, b)) return "y"
+    return null
+  }
+
+  private pathLength(pts: Point[]): number {
+    let sum = 0
+    for (let i = 0; i < pts.length - 1; i++) {
+      sum +=
+        Math.abs(pts[i + 1]!.x - pts[i]!.x) +
+        Math.abs(pts[i + 1]!.y - pts[i]!.y)
+    }
+    return sum
+  }
+
+  override _step() {
+    if (this.solvedTracePath) {
+      this.solved = true
+      return
+    }
+
+    const state = this.queue.shift()
+    if (!state) {
+      this.failed = true
+      this.error = "No collision-free path found"
+      return
+    }
+
+    const { path, collisionChipIds } = state
+
+    const collision = findFirstCollision(path, this.obstacles)
+
+    if (!collision) {
+      this.solvedTracePath = path
+      this.solved = true
+      return
+    }
+
+    let { segIndex, rect } = collision
+
+    // Never move the first or last segments - move adjacent segment instead
+    const isFirstSegment = segIndex === 0
+    const isLastSegment = segIndex === path.length - 2
+
+    if (isFirstSegment) {
+      // If first segment collides, move the second segment instead
+      if (path.length < 3) {
+        // Path too short to have an adjacent segment to move
+        return
+      }
+      segIndex = 1
+    } else if (isLastSegment) {
+      // If last segment collides, move the second-to-last segment instead
+      if (path.length < 3) {
+        // Path too short to have an adjacent segment to move
+        return
+      }
+      segIndex = path.length - 3
+    }
+
+    const a = path[segIndex]!
+    const b = path[segIndex + 1]!
+    const axis = this.axisOfSegment(a, b)
+    if (!axis) {
+      // Should not happen for elbow paths
+      return
+    }
+
+    const [PA, PB] = this.pins
+    const candidates: number[] = []
+
+    if (collisionChipIds.size === 0) {
+      // First collision on this search branch: use mid(PA, C) and mid(PB, C)
+      const m1 = midBetweenPointAndRect(axis, { x: PA.x, y: PA.y }, rect)
+      const m2 = midBetweenPointAndRect(axis, { x: PB.x, y: PB.y }, rect)
+
+      // Combine and deduplicate candidates
+      const allCandidates = [...m1, ...m2]
+      const uniqueCandidates = [...new Set(allCandidates)]
+      candidates.push(...uniqueCandidates)
+    } else {
+      // Subsequent collisions: mid between C and nearest rect/bounds from the set
+      const mids = candidateMidsFromSet(
+        axis,
+        rect,
+        this.rectById,
+        collisionChipIds,
+        this.aabb,
+      )
+      candidates.push(...mids)
+    }
+
+    // Generate new shifted paths, order by total path length (shorter first)
+    const newStates: Array<{
+      path: Point[]
+      collisionRectIds: Set<string>
+      len: number
+    }> = []
+
+    for (const coord of candidates) {
+      const newPath = shiftSegmentOrth(path, segIndex, axis, coord)
+      if (!newPath) continue
+      const key = pathKey(newPath)
+      if (this.visited.has(key)) continue
+      this.visited.add(key)
+      const nextSet = new Set(collisionChipIds)
+      nextSet.add(rect.chipId)
+      const len = this.pathLength(newPath)
+      newStates.push({ path: newPath, collisionRectIds: nextSet, len })
+    }
+
+    newStates.sort((a, b) => a.len - b.len)
+    for (const st of newStates) {
+      this.queue.push({ path: st.path, collisionChipIds: st.collisionRectIds })
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const g = visualizeInputProblem(this.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    // Draw all the new candidates
+    for (const { path, collisionChipIds: collisionRectIds } of this.queue) {
+      g.lines!.push({ points: path, strokeColor: "teal", strokeDash: "2 2" })
+    }
+
+    if (this.solvedTracePath) {
+      g.lines!.push({ points: this.solvedTracePath, strokeColor: "green" })
+    } else if (this.queue.length > 0) {
+      // Show next candidate to be explored
+      g.lines!.push({ points: this.queue[0]!.path, strokeColor: "orange" })
+    }
+
+    return g
+  }
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts

@@ -0,0 +1,57 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { ChipWithBounds } from "./rect"
+
+const EPS = 1e-9
+
+export const isVertical = (a: Point, b: Point, eps = EPS) =>
+  Math.abs(a.x - b.x) < eps
+export const isHorizontal = (a: Point, b: Point, eps = EPS) =>
+  Math.abs(a.y - b.y) < eps
+
+export const segmentIntersectsRect = (
+  a: Point,
+  b: Point,
+  r: ChipWithBounds,
+  eps = EPS,
+): boolean => {
+  const vert = isVertical(a, b, eps)
+  const horz = isHorizontal(a, b, eps)
+  if (!vert && !horz) return false
+
+  if (vert) {
+    const x = a.x
+    if (x < r.minX - eps || x > r.maxX + eps) return false
+    const segMinY = Math.min(a.y, b.y)
+    const segMaxY = Math.max(a.y, b.y)
+    const overlap = Math.min(segMaxY, r.maxY) - Math.max(segMinY, r.minY)
+    return overlap > eps
+  } else {
+    const y = a.y
+    if (y < r.minY - eps || y > r.maxY + eps) return false
+    const segMinX = Math.min(a.x, b.x)
+    const segMaxX = Math.max(a.x, b.x)
+    const overlap = Math.min(segMaxX, r.maxX) - Math.max(segMinX, r.minX)
+    return overlap > eps
+  }
+}
+
+export const findFirstCollision = (
+  pts: Point[],
+  rects: ChipWithBounds[],
+  opts: {
+    excludeRectIdsForSegment?: (segIndex: number) => Set<string>
+  } = {},
+): { segIndex: number; rect: ChipWithBounds } | null => {
+  for (let i = 0; i < pts.length - 1; i++) {
+    const a = pts[i]!
+    const b = pts[i + 1]!
+    const excluded = opts.excludeRectIdsForSegment?.(i) ?? new Set<string>()
+    for (const r of rects) {
+      if (excluded.has(r.chipId)) continue
+      if (segmentIntersectsRect(a, b, r)) {
+        return { segIndex: i, rect: r }
+      }
+    }
+  }
+  return null
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid.ts

@@ -0,0 +1,97 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { ChipWithBounds } from "./rect"
+
+const EPS = 1e-9
+
+export type Axis = "x" | "y"
+
+export const aabbFromPoints = (a: Point, b: Point) => ({
+  minX: Math.min(a.x, b.x),
+  maxX: Math.max(a.x, b.x),
+  minY: Math.min(a.y, b.y),
+  maxY: Math.max(a.y, b.y),
+})
+
+export const midBetweenPointAndRect = (
+  axis: Axis,
+  p: Point,
+  r: ChipWithBounds,
+  eps = EPS,
+): number[] => {
+  if (axis === "x") {
+    if (p.x < r.minX - eps) {
+      return [(p.x + r.minX) / 2]
+    }
+    if (p.x > r.maxX + eps) {
+      return [(p.x + r.maxX) / 2]
+    }
+    // Point is within rect bounds on this axis - generate candidates on both sides
+    return [r.minX - 0.2, r.maxX + 0.2]
+  } else {
+    if (p.y < r.minY - eps) {
+      return [(p.y + r.minY) / 2]
+    }
+    if (p.y > r.maxY + eps) {
+      return [(p.y + r.maxY) / 2]
+    }
+    // Point is within rect bounds on this axis - generate candidates on both sides
+    return [r.minY - 0.2, r.maxY + 0.2]
+  }
+}
+
+export const candidateMidsFromSet = (
+  axis: Axis,
+  colliding: ChipWithBounds,
+  rectsById: Map<string, ChipWithBounds>,
+  collisionRectIds: Set<string>,
+  aabb: { minX: number; maxX: number; minY: number; maxY: number },
+  eps = EPS,
+): number[] => {
+  const setRects = [...collisionRectIds]
+    .map((id) => rectsById.get(id))
+    .filter((r): r is ChipWithBounds => !!r)
+
+  if (axis === "x") {
+    const leftBoundaries = [aabb.minX, ...setRects.map((r) => r.maxX)].filter(
+      (v) => v < colliding.minX - eps,
+    )
+    const rightBoundaries = [aabb.maxX, ...setRects.map((r) => r.minX)].filter(
+      (v) => v > colliding.maxX + eps,
+    )
+
+    const leftNeighbor =
+      leftBoundaries.length > 0 ? Math.max(...leftBoundaries) : undefined
+    const rightNeighbor =
+      rightBoundaries.length > 0 ? Math.min(...rightBoundaries) : undefined
+
+    const out: number[] = []
+    if (leftNeighbor !== undefined) {
+      out.push((leftNeighbor + colliding.minX) / 2)
+    }
+    if (rightNeighbor !== undefined) {
+      out.push((colliding.maxX + rightNeighbor) / 2)
+    }
+    return out
+  } else {
+    const bottomBoundaries = [aabb.minY, ...setRects.map((r) => r.maxY)].filter(
+      (v) => v < colliding.minY - eps,
+    )
+    const topBoundaries = [aabb.maxY, ...setRects.map((r) => r.minY)].filter(
+      (v) => v > colliding.maxY + eps,
+    )
+
+    const bottomNeighbor =
+      bottomBoundaries.length > 0 ? Math.max(...bottomBoundaries) : undefined
+    const topNeighbor =
+      topBoundaries.length > 0 ? Math.min(...topBoundaries) : undefined
+
+    const out: number[] = []
+    if (bottomNeighbor !== undefined) {
+      out.push((bottomNeighbor + colliding.minY) / 2)
+    }
+    if (topNeighbor !== undefined) {
+      out.push((colliding.maxY + topNeighbor) / 2)
+    }
+    return out
+  }
+}