@tscircuit/schematic-trace-solver 0.0.128 → 0.0.130

package/dist/index.d.ts

@@ -621,6 +621,7 @@ declare class LongDistancePairSolver extends BaseSolver {
     private netConnMap;
     private newlyConnectedPinIds;
     private allSolvedTraces;
+    private maxMspPairDistance;
     constructor(params: {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
@@ -1151,12 +1152,13 @@ declare const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
  */
 declare const INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
 /**
- * How much of the label is allowed to hang off the end of the wire it names,
- * as a fraction of the label's length. A short elbow stub is technically clear
- * of every obstacle but reads as a label floating in space, so runs shorter
- * than this are not considered.
+ * Largest perpendicular deviation a route may have and still be labeled as one
+ * span. A route that is straight except for elbow jogs up to this size reads
+ * as a single wire, so its name may be centered over the whole route,
+ * bridging the jogs. Anything more meandering falls back to an anchored net
+ * label.
  */
-declare const MIN_INLINE_NET_LABEL_SEGMENT_RATIO = 0.5;
+declare const INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4;
 /**
  * A net label drawn parallel to the trace it names, rather than anchored to the
  * end of it. Used for point-to-point signal traces, where an anchored label
@@ -1213,6 +1215,13 @@ declare class InlineNetLabelSolver extends BaseSolver {
     getConstructorParams(): [InlineNetLabelSolverInput];
     _step(): void;
     private computeInlinePlacement;
+    /**
+     * Places the label over the whole route when the route is straight except
+     * for perpendicular jogs of at most INLINE_NET_LABEL_MAX_SPAN_JOG. The label
+     * sits clear of the route's full perpendicular extent and stays within its
+     * endpoints along the dominant axis.
+     */
+    private computeSpanPlacement;
     /**
      * An inline label may not sit on top of a chip, a component's text, or a
      * trace belonging to another net.
@@ -1297,4 +1306,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, DEFAULT_INLINE_NET_LABEL_HEIGHT, INLINE_NET_LABEL_TRACE_MARGIN, type InlineNetLabelPlacement, InlineNetLabelSolver, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, MIN_INLINE_NET_LABEL_SEGMENT_RATIO, type NetId, type NetLabelPlacement, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes, estimateInlineNetLabelWidth };
+export { type ChipId, DEFAULT_INLINE_NET_LABEL_HEIGHT, INLINE_NET_LABEL_MAX_SPAN_JOG, INLINE_NET_LABEL_TRACE_MARGIN, type InlineNetLabelPlacement, InlineNetLabelSolver, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type NetLabelPlacement, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes, estimateInlineNetLabelWidth };

package/dist/index.js

@@ -4618,6 +4618,7 @@ var NEAREST_NEIGHBOR_COUNT = 3;
 var distance3 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
+var manhattanDistance = (p1, p2) => Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
 var LongDistancePairSolver = class extends BaseSolver {
   constructor(params) {
     super();
@@ -4625,6 +4626,7 @@ var LongDistancePairSolver = class extends BaseSolver {
     const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } = this.params;
     this.inputProblem = inputProblem;
     this.allSolvedTraces = [...alreadySolvedTraces];
+    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
     const primaryConnectedPinIds = /* @__PURE__ */ new Set();
     for (const pair of primaryMspConnectionPairs) {
       primaryConnectedPinIds.add(pair.pins[0].pinId);
@@ -4660,6 +4662,12 @@ var LongDistancePairSolver = class extends BaseSolver {
         const neighbors = allPinIdsInNet.filter((otherPinId) => otherPinId !== unconnectedPinId).flatMap((otherPinId) => {
           const targetPin = pinMap.get(otherPinId);
           if (!targetPin) return [];
+          const isNamedTwoPinConnection = inputProblem.netConnections.some(
+            (connection) => connection.pinIds.length === 2 && connection.pinIds.includes(sourcePin.pinId) && connection.pinIds.includes(targetPin.pinId)
+          );
+          if (isNamedTwoPinConnection && manhattanDistance(sourcePin, targetPin) > this.maxMspPairDistance) {
+            return [];
+          }
           return [
             {
               pin: targetPin,
@@ -4694,6 +4702,7 @@ var LongDistancePairSolver = class extends BaseSolver {
   netConnMap;
   newlyConnectedPinIds = /* @__PURE__ */ new Set();
   allSolvedTraces = [];
+  maxMspPairDistance;
   getConstructorParams() {
     return this.params;
   }
@@ -11907,7 +11916,7 @@ var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
-var MIN_INLINE_NET_LABEL_SEGMENT_RATIO = 0.5;
+var INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4;
 var getPinPairKey2 = (pinIds) => [...pinIds].sort().join("::");
 var InlineNetLabelSolver = class extends BaseSolver {
   inputProblem;
@@ -11966,14 +11975,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     const height = directConnection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
     const width = directConnection.inlineNetLabelWidth ?? directConnection.netLabelWidth ?? estimateInlineNetLabelWidth(directConnection.netId, height);
     const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN;
-    const usableSegments = segments.filter(
-      (segment) => segment.length >= width * MIN_INLINE_NET_LABEL_SEGMENT_RATIO
-    ).sort((a, b) => {
-      const aFits = a.length >= width;
-      const bFits = b.length >= width;
-      if (aFits !== bFits) return aFits ? -1 : 1;
-      return b.length - a.length;
-    });
+    const usableSegments = segments.filter((segment) => segment.length >= width).sort((a, b) => b.length - a.length);
     for (const segment of usableSegments) {
       const sides = segment.axis === "x" ? ["y+", "y-"] : ["x-", "x+"];
       for (const side of sides) {
@@ -12008,6 +12010,91 @@ var InlineNetLabelSolver = class extends BaseSolver {
         }
       }
     }
+    const spanPlacement = this.computeSpanPlacement({
+      trace,
+      directConnection,
+      width,
+      height,
+      offset
+    });
+    if (spanPlacement) return spanPlacement;
+    return null;
+  }
+  /**
+   * Places the label over the whole route when the route is straight except
+   * for perpendicular jogs of at most INLINE_NET_LABEL_MAX_SPAN_JOG. The label
+   * sits clear of the route's full perpendicular extent and stays within its
+   * endpoints along the dominant axis.
+   */
+  computeSpanPlacement({
+    trace,
+    directConnection,
+    width,
+    height,
+    offset
+  }) {
+    const path = trace.tracePath;
+    if (path.length < 2) return null;
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (const point of path) {
+      minX = Math.min(minX, point.x);
+      maxX = Math.max(maxX, point.x);
+      minY = Math.min(minY, point.y);
+      maxY = Math.max(maxY, point.y);
+    }
+    const extentX = maxX - minX;
+    const extentY = maxY - minY;
+    const axis = extentX >= extentY ? "x" : "y";
+    const spanLength = axis === "x" ? extentX : extentY;
+    const jog = axis === "x" ? extentY : extentX;
+    if (jog > INLINE_NET_LABEL_MAX_SPAN_JOG) return null;
+    if (spanLength < width) return null;
+    const spanStart = axis === "x" ? minX : minY;
+    const spanEnd = axis === "x" ? maxX : maxY;
+    const mid = (spanStart + spanEnd) / 2;
+    const halfRange = (spanLength - width) / 2;
+    const offsets = [0];
+    for (let value = 0.1; value <= halfRange + 1e-9; value += 0.1) {
+      offsets.push(value, -value);
+    }
+    offsets.push(halfRange, -halfRange);
+    const sides = axis === "x" ? ["y+", "y-"] : ["x-", "x+"];
+    for (const side of sides) {
+      for (const alongOffset of offsets) {
+        const along = mid + alongOffset;
+        const center = side === "y+" ? { x: along, y: maxY + offset } : side === "y-" ? { x: along, y: minY - offset } : side === "x-" ? { x: minX - offset, y: along } : { x: maxX + offset, y: along };
+        const halfAlong = width / 2;
+        const halfAcross = height / 2;
+        const bounds = axis === "x" ? {
+          minX: center.x - halfAlong,
+          maxX: center.x + halfAlong,
+          minY: center.y - halfAcross,
+          maxY: center.y + halfAcross
+        } : {
+          minX: center.x - halfAcross,
+          maxX: center.x + halfAcross,
+          minY: center.y - halfAlong,
+          maxY: center.y + halfAlong
+        };
+        if (this.isObstructed(bounds, trace)) continue;
+        const anchorPoint = axis === "x" ? { x: along, y: side === "y+" ? maxY : minY } : { x: side === "x-" ? minX : maxX, y: along };
+        return {
+          globalConnNetId: trace.globalConnNetId,
+          netId: directConnection.netId,
+          mspPairId: trace.mspPairId,
+          pinIds: [...directConnection.pinIds],
+          axis,
+          anchorPoint,
+          center,
+          width,
+          height,
+          side
+        };
+      }
+    }
     return null;
   }
   /**
@@ -12674,9 +12761,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
 };
 export {
   DEFAULT_INLINE_NET_LABEL_HEIGHT,
+  INLINE_NET_LABEL_MAX_SPAN_JOG,
   INLINE_NET_LABEL_TRACE_MARGIN,
   InlineNetLabelSolver,
-  MIN_INLINE_NET_LABEL_SEGMENT_RATIO,
   SchematicTracePipelineSolver,
   SchematicTraceSingleLineSolver2,
   estimateInlineNetLabelWidth

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -24,12 +24,13 @@ export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
 export const INLINE_NET_LABEL_TRACE_MARGIN = 0.05
 
 /**
- * How much of the label is allowed to hang off the end of the wire it names,
- * as a fraction of the label's length. A short elbow stub is technically clear
- * of every obstacle but reads as a label floating in space, so runs shorter
- * than this are not considered.
+ * Largest perpendicular deviation a route may have and still be labeled as one
+ * span. A route that is straight except for elbow jogs up to this size reads
+ * as a single wire, so its name may be centered over the whole route,
+ * bridging the jogs. Anything more meandering falls back to an anchored net
+ * label.
  */
-export const MIN_INLINE_NET_LABEL_SEGMENT_RATIO = 0.5
+export const INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4
 
 /**
  * A net label drawn parallel to the trace it names, rather than anchored to the
@@ -165,20 +166,14 @@ export class InlineNetLabelSolver extends BaseSolver {
 
     const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN
 
-    // Runs the label fully fits on come first, then longer-to-shorter among the
-    // runs it may overhang. Within a run, try the preferred side before the far
-    // side, and positions near the middle before ones near the ends.
+    // First choice: a straight run the label fully fits on, longest first, so
+    // the text hugs the wire it names. Within a run, try the preferred side
+    // before the far side, and positions near the middle before the ends. The
+    // label never extends past the end of a run - a name hanging off its wire
+    // reads as floating text.
     const usableSegments = segments
-      .filter(
-        (segment) =>
-          segment.length >= width * MIN_INLINE_NET_LABEL_SEGMENT_RATIO,
-      )
-      .sort((a, b) => {
-        const aFits = a.length >= width
-        const bFits = b.length >= width
-        if (aFits !== bFits) return aFits ? -1 : 1
-        return b.length - a.length
-      })
+      .filter((segment) => segment.length >= width)
+      .sort((a, b) => b.length - a.length)
 
     for (const segment of usableSegments) {
       // "Above" the trace: +y for a horizontal trace, and -x for a vertical one
@@ -232,11 +227,138 @@ export class InlineNetLabelSolver extends BaseSolver {
       }
     }
 
+    // Second choice: no single run fits, but a route that is straight except
+    // for small jogs still reads as one wire - center the label over the
+    // route's overall span, bridging the jogs, without extending past its
+    // endpoints.
+    const spanPlacement = this.computeSpanPlacement({
+      trace,
+      directConnection,
+      width,
+      height,
+      offset,
+    })
+    if (spanPlacement) return spanPlacement
+
     // No room anywhere along the trace. Leave the net to the regular anchored
     // net label rather than drawing the name over a chip.
     return null
   }
 
+  /**
+   * Places the label over the whole route when the route is straight except
+   * for perpendicular jogs of at most INLINE_NET_LABEL_MAX_SPAN_JOG. The label
+   * sits clear of the route's full perpendicular extent and stays within its
+   * endpoints along the dominant axis.
+   */
+  private computeSpanPlacement({
+    trace,
+    directConnection,
+    width,
+    height,
+    offset,
+  }: {
+    trace: SolvedTracePath
+    directConnection: InputDirectConnection
+    width: number
+    height: number
+    offset: number
+  }): InlineNetLabelPlacement | null {
+    const path = trace.tracePath
+    if (path.length < 2) return null
+
+    let minX = Infinity
+    let maxX = -Infinity
+    let minY = Infinity
+    let maxY = -Infinity
+    for (const point of path) {
+      minX = Math.min(minX, point.x)
+      maxX = Math.max(maxX, point.x)
+      minY = Math.min(minY, point.y)
+      maxY = Math.max(maxY, point.y)
+    }
+
+    const extentX = maxX - minX
+    const extentY = maxY - minY
+    const axis: InlineNetLabelPlacement["axis"] = extentX >= extentY ? "x" : "y"
+    const spanLength = axis === "x" ? extentX : extentY
+    const jog = axis === "x" ? extentY : extentX
+
+    if (jog > INLINE_NET_LABEL_MAX_SPAN_JOG) return null
+    if (spanLength < width) return null
+
+    const spanStart = axis === "x" ? minX : minY
+    const spanEnd = axis === "x" ? maxX : maxY
+    const mid = (spanStart + spanEnd) / 2
+
+    // Slide candidates within the span, centered first (same scheme as the
+    // per-segment stage).
+    const halfRange = (spanLength - width) / 2
+    const offsets: number[] = [0]
+    for (let value = 0.1; value <= halfRange + 1e-9; value += 0.1) {
+      offsets.push(value, -value)
+    }
+    offsets.push(halfRange, -halfRange)
+
+    const sides: InlineNetLabelPlacement["side"][] =
+      axis === "x" ? ["y+", "y-"] : ["x-", "x+"]
+
+    for (const side of sides) {
+      for (const alongOffset of offsets) {
+        const along = mid + alongOffset
+        // The label clears the far side of every jog, not just the run it is
+        // nearest to.
+        const center: Point =
+          side === "y+"
+            ? { x: along, y: maxY + offset }
+            : side === "y-"
+              ? { x: along, y: minY - offset }
+              : side === "x-"
+                ? { x: minX - offset, y: along }
+                : { x: maxX + offset, y: along }
+
+        const halfAlong = width / 2
+        const halfAcross = height / 2
+        const bounds: Bounds =
+          axis === "x"
+            ? {
+                minX: center.x - halfAlong,
+                maxX: center.x + halfAlong,
+                minY: center.y - halfAcross,
+                maxY: center.y + halfAcross,
+              }
+            : {
+                minX: center.x - halfAcross,
+                maxX: center.x + halfAcross,
+                minY: center.y - halfAlong,
+                maxY: center.y + halfAlong,
+              }
+
+        if (this.isObstructed(bounds, trace)) continue
+
+        const anchorPoint: Point =
+          axis === "x"
+            ? { x: along, y: side === "y+" ? maxY : minY }
+            : { x: side === "x-" ? minX : maxX, y: along }
+
+        return {
+          globalConnNetId: trace.globalConnNetId,
+          netId: directConnection.netId,
+          mspPairId: trace.mspPairId,
+          pinIds: [...directConnection.pinIds],
+          axis,
+          anchorPoint,
+          center,
+          width,
+          height,
+          side,
+        }
+      }
+    }
+
+    return null
+  }
+
   /**
    * An inline label may not sit on top of a chip, a component's text, or a
    * trace belonging to another net.
@@ -374,11 +496,8 @@ export const estimateInlineNetLabelWidth = (
 /**
  * Points along a segment where the label's midpoint could sit, ordered from the
  * middle of the segment outwards. Sliding the label along the wire lets it
- * dodge a chip that only crowds one end.
- *
- * When the label is shorter than the segment, candidates are limited to
- * positions that keep it fully on the wire; when it is longer, only the
- * midpoint is offered (it will overhang either way).
+ * dodge a chip that only crowds one end. Candidates always keep the label
+ * fully on the wire; callers only pass segments the label fits on.
  */
 const getAnchorCandidates = (
   segment: AxisAlignedSegment,

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -1,5 +1,8 @@
 import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
-import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import {
+  DEFAULT_MAX_MSP_PAIR_DISTANCE,
+  type MspConnectionPair,
+} from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type {
   InputProblem,
   InputPin,
@@ -8,10 +11,10 @@ import type {
 } from "lib/types/InputProblem"
 import { BaseSolver } from "../BaseSolver/BaseSolver"
 import { SchematicTraceSingleLineSolver2 } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
-import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { ConnectivityMap } from "connectivity-map"
+import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
 import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabeledPeripheralConnection"
 
@@ -21,6 +24,9 @@ const distance = (p1: InputPin, p2: InputPin) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2))
 }
 
+const manhattanDistance = (p1: InputPin, p2: InputPin) =>
+  Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
+
 export class LongDistancePairSolver extends BaseSolver {
   public solvedLongDistanceTraces: SolvedTracePath[] = []
   private queuedCandidatePairs: Array<
@@ -37,6 +43,7 @@ export class LongDistancePairSolver extends BaseSolver {
   private netConnMap: ConnectivityMap
   private newlyConnectedPinIds = new Set<PinId>()
   private allSolvedTraces: SolvedTracePath[] = []
+  private maxMspPairDistance: number
 
   constructor(
     private params: {
@@ -53,6 +60,8 @@ export class LongDistancePairSolver extends BaseSolver {
 
     this.inputProblem = inputProblem
     this.allSolvedTraces = [...alreadySolvedTraces]
+    this.maxMspPairDistance =
+      inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE
 
     // 1. Create initial maps and sets for efficient lookup
     const primaryConnectedPinIds = new Set<PinId>()
@@ -104,6 +113,18 @@ export class LongDistancePairSolver extends BaseSolver {
           .flatMap((otherPinId) => {
             const targetPin = pinMap.get(otherPinId)
             if (!targetPin) return [] // Gracefully handle missing pins
+            const isNamedTwoPinConnection = inputProblem.netConnections.some(
+              (connection) =>
+                connection.pinIds.length === 2 &&
+                connection.pinIds.includes(sourcePin.pinId) &&
+                connection.pinIds.includes(targetPin.pinId),
+            )
+            if (
+              isNamedTwoPinConnection &&
+              manhattanDistance(sourcePin, targetPin) > this.maxMspPairDistance
+            ) {
+              return []
+            }
             return [
               {
                 pin: targetPin,

package/package.json

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

package/site/bug-reports/bug-report-20260811T075142Z.page.tsx

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

package/tests/assets/inline-net-label02.json

@@ -0,0 +1,112 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 0.4,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "schematic_port_0",
+          "x": -0.6000000000000001,
+          "y": 0.30000000000000004,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "schematic_port_1",
+          "x": -0.6000000000000001,
+          "y": 0.10000000000000003,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "schematic_port_2",
+          "x": -0.6000000000000001,
+          "y": -0.09999999999999998,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "schematic_port_3",
+          "x": -0.6000000000000001,
+          "y": -0.30000000000000004,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "schematic_port_4",
+          "x": 0.6000000000000001,
+          "y": -0.30000000000000004,
+          "_facingDirection": "x+"
+        },
+        {
+          "pinId": "schematic_port_5",
+          "x": 0.6000000000000001,
+          "y": -0.10000000000000003,
+          "_facingDirection": "x+"
+        },
+        {
+          "pinId": "schematic_port_6",
+          "x": 0.6000000000000001,
+          "y": 0.09999999999999998,
+          "_facingDirection": "x+"
+        },
+        {
+          "pinId": "schematic_port_7",
+          "x": 0.6000000000000001,
+          "y": 0.30000000000000004,
+          "_facingDirection": "x+"
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": {
+        "x": 3,
+        "y": 0.13249999999999998
+      },
+      "width": 1.13,
+      "height": 0.915,
+      "pins": [
+        {
+          "pinId": "schematic_port_8",
+          "x": 2.46,
+          "y": 0,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "schematic_port_9",
+          "x": 3.54,
+          "y": 0,
+          "_facingDirection": "x+"
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "netId": "USER_LED_ANODE",
+      "allowInlineNetLabel": true,
+      "inlineNetLabelWidth": 1.8,
+      "pinIds": [
+        "schematic_port_4",
+        "schematic_port_8"
+      ]
+    }
+  ],
+  "netConnections": [],
+  "textBoxes": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": -0.08000000000000002,
+        "y": 0.615
+      },
+      "width": 0.36,
+      "height": 0.25,
+      "text": "U1"
+    }
+  ],
+  "availableNetLabelOrientations": {},
+  "maxMspPairDistance": 2.4
+}