@tscircuit/schematic-trace-solver 0.0.187 → 0.0.189

package/tests/solvers/InlineNetLabelSolver/local-trace-label-shifts.test.ts

@@ -0,0 +1,296 @@
+import { expect, test } from "bun:test"
+import type { Point } from "@tscircuit/math-utils"
+import type { InputProblem } from "lib/types/InputProblem"
+import {
+  InlineNetLabelSolver,
+  type InlineNetLabelOutput,
+} from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getLocalTraceLabelShifts } from "lib/solvers/InlineNetLabelSolver/getLocalTraceLabelShifts"
+import {
+  getOutputLabelCollisions,
+  sameOutputLabelCollision,
+} from "lib/solvers/InlineNetLabelSolver/getOutputLabelCollisions"
+
+const trace = (net: string, path: Point[]): SolvedTracePath => ({
+  mspPairId: net,
+  mspConnectionPairIds: [net],
+  globalConnNetId: net,
+  dcConnNetId: net,
+  pinIds: [`${net}.1`, `${net}.2`],
+  pins: [
+    { pinId: `${net}.1`, chipId: "A", ...path[0]! },
+    { pinId: `${net}.2`, chipId: "B", ...path.at(-1)! },
+  ],
+  tracePath: path,
+})
+const fixture = () => {
+  const input: InputProblem = {
+    chips: [],
+    netConnections: [],
+    directConnections: [],
+    availableNetLabelOrientations: {},
+  }
+  const output: Omit<InlineNetLabelOutput, "inputProblem"> = {
+    traces: [
+      trace("wire", [
+        { x: 0, y: 1 },
+        { x: 1, y: 1 },
+        { x: 1, y: -1 },
+        { x: 0, y: -1 },
+      ]),
+    ],
+    netLabelPlacements: [
+      {
+        globalConnNetId: "label",
+        netId: "label",
+        pinIds: ["label.1"],
+        mspConnectionPairIds: [],
+        orientation: "x+",
+        anchorPoint: { x: 0.8, y: 0 },
+        center: { x: 1, y: 0 },
+        width: 0.4,
+        height: 0.2,
+      },
+    ],
+    inlineNetLabelPlacements: [],
+  }
+  return { input, output }
+}
+
+for (const rotation of [0, 1, 2, 3])
+  test(`slides an existing leg without adding bends (rotation ${rotation})`, () => {
+    const { input, output } = fixture()
+    const rotate = (p: Point): Point => {
+      for (let i = 0; i < rotation; i++) p = { x: -p.y, y: p.x }
+      return p
+    }
+    output.traces[0]!.tracePath = output.traces[0]!.tracePath.map(rotate)
+    output.traces[0]!.pins = output.traces[0]!.pins.map((pin) => ({
+      ...pin,
+      ...rotate(pin),
+    })) as SolvedTracePath["pins"]
+    const label = output.netLabelPlacements[0]!
+    label.anchorPoint = rotate(label.anchorPoint)
+    label.center = rotate(label.center)
+    label.orientation = (["x+", "y+", "x-", "y-"] as const)[rotation]!
+    if (rotation % 2) [label.width, label.height] = [label.height, label.width]
+    const saved = structuredClone(output)
+    const proposals = [...getLocalTraceLabelShifts(input, output)]
+    expect(proposals.length).toBeGreaterThan(0)
+    for (const proposal of proposals) {
+      const path = proposal.traces[0]!.tracePath
+      expect(path).toHaveLength(4)
+      expect(path[0]).toEqual(output.traces[0]!.tracePath[0])
+      expect(path.at(-1)).toEqual(output.traces[0]!.tracePath.at(-1))
+      expect([...getOutputLabelCollisions(proposal)]).toEqual([])
+    }
+    expect(output).toEqual(saved)
+  })
+
+test.each([
+  "chip",
+  "parallel wire",
+  "new crossing",
+  "junction",
+  "unconnected pin",
+] as const)(
+  "does not force a detour through a blocked corridor: %s",
+  (obstacle) => {
+    const { input, output } = fixture()
+    if (obstacle === "chip")
+      input.chips.push(
+        ...[0.75, 1.25].map((x) => ({
+          chipId: `C${x}`,
+          center: { x, y: 0 },
+          width: 0.08,
+          height: 0.5,
+          pins: [],
+        })),
+      )
+    if (obstacle === "parallel wire")
+      output.traces.push(
+        ...[0.75, 1.25].map((x) =>
+          trace(`other${x}`, [
+            { x, y: -2 },
+            { x, y: 2 },
+          ]),
+        ),
+      )
+    if (obstacle === "new crossing")
+      output.traces.push(
+        trace("other", [
+          { x: 0.6, y: 0 },
+          { x: 0.9, y: 0 },
+        ]),
+        trace("other2", [
+          { x: 1.1, y: 0 },
+          { x: 1.4, y: 0 },
+        ]),
+      )
+    if (obstacle === "junction")
+      output.traces.push({
+        ...trace("branch", [
+          { x: 1, y: 0.5 },
+          { x: 2, y: 0.5 },
+        ]),
+        globalConnNetId: "wire",
+      })
+    if (obstacle === "unconnected pin")
+      input.chips.push({
+        chipId: "ports",
+        center: { x: 10, y: 10 },
+        width: 1,
+        height: 1,
+        pins: [0.79, 1.21].map((x) => ({ pinId: `NC${x}`, x, y: 0 })),
+      })
+    expect([...getLocalTraceLabelShifts(input, output)]).toEqual([])
+  },
+)
+
+test("moves a neighboring power label with its short connector to free a side corridor", () => {
+  const { input, output } = fixture()
+  input.chips.push({
+    chipId: "C",
+    center: { x: 0.75, y: 0 },
+    width: 0.08,
+    height: 0.5,
+    pins: [],
+  })
+  const power = {
+    ...trace("power", [
+      { x: 0, y: -0.7 },
+      { x: 1.4, y: -0.7 },
+      { x: 1.4, y: 0.8 },
+    ]),
+    pinIds: ["power.1"],
+  }
+  power.pins = [power.pins[0], power.pins[0]]
+  output.traces.push(power)
+  output.netLabelPlacements.push({
+    globalConnNetId: "power",
+    netId: "power",
+    pinIds: ["power.1"],
+    mspConnectionPairIds: [],
+    orientation: "y+",
+    anchorPoint: { x: 1.4, y: 0.8 },
+    center: { x: 1.4, y: 0.95 },
+    width: 0.6,
+    height: 0.3,
+  })
+  const proposals = [...getLocalTraceLabelShifts(input, output)]
+  expect(proposals.length).toBeGreaterThan(0)
+  for (const proposal of proposals) {
+    expect(proposal.traces[0]!.tracePath).toHaveLength(4)
+    expect(proposal.traces[1]!.tracePath).toHaveLength(3)
+    expect(proposal.traces[1]!.tracePath[0]).toEqual(power.tracePath[0])
+    expect(proposal.netLabelPlacements[1]!.anchorPoint.x).toBeGreaterThan(1.4)
+    expect([...getOutputLabelCollisions(proposal)]).toEqual([])
+  }
+})
+
+test("clears a moved rail's own tag and a neighboring power label in one proposal", () => {
+  const { input, output } = fixture()
+  input.chips.push({
+    chipId: "C",
+    center: { x: 0.75, y: 0 },
+    width: 0.08,
+    height: 0.5,
+    pins: [],
+  })
+  const power = {
+    ...trace("power", [
+      { x: 0, y: -0.8 },
+      { x: 1.125, y: -0.8 },
+      { x: 1.125, y: -0.6 },
+    ]),
+    pinIds: ["power.1"],
+  }
+  power.pins = [power.pins[0], power.pins[0]]
+  output.traces.push(power)
+  output.netLabelPlacements.push(
+    {
+      globalConnNetId: "wire",
+      netId: "wire",
+      pinIds: ["wire.1", "wire.2"],
+      mspConnectionPairIds: [],
+      orientation: "x-",
+      anchorPoint: { x: 1, y: -0.5 },
+      center: { x: 0.8, y: -0.5 },
+      width: 0.4,
+      height: 0.2,
+    },
+    {
+      globalConnNetId: "power",
+      netId: "power",
+      pinIds: ["power.1"],
+      mspConnectionPairIds: [],
+      orientation: "y+",
+      anchorPoint: { x: 1.125, y: -0.6 },
+      center: { x: 1.125, y: -0.5 },
+      width: 0.15,
+      height: 0.2,
+    },
+  )
+  const saved = structuredClone(output)
+  const proposals = [...getLocalTraceLabelShifts(input, output)]
+  expect(proposals.length).toBeGreaterThan(0)
+  for (const proposal of proposals) {
+    expect(proposal.traces.map((trace) => trace.tracePath.length)).toEqual([
+      4, 3,
+    ])
+    expect(proposal.netLabelPlacements[1]!.anchorPoint.x).toBeCloseTo(1.25)
+    expect(proposal.netLabelPlacements[2]!.anchorPoint.x).toBeGreaterThan(1.25)
+    expect([...getOutputLabelCollisions(proposal)]).toEqual([])
+  }
+  expect(output).toEqual(saved)
+})
+
+test("collision identity preserves opaque trace, net, and pin IDs", () => {
+  const first = fixture().output
+  first.traces[0]!.mspPairId = "a/b"
+  first.netLabelPlacements[0]!.globalConnNetId = "c"
+  first.netLabelPlacements[0]!.pinIds = ["p,q"]
+  const second = structuredClone(first)
+  second.traces[0]!.mspPairId = "a"
+  second.netLabelPlacements[0]!.globalConnNetId = "b/c"
+  const a = getOutputLabelCollisions(first)[0]!
+  const b = getOutputLabelCollisions(second)[0]!
+  expect(a).toMatchObject({
+    kind: "trace-label",
+    trace: { kind: "routed", id: "a/b" },
+  })
+  expect(sameOutputLabelCollision(a, b)).toBe(false)
+  const splitPins = structuredClone(first)
+  splitPins.netLabelPlacements[0]!.pinIds = ["p", "q"]
+  expect(
+    sameOutputLabelCollision(a, getOutputLabelCollisions(splitPins)[0]!),
+  ).toBe(false)
+  expect(sameOutputLabelCollision(a, structuredClone(a))).toBe(true)
+})
+
+test("refinement steps candidates and retains output when they exhaust their budget", () => {
+  const { input, output } = fixture()
+  const solver = new InlineNetLabelSolver({
+    inputProblem: input,
+    ...output,
+    resolveTraceCollisions: true,
+  })
+  let failedCandidates = 0
+  while (!solver.solved && !solver.failed) {
+    if (solver.activeSubSolver) {
+      const candidate = solver.activeSubSolver
+      expect(candidate.iterations).toBe(0)
+      candidate.MAX_ITERATIONS = 0
+      solver.step()
+      expect(candidate.failed).toBe(true)
+      failedCandidates++
+    } else solver.step()
+  }
+  expect(failedCandidates).toBeGreaterThan(0)
+  expect(solver.solved).toBe(true)
+  expect(solver.getOutput().traces).toEqual(output.traces)
+  expect(solver.getOutput().netLabelPlacements).toEqual(
+    output.netLabelPlacements,
+  )
+})

package/tests/solvers/InlineNetLabelSolver/multi-pin-connected-components.test.ts

@@ -175,9 +175,11 @@ test("a short routed component is retained when replacing it would strand an int
   solver.solve()
 
   const output = solver.getOutput()
-  expect(output.inlineNetLabelPlacements).toHaveLength(0)
+  expect(output.inlineNetLabelPlacements.map((label) => label.pinIds)).toEqual([
+    ["U1.1"],
+  ])
   expect(output.traces).toEqual([shortTrace])
-  expect(output.netLabelPlacements).toEqual(anchoredLabels)
+  expect(output.netLabelPlacements).toEqual([anchoredLabels[0]!])
 })
 
 test("a generated anchored-label connector becomes an inline terminal stub", () => {
@@ -218,8 +220,8 @@ test("a generated anchored-label connector becomes an inline terminal stub", ()
     availableNetLabelOrientations: { SIGNAL: ["x-"] },
   }
   const generatedLabelConnector: SolvedTracePath = {
-    mspPairId: "available-net-orientation-0-SIGNAL",
-    mspConnectionPairIds: ["available-net-orientation-0-SIGNAL"],
+    mspPairId: "opaque/connector:1",
+    mspConnectionPairIds: ["opaque/connector:1"],
     dcConnNetId: "SIGNAL",
     globalConnNetId: "SIGNAL",
     userNetId: "SIGNAL",
@@ -237,6 +239,7 @@ test("a generated anchored-label connector becomes an inline terminal stub", ()
   const solver = new InlineNetLabelSolver({
     inputProblem,
     traces: [generatedLabelConnector],
+    netLabelConnectorTraceIds: new Set([generatedLabelConnector.mspPairId]),
     netLabelPlacements: [],
   })
   solver.solve()

package/tests/solvers/InlineNetLabelSolver/push-anchored-net-labels-away.test.ts

@@ -76,6 +76,7 @@ test("pushes a regular endpoint label and its wick past nearby inline text", ()
     traces,
     netLabelPlacements,
     inlineNetLabelPlacements,
+    netLabelConnectorTraceIds: new Set(traces.map((trace) => trace.mspPairId)),
   })
 
   expect(output.movedLabelCount).toBe(1)
@@ -289,7 +290,7 @@ test("moves a contiguous label row together and shoves an anchored obstacle", ()
   expect(output.netLabelPlacements[2]!.center.x).toBeLessThan(-2.5)
   expect(
     output.traces.filter((trace) =>
-      trace.mspPairId.startsWith("inline-net-label-clearance-"),
+      output.netLabelConnectorTraceIds.has(trace.mspPairId),
     ),
   ).toHaveLength(3)
 })

package/tests/solvers/InlineNetLabelSolver/shared-direct-and-named-connection.test.ts

@@ -0,0 +1,62 @@
+import { expect, test } from "bun:test"
+import { InlineNetLabelSolver } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+test.each(["CLOCK", ".A > .B"])(
+  "a named net and its direct pair %s produce one inline label",
+  (directName) => {
+    const connection = {
+      netId: "CLOCK",
+      pinIds: ["A.1", "B.1"] as [string, string],
+      allowInlineNetLabel: true,
+      inlineNetLabelWidth: 0.5,
+      inlineNetLabelHeight: 0.12,
+    }
+    const input: InputProblem = {
+      chips: [
+        {
+          chipId: "A",
+          center: { x: 0, y: 0 },
+          width: 1,
+          height: 1,
+          pins: [{ pinId: "A.1", x: 0.5, y: 0 }],
+        },
+        {
+          chipId: "B",
+          center: { x: 3, y: 0 },
+          width: 1,
+          height: 1,
+          pins: [{ pinId: "B.1", x: 2.5, y: 0 }],
+        },
+      ],
+      directConnections: [{ ...connection, netId: directName }],
+      netConnections: [connection],
+      availableNetLabelOrientations: {},
+    }
+    const trace: SolvedTracePath = {
+      mspPairId: "pair",
+      mspConnectionPairIds: ["pair"],
+      globalConnNetId: "CLOCK",
+      dcConnNetId: "CLOCK",
+      pinIds: connection.pinIds,
+      pins: [
+        { pinId: "A.1", chipId: "A", x: 0.5, y: 0 },
+        { pinId: "B.1", chipId: "B", x: 2.5, y: 0 },
+      ],
+      tracePath: [
+        { x: 0.5, y: 0 },
+        { x: 2.5, y: 0 },
+      ],
+    }
+    const solver = new InlineNetLabelSolver({
+      inputProblem: input,
+      traces: [trace],
+      netLabelPlacements: [],
+    })
+    solver.solve()
+    expect(solver.getOutput().inlineNetLabelPlacements).toHaveLength(1)
+    expect(solver.getOutput().inlineNetLabelPlacements[0]!.netId).toBe("CLOCK")
+    expect(solver.getOutput().traces).toEqual([trace])
+  },
+)

package/tests/solvers/InlineNetLabelSolver/two-pin-terminal-stubs-atomic.test.ts

@@ -3,7 +3,7 @@ import { InlineNetLabelSolver } from "lib/solvers/InlineNetLabelSolver/InlineNet
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 
-test("two-pin terminal stubs fall back atomically when one endpoint is obstructed", () => {
+test("disconnected endpoints keep independent label styles when one is obstructed", () => {
   const inputProblem: InputProblem = {
     chips: [
       {
@@ -79,6 +79,12 @@ test("two-pin terminal stubs fall back atomically when one endpoint is obstructe
   })
   solver.solve()
 
-  expect(solver.inlineNetLabelPlacements).toHaveLength(0)
-  expect(solver.getOutput().netLabelPlacements).toHaveLength(2)
+  expect(solver.inlineNetLabelPlacements.map((label) => label.pinIds)).toEqual([
+    ["U2.1"],
+  ])
+  expect(solver.getOutput().netLabelPlacements).toEqual([
+    netLabelPlacements[0]!,
+  ])
+  expect(netLabelPlacements).toHaveLength(2)
+  expect(solver.getOutput().traces).toHaveLength(0)
 })

package/tests/solvers/TraceCleanupSolver/perpendicular-detours-preserve-endpoints.test.ts

@@ -0,0 +1,60 @@
+import { expect, test } from "bun:test"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { generatePerpendicularTraceDetours } from "lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates"
+
+test("perpendicular detours keep both terminals for horizontal and vertical crossings", () => {
+  const crossings = [
+    {
+      path: [
+        { x: 0, y: 0 },
+        { x: 4, y: 0 },
+      ],
+      obstacleStart: { x: 2, y: -1 },
+      obstacleEnd: { x: 2, y: 1 },
+    },
+    {
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 4 },
+      ],
+      obstacleStart: { x: -1, y: 2 },
+      obstacleEnd: { x: 1, y: 2 },
+    },
+  ]
+
+  for (const crossing of crossings) {
+    const start = crossing.path[0]!
+    const end = crossing.path[1]!
+    const trace: SolvedTracePath = {
+      mspPairId: "signal",
+      dcConnNetId: "signal",
+      globalConnNetId: "signal",
+      pins: [
+        { ...start, pinId: "source", chipId: "source-chip" },
+        { ...end, pinId: "destination", chipId: "destination-chip" },
+      ],
+      pinIds: ["source", "destination"],
+      mspConnectionPairIds: ["signal"],
+      tracePath: crossing.path,
+    }
+    const candidates = generatePerpendicularTraceDetours({
+      trace,
+      segmentIndex: 0,
+      obstacleStart: crossing.obstacleStart,
+      obstacleEnd: crossing.obstacleEnd,
+      chipBounds: [],
+      clearance: 0.1,
+    })
+
+    expect(candidates).toHaveLength(4)
+    for (const candidate of candidates) {
+      expect(candidate.path[0]).toEqual(start)
+      expect(candidate.path.at(-1)).toEqual(end)
+      for (let index = 1; index < candidate.path.length; index++) {
+        const previous = candidate.path[index - 1]!
+        const current = candidate.path[index]!
+        expect(previous.x === current.x || previous.y === current.y).toBe(true)
+      }
+    }
+  }
+})