@tscircuit/fanout-solver 0.0.64 → 0.0.65

package/lib/fanout-solver.ts

@@ -39,6 +39,13 @@ import {
   routeBusAlternatives,
   routeBusAlternativesSteps,
 } from "./route-bus"
+import { routePeripheralSourceEscapesSteps } from "./route-peripheral-source-escapes"
+import { routeStagedPerimeterBusSteps } from "./route-staged-perimeter-bus"
+import { routeReservedSourceBusesSteps } from "./route-reserved-source-buses"
+import { repairPeripheralBusLengthsSteps } from "./repair-peripheral-bus-lengths"
+import { routeSplitPerimeterSourceEscapesSteps } from "./route-split-perimeter-source-escapes"
+import { routeSplitPerimeterBusSteps } from "./route-split-perimeter-bus"
+import { routeShallowSplitPerimeterBusSteps } from "./route-shallow-split-perimeter-bus"
 import { routeSingleLayerWithAdaptiveExitsSteps } from "./route-single-layer-adaptive-exits"
 import { routeSingleLayerWithPushAndShove } from "./route-single-layer-push-shove"
 import { getRuntimeProcess } from "./runtime-process"
@@ -84,6 +91,8 @@ interface ResolvedFanoutConfig {
 
 interface EvaluatedAssignment extends AssignmentAttempt {
   blockingBusIds: string[]
+  /** The bounded peripheral strategy may finish after complete validation. */
+  stopAfterCompleteValidation?: true
 }
 
 interface GroupedBeamState {
@@ -94,6 +103,7 @@ interface GroupedBeamState {
 interface MixedTerminationState {
   plans: FanoutRoutePlan[]
   failedBusIds: string[]
+  stopAfterCompleteValidation?: true
 }
 
 type RoutingStrategy = "default" | "group-by-layer" | "deep-first"
@@ -513,6 +523,43 @@ function createInitialLayerAssignment(params: {
     ) {
       assignment[bus.busId] = sourceLayer
     } else if (viaLayers.length > 0) {
+      // A source strictly inside a wide field can be enclosed by its routes.
+      // Boundary sources still have an outward channel, so preserve the
+      // ordinary layer preference for those buses.
+      const sourceXs = bus.connections.map(
+        (connection) => connection.sourcePoint.x,
+      )
+      const sourceYs = bus.connections.map(
+        (connection) => connection.sourcePoint.y,
+      )
+      const embeddedSingletonCount = (layer: string) =>
+        buses.filter((other) => {
+          const point = other.connections[0]?.sourcePoint
+          return (
+            other.termination.type === "boundary" &&
+            point !== undefined &&
+            point.x > Math.min(...sourceXs) + 1e-9 &&
+            point.x < Math.max(...sourceXs) - 1e-9 &&
+            point.y > Math.min(...sourceYs) + 1e-9 &&
+            point.y < Math.max(...sourceYs) - 1e-9 &&
+            getCommonExplicitExitTargetLayer(other) === layer &&
+            isDenseSingletonEmbeddedInMultiLayerWideBus({
+              singletonBus: other,
+              singletonTargetLayer: layer,
+              wideBuses: [bus],
+            })
+          )
+        }).length
+      const isolatedLayers = viaLayers.toSorted(
+        (a, b) => embeddedSingletonCount(a) - embeddedSingletonCount(b),
+      )
+      if (
+        embeddedSingletonCount(isolatedLayers[0]!) <
+        embeddedSingletonCount(viaLayers[0]!)
+      ) {
+        assignment[bus.busId] = isolatedLayers[0]!
+        continue
+      }
       if (
         preferOrderedCoordinatedWindingLayers &&
         busUsesCoordinatedWinding(bus)
@@ -1535,6 +1582,127 @@ export class FanoutSolver extends BaseSolver {
     })
   }
 
+  /** Reserve source escapes before joining complete buses around the package. */
+  private *routePeripheralMixedTerminationSteps(params: {
+    busLayerAssignments: Readonly<Record<string, string>>
+    busesInRoutingOrder: readonly PreparedBus[]
+  }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
+    if (this.config.allowBlindAndBuriedVias) return null
+    const bus = params.busesInRoutingOrder.find(
+      (candidate) =>
+        candidate.termination.type === "boundary" &&
+        (candidate.exitEdge === "right" || candidate.exitEdge === "left") &&
+        candidate.connections.length >= 16 &&
+        candidate.componentObstacles.length >= 200,
+    )
+    if (!bus) return null
+    const targetLayer = params.busLayerAssignments[bus.busId]
+    if (!targetLayer) return null
+    const targetLayerByBusId = new Map(
+      Object.entries(params.busLayerAssignments),
+    )
+    this.setInProgressPlans({
+      phase: "route-peripheral-source-escapes",
+      plans: [],
+      busId: bus.busId,
+    })
+    const sourceSteps = (
+      bus.exitEdge === "left"
+        ? routeSplitPerimeterSourceEscapesSteps
+        : routePeripheralSourceEscapesSteps
+    )({
+      ...this.config,
+      srj: this.routingSrj,
+      buses: this.preparedBuses,
+      bus,
+      targetLayer,
+      targetLayerByBusId,
+    })
+    let sourceResult = sourceSteps.next()
+    while (!sourceResult.done) {
+      yield
+      sourceResult = sourceSteps.next()
+    }
+    if (!sourceResult.value) return null
+    let source = sourceResult.value
+    const stageParams = {
+      ...this.config,
+      ...source,
+      srj: this.routingSrj,
+      bus,
+      targetLayer,
+    }
+    const stageSteps =
+      "lowerConnectionIndices" in source
+        ? routeSplitPerimeterBusSteps({ ...stageParams, ...source })
+        : routeStagedPerimeterBusSteps(stageParams)
+    let stageResult = stageSteps.next()
+    while (!stageResult.done) {
+      yield
+      stageResult = stageSteps.next()
+    }
+    let stagePlans = stageResult.value
+    if (!stagePlans && "lowerConnectionIndices" in source) {
+      const shallowSteps = routeShallowSplitPerimeterBusSteps({
+        ...stageParams,
+        ...source,
+        buses: this.preparedBuses,
+      })
+      let shallowResult = shallowSteps.next()
+      while (!shallowResult.done) {
+        yield
+        shallowResult = shallowSteps.next()
+      }
+      if (shallowResult.value) {
+        source = shallowResult.value
+        stagePlans = shallowResult.value.plans
+      }
+    }
+    if (!stagePlans) return null
+    this.setInProgressPlans({
+      phase: "route-peripheral-bus-continuations",
+      plans: stagePlans,
+      busId: bus.busId,
+    })
+    const remainingSteps = routeReservedSourceBusesSteps({
+      ...this.config,
+      srj: this.routingSrj,
+      buses: this.preparedBuses,
+      sourceEscapes: source.sourceEscapes,
+      sourceBoundary: source.sourceBoundary,
+      initialPlans: stagePlans,
+      targetLayerByBusId,
+    })
+    let remainingResult = remainingSteps.next()
+    while (!remainingResult.done) {
+      yield
+      remainingResult = remainingSteps.next()
+    }
+    if (!remainingResult.value) return null
+    const repairSteps = repairPeripheralBusLengthsSteps({
+      ...this.config,
+      srj: this.routingSrj,
+      inputSrj: this.inputSrj,
+      plans: remainingResult.value,
+      preparedBuses: this.preparedBuses,
+      sharedBoundary: this.getValidationBoundary(),
+    })
+    let repairResult = repairSteps.next()
+    while (!repairResult.done) {
+      yield
+      repairResult = repairSteps.next()
+    }
+    if (!repairResult.value) return null
+    const plans = repairResult.value
+    const output = buildOutputSimpleRouteJson({
+      inputSrj: this.inputSrj,
+      plans,
+      layerNames: this.config.layerNames,
+    })
+    if (!this.validateCompletePlans(plans, output).valid) return null
+    return { plans, failedBusIds: [], stopAfterCompleteValidation: true }
+  }
+
   /**
    * Through-all source vias from a wide boundary bus can consume the only
    * legal dogbone channel for nearby plane pads. Conversely, routing hundreds
@@ -5142,6 +5310,23 @@ export class FanoutSolver extends BaseSolver {
 
     let mixedTerminationState: MixedTerminationState | null = null
     if (!useSingleLayerPushAndShove && routingStrategy === "default") {
+      const peripheralSolver = this.createWorkSolver(
+        "PeripheralMixedTerminationSolver",
+        this.routePeripheralMixedTerminationSteps({
+          busLayerAssignments,
+          busesInRoutingOrder,
+        }),
+      )
+      mixedTerminationState = (yield {
+        type: "subsolver",
+        solver: peripheralSolver,
+      }) as MixedTerminationState | null
+    }
+    if (
+      !mixedTerminationState &&
+      !useSingleLayerPushAndShove &&
+      routingStrategy === "default"
+    ) {
       const denseSolver = this.createWorkSolver(
         "DenseMixedTerminationSolver",
         this.routeDenseThroughAllMixedTerminationSteps({
@@ -5341,6 +5526,10 @@ export class FanoutSolver extends BaseSolver {
     return {
       summary,
       plans,
+      ...(mixedTerminationState?.stopAfterCompleteValidation &&
+      validation?.valid
+        ? { stopAfterCompleteValidation: true as const }
+        : {}),
       blockingBusIds: [...blockingBusCounts.entries()]
         .toSorted(([, firstCount], [, secondCount]) => secondCount - firstCount)
         .map(([busId]) => busId),
@@ -5361,7 +5550,8 @@ export class FanoutSolver extends BaseSolver {
     if (
       bestAttempt.summary.routedConnectionCount ===
         this.inputSrj.connections.length &&
-      this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0
+      (bestAttempt.stopAfterCompleteValidation ||
+        this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0)
     ) {
       return bestAttempt
     }
@@ -5378,7 +5568,8 @@ export class FanoutSolver extends BaseSolver {
       if (
         bestAttempt.summary.routedConnectionCount ===
           this.inputSrj.connections.length &&
-        this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0
+        (bestAttempt.stopAfterCompleteValidation ||
+          this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0)
       ) {
         return bestAttempt
       }
@@ -5932,10 +6123,11 @@ export class FanoutSolver extends BaseSolver {
       bestScore: this.bestAttempt.summary.score,
     }
     if (
-      this.groupedBeamEvaluated &&
-      attempt.summary.routedConnectionCount ===
-        this.inputSrj.connections.length &&
-      this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0
+      (attempt.stopAfterCompleteValidation && this.hasCompleteBestAttempt()) ||
+      (this.groupedBeamEvaluated &&
+        attempt.summary.routedConnectionCount ===
+          this.inputSrj.connections.length &&
+        this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0)
     ) {
       this.completeBestAttemptEndpoints()
       this.solved = true

package/lib/get-free-boundary-tracks.ts

@@ -0,0 +1,102 @@
+import { getCornerBandSide } from "./boundary-exit"
+import type { RouteBusParams } from "./route-bus"
+
+/** Midpoints of unoccupied edge intervals, clipped to the bus's declared band. */
+export function getFreeBoundaryTracks(
+  params: Pick<
+    RouteBusParams,
+    | "bus"
+    | "targetLayer"
+    | "acceptedPlans"
+    | "reservedVias"
+    | "traceWidth"
+    | "clearance"
+  >,
+): number[] {
+  const { bus, targetLayer, traceWidth, clearance } = params
+  if (!bus.exitEdge) return []
+  const vertical = bus.exitEdge === "left" || bus.exitEdge === "right"
+  const along = vertical ? "y" : "x"
+  const across = vertical ? "x" : "y"
+  const boundary = bus.sharedBoundary
+  const edge =
+    bus.exitEdge === "left"
+      ? boundary.minX
+      : bus.exitEdge === "right"
+        ? boundary.maxX
+        : bus.exitEdge === "bottom"
+          ? boundary.minY
+          : boundary.maxY
+  const lower = vertical ? boundary.minY : boundary.minX
+  const upper = vertical ? boundary.maxY : boundary.maxX
+  const middle = (lower + upper) / 2
+  const side = getCornerBandSide(bus.exitEdge, bus.preferredExit)
+  const minimum = (side === "maximum" ? middle : lower) + traceWidth / 2
+  const maximum = (side === "minimum" ? middle : upper) - traceWidth / 2
+  const blocked: [number, number][] = []
+  for (const plan of params.acceptedPlans) {
+    for (const segment of [
+      ...plan.segments,
+      ...(plan.planeEndpointSegments ?? []),
+    ]) {
+      if (segment.layer !== targetLayer) continue
+      const radius = (segment.width + traceWidth) / 2 + clearance
+      const start = segment.start[across]
+      const delta = segment.end[across] - start
+      let from = 0
+      let to = 1
+      if (Math.abs(delta) < 1e-9) {
+        if (Math.abs(start - edge) > radius) continue
+      } else {
+        const first = (edge - radius - start) / delta
+        const last = (edge + radius - start) / delta
+        from = Math.max(0, Math.min(first, last))
+        to = Math.min(1, Math.max(first, last))
+        if (from > to) continue
+      }
+      const alongStart = segment.start[along]
+      const alongDelta = segment.end[along] - alongStart
+      const first = alongStart + from * alongDelta
+      const last = alongStart + to * alongDelta
+      blocked.push([
+        Math.min(first, last) - radius,
+        Math.max(first, last) + radius,
+      ])
+    }
+  }
+  const vias = [
+    ...params.acceptedPlans.flatMap((plan) => [
+      ...(plan.via ? [plan.via] : []),
+      ...(plan.additionalVias ?? []),
+      ...(plan.planeEndpointVia ? [plan.planeEndpointVia] : []),
+    ]),
+    ...(params.reservedVias ?? []).map((reserved) => reserved.via),
+  ]
+  for (const via of vias) {
+    if (!via.spanLayers.includes(targetLayer)) continue
+    const radius = via.diameter / 2 + traceWidth / 2 + clearance
+    const distance = Math.abs(via.center[across] - edge)
+    if (distance >= radius) continue
+    const extent = Math.sqrt(radius * radius - distance * distance)
+    blocked.push([via.center[along] - extent, via.center[along] + extent])
+  }
+  const gaps: [number, number][] = []
+  let cursor = minimum
+  for (const [from, to] of blocked.sort((a, b) => a[0] - b[0])) {
+    if (to <= cursor || from >= maximum) continue
+    if (from > cursor) gaps.push([cursor, Math.min(from, maximum)])
+    cursor = Math.max(cursor, to)
+    if (cursor >= maximum) break
+  }
+  if (cursor < maximum) gaps.push([cursor, maximum])
+  // Edge order gives deterministic, symmetric coverage without hard-coded tracks.
+  const tracks = gaps
+    .filter(([from, to]) => to - from > 1e-6)
+    .map(([from, to]) => (from + to) / 2)
+  return tracks.length <= 32
+    ? tracks
+    : Array.from(
+        { length: 32 },
+        (_, index) => tracks[Math.round((index * (tracks.length - 1)) / 31)]!,
+      )
+}

package/lib/match-angularly-ordered-local-vias.ts

@@ -0,0 +1,239 @@
+import { distance, distancePointToSegment, segmentsAreClear } from "./geometry"
+import {
+  getComponentDogboneViaSiteCandidates,
+  matchComponentDogboneViaSites,
+  type DogboneViaSiteGeometryRules,
+} from "./match-component-dogbone-via-sites"
+import type {
+  Point2D,
+  PreparedBus,
+  PreparedConnection,
+  RoutedSegment,
+} from "./types"
+
+const EPSILON = 1e-9
+const TAU = Math.PI * 2
+interface Candidate {
+  connectionIndex: number
+  point: Point2D
+  angle: number
+  sourceSegment: RoutedSegment
+  siteIndex: number
+}
+
+/** Reserve ordered source vias, then assign every remaining source via together. */
+export function matchAngularlyOrderedLocalVias(params: {
+  buses: readonly PreparedBus[]
+  busId: string
+  rules: DogboneViaSiteGeometryRules
+  maximumOrderingStates?: number
+  maximumCompleteAssignments?: number
+}): Map<number, Point2D> | null {
+  const { buses, rules } = params
+  const bus = buses.find((b) => b.busId === params.busId)
+  if (
+    !bus ||
+    bus.termination.type !== "boundary" ||
+    !bus.exitEdge ||
+    bus.connections.length < 3
+  )
+    return null
+  const maximumOrderingStates = params.maximumOrderingStates ?? 10_000
+  const maximumCompleteAssignments = params.maximumCompleteAssignments ?? 16
+  for (const [name, value] of Object.entries({
+    maximumOrderingStates,
+    maximumCompleteAssignments,
+  })) {
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new Error(`FanoutSolver: ${name} must be a positive safe integer`)
+  }
+  const center = {
+    x: (bus.componentBounds.minX + bus.componentBounds.maxX) / 2,
+    y: (bus.componentBounds.minY + bus.componentBounds.maxY) / 2,
+  }
+  const angle = (p: Point2D) => Math.atan2(p.y - center.y, p.x - center.x)
+  const targetCoordinate = (c: PreparedConnection) => {
+    const p = c.exitTargetPoint ?? c.targetPoint
+    return bus.exitEdge === "right"
+      ? p.y
+      : bus.exitEdge === "top"
+        ? -p.x
+        : bus.exitEdge === "left"
+          ? -p.y
+          : p.x
+  }
+  const ordered = bus.connections.toSorted(
+    (a, b) =>
+      targetCoordinate(a) - targetCoordinate(b) ||
+      a.connectionIndex - b.connectionIndex,
+  )
+  const sourceAngles: number[] = []
+  for (const c of ordered) {
+    if (distance(c.sourcePoint, center) < EPSILON) return null
+    let a = angle(c.sourcePoint)
+    while (a < (sourceAngles.at(-1) ?? a) - EPSILON) a += TAU
+    sourceAngles.push(a)
+  }
+  if (sourceAngles.at(-1)! - sourceAngles[0]! >= TAU - EPSILON) return null
+  const connections = new Map(
+    buses.flatMap((b) =>
+      b.connections.map((c) => [c.connectionIndex, c] as const),
+    ),
+  )
+  const orderedIndex = new Map(ordered.map((c, i) => [c.connectionIndex, i]))
+  const sites = new Map<string, number>()
+  const candidateGroups = new Map<number, Candidate[]>()
+  for (const c of connections.values())
+    candidateGroups.set(c.connectionIndex, [])
+  for (const raw of getComponentDogboneViaSiteCandidates(buses, rules)) {
+    const c = connections.get(raw.connectionIndex)!
+    const key = `${raw.point.x.toFixed(9)},${raw.point.y.toFixed(9)}`
+    if (!sites.has(key)) sites.set(key, sites.size)
+    const index = orderedIndex.get(raw.connectionIndex)
+    const sourceAngle = angle(c.sourcePoint)
+    const a =
+      index === undefined
+        ? angle(raw.point)
+        : sourceAngles[index]! +
+          Math.atan2(
+            Math.sin(angle(raw.point) - sourceAngle),
+            Math.cos(angle(raw.point) - sourceAngle),
+          )
+    candidateGroups.get(raw.connectionIndex)!.push({
+      ...raw,
+      angle: a,
+      siteIndex: sites.get(key)!,
+      sourceSegment: {
+        start: c.sourcePoint,
+        end: raw.point,
+        layer: c.sourceLayer,
+        width: rules.traceWidth,
+      },
+    })
+  }
+  const groups = [...candidateGroups.entries()].map(
+    ([connectionIndex, candidates]) => ({ connectionIndex, candidates }),
+  )
+  if (groups.some((g) => g.candidates.length === 0)) return null
+  const domains = ordered.map((c, i) =>
+    candidateGroups
+      .get(c.connectionIndex)!
+      .toSorted(
+        (a, b) =>
+          Math.abs(a.angle - sourceAngles[i]!) -
+            Math.abs(b.angle - sourceAngles[i]!) ||
+          distance(b.point, center) - distance(a.point, center),
+      ),
+  )
+  const requiredHoleSeparation = rules.viaHoleDiameter
+    ? rules.viaHoleDiameter + (rules.holeToHoleClearance ?? rules.clearance)
+    : 0
+  const requiredViaToTraceSeparation =
+    rules.viaDiameter / 2 + rules.traceWidth / 2 + rules.clearance
+  const compatible = (a: Candidate, b: Candidate) => {
+    const share =
+      rules.canShareCopper?.(a.connectionIndex, b.connectionIndex) ?? false
+    const minimumViaDistance = share
+      ? requiredHoleSeparation
+      : Math.max(requiredHoleSeparation, rules.viaDiameter + rules.clearance)
+    if (distance(a.point, b.point) < minimumViaDistance - EPSILON) return false
+    if (share) return true
+    return (
+      distancePointToSegment(
+        a.point,
+        b.sourceSegment.start,
+        b.sourceSegment.end,
+      ) >=
+        requiredViaToTraceSeparation - EPSILON &&
+      distancePointToSegment(
+        b.point,
+        a.sourceSegment.start,
+        a.sourceSegment.end,
+      ) >=
+        requiredViaToTraceSeparation - EPSILON &&
+      segmentsAreClear(a.sourceSegment, b.sourceSegment, rules.clearance)
+    )
+  }
+  const forbidden = new Map<Candidate, Set<Candidate>>()
+  for (const domain of domains)
+    for (const a of domain) {
+      const conflicts = new Set<Candidate>()
+      for (const group of groups)
+        for (const b of group.candidates) {
+          if (a.connectionIndex !== b.connectionIndex && !compatible(a, b))
+            conflicts.add(b)
+        }
+      forbidden.set(a, conflicts)
+    }
+  const chosen: Candidate[] = []
+  // A perfect matching is necessary because distinct drilled holes cannot use
+  // the same site. It is a pruning test; native matching still validates copper.
+  const canUseDistinctSiteCheck =
+    requiredHoleSeparation > EPSILON || !rules.canShareCopper
+  const remainingSitesCanMatch = () => {
+    if (!canUseDistinctSiteCheck) return true
+    const selected = new Map(
+      chosen.map((c) => [c.connectionIndex, c.siteIndex]),
+    )
+    const allowed = groups
+      .map((g) =>
+        g.candidates
+          .filter(
+            (c) =>
+              (!selected.has(c.connectionIndex) ||
+                selected.get(c.connectionIndex) === c.siteIndex) &&
+              chosen.every((a) => !forbidden.get(a)!.has(c)),
+          )
+          .map((c) => c.siteIndex),
+      )
+      .sort((a, b) => a.length - b.length)
+    if (allowed.some((d) => d.length === 0)) return false
+    const owner = new Int32Array(sites.size).fill(-1)
+    const augment = (index: number, visited: Uint8Array): boolean => {
+      for (const site of allowed[index]!) {
+        if (visited[site]) continue
+        visited[site] = 1
+        if (owner[site] === -1 || augment(owner[site]!, visited)) {
+          owner[site] = index
+          return true
+        }
+      }
+      return false
+    }
+    return allowed.every((_, i) => augment(i, new Uint8Array(sites.size)))
+  }
+  let states = 0
+  let completeAssignments = 0
+  let result: Map<number, Point2D> | null = null
+  const search = (index: number): boolean => {
+    if (++states > maximumOrderingStates) return false
+    if (index === domains.length) {
+      if (++completeAssignments > maximumCompleteAssignments) return false
+      const fixed = new Map(rules.fixedViaPointsByConnectionIndex)
+      for (const c of chosen) fixed.set(c.connectionIndex, c.point)
+      result = matchComponentDogboneViaSites(buses, {
+        ...rules,
+        fixedViaPointsByConnectionIndex: fixed,
+      })
+      return result !== null
+    }
+    for (const candidate of domains[index]!) {
+      if (
+        candidate.angle < (chosen.at(-1)?.angle ?? -Infinity) - EPSILON ||
+        chosen.some((c) => forbidden.get(c)!.has(candidate))
+      )
+        continue
+      chosen.push(candidate)
+      if (remainingSitesCanMatch() && search(index + 1)) return true
+      chosen.pop()
+      if (
+        states > maximumOrderingStates ||
+        completeAssignments >= maximumCompleteAssignments
+      )
+        break
+    }
+    return false
+  }
+  search(0)
+  return result
+}

package/lib/reflect-fanout-x.ts

@@ -0,0 +1,67 @@
+/**
+ * View horizontal fanout geometry from its opposite edge. A shared memo keeps
+ * pad identity intact: clearance checks compare a plan's sourceObstacle with
+ * the same obstacle in the transformed SRJ.
+ */
+export function reflectFanoutX<T>(value: T): T {
+  const memo = new Map<object, unknown>()
+  const reflect = (item: unknown): unknown => {
+    if (item === null || typeof item !== "object") return item
+    if (memo.has(item)) return memo.get(item)
+    if (item instanceof Map) {
+      const result = new Map()
+      memo.set(item, result)
+      for (const [key, entry] of item) result.set(key, reflect(entry))
+      return result
+    }
+    if (item instanceof Set) {
+      const result = new Set(item)
+      memo.set(item, result)
+      return result
+    }
+    if (Array.isArray(item)) {
+      const result: unknown[] = []
+      memo.set(item, result)
+      for (const entry of item) result.push(reflect(entry))
+      return result
+    }
+    const original = item as Record<string, unknown>
+    const result: Record<string, unknown> = {}
+    memo.set(item, result)
+    for (const [key, entry] of Object.entries(original))
+      result[key] = reflect(entry)
+    if (typeof original.x === "number" && typeof original.y === "number")
+      result.x = -original.x
+    if (
+      typeof original.minX === "number" &&
+      typeof original.maxX === "number"
+    ) {
+      result.minX = -original.maxX
+      result.maxX = -original.minX
+    }
+    if (Array.isArray(original.xCoordinates))
+      result.xCoordinates = original.xCoordinates
+        .map((x: number) => -x)
+        .sort((a, b) => a - b)
+    if (typeof original.ccwRotationDegrees === "number")
+      result.ccwRotationDegrees = -original.ccwRotationDegrees
+    const edge = (direction: string) =>
+      direction === "left"
+        ? "right"
+        : direction === "right"
+          ? "left"
+          : direction
+    for (const key of ["direction", "exitEdge", "preferredExit"] as const) {
+      if (typeof original[key] === "string")
+        result[key] = original[key].split("-").map(edge).join("-")
+    }
+    if (
+      original.cornerBandSide &&
+      (original.exitEdge === "top" || original.exitEdge === "bottom")
+    )
+      result.cornerBandSide =
+        original.cornerBandSide === "minimum" ? "maximum" : "minimum"
+    return result
+  }
+  return reflect(value) as T
+}