@tscircuit/schematic-trace-solver 0.0.57 → 0.0.61

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -20,6 +20,7 @@ import {
   isYOrientation,
   rangesOverlap,
   rectsOverlap,
+  simplifyOrthogonalPath,
   traceCrossesBoundsInterior,
   tracePathCrossesAnyBounds,
   tracePathCrossesAnyTrace,
@@ -127,7 +128,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
 
   private applyCandidate(
     label: NetLabelPlacement,
-    candidate: CandidateLabel,
+    candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
     this.outputNetLabelPlacements[labelIndex] = {
@@ -139,14 +140,33 @@ export class AvailableNetOrientationSolver extends BaseSolver {
 
   private addConnectorTrace(
     label: NetLabelPlacement,
-    candidate: CandidateLabel,
+    candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
-    const tracePath = getConnectorTracePath(
-      label.anchorPoint,
-      candidate.anchorPoint,
-      candidate.orientation,
-    )
+    let tracePath: Point[]
+
+    if (candidate.phase === "lateral-shift") {
+      const orientDir = dir(candidate.orientation)
+      const kickedSource = {
+        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP,
+      }
+      tracePath = simplifyOrthogonalPath([
+        label.anchorPoint,
+        ...getConnectorTracePath(
+          kickedSource,
+          candidate.anchorPoint,
+          candidate.orientation,
+        ),
+      ])
+    } else {
+      tracePath = getConnectorTracePath(
+        label.anchorPoint,
+        candidate.anchorPoint,
+        candidate.orientation,
+      )
+    }
+
     if (tracePath.length < 2) return
 
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`
@@ -185,10 +205,19 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       labelIndex,
       orientations,
     )
+    if (rotatedCandidate) return rotatedCandidate
+
+    const shiftedCandidate = this.findValidShiftedCandidate(
+      label,
+      orientations[0]!,
+      labelIndex,
+    )
+    if (shiftedCandidate) return shiftedCandidate
 
-    return (
-      rotatedCandidate ??
-      this.findValidShiftedCandidate(label, orientations[0]!, labelIndex)
+    return this.findValidLateralShiftedCandidate(
+      label,
+      orientations[0]!,
+      labelIndex,
     )
   }
 
@@ -266,6 +295,63 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
+  /**
+   * When all candidates fail for the current (unshifted) position, try
+   * shifting the label anchor laterally — x for y-orientations, y for
+   * x-orientations — and re-attempting the required orientation.
+   *
+   * Offsets are tried in alternating sign order:
+   *   -1·step, +1·step, -2·step, +2·step, …
+   * so the nearest escape routes are tested first.
+   */
+  private findValidLateralShiftedCandidate(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    labelIndex: number,
+  ): EvaluatedCandidate | null {
+    const direction = dir(orientation)
+    const initialBaseAnchor = this.getSearchStartAnchor(label, orientation)
+
+    // Lateral axis: perpendicular to the orientation direction
+    const lateralDir: Point = {
+      x: isYOrientation(orientation) ? 1 : 0,
+      y: isXOrientation(orientation) ? 1 : 0,
+    }
+
+    const maxSteps = Math.ceil(this.maxSearchDistance / LABEL_SEARCH_STEP)
+
+    for (let step = 1; step <= maxSteps; step++) {
+      for (const sign of [-1, 1]) {
+        const lateralOffset = sign * step * LABEL_SEARCH_STEP
+        const baseAnchor = {
+          x: initialBaseAnchor.x + lateralDir.x * lateralOffset,
+          y: initialBaseAnchor.y + lateralDir.y * lateralOffset,
+        }
+
+        const maxSearchDistance = this.getLateralColumnMaxDistance(
+          label,
+          orientation,
+          baseAnchor,
+        )
+
+        const candidate = this.findValidCandidateInShiftColumn({
+          label,
+          labelIndex,
+          orientation,
+          direction,
+          baseAnchor,
+          maxSearchDistance,
+          outwardDistance: lateralOffset,
+          phase: "lateral-shift",
+        })
+
+        if (candidate) return candidate
+      }
+    }
+
+    return null
+  }
+
   private findValidCandidateInShiftColumn(params: {
     label: NetLabelPlacement
     labelIndex: number
@@ -274,6 +360,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     baseAnchor: Point
     maxSearchDistance: number
     outwardDistance: number
+    phase?: CandidatePhase
   }) {
     const {
       label,
@@ -283,6 +370,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       baseAnchor,
       maxSearchDistance,
       outwardDistance,
+      phase = "shift",
     } = params
 
     for (
@@ -299,7 +387,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         candidate,
         label,
         labelIndex,
-        "shift",
+        phase,
         distance,
         outwardDistance,
       )
@@ -412,6 +500,32 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return Math.min(this.maxSearchDistance, labelLength * 2)
   }
 
+  private getLateralColumnMaxDistance(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    baseAnchor: Point,
+  ) {
+    const chipId = label.pinIds
+      .map((pid) => this.pinMap[pid]?.chipId)
+      .find(Boolean)
+    const chip = chipId
+      ? this.chipObstacleSpatialIndex.chips.find((c) => c.chipId === chipId)
+      : null
+
+    if (chip) {
+      if (orientation === "y-")
+        return Math.max(0, baseAnchor.y - chip.bounds.minY)
+      if (orientation === "y+")
+        return Math.max(0, chip.bounds.maxY - baseAnchor.y)
+      if (orientation === "x-")
+        return Math.max(0, baseAnchor.x - chip.bounds.minX)
+      if (orientation === "x+")
+        return Math.max(0, chip.bounds.maxX - baseAnchor.x)
+    }
+
+    return this.getSearchDistanceLimit(label, orientation)
+  }
+
   private createCandidate(
     label: NetLabelPlacement,
     anchorPoint: Point,
@@ -431,9 +545,25 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   }
 
   private getNetLabelWidth(label: NetLabelPlacement) {
-    if (!label.netId) return undefined
-    return this.inputProblem.netConnections.find(
-      (connection) => connection.netId === label.netId,
+    if (label.netId) {
+      const ncWidth = this.inputProblem.netConnections.find(
+        (connection) => connection.netId === label.netId,
+      )?.netLabelWidth
+      if (ncWidth !== undefined) return ncWidth
+
+      const dcWidthByNetId = this.inputProblem.directConnections.find(
+        (dc) => dc.netId === label.netId,
+      )?.netLabelWidth
+      if (dcWidthByNetId !== undefined) return dcWidthByNetId
+    }
+
+    const dcWidthByPinId = this.inputProblem.directConnections.find((dc) =>
+      dc.pinIds.some((pid) => label.pinIds.includes(pid)),
+    )?.netLabelWidth
+    if (dcWidthByPinId !== undefined) return dcWidthByPinId
+
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => label.pinIds.includes(pid)),
     )?.netLabelWidth
   }
 
@@ -458,6 +588,12 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       return "trace-collision"
     }
 
+    for (const chip of this.chipObstacleSpatialIndex.chips) {
+      if (tracePathCrossesAnyBounds(connectorTrace, chip.bounds)) {
+        return "chip-collision"
+      }
+    }
+
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue
       const otherLabel = this.outputNetLabelPlacements[i]!

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -168,7 +168,7 @@ export const getConnectorTracePath = (
       : [source, { x: source.x, y: target.y }, target],
   )
 
-const simplifyOrthogonalPath = (path: Point[]) => {
+export const simplifyOrthogonalPath = (path: Point[]) => {
   const deduped = path.filter(
     (point, index) => index === 0 || !pointsEqual(point, path[index - 1]!),
   )

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -33,7 +33,7 @@ export type CandidateStatus =
   | "trace-collision"
   | "netlabel-collision"
 
-export type CandidatePhase = "rotate" | "shift"
+export type CandidatePhase = "rotate" | "shift" | "lateral-shift"
 
 export type EvaluatedCandidate = CandidateLabel & {
   status: CandidateStatus

package/lib/solvers/Example28Solver/reroute.ts

@@ -1,5 +1,6 @@
 import type { Point } from "@tscircuit/math-utils"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { segmentIntersectsRect as segmentIntersectsLabelRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
@@ -73,9 +74,39 @@ export const generateRerouteCandidateResults = ({
   outputNetLabelPlacements: NetLabelPlacement[]
   chipObstacles: ChipObstacle[]
 }) => {
-  const rawCandidates = generateCandidatePaths(trace, label, inputProblem)
   const seen = new Set<string>()
   const candidateResults: RerouteCandidateResult[] = []
+  const horizontalSegmentPushCandidate = generateHorizontalSegmentPushCandidate(
+    trace,
+    label,
+  )
+
+  if (horizontalSegmentPushCandidate) {
+    candidateResults.push(
+      createCandidateResult({
+        trace,
+        obstacleLabel: label,
+        path: horizontalSegmentPushCandidate,
+        seen,
+        outputTraces,
+        outputNetLabelPlacements,
+        chipObstacles,
+        usesHorizontalSegmentPush: true,
+      }),
+    )
+  }
+
+  const rawCandidates = [
+    ...generateLabelHugCandidates(trace, label),
+    ...generateRerouteCandidates({
+      trace,
+      label,
+      problem: inputProblem,
+      paddingBuffer: LABEL_SIDE_CLEARANCE,
+      detourCount: 0,
+    }),
+    ...generateEndpointDetourCandidates(trace, label),
+  ]
 
   for (const rawCandidate of rawCandidates) {
     candidateResults.push(
@@ -94,22 +125,6 @@ export const generateRerouteCandidateResults = ({
   return candidateResults
 }
 
-const generateCandidatePaths = (
-  trace: SolvedTracePath,
-  label: NetLabelPlacement,
-  inputProblem: InputProblem,
-) => [
-  ...generateLabelHugCandidates(trace, label),
-  ...generateRerouteCandidates({
-    trace,
-    label,
-    problem: inputProblem,
-    paddingBuffer: LABEL_SIDE_CLEARANCE,
-    detourCount: 0,
-  }),
-  ...generateEndpointDetourCandidates(trace, label),
-]
-
 const createCandidateResult = ({
   trace,
   obstacleLabel,
@@ -118,6 +133,7 @@ const createCandidateResult = ({
   outputTraces,
   outputNetLabelPlacements,
   chipObstacles,
+  usesHorizontalSegmentPush,
 }: {
   trace: SolvedTracePath
   obstacleLabel: NetLabelPlacement
@@ -126,6 +142,7 @@ const createCandidateResult = ({
   outputTraces: SolvedTracePath[]
   outputNetLabelPlacements: NetLabelPlacement[]
   chipObstacles: ChipObstacle[]
+  usesHorizontalSegmentPush?: boolean
 }): RerouteCandidateResult => {
   const key = getPathKey(path)
 
@@ -133,6 +150,7 @@ const createCandidateResult = ({
     return {
       path,
       status: "duplicate",
+      usesHorizontalSegmentPush,
       selected: false,
     }
   }
@@ -143,6 +161,7 @@ const createCandidateResult = ({
     return {
       path,
       status: "chip-collision",
+      usesHorizontalSegmentPush,
       selected: false,
     }
   }
@@ -157,6 +176,7 @@ const createCandidateResult = ({
       outputNetLabelPlacements,
     }),
     status: "valid",
+    usesHorizontalSegmentPush,
     selected: false,
   }
 }
@@ -259,6 +279,13 @@ const selectBestReroutePath = ({
   outputNetLabelPlacements: NetLabelPlacement[]
   candidateResults: RerouteCandidateResult[]
 }) => {
+  for (const candidate of candidateResults) {
+    if (!candidate.usesHorizontalSegmentPush) continue
+    if (candidate.status !== "valid") continue
+    if (!candidate.score) continue
+    return candidate.path
+  }
+
   let bestPath: Point[] | null = null
   let bestScore = scoreTracePath({
     trace,
@@ -279,6 +306,99 @@ const selectBestReroutePath = ({
   return bestPath
 }
 
+const generateHorizontalSegmentPushCandidate = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+): Point[] | null => {
+  const labelDirection = dir(label.orientation)
+  if (labelDirection.x === 0) return null
+
+  const path = trace.tracePath
+  const bounds = getRectBounds(label.center, label.width, label.height)
+  const collidingVerticalSegmentIndex = path.findIndex((start, index) => {
+    const end = path[index + 1]
+    if (!end) return false
+    if (Math.abs(start.x - end.x) >= 1e-9) return false
+    return segmentIntersectsLabelRect(start, end, bounds)
+  })
+
+  if (
+    collidingVerticalSegmentIndex <= 0 ||
+    collidingVerticalSegmentIndex >= path.length - 2
+  ) {
+    return null
+  }
+
+  const previousAnchor = path[collidingVerticalSegmentIndex - 1]!
+  const verticalStart = path[collidingVerticalSegmentIndex]!
+  const verticalEnd = path[collidingVerticalSegmentIndex + 1]!
+  const nextAnchor = path[collidingVerticalSegmentIndex + 2]!
+
+  if (
+    Math.abs(previousAnchor.y - verticalStart.y) >= 1e-9 ||
+    Math.abs(verticalEnd.y - nextAnchor.y) >= 1e-9
+  ) {
+    return null
+  }
+
+  let segmentPushX = bounds.minX - LABEL_SIDE_CLEARANCE
+  if (labelDirection.x > 0) {
+    segmentPushX = bounds.maxX + LABEL_SIDE_CLEARANCE
+  }
+  const segmentPushStartY = getClearedHorizontalY({
+    start: previousAnchor,
+    end: { x: segmentPushX, y: verticalStart.y },
+    labelBounds: bounds,
+  })
+  const segmentPushEndY = getClearedHorizontalY({
+    start: { x: segmentPushX, y: verticalEnd.y },
+    end: nextAnchor,
+    labelBounds: bounds,
+  })
+
+  const segmentPushPath: Point[] = [
+    ...path.slice(0, collidingVerticalSegmentIndex - 1),
+    previousAnchor,
+  ]
+
+  if (Math.abs(previousAnchor.y - segmentPushStartY) >= 1e-9) {
+    segmentPushPath.push({ x: previousAnchor.x, y: segmentPushStartY })
+  }
+
+  segmentPushPath.push({ x: segmentPushX, y: segmentPushStartY })
+  segmentPushPath.push({ x: segmentPushX, y: segmentPushEndY })
+
+  if (Math.abs(nextAnchor.y - segmentPushEndY) >= 1e-9) {
+    segmentPushPath.push({ x: nextAnchor.x, y: segmentPushEndY })
+  }
+
+  segmentPushPath.push(
+    nextAnchor,
+    ...path.slice(collidingVerticalSegmentIndex + 3),
+  )
+
+  return simplifyPath(segmentPushPath)
+}
+
+const getClearedHorizontalY = ({
+  start,
+  end,
+  labelBounds,
+}: {
+  start: Point
+  end: Point
+  labelBounds: { minX: number; minY: number; maxX: number; maxY: number }
+}) => {
+  if (!segmentIntersectsLabelRect(start, end, labelBounds)) return start.y
+
+  const labelCenterY = (labelBounds.minY + labelBounds.maxY) / 2
+  if (start.y >= labelCenterY) {
+    return labelBounds.maxY + LABEL_HUG_CLEARANCE
+  }
+
+  return labelBounds.minY - LABEL_HUG_CLEARANCE
+}
+
 const markSelectedCandidate = (
   candidateResults: RerouteCandidateResult[],
   bestPath: Point[] | null,

package/lib/solvers/Example28Solver/types.ts

@@ -32,6 +32,7 @@ export type RerouteCandidateResult = {
   path: Point[]
   score?: TracePathScore
   status: "valid" | "duplicate" | "chip-collision"
+  usesHorizontalSegmentPush?: boolean
   selected: boolean
 }
 

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -250,6 +250,36 @@ export class NetLabelPlacementSolver extends BaseSolver {
     return groups
   }
 
+  private getNetLabelWidthForGroup(
+    group: OverlappingSameNetTraceGroup,
+  ): number | undefined {
+    if (group.netId) {
+      const ncWidth = this.inputProblem.netConnections.find(
+        (nc) => nc.netId === group.netId,
+      )?.netLabelWidth
+      if (ncWidth !== undefined) return ncWidth
+
+      const dcWidthByNetId = this.inputProblem.directConnections.find(
+        (dc) => dc.netId === group.netId,
+      )?.netLabelWidth
+      if (dcWidthByNetId !== undefined) return dcWidthByNetId
+    }
+
+    const pinIds = group.overlappingTraces?.pins.map((p) => p.pinId) ?? []
+    if (group.portOnlyPinId) {
+      pinIds.push(group.portOnlyPinId)
+    }
+
+    const dcWidthByPinId = this.inputProblem.directConnections.find((dc) =>
+      dc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelWidth
+    if (dcWidthByPinId !== undefined) return dcWidthByPinId
+
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelWidth
+  }
+
   override _step() {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement!)
@@ -273,11 +303,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
         this.currentGroup
       ) {
         this.triedAnyOrientationFallbackForCurrentGroup = true
-        const netLabelWidth = this.currentGroup.netId
-          ? this.inputProblem.netConnections.find(
-              (nc) => nc.netId === this.currentGroup!.netId,
-            )?.netLabelWidth
-          : undefined
+        const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup)
         this.activeSubSolver = new SingleNetLabelPlacementSolver({
           inputProblem: this.inputProblem,
           inputTraceMap: this.inputTraceMap,
@@ -313,11 +339,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
     this.currentGroup = nextOverlappingSameNetTraceGroup
     this.triedAnyOrientationFallbackForCurrentGroup = false
 
-    const netLabelWidth = this.currentGroup.netId
-      ? this.inputProblem.netConnections.find(
-          (nc) => nc.netId === this.currentGroup!.netId,
-        )?.netLabelWidth
-      : undefined
+    const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup)
 
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts

@@ -338,14 +338,26 @@ const getNetLabelWidth = (
   inputProblem: InputProblem,
   label: NetLabelPlacement,
 ) => {
-  const configuredWidth = inputProblem.netConnections.find(
+  const ncWidthByNetId = inputProblem.netConnections.find(
     (connection) => connection.netId === label.netId,
   )?.netLabelWidth
-  if (configuredWidth !== undefined) return configuredWidth
+  if (ncWidthByNetId !== undefined) return ncWidthByNetId
 
-  return label.orientation === "y+" || label.orientation === "y-"
-    ? label.height
-    : label.width
+  const dcWidth = inputProblem.directConnections.find((dc) =>
+    dc.pinIds.some((pid) => label.pinIds.includes(pid)),
+  )?.netLabelWidth
+  if (dcWidth !== undefined) return dcWidth
+
+  const ncWidthByPinId = inputProblem.netConnections.find((nc) =>
+    nc.pinIds.some((pid) => label.pinIds.includes(pid)),
+  )?.netLabelWidth
+  if (ncWidthByPinId !== undefined) return ncWidthByPinId
+
+  if (label.orientation === "y+" || label.orientation === "y-") {
+    return label.height
+  }
+
+  return label.width
 }
 
 const roundDistance = (distance: number) => Number(distance.toFixed(6))

package/lib/solvers/TraceCleanupSolver/is4PointRectangle.ts

@@ -1,5 +1,10 @@
 import type { Point } from "@tscircuit/math-utils"
 
+const EPS = 1e-6
+
+const sameX = (a: Point, b: Point) => Math.abs(a.x - b.x) <= EPS
+const sameY = (a: Point, b: Point) => Math.abs(a.y - b.y) <= EPS
+
 /**
  * Checks if a given path of four points forms a rectangle with horizontal and vertical segments.
  * It verifies if the path forms either an H-V-H "C" shape or a V-H-V "C" shape.
@@ -9,9 +14,9 @@ export const is4PointRectangle = (path: Point[]): boolean => {
   const [p0, p1, p2, p3] = path
   // H-V-H "C" shape
   const isHVHC =
-    p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x
+    sameY(p0, p1) && sameX(p1, p2) && sameY(p2, p3) && sameX(p0, p3)
   // V-H-V "C" shape
   const isVHVC =
-    p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y
+    sameX(p0, p1) && sameY(p1, p2) && sameX(p2, p3) && sameY(p0, p3)
   return isHVHC || isVHVC
 }

package/lib/types/InputProblem.ts

@@ -24,6 +24,7 @@ export interface InputChip {
 export interface InputDirectConnection {
   pinIds: [PinId, PinId]
   netId?: string
+  netLabelWidth?: number
 }
 
 export interface InputNetConnection {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.57",
+  "version": "0.0.61",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/examples/example35.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example35.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/examples/example36.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example36.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/examples/example37.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example37.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/examples/example38.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example38.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />