@tscircuit/schematic-trace-solver 0.0.148 → 0.0.149

package/dist/index.d.ts

@@ -1186,6 +1186,8 @@ 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;
+/** Clearance between a generated terminal stub and an unrelated trace. */
+declare const INLINE_NET_LABEL_STUB_TRACE_CLEARANCE = 0.05;
 /**
  * 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
@@ -1361,4 +1363,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-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 };
+export { type ChipId, DEFAULT_INLINE_NET_LABEL_HEIGHT, INLINE_NET_LABEL_MAX_SPAN_JOG, INLINE_NET_LABEL_STUB_TRACE_CLEARANCE, 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

@@ -12678,47 +12678,6 @@ 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/alignPortOnlyInlineNetLabelStubs.ts
 var getStubDirection = (path) => {
   const [start, end] = path;
@@ -12867,6 +12826,47 @@ var alignPortOnlyInlineNetLabelStubs = ({
   return alignedPlacements;
 };
 
+// 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/pushAnchoredNetLabelsAwayFromInlineLabels.ts
 var LABEL_CLEARANCE2 = 0.05;
 var POINT_EPSILON = 1e-6;
@@ -13229,6 +13229,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
+var INLINE_NET_LABEL_STUB_TRACE_CLEARANCE = 0.05;
 var INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4;
 var getPinPairKey2 = (pinIds) => [...pinIds].sort().join("::");
 var InlineNetLabelSolver = class extends BaseSolver {
@@ -13329,7 +13330,15 @@ var InlineNetLabelSolver = class extends BaseSolver {
     const stubLength = Math.max(width + 0.2, 0.6);
     const start = inputPin ? { x: inputPin.x, y: inputPin.y } : anchoredPlacement.anchorPoint;
     const direction = inputPin && inputChip ? inputPin._facingDirection ?? getPinDirection(inputPin, inputChip) : anchoredPlacement.orientation;
-    const end = direction === "x+" ? { x: start.x + stubLength, y: start.y } : direction === "x-" ? { x: start.x - stubLength, y: start.y } : direction === "y+" ? { x: start.x, y: start.y + stubLength } : { x: start.x, y: start.y - stubLength };
+    const intendedEnd = direction === "x+" ? { x: start.x + stubLength, y: start.y } : direction === "x-" ? { x: start.x - stubLength, y: start.y } : direction === "y+" ? { x: start.x, y: start.y + stubLength } : { x: start.x, y: start.y - stubLength };
+    const end = getCollisionLimitedTerminalStubEnd({
+      start,
+      intendedEnd,
+      minimumLength: width + 2 * INLINE_NET_LABEL_TRACE_MARGIN,
+      traces: this.traces,
+      ownGlobalConnNetId: anchoredPlacement.globalConnNetId
+    });
+    if (!end) return null;
     const axis = direction === "x+" || direction === "x-" ? "x" : "y";
     const side = axis === "x" ? "y+" : "x-";
     const anchorPoint = {
@@ -13681,6 +13690,55 @@ var doesPathIntersectBounds2 = (path, bounds) => {
   }
   return false;
 };
+var GEOMETRY_EPSILON = 1e-6;
+var getCollisionLimitedTerminalStubEnd = ({
+  start,
+  intendedEnd,
+  minimumLength,
+  traces,
+  ownGlobalConnNetId
+}) => {
+  const isHorizontal4 = Math.abs(intendedEnd.x - start.x) >= Math.abs(intendedEnd.y - start.y);
+  const alongAxis = isHorizontal4 ? "x" : "y";
+  const acrossAxis = isHorizontal4 ? "y" : "x";
+  const direction = Math.sign(intendedEnd[alongAxis] - start[alongAxis]) || 1;
+  const intendedLength = Math.abs(intendedEnd[alongAxis] - start[alongAxis]);
+  let availableLength = intendedLength;
+  for (const trace of traces) {
+    if (trace.globalConnNetId === ownGlobalConnNetId) continue;
+    for (let segmentIndex = 0; segmentIndex < trace.tracePath.length - 1; segmentIndex++) {
+      const segmentStart = trace.tracePath[segmentIndex];
+      const segmentEnd = trace.tracePath[segmentIndex + 1];
+      const startAlong = (segmentStart[alongAxis] - start[alongAxis]) * direction;
+      const endAlong = (segmentEnd[alongAxis] - start[alongAxis]) * direction;
+      const startAcross = segmentStart[acrossAxis] - start[acrossAxis];
+      const endAcross = segmentEnd[acrossAxis] - start[acrossAxis];
+      const minAlong = Math.min(startAlong, endAlong);
+      const maxAlong = Math.max(startAlong, endAlong);
+      const minAcross = Math.min(startAcross, endAcross);
+      const maxAcross = Math.max(startAcross, endAcross);
+      let collisionDistance;
+      const isCollinear = Math.abs(startAcross) <= GEOMETRY_EPSILON && Math.abs(endAcross) <= GEOMETRY_EPSILON;
+      if (isCollinear && maxAlong >= -GEOMETRY_EPSILON && minAlong <= intendedLength + GEOMETRY_EPSILON) {
+        collisionDistance = Math.max(0, minAlong);
+      } else {
+        const crossesStubAxis = minAcross <= GEOMETRY_EPSILON && maxAcross >= -GEOMETRY_EPSILON;
+        const perpendicularAlong = (startAlong + endAlong) / 2;
+        if (crossesStubAxis && Math.abs(startAlong - endAlong) <= GEOMETRY_EPSILON && perpendicularAlong >= -GEOMETRY_EPSILON && perpendicularAlong <= intendedLength + GEOMETRY_EPSILON) {
+          collisionDistance = Math.max(0, perpendicularAlong);
+        }
+      }
+      if (collisionDistance !== void 0) {
+        availableLength = Math.min(
+          availableLength,
+          collisionDistance - INLINE_NET_LABEL_STUB_TRACE_CLEARANCE
+        );
+      }
+    }
+  }
+  if (availableLength + GEOMETRY_EPSILON < minimumLength) return null;
+  return isHorizontal4 ? { x: start.x + direction * availableLength, y: start.y } : { x: start.x, y: start.y + direction * availableLength };
+};
 
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
@@ -14246,6 +14304,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
 export {
   DEFAULT_INLINE_NET_LABEL_HEIGHT,
   INLINE_NET_LABEL_MAX_SPAN_JOG,
+  INLINE_NET_LABEL_STUB_TRACE_CLEARANCE,
   INLINE_NET_LABEL_TRACE_MARGIN,
   InlineNetLabelSolver,
   SchematicTracePipelineSolver,

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -13,11 +13,11 @@ import type {
 } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import { alignPortOnlyInlineNetLabelStubs } from "./alignPortOnlyInlineNetLabelStubs"
 import {
   type AxisAlignedSegment,
   getAxisAlignedSegments,
 } from "./getAxisAlignedSegments"
-import { alignPortOnlyInlineNetLabelStubs } from "./alignPortOnlyInlineNetLabelStubs"
 import { pushAnchoredNetLabelsAwayFromInlineLabels } from "./pushAnchoredNetLabelsAwayFromInlineLabels"
 
 export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
@@ -27,6 +27,9 @@ export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
  */
 export const INLINE_NET_LABEL_TRACE_MARGIN = 0.05
 
+/** Clearance between a generated terminal stub and an unrelated trace. */
+export const INLINE_NET_LABEL_STUB_TRACE_CLEARANCE = 0.05
+
 /**
  * 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
@@ -248,7 +251,7 @@ export class InlineNetLabelSolver extends BaseSolver {
       inputPin && inputChip
         ? (inputPin._facingDirection ?? getPinDirection(inputPin, inputChip))
         : anchoredPlacement.orientation
-    const end: Point =
+    const intendedEnd: Point =
       direction === "x+"
         ? { x: start.x + stubLength, y: start.y }
         : direction === "x-"
@@ -257,6 +260,15 @@ export class InlineNetLabelSolver extends BaseSolver {
             ? { x: start.x, y: start.y + stubLength }
             : { x: start.x, y: start.y - stubLength }
 
+    const end = getCollisionLimitedTerminalStubEnd({
+      start,
+      intendedEnd,
+      minimumLength: width + 2 * INLINE_NET_LABEL_TRACE_MARGIN,
+      traces: this.traces,
+      ownGlobalConnNetId: anchoredPlacement.globalConnNetId,
+    })
+    if (!end) return null
+
     const axis: InlineNetLabelPlacement["axis"] =
       direction === "x+" || direction === "x-" ? "x" : "y"
     const side: InlineNetLabelPlacement["side"] = axis === "x" ? "y+" : "x-"
@@ -777,3 +789,90 @@ const doesPathIntersectBounds = (path: Point[], bounds: Bounds): boolean => {
   }
   return false
 }
+
+const GEOMETRY_EPSILON = 1e-6
+
+/**
+ * Shortens an axis-aligned terminal stub before the first unrelated trace.
+ * Coordinates are schematic-world millimetres with +x right and +y up.
+ */
+const getCollisionLimitedTerminalStubEnd = ({
+  start,
+  intendedEnd,
+  minimumLength,
+  traces,
+  ownGlobalConnNetId,
+}: {
+  start: Point
+  intendedEnd: Point
+  minimumLength: number
+  traces: SolvedTracePath[]
+  ownGlobalConnNetId: string
+}): Point | null => {
+  const isHorizontal =
+    Math.abs(intendedEnd.x - start.x) >= Math.abs(intendedEnd.y - start.y)
+  const alongAxis = isHorizontal ? "x" : "y"
+  const acrossAxis = isHorizontal ? "y" : "x"
+  const direction = Math.sign(intendedEnd[alongAxis] - start[alongAxis]) || 1
+  const intendedLength = Math.abs(intendedEnd[alongAxis] - start[alongAxis])
+  let availableLength = intendedLength
+
+  for (const trace of traces) {
+    if (trace.globalConnNetId === ownGlobalConnNetId) continue
+
+    for (
+      let segmentIndex = 0;
+      segmentIndex < trace.tracePath.length - 1;
+      segmentIndex++
+    ) {
+      const segmentStart = trace.tracePath[segmentIndex]!
+      const segmentEnd = trace.tracePath[segmentIndex + 1]!
+      const startAlong =
+        (segmentStart[alongAxis] - start[alongAxis]) * direction
+      const endAlong = (segmentEnd[alongAxis] - start[alongAxis]) * direction
+      const startAcross = segmentStart[acrossAxis] - start[acrossAxis]
+      const endAcross = segmentEnd[acrossAxis] - start[acrossAxis]
+      const minAlong = Math.min(startAlong, endAlong)
+      const maxAlong = Math.max(startAlong, endAlong)
+      const minAcross = Math.min(startAcross, endAcross)
+      const maxAcross = Math.max(startAcross, endAcross)
+
+      let collisionDistance: number | undefined
+      const isCollinear =
+        Math.abs(startAcross) <= GEOMETRY_EPSILON &&
+        Math.abs(endAcross) <= GEOMETRY_EPSILON
+      if (
+        isCollinear &&
+        maxAlong >= -GEOMETRY_EPSILON &&
+        minAlong <= intendedLength + GEOMETRY_EPSILON
+      ) {
+        collisionDistance = Math.max(0, minAlong)
+      } else {
+        const crossesStubAxis =
+          minAcross <= GEOMETRY_EPSILON && maxAcross >= -GEOMETRY_EPSILON
+        const perpendicularAlong = (startAlong + endAlong) / 2
+        if (
+          crossesStubAxis &&
+          Math.abs(startAlong - endAlong) <= GEOMETRY_EPSILON &&
+          perpendicularAlong >= -GEOMETRY_EPSILON &&
+          perpendicularAlong <= intendedLength + GEOMETRY_EPSILON
+        ) {
+          collisionDistance = Math.max(0, perpendicularAlong)
+        }
+      }
+
+      if (collisionDistance !== undefined) {
+        availableLength = Math.min(
+          availableLength,
+          collisionDistance - INLINE_NET_LABEL_STUB_TRACE_CLEARANCE,
+        )
+      }
+    }
+  }
+
+  if (availableLength + GEOMETRY_EPSILON < minimumLength) return null
+
+  return isHorizontal
+    ? { x: start.x + direction * availableLength, y: start.y }
+    : { x: start.x, y: start.y + direction * availableLength }
+}

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.148",
+  "version": "0.0.149",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/examples/example51.page.tsx

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