obstacleMargin / defaultObstacleMargin has no effect on produced clearance (non-monotonic)

[maci0]

The pipelines thread srj.defaultObstacleMargin into the HD solvers (obstacleMargin: cms.srj.defaultObstacleMargin ?? 0.15), but the produced clearance does not track it.

Repro

Route bugreport01 at increasing defaultObstacleMargin and measure the smallest different-net trace-edge-to-edge gap in the output (via minimumDistanceBetweenSegments minus half-widths):

AutoroutingPipelineSolver4 (the default CapacityMeshAutorouter picks):

obstacleMargin=0    -> min gap 0.1135 mm
obstacleMargin=0.1  -> min gap 0.1257 mm
obstacleMargin=0.2  -> min gap 0.0992 mm   <- smaller than margin=0
obstacleMargin=0.3  -> min gap 0.1139 mm

AutoroutingPipelineSolver2 (): flat 0.1130 mm for every margin 0…0.3.

Expected: the min produced gap grows monotonically with obstacleMargin.
Actual: it is noise around ~0.11mm (Pipeline4) or perfectly flat (Pipeline2).

Impact

There is no way to widen the router's clearance target. On a dense 2-layer board
(1.27mm module edge + a USB-C pad row) the router squeezes different-net copper to
~0.005-0.076mm - below JLC's 0.0889mm (3.5mil) floor - and raising
traceClearance/defaultObstacleMargin does nothing to fix it. Combined with #1507
(crossing penalty) this makes dense boards unroutable to a fab-clean DRC.

Repro test attached on request (routes the fixture at several margins and prints the min gap).

[maci0]

Runnable repro (drop in tests/, uses the bundled bugreport01 fixture):

import { test } from "bun:test"
import { readFileSync } from "node:fs"
import { AutoroutingPipelineSolver4 as CapacityMeshSolver } from "../lib"
import { minimumDistanceBetweenSegments } from "../lib/utils/minimumDistanceBetweenSegments"
import type { SimpleRouteJson } from "../lib/types"

// Route the same board at increasing obstacleMargin and measure the smallest
// different-net trace-edge-to-edge gap actually produced. If the router honors
// obstacleMargin the produced gap should grow monotonically with it.
test("produced clearance vs configured obstacleMargin (should be monotonic)", () => {
  const raw = JSON.parse(
    readFileSync(
      "fixtures/bug-reports/bugreport01-be84eb/bugreport01-be84eb.json",
      "utf8",
    ),
  )
  const base: SimpleRouteJson = raw.simple_route_json ?? raw

  const minGapFor = (margin: number): number => {
    const srj = JSON.parse(JSON.stringify(base)) as SimpleRouteJson
    srj.defaultObstacleMargin = margin
    const solver = new CapacityMeshSolver(srj as any)
    solver.solve()
    if (!(solver as any).solved) return NaN
    const traces = (solver as any).getOutputSimplifiedPcbTraces()
    const segs: Array<{
      conn: string
      layer: string
      w: number
      a: { x: number; y: number }
      b: { x: number; y: number }
    }> = []
    for (const t of traces) {
      for (let i = 0; i < t.route.length - 1; i++) {
        const p = t.route[i]
        const q = t.route[i + 1]
        if (p.route_type !== "wire" || q.route_type !== "wire") continue
        if (p.layer !== q.layer) continue
        segs.push({
          conn: t.connection_name,
          layer: p.layer,
          w: p.width,
          a: { x: p.x, y: p.y },
          b: { x: q.x, y: q.y },
        })
      }
    }
    let min = Infinity
    for (let i = 0; i < segs.length; i++)
      for (let j = i + 1; j < segs.length; j++) {
        const a = segs[i]
        const b = segs[j]
        if (a.conn === b.conn || a.layer !== b.layer) continue
        const gap =
          minimumDistanceBetweenSegments(a.a, a.b, b.a, b.b) - (a.w + b.w) / 2
        if (gap < min) min = gap
      }
    return min
  }

  for (const m of [0, 0.1, 0.2, 0.3]) {
    console.log(`obstacleMargin=${m}  ->  min produced gap=${minGapFor(m).toFixed(4)}mm`)
  }
})

Output on AutoroutingPipelineSolver4:

obstacleMargin=0    -> min produced gap 0.1135 mm
obstacleMargin=0.1  -> 0.1257 mm
obstacleMargin=0.2  -> 0.0992 mm
obstacleMargin=0.3  -> 0.1139 mm

Non-monotonic, ~flat at 0.11 mm regardless of the configured margin.