@tscircuit/schematic-trace-solver 0.0.126 → 0.0.128

package/README.md

@@ -35,6 +35,34 @@ Finally, the `NetLabelPlacementSolver` places net labels for each net connection
 this requires drawing small traces to adapt to the `availableFacingDirections` of the net connection.
 If there is crowding at the pin, we look for an available spot along the trace connected to the pin.
 
+### Inline net labels
+
+A point-to-point signal trace can be labeled *inline*: the net name is drawn
+parallel to the wire (above a horizontal trace, to the left of a vertical one)
+instead of as an anchored label hanging off the end of it. This keeps the visual
+line between the two pins intact.
+
+Inline labels are opt-in per direct connection - set `allowInlineNetLabel: true`
+on the `directConnection`. The caller (usually [@tscircuit/core](https://github.com/tscircuit/core))
+decides which connections deserve one; the solver only honors the request when
+the connection actually got routed, since there is nothing to run parallel to
+otherwise.
+
+The `InlineNetLabelSolver` runs last in the pipeline and exposes
+`inlineNetLabelPlacements`. A net that receives an inline label has its anchored
+`NetLabelPlacement` removed from `getOutput().netLabelPlacements`, so a net is
+never labeled twice.
+
+```tsx
+directConnections: [
+  {
+    pinIds: ["U1.1", "D1.1"],
+    netId: "USER_LED_ANODE",
+    allowInlineNetLabel: true,
+  },
+]
+```
+
 ## Usage
 
 ```tsx

package/dist/index.d.ts

@@ -88,6 +88,27 @@ interface InputDirectConnection {
     pinIds: [PinId, PinId];
     netId?: string;
     netLabelWidth?: number;
+    /**
+     * When true, this point-to-point connection may be labeled with an "inline
+     * net label": the net name is drawn parallel to (and offset from) the routed
+     * trace instead of being placed as a separate anchored net label at the end
+     * of the trace.
+     *
+     * Only set this for connections whose net name is worth showing on the wire -
+     * the solver trusts the caller (e.g. @tscircuit/core) to make that decision.
+     * An inline label is only emitted when the connection actually got routed.
+     */
+    allowInlineNetLabel?: boolean;
+    /**
+     * Extent of the inline net label along the trace. Falls back to
+     * `netLabelWidth`, then to an estimate from the netId text.
+     */
+    inlineNetLabelWidth?: number;
+    /**
+     * Height of the inline net label text. Defaults to
+     * DEFAULT_INLINE_NET_LABEL_HEIGHT.
+     */
+    inlineNetLabelHeight?: number;
 }
 interface InputNetConnection {
     netId: string;
@@ -1124,6 +1145,97 @@ declare class TraceElbowTransitionSimplificationSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+declare const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
+/**
+ * Gap between the trace and the near edge of the inline label text.
+ */
+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.
+ */
+declare const MIN_INLINE_NET_LABEL_SEGMENT_RATIO = 0.5;
+/**
+ * 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
+ * would break the visual line between the two pins.
+ *
+ * `center` is the center of the text box in the schematic's own (unrotated)
+ * coordinate space. `width` is the extent of the text along the trace and
+ * `height` is its extent perpendicular to the trace, so a vertical label has
+ * its `width` running along y.
+ */
+interface InlineNetLabelPlacement {
+    globalConnNetId: string;
+    netId?: string;
+    mspPairId: string;
+    pinIds: PinId[];
+    /** Axis the text runs along: "x" reads left-to-right, "y" reads bottom-to-top */
+    axis: "x" | "y";
+    /** Midpoint of the trace segment the label is attached to */
+    anchorPoint: Point;
+    /** Center of the label text, offset perpendicular to the trace */
+    center: Point;
+    /** Extent along the trace */
+    width: number;
+    /** Extent perpendicular to the trace */
+    height: number;
+    /**
+     * Which side of the trace the label sits on. For a horizontal trace, "y+" is
+     * above; for a vertical trace, "x-" is the left side (which is "above" once
+     * the text is rotated).
+     */
+    side: "x+" | "x-" | "y+" | "y-";
+}
+interface InlineNetLabelSolverInput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+/**
+ * Places "inline net labels" - net names drawn alongside the trace they belong
+ * to - for direct connections that opted in via `allowInlineNetLabel`.
+ *
+ * Any regular (anchored) net label placement for the same net is dropped, so a
+ * net is never labeled twice.
+ */
+declare class InlineNetLabelSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    inputNetLabelPlacements: NetLabelPlacement[];
+    inlineNetLabelPlacements: InlineNetLabelPlacement[];
+    /** Direct connections that opted in, still waiting to be processed */
+    queuedDirectConnections: InputDirectConnection[];
+    private tracesByPinPairKey;
+    constructor(input: InlineNetLabelSolverInput);
+    getConstructorParams(): [InlineNetLabelSolverInput];
+    _step(): void;
+    private computeInlinePlacement;
+    /**
+     * An inline label may not sit on top of a chip, a component's text, or a
+     * trace belonging to another net.
+     */
+    private isObstructed;
+    /**
+     * Net label placements superseded by an inline label. A net gets one label or
+     * the other, never both.
+     */
+    private getSupersededNetLabelKeys;
+    getOutput(): {
+        traces: SolvedTracePath[];
+        netLabelPlacements: NetLabelPlacement[];
+        inlineNetLabelPlacements: InlineNetLabelPlacement[];
+    };
+    visualize(): GraphicsObject;
+}
+/**
+ * Mirrors the net label text width used by @tscircuit/core so a label that core
+ * did not measure for us still reserves a sane amount of space.
+ */
+declare const estimateInlineNetLabelWidth: (text: string, fontSize?: number) => number;
+
 /**
  * Pipeline solver that runs a series of solvers to find the best schematic layout.
  * Coordinates the entire layout process from chip partitioning through final packing.
@@ -1162,13 +1274,14 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preAlignmentTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver;
     finalTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver;
     sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver;
+    inlineNetLabelSolver?: InlineNetLabelSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
     hideRatsNet: boolean;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceElbowTransitionSimplificationSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver> | PipelineStep<typeof SameNetJunctionAlignmentSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceElbowTransitionSimplificationSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver> | PipelineStep<typeof SameNetJunctionAlignmentSolver> | PipelineStep<typeof InlineNetLabelSolver>)[];
     constructor(inputProblem: InputProblem, opts?: Options);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>;
     currentPipelineStepIndex: number;
@@ -1184,4 +1297,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes };
+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 };

package/dist/index.js

@@ -11863,6 +11863,299 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/InlineNetLabelSolver/getAxisAlignedSegments.ts
+var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
+  const segments = [];
+  let runStart = null;
+  let runAxis = null;
+  let runSign = 0;
+  const closeRun = (runEnd) => {
+    if (runStart && runAxis) {
+      const length = runAxis === "x" ? Math.abs(runEnd.x - runStart.x) : Math.abs(runEnd.y - runStart.y);
+      if (length > epsilon) {
+        segments.push({ start: runStart, end: runEnd, axis: runAxis, length });
+      }
+    }
+    runStart = null;
+    runAxis = null;
+    runSign = 0;
+  };
+  for (let i = 0; i < path.length - 1; i++) {
+    const a = path[i];
+    const b = path[i + 1];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    if (Math.abs(dx) <= epsilon && Math.abs(dy) <= epsilon) continue;
+    const axis = Math.abs(dy) <= epsilon ? "x" : Math.abs(dx) <= epsilon ? "y" : null;
+    if (!axis) {
+      closeRun(a);
+      continue;
+    }
+    const sign = Math.sign(axis === "x" ? dx : dy);
+    if (runStart && runAxis === axis && runSign === sign) continue;
+    closeRun(a);
+    runStart = a;
+    runAxis = axis;
+    runSign = sign;
+  }
+  if (path.length >= 2) {
+    closeRun(path[path.length - 1]);
+  }
+  return segments.sort((a, b) => b.length - a.length);
+};
+
+// 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 getPinPairKey2 = (pinIds) => [...pinIds].sort().join("::");
+var InlineNetLabelSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  inputNetLabelPlacements;
+  inlineNetLabelPlacements = [];
+  /** Direct connections that opted in, still waiting to be processed */
+  queuedDirectConnections;
+  tracesByPinPairKey;
+  constructor(input) {
+    super();
+    this.inputProblem = input.inputProblem;
+    this.traces = input.traces;
+    this.inputNetLabelPlacements = input.netLabelPlacements;
+    this.queuedDirectConnections = this.inputProblem.directConnections.filter(
+      (dc) => dc.allowInlineNetLabel && dc.netId
+    );
+    this.tracesByPinPairKey = /* @__PURE__ */ new Map();
+    for (const trace of this.traces) {
+      const key = getPinPairKey2(trace.pins.map((p) => p.pinId));
+      const existing = this.tracesByPinPairKey.get(key);
+      if (existing) {
+        existing.push(trace);
+      } else {
+        this.tracesByPinPairKey.set(key, [trace]);
+      }
+    }
+  }
+  getConstructorParams() {
+    return [
+      {
+        inputProblem: this.inputProblem,
+        traces: this.traces,
+        netLabelPlacements: this.inputNetLabelPlacements
+      }
+    ];
+  }
+  _step() {
+    const directConnection = this.queuedDirectConnections.shift();
+    if (!directConnection) {
+      this.solved = true;
+      this.stats.inlineNetLabelCount = this.inlineNetLabelPlacements.length;
+      return;
+    }
+    const placement = this.computeInlinePlacement(directConnection);
+    if (placement) {
+      this.inlineNetLabelPlacements.push(placement);
+    }
+  }
+  computeInlinePlacement(directConnection) {
+    const traces = this.tracesByPinPairKey.get(getPinPairKey2(directConnection.pinIds)) ?? [];
+    if (traces.length === 0) return null;
+    const trace = traces[0];
+    const segments = getAxisAlignedSegments(trace.tracePath);
+    if (segments.length === 0) return null;
+    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;
+    });
+    for (const segment of usableSegments) {
+      const sides = segment.axis === "x" ? ["y+", "y-"] : ["x-", "x+"];
+      for (const side of sides) {
+        for (const anchorPoint of getAnchorCandidates(segment, width)) {
+          const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset } : side === "y-" ? { x: anchorPoint.x, y: anchorPoint.y - offset } : side === "x-" ? { x: anchorPoint.x - offset, y: anchorPoint.y } : { x: anchorPoint.x + offset, y: anchorPoint.y };
+          const halfAlong = width / 2;
+          const halfAcross = height / 2;
+          const bounds = segment.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;
+          return {
+            globalConnNetId: trace.globalConnNetId,
+            netId: directConnection.netId,
+            mspPairId: trace.mspPairId,
+            pinIds: [...directConnection.pinIds],
+            axis: segment.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.
+   */
+  isObstructed(bounds, ownTrace) {
+    for (const chip of this.inputProblem.chips) {
+      const chipBounds = {
+        minX: chip.center.x - chip.width / 2,
+        maxX: chip.center.x + chip.width / 2,
+        minY: chip.center.y - chip.height / 2,
+        maxY: chip.center.y + chip.height / 2
+      };
+      if (boundsOverlap(bounds, chipBounds)) return true;
+    }
+    for (const textBox of this.inputProblem.textBoxes ?? []) {
+      if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
+    }
+    for (const trace of this.traces) {
+      if (trace.mspPairId === ownTrace.mspPairId) continue;
+      if (trace.globalConnNetId === ownTrace.globalConnNetId) continue;
+      if (doesPathIntersectBounds(trace.tracePath, bounds)) return true;
+    }
+    return false;
+  }
+  /**
+   * Net label placements superseded by an inline label. A net gets one label or
+   * the other, never both.
+   */
+  getSupersededNetLabelKeys() {
+    const keys = /* @__PURE__ */ new Set();
+    for (const placement of this.inlineNetLabelPlacements) {
+      keys.add(placement.globalConnNetId);
+    }
+    return keys;
+  }
+  getOutput() {
+    const superseded = this.getSupersededNetLabelKeys();
+    return {
+      traces: this.traces,
+      netLabelPlacements: this.inputNetLabelPlacements.filter(
+        (placement) => !superseded.has(placement.globalConnNetId)
+      ),
+      inlineNetLabelPlacements: this.inlineNetLabelPlacements
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem);
+    graphics.lines ??= [];
+    graphics.rects ??= [];
+    graphics.points ??= [];
+    graphics.texts ??= [];
+    for (const trace of this.traces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    const { netLabelPlacements } = this.getOutput();
+    for (const label of netLabelPlacements) {
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+      });
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+        label: `anchorPoint
+orientation: ${label.orientation}`
+      });
+    }
+    for (const inlineLabel of this.inlineNetLabelPlacements) {
+      const isHorizontal4 = inlineLabel.axis === "x";
+      graphics.rects.push({
+        center: inlineLabel.center,
+        width: isHorizontal4 ? inlineLabel.width : inlineLabel.height,
+        height: isHorizontal4 ? inlineLabel.height : inlineLabel.width,
+        fill: getColorFromString(inlineLabel.globalConnNetId, 0.35),
+        strokeColor: "green",
+        label: [
+          `INLINE netId: ${inlineLabel.netId}`,
+          `axis: ${inlineLabel.axis}`,
+          `side: ${inlineLabel.side}`
+        ].join("\n")
+      });
+      graphics.texts.push({
+        x: inlineLabel.center.x,
+        y: inlineLabel.center.y,
+        text: inlineLabel.netId ?? "",
+        color: "green",
+        fontSize: inlineLabel.height,
+        anchorSide: "center",
+        // Vertical labels read bottom-to-top, alongside the wire they name.
+        rotation: inlineLabel.axis === "y" ? 90 : void 0
+      });
+      graphics.points.push({
+        x: inlineLabel.anchorPoint.x,
+        y: inlineLabel.anchorPoint.y,
+        color: "green",
+        label: `inline anchor
+${inlineLabel.netId}`
+      });
+    }
+    return graphics;
+  }
+};
+var estimateInlineNetLabelWidth = (text, fontSize = DEFAULT_INLINE_NET_LABEL_HEIGHT) => {
+  const fontScale = fontSize / 0.18;
+  return text.length * 0.12 * fontScale + 0.12 * fontScale;
+};
+var getAnchorCandidates = (segment, labelWidth, step = 0.1) => {
+  const along = segment.axis === "x" ? "x" : "y";
+  const start = segment.start[along];
+  const end = segment.end[along];
+  const mid = (start + end) / 2;
+  const direction = Math.sign(end - start) || 1;
+  const pointAt = (value) => segment.axis === "x" ? { x: value, y: segment.start.y } : { x: segment.start.x, y: segment.start.y + (value - start) };
+  const slack = segment.length - labelWidth;
+  if (slack <= 0) return [pointAt(mid)];
+  const offsets = [0];
+  for (let offset = step; offset <= slack / 2 + 1e-9; offset += step) {
+    offsets.push(offset, -offset);
+  }
+  offsets.push(slack / 2, -slack / 2);
+  return offsets.map((offset) => pointAt(mid + offset * direction));
+};
+var doesPathIntersectBounds = (path, bounds) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const a = path[i];
+    const b = path[i + 1];
+    const segmentBounds = {
+      minX: Math.min(a.x, b.x),
+      maxX: Math.max(a.x, b.x),
+      minY: Math.min(a.y, b.y),
+      maxY: Math.max(a.y, b.y)
+    };
+    if (boundsOverlap(segmentBounds, bounds)) return true;
+  }
+  return false;
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -11897,6 +12190,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   preAlignmentTraceElbowTransitionSimplificationSolver;
   finalTraceElbowTransitionSimplificationSolver;
   sameNetJunctionAlignmentSolver;
+  inlineNetLabelSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -12252,6 +12546,20 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           }
         ];
       }
+    ),
+    definePipelineStep(
+      "inlineNetLabelSolver",
+      InlineNetLabelSolver,
+      (instance) => {
+        const junctionOutput = instance.sameNetJunctionAlignmentSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: junctionOutput.traces,
+            netLabelPlacements: junctionOutput.netLabelPlacements
+          }
+        ];
+      }
     )
   ];
   constructor(inputProblem, opts) {
@@ -12365,6 +12673,11 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   }
 };
 export {
+  DEFAULT_INLINE_NET_LABEL_HEIGHT,
+  INLINE_NET_LABEL_TRACE_MARGIN,
+  InlineNetLabelSolver,
+  MIN_INLINE_NET_LABEL_SEGMENT_RATIO,
   SchematicTracePipelineSolver,
-  SchematicTraceSingleLineSolver2
+  SchematicTraceSingleLineSolver2,
+  estimateInlineNetLabelWidth
 };

package/lib/index.ts

@@ -1,3 +1,5 @@
 export * from "./solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 export * from "./types/InputProblem"
+export * from "./solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+export type { NetLabelPlacement } from "./solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 export { SchematicTraceSingleLineSolver2 } from "./solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -0,0 +1,426 @@
+import type { Bounds, Point } from "@tscircuit/math-utils"
+import type { GraphicsObject, Rect } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type {
+  InputDirectConnection,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import {
+  type AxisAlignedSegment,
+  getAxisAlignedSegments,
+} from "./getAxisAlignedSegments"
+
+export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
+
+/**
+ * Gap between the trace and the near edge of the inline label text.
+ */
+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.
+ */
+export const MIN_INLINE_NET_LABEL_SEGMENT_RATIO = 0.5
+
+/**
+ * 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
+ * would break the visual line between the two pins.
+ *
+ * `center` is the center of the text box in the schematic's own (unrotated)
+ * coordinate space. `width` is the extent of the text along the trace and
+ * `height` is its extent perpendicular to the trace, so a vertical label has
+ * its `width` running along y.
+ */
+export interface InlineNetLabelPlacement {
+  globalConnNetId: string
+  netId?: string
+  mspPairId: string
+  pinIds: PinId[]
+
+  /** Axis the text runs along: "x" reads left-to-right, "y" reads bottom-to-top */
+  axis: "x" | "y"
+
+  /** Midpoint of the trace segment the label is attached to */
+  anchorPoint: Point
+
+  /** Center of the label text, offset perpendicular to the trace */
+  center: Point
+
+  /** Extent along the trace */
+  width: number
+  /** Extent perpendicular to the trace */
+  height: number
+
+  /**
+   * Which side of the trace the label sits on. For a horizontal trace, "y+" is
+   * above; for a vertical trace, "x-" is the left side (which is "above" once
+   * the text is rotated).
+   */
+  side: "x+" | "x-" | "y+" | "y-"
+}
+
+interface InlineNetLabelSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+const getPinPairKey = (pinIds: readonly string[]) =>
+  [...pinIds].sort().join("::")
+
+/**
+ * Places "inline net labels" - net names drawn alongside the trace they belong
+ * to - for direct connections that opted in via `allowInlineNetLabel`.
+ *
+ * Any regular (anchored) net label placement for the same net is dropped, so a
+ * net is never labeled twice.
+ */
+export class InlineNetLabelSolver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  inputNetLabelPlacements: NetLabelPlacement[]
+
+  inlineNetLabelPlacements: InlineNetLabelPlacement[] = []
+
+  /** Direct connections that opted in, still waiting to be processed */
+  queuedDirectConnections: InputDirectConnection[]
+
+  private tracesByPinPairKey: Map<string, SolvedTracePath[]>
+
+  constructor(input: InlineNetLabelSolverInput) {
+    super()
+    this.inputProblem = input.inputProblem
+    this.traces = input.traces
+    this.inputNetLabelPlacements = input.netLabelPlacements
+
+    this.queuedDirectConnections = this.inputProblem.directConnections.filter(
+      (dc) => dc.allowInlineNetLabel && dc.netId,
+    )
+
+    this.tracesByPinPairKey = new Map()
+    for (const trace of this.traces) {
+      const key = getPinPairKey(trace.pins.map((p) => p.pinId))
+      const existing = this.tracesByPinPairKey.get(key)
+      if (existing) {
+        existing.push(trace)
+      } else {
+        this.tracesByPinPairKey.set(key, [trace])
+      }
+    }
+  }
+
+  override getConstructorParams(): [InlineNetLabelSolverInput] {
+    return [
+      {
+        inputProblem: this.inputProblem,
+        traces: this.traces,
+        netLabelPlacements: this.inputNetLabelPlacements,
+      },
+    ]
+  }
+
+  override _step() {
+    const directConnection = this.queuedDirectConnections.shift()
+    if (!directConnection) {
+      this.solved = true
+      this.stats.inlineNetLabelCount = this.inlineNetLabelPlacements.length
+      return
+    }
+
+    const placement = this.computeInlinePlacement(directConnection)
+    if (placement) {
+      this.inlineNetLabelPlacements.push(placement)
+    }
+  }
+
+  private computeInlinePlacement(
+    directConnection: InputDirectConnection,
+  ): InlineNetLabelPlacement | null {
+    // Only connections the router actually drew a trace for can carry an inline
+    // label - there's nothing to run parallel to otherwise.
+    const traces =
+      this.tracesByPinPairKey.get(getPinPairKey(directConnection.pinIds)) ?? []
+    if (traces.length === 0) return null
+
+    const trace = traces[0]!
+    const segments = getAxisAlignedSegments(trace.tracePath)
+    if (segments.length === 0) return null
+
+    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
+
+    // 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.
+    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
+      })
+
+    for (const segment of usableSegments) {
+      // "Above" the trace: +y for a horizontal trace, and -x for a vertical one
+      // (rotating the text 90deg counter-clockwise maps "above" onto the left).
+      const sides: InlineNetLabelPlacement["side"][] =
+        segment.axis === "x" ? ["y+", "y-"] : ["x-", "x+"]
+
+      for (const side of sides) {
+        for (const anchorPoint of getAnchorCandidates(segment, width)) {
+          const center =
+            side === "y+"
+              ? { x: anchorPoint.x, y: anchorPoint.y + offset }
+              : side === "y-"
+                ? { x: anchorPoint.x, y: anchorPoint.y - offset }
+                : side === "x-"
+                  ? { x: anchorPoint.x - offset, y: anchorPoint.y }
+                  : { x: anchorPoint.x + offset, y: anchorPoint.y }
+
+          const halfAlong = width / 2
+          const halfAcross = height / 2
+          const bounds: Bounds =
+            segment.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
+
+          return {
+            globalConnNetId: trace.globalConnNetId,
+            netId: directConnection.netId,
+            mspPairId: trace.mspPairId,
+            pinIds: [...directConnection.pinIds],
+            axis: segment.axis,
+            anchorPoint,
+            center,
+            width,
+            height,
+            side,
+          }
+        }
+      }
+    }
+
+    // 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
+  }
+
+  /**
+   * An inline label may not sit on top of a chip, a component's text, or a
+   * trace belonging to another net.
+   */
+  private isObstructed(bounds: Bounds, ownTrace: SolvedTracePath): boolean {
+    for (const chip of this.inputProblem.chips) {
+      const chipBounds: Bounds = {
+        minX: chip.center.x - chip.width / 2,
+        maxX: chip.center.x + chip.width / 2,
+        minY: chip.center.y - chip.height / 2,
+        maxY: chip.center.y + chip.height / 2,
+      }
+      if (boundsOverlap(bounds, chipBounds)) return true
+    }
+
+    for (const textBox of this.inputProblem.textBoxes ?? []) {
+      if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true
+    }
+
+    for (const trace of this.traces) {
+      if (trace.mspPairId === ownTrace.mspPairId) continue
+      if (trace.globalConnNetId === ownTrace.globalConnNetId) continue
+      if (doesPathIntersectBounds(trace.tracePath, bounds)) return true
+    }
+
+    return false
+  }
+
+  /**
+   * Net label placements superseded by an inline label. A net gets one label or
+   * the other, never both.
+   */
+  private getSupersededNetLabelKeys(): Set<string> {
+    const keys = new Set<string>()
+    for (const placement of this.inlineNetLabelPlacements) {
+      keys.add(placement.globalConnNetId)
+    }
+    return keys
+  }
+
+  getOutput() {
+    const superseded = this.getSupersededNetLabelKeys()
+    return {
+      traces: this.traces,
+      netLabelPlacements: this.inputNetLabelPlacements.filter(
+        (placement) => !superseded.has(placement.globalConnNetId),
+      ),
+      inlineNetLabelPlacements: this.inlineNetLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    // Mirrors the previous pipeline stage's visualization so that a problem
+    // with no inline labels renders identically, then layers the inline labels
+    // on top.
+    const graphics = visualizeInputProblem(this.inputProblem)
+    graphics.lines ??= []
+    graphics.rects ??= []
+    graphics.points ??= []
+    graphics.texts ??= []
+
+    for (const trace of this.traces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+
+    const { netLabelPlacements } = this.getOutput()
+    for (const label of netLabelPlacements) {
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}`,
+      } as Rect & { strokeColor: string })
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+        label: `anchorPoint\norientation: ${label.orientation}`,
+      })
+    }
+
+    for (const inlineLabel of this.inlineNetLabelPlacements) {
+      const isHorizontal = inlineLabel.axis === "x"
+      graphics.rects.push({
+        center: inlineLabel.center,
+        width: isHorizontal ? inlineLabel.width : inlineLabel.height,
+        height: isHorizontal ? inlineLabel.height : inlineLabel.width,
+        fill: getColorFromString(inlineLabel.globalConnNetId, 0.35),
+        strokeColor: "green",
+        label: [
+          `INLINE netId: ${inlineLabel.netId}`,
+          `axis: ${inlineLabel.axis}`,
+          `side: ${inlineLabel.side}`,
+        ].join("\n"),
+      } as Rect & { strokeColor: string })
+      graphics.texts.push({
+        x: inlineLabel.center.x,
+        y: inlineLabel.center.y,
+        text: inlineLabel.netId ?? "",
+        color: "green",
+        fontSize: inlineLabel.height,
+        anchorSide: "center",
+        // Vertical labels read bottom-to-top, alongside the wire they name.
+        rotation: inlineLabel.axis === "y" ? 90 : undefined,
+      })
+      graphics.points.push({
+        x: inlineLabel.anchorPoint.x,
+        y: inlineLabel.anchorPoint.y,
+        color: "green",
+        label: `inline anchor\n${inlineLabel.netId}`,
+      })
+    }
+
+    return graphics
+  }
+}
+
+/**
+ * Mirrors the net label text width used by @tscircuit/core so a label that core
+ * did not measure for us still reserves a sane amount of space.
+ */
+export const estimateInlineNetLabelWidth = (
+  text: string,
+  fontSize = DEFAULT_INLINE_NET_LABEL_HEIGHT,
+) => {
+  const fontScale = fontSize / 0.18
+  return text.length * 0.12 * fontScale + 0.12 * fontScale
+}
+
+/**
+ * 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).
+ */
+const getAnchorCandidates = (
+  segment: AxisAlignedSegment,
+  labelWidth: number,
+  step = 0.1,
+): Point[] => {
+  const along = segment.axis === "x" ? "x" : "y"
+  const start = segment.start[along]
+  const end = segment.end[along]
+  const mid = (start + end) / 2
+  const direction = Math.sign(end - start) || 1
+
+  const pointAt = (value: number): Point =>
+    segment.axis === "x"
+      ? { x: value, y: segment.start.y }
+      : { x: segment.start.x, y: segment.start.y + (value - start) }
+
+  const slack = segment.length - labelWidth
+  if (slack <= 0) return [pointAt(mid)]
+
+  const offsets: number[] = [0]
+  for (let offset = step; offset <= slack / 2 + 1e-9; offset += step) {
+    offsets.push(offset, -offset)
+  }
+  // Always consider both extremes, even when they fall between samples.
+  offsets.push(slack / 2, -slack / 2)
+
+  return offsets.map((offset) => pointAt(mid + offset * direction))
+}
+
+const doesPathIntersectBounds = (path: Point[], bounds: Bounds): boolean => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const a = path[i]!
+    const b = path[i + 1]!
+    const segmentBounds: Bounds = {
+      minX: Math.min(a.x, b.x),
+      maxX: Math.max(a.x, b.x),
+      minY: Math.min(a.y, b.y),
+      maxY: Math.max(a.y, b.y),
+    }
+    // Trace segments are axis-aligned, so their bounding box is the segment.
+    if (boundsOverlap(segmentBounds, bounds)) return true
+  }
+  return false
+}

package/lib/solvers/InlineNetLabelSolver/getAxisAlignedSegments.ts

@@ -0,0 +1,73 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export interface AxisAlignedSegment {
+  start: Point
+  end: Point
+  axis: "x" | "y"
+  length: number
+}
+
+/**
+ * Splits a trace path into its axis-aligned runs - the straight stretches of
+ * wire an inline net label can sit alongside without crossing a corner -
+ * ordered longest first.
+ *
+ * Segments that continue in the same direction are merged, so a straight
+ * stretch split into several points counts as one run. A reversal (a trace
+ * doubling back on itself) starts a new run, and diagonal segments are dropped
+ * since they have no well-defined "parallel" direction.
+ */
+export const getAxisAlignedSegments = (
+  path: Point[],
+  epsilon = 1e-6,
+): AxisAlignedSegment[] => {
+  const segments: AxisAlignedSegment[] = []
+
+  let runStart: Point | null = null
+  let runAxis: "x" | "y" | null = null
+  let runSign = 0
+
+  const closeRun = (runEnd: Point) => {
+    if (runStart && runAxis) {
+      const length =
+        runAxis === "x"
+          ? Math.abs(runEnd.x - runStart.x)
+          : Math.abs(runEnd.y - runStart.y)
+      if (length > epsilon) {
+        segments.push({ start: runStart, end: runEnd, axis: runAxis, length })
+      }
+    }
+    runStart = null
+    runAxis = null
+    runSign = 0
+  }
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const a = path[i]!
+    const b = path[i + 1]!
+    const dx = b.x - a.x
+    const dy = b.y - a.y
+
+    if (Math.abs(dx) <= epsilon && Math.abs(dy) <= epsilon) continue
+    const axis: "x" | "y" | null =
+      Math.abs(dy) <= epsilon ? "x" : Math.abs(dx) <= epsilon ? "y" : null
+    if (!axis) {
+      closeRun(a)
+      continue
+    }
+    const sign = Math.sign(axis === "x" ? dx : dy)
+
+    if (runStart && runAxis === axis && runSign === sign) continue
+
+    closeRun(a)
+    runStart = a
+    runAxis = axis
+    runSign = sign
+  }
+
+  if (path.length >= 2) {
+    closeRun(path[path.length - 1]!)
+  }
+
+  return segments.sort((a, b) => b.length - a.length)
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -31,6 +31,7 @@ import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSol
 import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
 import { SameNetJunctionAlignmentSolver } from "../SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver"
 import { TraceElbowTransitionSimplificationSolver } from "../TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver"
+import { InlineNetLabelSolver } from "../InlineNetLabelSolver/InlineNetLabelSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -93,6 +94,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   preAlignmentTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver
   finalTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver
   sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver
+  inlineNetLabelSolver?: InlineNetLabelSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -502,6 +504,21 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep(
+      "inlineNetLabelSolver",
+      InlineNetLabelSolver,
+      (instance) => {
+        const junctionOutput =
+          instance.sameNetJunctionAlignmentSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: junctionOutput.traces,
+            netLabelPlacements: junctionOutput.netLabelPlacements,
+          },
+        ]
+      },
+    ),
   ]
 
   constructor(inputProblem: InputProblem, opts?: Options) {

package/lib/types/InputProblem.ts

@@ -34,6 +34,30 @@ export interface InputDirectConnection {
   pinIds: [PinId, PinId]
   netId?: string
   netLabelWidth?: number
+
+  /**
+   * When true, this point-to-point connection may be labeled with an "inline
+   * net label": the net name is drawn parallel to (and offset from) the routed
+   * trace instead of being placed as a separate anchored net label at the end
+   * of the trace.
+   *
+   * Only set this for connections whose net name is worth showing on the wire -
+   * the solver trusts the caller (e.g. @tscircuit/core) to make that decision.
+   * An inline label is only emitted when the connection actually got routed.
+   */
+  allowInlineNetLabel?: boolean
+
+  /**
+   * Extent of the inline net label along the trace. Falls back to
+   * `netLabelWidth`, then to an estimate from the netId text.
+   */
+  inlineNetLabelWidth?: number
+
+  /**
+   * Height of the inline net label text. Defaults to
+   * DEFAULT_INLINE_NET_LABEL_HEIGHT.
+   */
+  inlineNetLabelHeight?: number
 }
 
 export interface InputNetConnection {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.126",
+  "version": "0.0.128",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -19,7 +19,7 @@
     "calculate-elbow": "^0.0.12",
     "connectivity-map": "^1.0.0",
     "flatbush": "^4.5.0",
-    "graphics-debug": "^0.0.96",
+    "graphics-debug": "^0.0.98",
     "react": "^19.1.1",
     "react-cosmos": "^7.0.0",
     "react-cosmos-plugin-vite": "^7.0.0",

package/site/examples/inline-net-label01.page.tsx

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

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

@@ -0,0 +1,47 @@
+{
+  "chips": [
+    {
+      "chipId": "U1",
+      "center": { "x": 0, "y": 0 },
+      "width": 1,
+      "height": 0.6,
+      "pins": [{ "pinId": "U1.1", "x": 0.5, "y": 0 }]
+    },
+    {
+      "chipId": "U2",
+      "center": { "x": 3, "y": 0 },
+      "width": 1,
+      "height": 0.6,
+      "pins": [{ "pinId": "U2.1", "x": 2.5, "y": 0 }]
+    },
+    {
+      "chipId": "U3",
+      "center": { "x": 0, "y": -2 },
+      "width": 0.6,
+      "height": 1,
+      "pins": [{ "pinId": "U3.1", "x": 0, "y": -2.5 }]
+    },
+    {
+      "chipId": "U4",
+      "center": { "x": 0, "y": -4.5 },
+      "width": 0.6,
+      "height": 1,
+      "pins": [{ "pinId": "U4.1", "x": 0, "y": -4 }]
+    }
+  ],
+  "directConnections": [
+    {
+      "pinIds": ["U1.1", "U2.1"],
+      "netId": "USER_LED_ANODE",
+      "allowInlineNetLabel": true
+    },
+    {
+      "pinIds": ["U3.1", "U4.1"],
+      "netId": "SPI_SCK",
+      "allowInlineNetLabel": true
+    }
+  ],
+  "netConnections": [],
+  "availableNetLabelOrientations": {},
+  "maxMspPairDistance": 2.4
+}

package/tests/functions/getAxisAlignedSegments.test.ts

@@ -0,0 +1,56 @@
+import { expect, test } from "bun:test"
+import { getAxisAlignedSegments } from "lib/solvers/InlineNetLabelSolver/getAxisAlignedSegments"
+
+test("getAxisAlignedSegments returns runs longest first", () => {
+  const segments = getAxisAlignedSegments([
+    { x: 0, y: 0 },
+    { x: 1, y: 0 },
+    { x: 1, y: 3 },
+    { x: 2, y: 3 },
+  ])
+
+  expect(segments.map((s) => [s.axis, s.length])).toEqual([
+    ["y", 3],
+    ["x", 1],
+    ["x", 1],
+  ])
+  expect(segments[0]).toMatchObject({
+    start: { x: 1, y: 0 },
+    end: { x: 1, y: 3 },
+  })
+})
+
+test("getAxisAlignedSegments merges collinear points", () => {
+  const segments = getAxisAlignedSegments([
+    { x: 0, y: 0 },
+    { x: 1, y: 0 },
+    { x: 2, y: 0 },
+    { x: 2, y: 1 },
+  ])
+
+  expect(segments.map((s) => [s.axis, s.length])).toEqual([
+    ["x", 2],
+    ["y", 1],
+  ])
+})
+
+test("getAxisAlignedSegments splits a run that doubles back", () => {
+  const segments = getAxisAlignedSegments([
+    { x: 0, y: 0 },
+    { x: 3, y: 0 },
+    { x: 1, y: 0 },
+  ])
+
+  expect(segments.map((s) => s.length)).toEqual([3, 2])
+})
+
+test("getAxisAlignedSegments returns nothing for degenerate paths", () => {
+  expect(getAxisAlignedSegments([])).toEqual([])
+  expect(getAxisAlignedSegments([{ x: 0, y: 0 }])).toEqual([])
+  expect(
+    getAxisAlignedSegments([
+      { x: 0, y: 0 },
+      { x: 0, y: 0 },
+    ]),
+  ).toEqual([])
+})

package/tests/solvers/InlineNetLabelSolver/__snapshots__/inline-net-label01.snap.svg

@@ -0,0 +1,54 @@
+<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><polyline data-points="0.5,0 2.5,0" data-type="line" data-label="" points="214.33962264150944,71.69811320754715 425.66037735849056,71.69811320754715" fill="none" stroke="hsl(48, 100%, 50%, 0.8)" stroke-width="1px"/></g><g><polyline data-points="0,-2.5 0,-4" data-type="line" data-label="" points="161.50943396226415,335.84905660377353 161.50943396226415,494.33962264150944" fill="none" stroke="hsl(136, 100%, 50%, 0.8)" stroke-width="1px"/></g><g><polyline data-points="0.5,0 2.5,0" data-type="line" data-label="" points="214.33962264150944,71.69811320754715 425.66037735849056,71.69811320754715" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="0,-2.5 0,-4" data-type="line" data-label="" points="161.50943396226415,335.84905660377353 161.50943396226415,494.33962264150944" fill="none" stroke="purple" stroke-width="1px"/></g><g><rect data-type="rect" data-label="U1" data-x="0" data-y="0" x="108.67924528301887" y="39.999999999999986" width="105.66037735849056" height="63.39622641509433" fill="hsl(164, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009464285714285715"/></g><g><rect data-type="rect" data-label="U2" data-x="3" data-y="0" x="425.66037735849056" y="39.999999999999986" width="105.66037735849056" height="63.39622641509433" fill="hsl(165, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009464285714285715"/></g><g><rect data-type="rect" data-label="U3" data-x="0" data-y="-2" x="129.81132075471697" y="230.18867924528303" width="63.39622641509436" height="105.66037735849054" fill="hsl(166, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009464285714285715"/></g><g><rect data-type="rect" data-label="U4" data-x="0" data-y="-4.5" x="129.81132075471697" y="494.3396226415094" width="63.39622641509436" height="105.66037735849056" fill="hsl(167, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009464285714285715"/></g><g><rect data-type="rect" data-label="INLINE netId: USER_LED_ANODE
+axis: x
+side: y+" data-x="1.5" data-y="0.14" x="224.90566037735852" y="47.39622641509432" width="190.18867924528297" height="19.01886792452831" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009464285714285715"/></g><g><rect data-type="rect" data-label="INLINE netId: SPI_SCK
+axis: y
+side: x-" data-x="-0.14" data-y="-3.25" x="137.20754716981133" y="364.3773584905661" width="19.01886792452828" height="101.43396226415086" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009464285714285715"/></g><text data-type="text" data-label="USER_LED_ANODE" data-x="1.5" data-y="0.14" x="320" y="56.90566037735847" fill="green" font-size="19.0188679245283" font-family="sans-serif" text-anchor="middle" dominant-baseline="central">USER_LED_ANODE</text><text data-type="text" data-label="SPI_SCK" data-x="-0.14" data-y="-3.25" x="146.7169811320755" y="415.09433962264154" fill="green" font-size="19.0188679245283" font-family="sans-serif" text-anchor="middle" dominant-baseline="central" transform="rotate(-90, 146.7169811320755, 415.09433962264154)">SPI_SCK</text><g><circle data-type="point" data-label="U1.1
+x+" data-x="0.5" data-y="0" cx="214.33962264150944" cy="71.69811320754715" r="3" fill="hsl(319, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="U2.1
+x-" data-x="2.5" data-y="0" cx="425.66037735849056" cy="71.69811320754715" r="3" fill="hsl(200, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="U3.1
+y-" data-x="0" data-y="-2.5" cx="161.50943396226415" cy="335.84905660377353" r="3" fill="hsl(81, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="U4.1
+y+" data-x="0" data-y="-4" cx="161.50943396226415" cy="494.33962264150944" r="3" fill="hsl(322, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="inline anchor
+USER_LED_ANODE" data-x="1.5" data-y="0" cx="320" cy="71.69811320754715" r="3" fill="green"/></g><g><circle data-type="point" data-label="inline anchor
+SPI_SCK" data-x="0" data-y="-3.25" cx="161.50943396226415" cy="415.09433962264154" r="3" fill="green"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
+              document.currentScript.parentElement.addEventListener('mousemove', (e) => {
+                const svg = e.currentTarget;
+                const rect = svg.getBoundingClientRect();
+                const x = e.clientX - rect.left;
+                const y = e.clientY - rect.top;
+                const crosshair = svg.getElementById('crosshair');
+                const h = svg.getElementById('crosshair-h');
+                const v = svg.getElementById('crosshair-v');
+                const coords = svg.getElementById('coordinates');
+                
+                crosshair.style.display = 'block';
+                h.setAttribute('x1', '0');
+                h.setAttribute('x2', '640');
+                h.setAttribute('y1', y);
+                h.setAttribute('y2', y);
+                v.setAttribute('x1', x);
+                v.setAttribute('x2', x);
+                v.setAttribute('y1', '0');
+                v.setAttribute('y2', '640');
+
+                // Calculate real coordinates using inverse transformation
+                const matrix = {"a":105.66037735849056,"c":0,"e":161.50943396226415,"b":0,"d":-105.66037735849056,"f":71.69811320754715};
+                // Manually invert and apply the affine transform
+                // Since we only use translate and scale, we can directly compute:
+                // x' = (x - tx) / sx
+                // y' = (y - ty) / sy
+                const sx = matrix.a;
+                const sy = matrix.d;
+                const tx = matrix.e; 
+                const ty = matrix.f;
+                const realPoint = {
+                  x: (x - tx) / sx,
+                  y: (y - ty) / sy // Flip y back since we used negative scale
+                }
+                
+                coords.textContent = `(${realPoint.x.toFixed(2)}, ${realPoint.y.toFixed(2)})`;
+                coords.setAttribute('x', (x + 5).toString());
+                coords.setAttribute('y', (y - 5).toString());
+              });
+              document.currentScript.parentElement.addEventListener('mouseleave', () => {
+                document.currentScript.parentElement.getElementById('crosshair').style.display = 'none';
+              });
+            ]]></script></svg>

package/tests/solvers/InlineNetLabelSolver/inline-net-label01.test.ts

@@ -0,0 +1,44 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import inputProblem from "../../assets/inline-net-label01.json"
+import "tests/fixtures/matcher"
+
+test("inline-net-label01 places inline labels alongside point-to-point traces", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  const inlinePlacements = solver
+    .inlineNetLabelSolver!.inlineNetLabelPlacements.slice()
+    .sort((a, b) => (a.netId ?? "").localeCompare(b.netId ?? ""))
+
+  expect(inlinePlacements.map((p) => p.netId)).toEqual([
+    "SPI_SCK",
+    "USER_LED_ANODE",
+  ])
+
+  const [spiSck, userLedAnode] = inlinePlacements
+
+  // The horizontal trace gets a horizontal label sitting above the wire.
+  expect(userLedAnode!.axis).toBe("x")
+  expect(userLedAnode!.side).toBe("y+")
+  expect(userLedAnode!.center.x).toBeCloseTo(userLedAnode!.anchorPoint.x, 6)
+  expect(userLedAnode!.center.y).toBeGreaterThan(userLedAnode!.anchorPoint.y)
+
+  // The vertical trace gets a vertical label on the left of the wire, which is
+  // "above" it once the text is rotated.
+  expect(spiSck!.axis).toBe("y")
+  expect(spiSck!.side).toBe("x-")
+  expect(spiSck!.center.y).toBeCloseTo(spiSck!.anchorPoint.y, 6)
+  expect(spiSck!.center.x).toBeLessThan(spiSck!.anchorPoint.x)
+
+  // An inline label replaces the anchored label for that net, it never adds a
+  // second label.
+  const inlineNetIds = new Set(inlinePlacements.map((p) => p.globalConnNetId))
+  const anchoredNetIds = solver
+    .inlineNetLabelSolver!.getOutput()
+    .netLabelPlacements.map((p) => p.globalConnNetId)
+  expect(anchoredNetIds.filter((id) => inlineNetIds.has(id))).toEqual([])
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})