@tscircuit/schematic-trace-solver 0.0.113 → 0.0.115

package/dist/index.d.ts

@@ -146,17 +146,11 @@ type RectPadding = {
     maxY?: number;
 };
 
-type RectBounds = {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-};
-type ChipObstacleRect = RectBounds & {
+type ChipObstacleRect = Bounds & {
     kind: "chip";
     chipId: string;
 };
-type TextBoxObstacleRect = RectBounds & {
+type TextBoxObstacleRect = Bounds & {
     kind: "text_box";
     textBox: NonNullable<InputProblem["textBoxes"]>[number];
 };
@@ -586,6 +580,8 @@ declare class LongDistancePairSolver extends BaseSolver {
     solvedLongDistanceTraces: SolvedTracePath[];
     private queuedCandidatePairs;
     private currentCandidatePair;
+    private queuedFailedConnectionPairs;
+    private currentFailedConnectionPair;
     private subSolver;
     private chipMap;
     private inputProblem;
@@ -596,12 +592,15 @@ declare class LongDistancePairSolver extends BaseSolver {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
         primaryMspConnectionPairs: MspConnectionPair[];
+        failedConnectionPairs: MspConnectionPair[];
     });
     getConstructorParams(): {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
         primaryMspConnectionPairs: MspConnectionPair[];
+        failedConnectionPairs: MspConnectionPair[];
     };
+    private acceptFailedConnectionPair;
     _step(): void;
     visualize(): graphics_debug.GraphicsObject;
     getOutput(): {

package/dist/index.js

@@ -420,6 +420,33 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   return edges;
 }
 
+// lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts
+var isLabeledPeripheralConnection = ({
+  inputProblem,
+  chipMap,
+  pins
+}) => {
+  const [firstPin, secondPin] = pins;
+  const directConnection = inputProblem.directConnections.find(
+    (connection) => connection.pinIds.includes(firstPin.pinId) && connection.pinIds.includes(secondPin.pinId)
+  );
+  if (directConnection?.netLabelWidth === void 0) return false;
+  const firstChip = chipMap[firstPin.chipId];
+  const secondChip = chipMap[secondPin.chipId];
+  if (!firstChip || !secondChip) return false;
+  const hasSinglePinPeripheral = firstChip.pins.length === 1 || secondChip.pins.length === 1;
+  if (!hasSinglePinPeripheral) return false;
+  let firstFacingDirection = firstPin._facingDirection;
+  if (!firstFacingDirection) {
+    firstFacingDirection = getPinDirection(firstPin, firstChip);
+  }
+  let secondFacingDirection = secondPin._facingDirection;
+  if (!secondFacingDirection) {
+    secondFacingDirection = getPinDirection(secondPin, secondChip);
+  }
+  return firstFacingDirection === "x-" && secondFacingDirection === "x+" || firstFacingDirection === "x+" && secondFacingDirection === "x-";
+};
+
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
 var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
 var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
@@ -489,8 +516,16 @@ var MspConnectionPairSolver = class extends BaseSolver {
       const p1 = this.pinMap[pin1];
       const p2 = this.pinMap[pin2];
       const pinPairKey = getPinPairKey([pin1, pin2]);
-      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey) ? distance(p1, p2) : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
-      if (pairDistance > this.maxMspPairDistance) {
+      let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+      if (this.directConnectionPinPairKeys.has(pinPairKey)) {
+        pairDistance = distance(p1, p2);
+      }
+      const isLabeledPeripheral = isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: [p1, p2]
+      });
+      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
         return;
       }
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
@@ -1081,6 +1116,9 @@ var generateInternalSegmentCollisionDetours = ({
   ]).filter(hasOnlyNonzeroOrthogonalSegments);
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+import { boundsDistance } from "@tscircuit/math-utils";
+
 // lib/solvers/GuidelinesSolver/getInputChipBounds.ts
 function getInputChipBounds(chip) {
   const halfWidth = chip.width / 2;
@@ -1094,6 +1132,7 @@ function getInputChipBounds(chip) {
 }
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+var MIN_ROUTABLE_OBSTACLE_GAP = 0.05;
 var isTextBoxObstacle = (obstacle) => obstacle.kind === "text_box";
 var chipToRect = (chip) => {
   const b = getInputChipBounds(chip);
@@ -1102,7 +1141,17 @@ var chipToRect = (chip) => {
 var getObstacleRects = (problem, opts = {}) => {
   const chipRects = problem.chips.map(chipToRect);
   const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
-    const b = getTextBoxBounds(textBox, opts.textBoxPadding);
+    const textBounds = getTextBoxBounds(textBox, opts.textBoxPadding);
+    const attachedChipBounds = chipRects.find(
+      (chip) => chip.chipId === textBox.chipId
+    );
+    const gap = attachedChipBounds ? boundsDistance(textBounds, attachedChipBounds) : Number.POSITIVE_INFINITY;
+    const b = attachedChipBounds && gap > 0 && gap < MIN_ROUTABLE_OBSTACLE_GAP ? {
+      minX: Math.min(textBounds.minX, attachedChipBounds.maxX),
+      maxX: Math.max(textBounds.maxX, attachedChipBounds.minX),
+      minY: Math.min(textBounds.minY, attachedChipBounds.maxY),
+      maxY: Math.max(textBounds.maxY, attachedChipBounds.minY)
+    } : textBounds;
     return {
       kind: "text_box",
       textBox,
@@ -1172,9 +1221,9 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle));
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId));
     this.endpointTextObstacles = new Set(
-      endpointChipIds.size > 1 ? this.obstacles.filter(isTextBoxObstacle).filter(
+      this.obstacles.filter(isTextBoxObstacle).filter(
         (obstacle) => obstacle.textBox.chipId !== void 0 && endpointChipIds.has(obstacle.textBox.chipId)
-      ) : []
+      )
     );
     const [pin1, pin2] = this.pins;
     const directShortPath = calculateDirectShortPath(pin1, pin2);
@@ -4495,6 +4544,13 @@ var LongDistancePairSolver = class extends BaseSolver {
         pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
       }
     }
+    this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
+      (connectionPair) => isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: connectionPair.pins
+      })
+    );
     const candidatePairs = [];
     const addedPairKeys = /* @__PURE__ */ new Set();
     for (const netId of Object.keys(netConnMap.netMap)) {
@@ -4535,6 +4591,8 @@ var LongDistancePairSolver = class extends BaseSolver {
   solvedLongDistanceTraces = [];
   queuedCandidatePairs = [];
   currentCandidatePair = null;
+  queuedFailedConnectionPairs = [];
+  currentFailedConnectionPair = null;
   subSolver = null;
   chipMap = {};
   inputProblem;
@@ -4544,8 +4602,31 @@ var LongDistancePairSolver = class extends BaseSolver {
   getConstructorParams() {
     return this.params;
   }
+  acceptFailedConnectionPair(tracePath) {
+    const connectionPair = this.currentFailedConnectionPair;
+    if (!connectionPair) return;
+    const solvedTrace = {
+      ...connectionPair,
+      tracePath,
+      mspConnectionPairIds: [connectionPair.mspPairId],
+      pinIds: connectionPair.pins.map((pin) => pin.pinId)
+    };
+    this.solvedLongDistanceTraces.push(solvedTrace);
+    this.allSolvedTraces.push(solvedTrace);
+    for (const pin of connectionPair.pins) {
+      this.newlyConnectedPinIds.add(pin.pinId);
+    }
+  }
   _step() {
-    if (this.subSolver?.solved) {
+    if (this.subSolver?.solved && this.currentFailedConnectionPair) {
+      const tracePath = this.subSolver.solvedTracePath;
+      if (tracePath) {
+        this.acceptFailedConnectionPair(tracePath);
+      }
+      this.subSolver = null;
+      this.currentCandidatePair = null;
+      this.currentFailedConnectionPair = null;
+    } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath;
       if (newTracePath && this.currentCandidatePair) {
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
@@ -4576,11 +4657,23 @@ var LongDistancePairSolver = class extends BaseSolver {
     } else if (this.subSolver?.failed) {
       this.subSolver = null;
       this.currentCandidatePair = null;
+      this.currentFailedConnectionPair = null;
     }
     if (this.subSolver) {
       this.subSolver.step();
       return;
     }
+    const failedConnectionPair = this.queuedFailedConnectionPairs.shift();
+    if (failedConnectionPair) {
+      this.currentFailedConnectionPair = failedConnectionPair;
+      this.currentCandidatePair = failedConnectionPair.pins;
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: failedConnectionPair.pins,
+        chipMap: this.chipMap
+      });
+      return;
+    }
     while (this.queuedCandidatePairs.length > 0) {
       const nextPair = this.queuedCandidatePairs.shift();
       const [p1, p2] = nextPair;
@@ -10703,7 +10796,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: instance.inputProblem,
           primaryMspConnectionPairs: instance.mspConnectionPairSolver.mspConnectionPairs,
-          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths
+          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths,
+          failedConnectionPairs: instance.schematicTraceLinesSolver.failedConnectionPairs
         }
       ],
       {

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -13,6 +13,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { ConnectivityMap } from "connectivity-map"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
+import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabeledPeripheralConnection"
 
 const NEAREST_NEIGHBOR_COUNT = 3
 
@@ -28,6 +29,8 @@ export class LongDistancePairSolver extends BaseSolver {
   private currentCandidatePair:
     | [InputPin & { chipId: string }, InputPin & { chipId: string }]
     | null = null
+  private queuedFailedConnectionPairs: MspConnectionPair[] = []
+  private currentFailedConnectionPair: MspConnectionPair | null = null
   private subSolver: SchematicTraceSingleLineSolver2 | null = null
   private chipMap: Record<string, InputChip> = {}
   private inputProblem: InputProblem
@@ -40,6 +43,7 @@ export class LongDistancePairSolver extends BaseSolver {
       inputProblem: InputProblem
       alreadySolvedTraces: SolvedTracePath[]
       primaryMspConnectionPairs: MspConnectionPair[]
+      failedConnectionPairs: MspConnectionPair[]
     },
   ) {
     super()
@@ -66,6 +70,16 @@ export class LongDistancePairSolver extends BaseSolver {
         pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId })
       }
     }
+    // Retry failed MSP pairs with their existing identity before creating
+    // new nearest-neighbor candidates.
+    this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
+      (connectionPair) =>
+        isLabeledPeripheralConnection({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pins: connectionPair.pins,
+        }),
+    )
 
     // 2. Generate candidate pairs using N-Nearest-Neighbors approach
     const candidatePairs: Array<
@@ -129,9 +143,36 @@ export class LongDistancePairSolver extends BaseSolver {
     return this.params
   }
 
+  private acceptFailedConnectionPair(tracePath: SolvedTracePath["tracePath"]) {
+    const connectionPair = this.currentFailedConnectionPair
+    if (!connectionPair) return
+
+    // Reuse the original pair so downstream solvers retain its connectivity
+    // IDs, user net ID, pins, and MSP pair ID.
+    const solvedTrace: SolvedTracePath = {
+      ...connectionPair,
+      tracePath,
+      mspConnectionPairIds: [connectionPair.mspPairId],
+      pinIds: connectionPair.pins.map((pin) => pin.pinId),
+    }
+    this.solvedLongDistanceTraces.push(solvedTrace)
+    this.allSolvedTraces.push(solvedTrace)
+    for (const pin of connectionPair.pins) {
+      this.newlyConnectedPinIds.add(pin.pinId)
+    }
+  }
+
   override _step() {
     // 1. Check if a sub-solver has finished and process its result
-    if (this.subSolver?.solved) {
+    if (this.subSolver?.solved && this.currentFailedConnectionPair) {
+      const tracePath = this.subSolver.solvedTracePath
+      if (tracePath) {
+        this.acceptFailedConnectionPair(tracePath)
+      }
+      this.subSolver = null
+      this.currentCandidatePair = null
+      this.currentFailedConnectionPair = null
+    } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath
       if (newTracePath && this.currentCandidatePair) {
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
@@ -166,6 +207,7 @@ export class LongDistancePairSolver extends BaseSolver {
     } else if (this.subSolver?.failed) {
       this.subSolver = null
       this.currentCandidatePair = null
+      this.currentFailedConnectionPair = null
     }
 
     // 2. If a sub-solver is already running, let it continue
@@ -174,6 +216,18 @@ export class LongDistancePairSolver extends BaseSolver {
       return
     }
 
+    const failedConnectionPair = this.queuedFailedConnectionPairs.shift()
+    if (failedConnectionPair) {
+      this.currentFailedConnectionPair = failedConnectionPair
+      this.currentCandidatePair = failedConnectionPair.pins
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: failedConnectionPair.pins,
+        chipMap: this.chipMap,
+      })
+      return
+    }
+
     // 3. Find the next valid candidate pair and start a new sub-solver
     while (this.queuedCandidatePairs.length > 0) {
       const nextPair = this.queuedCandidatePairs.shift()!

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -14,6 +14,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
 import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
+import { isLabeledPeripheralConnection } from "./isLabeledPeripheralConnection"
 
 export type MspConnectionPairId = string
 export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
@@ -116,10 +117,18 @@ export class MspConnectionPairSolver extends BaseSolver {
       const pinPairKey = getPinPairKey([pin1!, pin2!])
       // Explicit source traces are classified by straight-line distance when
       // their input is created; named nets retain the orthogonal route metric.
-      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey)
-        ? distance(p1, p2)
-        : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
-      if (pairDistance > this.maxMspPairDistance) {
+      let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
+      if (this.directConnectionPinPairKeys.has(pinPairKey)) {
+        pairDistance = distance(p1, p2)
+      }
+      // Labeled one-pin peripherals need a real trace even when they are far
+      // apart; skipping the MSP pair would leave only the fallback path.
+      const isLabeledPeripheral = isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: [p1, p2],
+      })
+      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
         // Too far apart; skip creating an MSP pair for this net
         return
       }

package/lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts

@@ -0,0 +1,44 @@
+import type { InputChip, InputPin, InputProblem } from "lib/types/InputProblem"
+import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+
+type PinWithChipId = InputPin & { chipId: string }
+
+export const isLabeledPeripheralConnection = ({
+  inputProblem,
+  chipMap,
+  pins,
+}: {
+  inputProblem: InputProblem
+  chipMap: Record<string, InputChip>
+  pins: [PinWithChipId, PinWithChipId]
+}): boolean => {
+  const [firstPin, secondPin] = pins
+  const directConnection = inputProblem.directConnections.find(
+    (connection) =>
+      connection.pinIds.includes(firstPin.pinId) &&
+      connection.pinIds.includes(secondPin.pinId),
+  )
+  if (directConnection?.netLabelWidth === undefined) return false
+
+  const firstChip = chipMap[firstPin.chipId]
+  const secondChip = chipMap[secondPin.chipId]
+  if (!firstChip || !secondChip) return false
+
+  const hasSinglePinPeripheral =
+    firstChip.pins.length === 1 || secondChip.pins.length === 1
+  if (!hasSinglePinPeripheral) return false
+
+  let firstFacingDirection = firstPin._facingDirection
+  if (!firstFacingDirection) {
+    firstFacingDirection = getPinDirection(firstPin, firstChip)
+  }
+  let secondFacingDirection = secondPin._facingDirection
+  if (!secondFacingDirection) {
+    secondFacingDirection = getPinDirection(secondPin, secondChip)
+  }
+
+  return (
+    (firstFacingDirection === "x-" && secondFacingDirection === "x+") ||
+    (firstFacingDirection === "x+" && secondFacingDirection === "x-")
+  )
+}

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

@@ -123,16 +123,16 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     })
     this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle))
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId))
+    // Same-chip routes also need these obstacles so they can escape around
+    // attached text after a narrow chip-to-text channel is closed.
     this.endpointTextObstacles = new Set(
-      endpointChipIds.size > 1
-        ? this.obstacles
-            .filter(isTextBoxObstacle)
-            .filter(
-              (obstacle) =>
-                obstacle.textBox.chipId !== undefined &&
-                endpointChipIds.has(obstacle.textBox.chipId),
-            )
-        : [],
+      this.obstacles
+        .filter(isTextBoxObstacle)
+        .filter(
+          (obstacle) =>
+            obstacle.textBox.chipId !== undefined &&
+            endpointChipIds.has(obstacle.textBox.chipId),
+        ),
     )
 
     const [pin1, pin2] = this.pins

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

@@ -1,20 +1,21 @@
+import { boundsDistance, type Bounds } from "@tscircuit/math-utils"
 import { getInputChipBounds } from "lib/solvers/GuidelinesSolver/getInputChipBounds"
 import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
 
-export type RectBounds = {
-  minX: number
-  minY: number
-  maxX: number
-  maxY: number
-}
+// Component text is normally placed 0.04 units from its chip. A trace
+// centerline can fit mathematically, but its rendered stroke cannot usefully
+// occupy that channel.
+const MIN_ROUTABLE_OBSTACLE_GAP = 0.05
+
+export type { Bounds as RectBounds } from "@tscircuit/math-utils"
 
-export type ChipObstacleRect = RectBounds & {
+export type ChipObstacleRect = Bounds & {
   kind: "chip"
   chipId: string
 }
 
-export type TextBoxObstacleRect = RectBounds & {
+export type TextBoxObstacleRect = Bounds & {
   kind: "text_box"
   textBox: NonNullable<InputProblem["textBoxes"]>[number]
 }
@@ -36,7 +37,22 @@ export const getObstacleRects = (
 ): ObstacleRect[] => {
   const chipRects = problem.chips.map(chipToRect)
   const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
-    const b = getTextBoxBounds(textBox, opts.textBoxPadding)
+    const textBounds = getTextBoxBounds(textBox, opts.textBoxPadding)
+    const attachedChipBounds = chipRects.find(
+      (chip) => chip.chipId === textBox.chipId,
+    )
+    const gap = attachedChipBounds
+      ? boundsDistance(textBounds, attachedChipBounds)
+      : Number.POSITIVE_INFINITY
+    const b =
+      attachedChipBounds && gap > 0 && gap < MIN_ROUTABLE_OBSTACLE_GAP
+        ? {
+            minX: Math.min(textBounds.minX, attachedChipBounds.maxX),
+            maxX: Math.max(textBounds.maxX, attachedChipBounds.minX),
+            minY: Math.min(textBounds.minY, attachedChipBounds.maxY),
+            maxY: Math.max(textBounds.maxY, attachedChipBounds.minY),
+          }
+        : textBounds
     return {
       kind: "text_box" as const,
       textBox,

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -140,6 +140,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
             instance.mspConnectionPairSolver!.mspConnectionPairs,
           alreadySolvedTraces:
             instance.schematicTraceLinesSolver!.solvedTracePaths,
+          failedConnectionPairs:
+            instance.schematicTraceLinesSolver!.failedConnectionPairs,
         },
       ],
       {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.113",
+  "version": "0.0.115",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -13,7 +13,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.2.2",
     "@react-hook/resize-observer": "^2.0.2",
-    "@tscircuit/math-utils": "^0.0.19",
+    "@tscircuit/math-utils": "^0.0.36",
     "@types/bun": "^1.2.21",
     "bun-match-svg": "^0.0.13",
     "calculate-elbow": "^0.0.12",

package/site/bug-reports/bug-report-20260728T144234Z.page.tsx

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

package/site/bug-reports/bug-report-20260728T225606Z.page.tsx

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