@tscircuit/core 0.0.1317 → 0.0.1318

package/dist/index.js

@@ -3778,10 +3778,15 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
         edges2.push({ from: anchorPos, to: { x: labelPos.x, y: anchorPos.y } });
         edges2.push({ from: { x: labelPos.x, y: anchorPos.y }, to: labelPos });
       }
+      const junctions2 = createSchematicTraceJunctions({
+        edges: edges2,
+        db,
+        source_trace_id: trace.source_trace_id
+      });
       const dbTrace2 = db.schematic_trace.insert({
         source_trace_id: trace.source_trace_id,
         edges: edges2,
-        junctions: [],
+        junctions: junctions2,
         subcircuit_connectivity_map_key: trace.subcircuit_connectivity_map_key ?? void 0
       });
       trace.schematic_trace_id = dbTrace2.schematic_trace_id;
@@ -19127,6 +19132,24 @@ function createSchematicTraceSolverInputProblem(group) {
 // lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/applyTracesFromSolverOutput.ts
 import "@tscircuit/schematic-trace-solver";
 
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/segment-intersection.ts
+var cross = (ax, ay, bx, by) => {
+  return ax * by - ay * bx;
+};
+function segmentIntersection(p1, p2, q1, q2, tol) {
+  const r = { x: p2.x - p1.x, y: p2.y - p1.y };
+  const s = { x: q2.x - q1.x, y: q2.y - q1.y };
+  const rxs = cross(r.x, r.y, s.x, s.y);
+  const q_p = { x: q1.x - p1.x, y: q1.y - p1.y };
+  const q_pxr = cross(q_p.x, q_p.y, r.x, r.y);
+  if (Math.abs(rxs) < tol && Math.abs(q_pxr) < tol) return null;
+  if (Math.abs(rxs) < tol && Math.abs(q_pxr) >= tol) return null;
+  const t = cross(q_p.x, q_p.y, s.x, s.y) / rxs;
+  const u = cross(q_p.x, q_p.y, r.x, r.y) / rxs;
+  if (t < -tol || t > 1 + tol || u < -tol || u > 1 + tol) return null;
+  return { x: p1.x + t * r.x, y: p1.y + t * r.y };
+}
+
 // lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/compute-crossings.ts
 var TOL = 1e-6;
 function isHorizontalEdge(edge) {
@@ -19146,27 +19169,6 @@ function paramAlong(a, b, p) {
   const t = ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / ((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y));
   return Math.max(0, Math.min(1, t)) * L;
 }
-function cross(ax, ay, bx, by) {
-  return ax * by - ay * bx;
-}
-function segmentIntersection(p1, p2, q1, q2) {
-  const r = { x: p2.x - p1.x, y: p2.y - p1.y };
-  const s = { x: q2.x - q1.x, y: q2.y - q1.y };
-  const rxs = cross(r.x, r.y, s.x, s.y);
-  const q_p = { x: q1.x - p1.x, y: q1.y - p1.y };
-  const q_pxr = cross(q_p.x, q_p.y, r.x, r.y);
-  if (Math.abs(rxs) < TOL && Math.abs(q_pxr) < TOL) {
-    return null;
-  }
-  if (Math.abs(rxs) < TOL && Math.abs(q_pxr) >= TOL) {
-    return null;
-  }
-  const t = cross(q_p.x, q_p.y, s.x, s.y) / rxs;
-  const u = cross(q_p.x, q_p.y, r.x, r.y) / rxs;
-  if (t < -TOL || t > 1 + TOL || u < -TOL || u > 1 + TOL) return null;
-  const pt = { x: p1.x + t * r.x, y: p1.y + t * r.y };
-  return pt;
-}
 function mergeIntervals(intervals, tol = TOL) {
   if (intervals.length === 0) return intervals;
   intervals.sort((a, b) => a.start - b.start);
@@ -19232,7 +19234,10 @@ function computeCrossings(traces, opts = {}) {
         const B = traces[tj];
         for (let ej = tj === ti ? ei + 1 : 0; ej < B.edges.length; ej++) {
           const eB = B.edges[ej];
-          const P = segmentIntersection(eA.from, eA.to, eB.from, eB.to);
+          if (A.connectivity_key !== void 0 && A.connectivity_key === B.connectivity_key) {
+            continue;
+          }
+          const P = segmentIntersection(eA.from, eA.to, eB.from, eB.to, tol);
           if (!P) continue;
           const LA = length6(eA.from, eA.to);
           const LB = length6(eB.from, eB.to);
@@ -19270,6 +19275,7 @@ function computeCrossings(traces, opts = {}) {
   }
   const out = traces.map((t) => ({
     source_trace_id: t.source_trace_id,
+    connectivity_key: t.connectivity_key,
     edges: []
   }));
   for (let ti = 0; ti < traces.length; ti++) {
@@ -19323,6 +19329,9 @@ function dedupePoints(points, tol = TOL2) {
 function edgeVec(e) {
   return { x: e.to.x - e.from.x, y: e.to.y - e.from.y };
 }
+function isEndpointOfEdge(p, e, tol = TOL2) {
+  return pointEq(p, e.from, tol) || pointEq(p, e.to, tol);
+}
 function isParallel(e1, e2, tol = TOL2) {
   const v1 = edgeVec(e1);
   const v2 = edgeVec(e2);
@@ -19386,6 +19395,22 @@ function computeJunctions(traces, opts = {}) {
     for (let j = i + 1; j < traces.length; j++) {
       const B = traces[j];
       const BEnds = endpointsByTrace[j];
+      const isSameNet = A.connectivity_key !== void 0 && A.connectivity_key === B.connectivity_key;
+      if (isSameNet) {
+        for (const eA of A.edges) {
+          for (const eB of B.edges) {
+            const p = segmentIntersection(eA.from, eA.to, eB.from, eB.to, tol);
+            if (!p) continue;
+            if (isEndpointOfEdge(p, eA, tol) || isEndpointOfEdge(p, eB, tol)) {
+              continue;
+            }
+            result[A.source_trace_id].push(p);
+            if (A.source_trace_id !== B.source_trace_id) {
+              result[B.source_trace_id].push(p);
+            }
+          }
+        }
+      }
       for (const pa of AEnds) {
         for (const pb of BEnds) {
           if (pointEq(pa, pb, tol)) {
@@ -19508,6 +19533,18 @@ function applyTracesFromSolverOutput(args) {
         String(solvedTracePath.userNetId)
       );
     }
+    if (!subcircuit_connectivity_map_key) {
+      const sourcePortConnKeys = solvedTraceSchematicPortIds.map((schematicPortId) => {
+        const schematicPort = db.schematic_port.get(schematicPortId);
+        const sourcePortId = schematicPort?.source_port_id;
+        if (!sourcePortId) return void 0;
+        return db.source_port.get(sourcePortId)?.subcircuit_connectivity_map_key;
+      }).filter((key) => Boolean(key));
+      const uniqueSourcePortConnKeys = new Set(sourcePortConnKeys);
+      if (uniqueSourcePortConnKeys.size === 1) {
+        subcircuit_connectivity_map_key = sourcePortConnKeys[0];
+      }
+    }
     pendingTraces.push({
       source_trace_id,
       edges,
@@ -19520,10 +19557,24 @@ function applyTracesFromSolverOutput(args) {
   const withCrossings = computeCrossings(
     pendingTraces.map((t) => ({
       source_trace_id: t.source_trace_id,
-      edges: t.edges
+      edges: t.edges,
+      connectivity_key: t.subcircuit_connectivity_map_key
     }))
   );
-  const junctionsById = computeJunctions(withCrossings);
+  const existingTracesForJunctions = [];
+  for (const t of db.schematic_trace.list()) {
+    if (!t.source_trace_id || t.edges.length === 0) continue;
+    const sourceTrace = db.source_trace.get(t.source_trace_id);
+    existingTracesForJunctions.push({
+      source_trace_id: t.source_trace_id,
+      edges: t.edges,
+      connectivity_key: t.subcircuit_connectivity_map_key ?? sourceTrace?.subcircuit_connectivity_map_key
+    });
+  }
+  const junctionsById = computeJunctions([
+    ...withCrossings,
+    ...existingTracesForJunctions
+  ]);
   for (const t of withCrossings) {
     db.schematic_trace.insert({
       source_trace_id: t.source_trace_id,
@@ -23515,7 +23566,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1316",
+  version: "0.0.1317",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1317",
+  "version": "0.0.1318",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",