@tscircuit/core 0.0.1897 → 0.0.1899

package/dist/index.js

@@ -26555,6 +26555,7 @@ function normalizeFanoutPlanCorners(params) {
   if (new Set(params.plans.map((p) => p.connectionIndex)).size !== params.plans.length)
     return null;
   let plans = [...params.plans];
+  let repairedSourceCorners = false;
   if (params.repairPlaneSourceCorners || params.repairSignalSourceCorners) {
     for (let index = 0; index < plans.length; index++) {
       const plan = plans[index];
@@ -26575,8 +26576,14 @@ function normalizeFanoutPlanCorners(params) {
       );
       if (!normalized) return null;
       plans[index] = normalized;
+      repairedSourceCorners = true;
     }
   }
+  if (repairedSourceCorners && params.rematchRepairedLengths) {
+    const rematched = params.rematchRepairedLengths(plans);
+    if (!rematched) return null;
+    plans = rematched;
+  }
   const sourceNormalizedPlans = [...plans];
   const pairs3 = getDeclaredDifferentialPairs(params.inputSrj);
   for (const plan of plans) {
@@ -33338,6 +33345,90 @@ function buildOutputSimpleRouteJson(params) {
   };
 }
 
+// node_modules/@tscircuit/fanout-solver/lib/dense-boundary-routing-policy.ts
+var minimumJointBoundaryBusCount = 5;
+var maximumJointBoundaryBusCount = 40;
+var maximumJointBoundaryConnectionCount = 64;
+var minimumLargeBoundaryOnlyBusCount = 10;
+var minimumMixedRoutingPlaneBusCount = 8;
+function shouldUseJointBoundaryViaReservation(boundaryBusConnectionCounts) {
+  const boundaryBusCount = boundaryBusConnectionCounts.length;
+  const boundaryConnectionCount = boundaryBusConnectionCounts.reduce(
+    (sum, count) => sum + count,
+    0
+  );
+  return boundaryBusCount >= minimumJointBoundaryBusCount && boundaryBusCount <= maximumJointBoundaryBusCount && boundaryConnectionCount <= maximumJointBoundaryConnectionCount || boundaryBusCount === 4 && new Set(boundaryBusConnectionCounts).size > 1;
+}
+function getDenseBoundaryRoutingMode({
+  boundaryBusConnectionCounts,
+  planeBusCount
+}) {
+  const boundaryBusCount = boundaryBusConnectionCounts.length;
+  if (boundaryBusCount <= minimumLargeBoundaryOnlyBusCount - 1 && planeBusCount >= minimumMixedRoutingPlaneBusCount) {
+    return "mixed_with_planes";
+  }
+  if (boundaryBusCount >= minimumLargeBoundaryOnlyBusCount && planeBusCount === 0 && shouldUseJointBoundaryViaReservation(boundaryBusConnectionCounts)) {
+    return "large_boundary_only";
+  }
+  return null;
+}
+function getAverageBusBoundaryTargetTrack(bus) {
+  if (!bus.exitEdge) {
+    throw new Error(
+      `Cannot order boundary bus ${bus.busId} without an exit edge`
+    );
+  }
+  const boundaryDirection = getDirectionForExitEdge(bus.exitEdge);
+  return bus.connections.reduce(
+    (sum, connection) => sum + getBoundaryTargetTrack({ bus, connection, boundaryDirection }),
+    0
+  ) / bus.connections.length;
+}
+function orderDenseBoundaryBusesForRouting({
+  busesInRoutingOrder,
+  busLayerAssignments,
+  routingMode
+}) {
+  if (routingMode !== "large_boundary_only") return [...busesInRoutingOrder];
+  const singletonBuses = busesInRoutingOrder.filter(
+    (bus) => bus.connections.length === 1
+  );
+  if (new Set(singletonBuses.map((bus) => bus.exitEdge)).size !== 1) {
+    return [...busesInRoutingOrder];
+  }
+  const nonSingletonBuses = [
+    ...busesInRoutingOrder.filter((bus) => bus.connections.length >= 8).toSorted(
+      (first, second) => getAverageBusBoundaryTargetTrack(second) - getAverageBusBoundaryTargetTrack(first)
+    ),
+    ...busesInRoutingOrder.filter(
+      (bus) => bus.connections.length > 1 && bus.connections.length < 8
+    )
+  ];
+  const singletonLayerGroups = [];
+  for (const bus of singletonBuses) {
+    const targetLayer2 = busLayerAssignments[bus.busId];
+    if (!targetLayer2) {
+      throw new Error(`Cannot order boundary bus ${bus.busId} without a layer`);
+    }
+    let singletonLayerGroup = singletonLayerGroups.find(
+      (candidate) => candidate.targetLayer === targetLayer2
+    );
+    if (!singletonLayerGroup) {
+      singletonLayerGroup = { targetLayer: targetLayer2, buses: [] };
+      singletonLayerGroups.push(singletonLayerGroup);
+    }
+    singletonLayerGroup.buses.push(bus);
+  }
+  return [
+    ...nonSingletonBuses,
+    ...singletonLayerGroups.flatMap(
+      (singletonLayerGroup) => singletonLayerGroup.buses.toSorted(
+        (first, second) => getAverageBusBoundaryTargetTrack(second) - getAverageBusBoundaryTargetTrack(first)
+      )
+    )
+  ];
+}
+
 // node_modules/@tscircuit/fanout-solver/lib/source-pad-reentry.ts
 var EPSILON15 = 1e-7;
 function getSourcePadReentries(plan, clearance) {
@@ -43740,9 +43831,6 @@ function busUsesCoordinatedWinding(bus) {
     )
   );
 }
-function shouldUseJointBoundaryViaReservation(boundaryBusConnectionCounts) {
-  return boundaryBusConnectionCounts.length === 5 || boundaryBusConnectionCounts.length === 6 || boundaryBusConnectionCounts.length === 7 || boundaryBusConnectionCounts.length === 8 || boundaryBusConnectionCounts.length === 9 || boundaryBusConnectionCounts.length === 4 && new Set(boundaryBusConnectionCounts).size > 1;
-}
 function shouldDeferSingletonBoundaryViaReservation(boundaryBusConnectionCounts) {
   const boundaryBusCount = boundaryBusConnectionCounts.length;
   const singletonBusCount = boundaryBusConnectionCounts.filter(
@@ -44813,13 +44901,20 @@ var FanoutSolver = class extends BaseSolver {
     const unroutablePlaneBusIds = /* @__PURE__ */ new Set();
     let failedBoundaryBus;
     let failedWideBoundaryBus;
+    const boundaryBusConnectionCounts = boundaryBuses.map(
+      (bus) => bus.connections.length
+    );
+    const denseBoundaryRoutingMode = getDenseBoundaryRoutingMode({
+      boundaryBusConnectionCounts,
+      planeBusCount: planeBuses.length
+    });
     debugDense(
       "start",
       boundaryBuses.map((bus) => `${bus.busId}:${bus.connections.length}`),
       `planes:${planeBuses.length}`,
       `joint:${useJointBoundaryViaReservation}`
     );
-    if (boundaryBuses.length === 0 || boundaryBuses.length > 9 || planeBuses.length < 8 || boundaryBuses.some((bus) => !busUsesCoordinatedWinding(bus)) || planeBuses.some((bus) => bus.connections.length !== 1) || boundaryBuses.length + planeBuses.length !== params.busesInRoutingOrder.length) {
+    if (boundaryBuses.length === 0 || denseBoundaryRoutingMode === null || boundaryBuses.some((bus) => !busUsesCoordinatedWinding(bus)) || planeBuses.some((bus) => bus.connections.length !== 1) || boundaryBuses.length + planeBuses.length !== params.busesInRoutingOrder.length) {
       return null;
     }
     const connectionNameByIndex = new Map(
@@ -44829,9 +44924,6 @@ var FanoutSolver = class extends BaseSolver {
         )
       )
     );
-    const boundaryBusConnectionCounts = boundaryBuses.map(
-      (bus) => bus.connections.length
-    );
     const singletonBoundaryBusCount = boundaryBusConnectionCounts.filter(
       (connectionCount) => connectionCount === 1
     ).length;
@@ -45132,17 +45224,21 @@ var FanoutSolver = class extends BaseSolver {
     });
     yield;
     if (seedViaPoints) {
-      const denseBoundaryBusesInRoutingOrder = [
-        ...hasForeignAllLayerObstaclesInComponent ? [] : multiLayerLeadingSingletonBuses,
-        ...boundaryBuses.filter(
-          (bus) => (hasForeignAllLayerObstaclesInComponent || !multiLayerLeadingSingletonBuses.includes(bus)) && !throughAllLeadingBuses.includes(bus)
-        ).flatMap((bus) => [
-          ...throughAllLeadingBuses.filter(
-            (candidate) => getContainingWideSourceField(candidate) === bus
-          ),
-          bus
-        ])
-      ];
+      const denseBoundaryBusesInRoutingOrder = orderDenseBoundaryBusesForRouting({
+        busesInRoutingOrder: [
+          ...hasForeignAllLayerObstaclesInComponent ? [] : multiLayerLeadingSingletonBuses,
+          ...boundaryBuses.filter(
+            (bus) => (hasForeignAllLayerObstaclesInComponent || !multiLayerLeadingSingletonBuses.includes(bus)) && !throughAllLeadingBuses.includes(bus)
+          ).flatMap((bus) => [
+            ...throughAllLeadingBuses.filter(
+              (candidate) => getContainingWideSourceField(candidate) === bus
+            ),
+            bus
+          ])
+        ],
+        busLayerAssignments: params.busLayerAssignments,
+        routingMode: denseBoundaryRoutingMode
+      });
       const allWideBusesExitDirectly = wideBoundaryBuses.every(
         (bus) => bus.exitEdge && bus.direction === getDirectionForExitEdge(bus.exitEdge)
       );
@@ -45684,7 +45780,6 @@ var FanoutSolver = class extends BaseSolver {
         debugDense("route:complete", bus.busId, busPlans.length);
         return true;
       }.bind(this);
-      const firstBoundaryBus = denseBoundaryBusesInRoutingOrder[0];
       const routedBoundaryBuses = [];
       const reserveAllPlaneDogbonesAfterFirstWideBus = (bus) => {
         if (bus.connections.length >= 8 && !useConfiguredDensePlaneRouting && !useSameNetPlaneCopperStaging && process.env.FANOUT_DEBUG_NO_PLANE_EXPANSION !== "1" && activeBoundaryReservationPlaneBuses.length < planeBuses.length) {
@@ -45692,23 +45787,32 @@ var FanoutSolver = class extends BaseSolver {
           debugDense("plane-reservations:expanded", planeBuses.length);
         }
       };
-      const firstBoundaryBusRouted = yield* routeMatchedBoundaryBusSteps(firstBoundaryBus);
-      this.setInProgressPlans({
-        phase: "route-dense-boundary-buses",
-        plans: matchedPlans,
-        strategy: "default",
-        unitIndex: ++denseWorkUnitIndex,
-        unitCount: denseWorkUnitCount,
-        busId: firstBoundaryBus.busId
-      });
-      yield;
-      if (firstBoundaryBusRouted) {
+      const firstBoundaryCandidates = denseBoundaryRoutingMode === "large_boundary_only" ? denseBoundaryBusesInRoutingOrder : denseBoundaryBusesInRoutingOrder.slice(0, 1);
+      let firstBoundaryBus;
+      for (const candidate of firstBoundaryCandidates) {
+        const candidateRouted = yield* routeMatchedBoundaryBusSteps(candidate);
+        this.setInProgressPlans({
+          phase: "route-dense-boundary-buses",
+          plans: matchedPlans,
+          strategy: "default",
+          unitIndex: ++denseWorkUnitIndex,
+          unitCount: denseWorkUnitCount,
+          busId: candidate.busId
+        });
+        yield;
+        if (!candidateRouted) continue;
+        firstBoundaryBus = candidate;
+        break;
+      }
+      if (firstBoundaryBus) {
         routedBoundaryBuses.push(firstBoundaryBus);
         reserveAllPlaneDogbonesAfterFirstWideBus(firstBoundaryBus);
       } else {
         matchedRoutingSucceeded = false;
       }
-      const remainingBoundaryBuses = denseBoundaryBusesInRoutingOrder.slice(1);
+      const remainingBoundaryBuses = denseBoundaryBusesInRoutingOrder.filter(
+        (bus) => bus !== firstBoundaryBus
+      );
       while (matchedRoutingSucceeded && remainingBoundaryBuses.length > 0) {
         const blockingSegments = matchedPlans.flatMap(
           (plan) => plan.segments.map((segment2) => ({
@@ -61704,7 +61808,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1896",
+  version: "0.0.1898",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -61744,7 +61848,7 @@ var package_default = {
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.54",
     "@tscircuit/create-fdm-enclosure": "0.0.4",
-    "@tscircuit/fanout-solver": "0.0.74",
+    "@tscircuit/fanout-solver": "0.0.76",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1897",
+  "version": "0.0.1899",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -41,7 +41,7 @@
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.54",
     "@tscircuit/create-fdm-enclosure": "0.0.4",
-    "@tscircuit/fanout-solver": "0.0.74",
+    "@tscircuit/fanout-solver": "0.0.76",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",