@tscircuit/core 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -484,9 +484,9 @@ var ParseStatus = class _ParseStatus {
     }
     return { status: status.value, value: arrayValue };
   }
-  static async mergeObjectAsync(status, pairs) {
+  static async mergeObjectAsync(status, pairs2) {
     const syncPairs = [];
-    for (const pair of pairs) {
+    for (const pair of pairs2) {
       const key = await pair.key;
       const value = await pair.value;
       syncPairs.push({
@@ -496,9 +496,9 @@ var ParseStatus = class _ParseStatus {
     }
     return _ParseStatus.mergeObjectSync(status, syncPairs);
   }
-  static mergeObjectSync(status, pairs) {
+  static mergeObjectSync(status, pairs2) {
     const finalObject = {};
-    for (const pair of pairs) {
+    for (const pair of pairs2) {
       const { key, value } = pair;
       if (key.status === "aborted")
         return INVALID;
@@ -2224,11 +2224,11 @@ var ZodObject = class _ZodObject extends ZodType {
         }
       }
     }
-    const pairs = [];
+    const pairs2 = [];
     for (const key of shapeKeys) {
       const keyValidator = shape[key];
       const value = ctx.data[key];
-      pairs.push({
+      pairs2.push({
         key: { status: "valid", value: key },
         value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
         alwaysSet: key in ctx.data
@@ -2238,7 +2238,7 @@ var ZodObject = class _ZodObject extends ZodType {
       const unknownKeys = this._def.unknownKeys;
       if (unknownKeys === "passthrough") {
         for (const key of extraKeys) {
-          pairs.push({
+          pairs2.push({
             key: { status: "valid", value: key },
             value: { status: "valid", value: ctx.data[key] }
           });
@@ -2259,7 +2259,7 @@ var ZodObject = class _ZodObject extends ZodType {
       const catchall = this._def.catchall;
       for (const key of extraKeys) {
         const value = ctx.data[key];
-        pairs.push({
+        pairs2.push({
           key: { status: "valid", value: key },
           value: catchall._parse(
             new ParseInputLazyPath(ctx, value, ctx.path, key)
@@ -2272,7 +2272,7 @@ var ZodObject = class _ZodObject extends ZodType {
     if (ctx.common.async) {
       return Promise.resolve().then(async () => {
         const syncPairs = [];
-        for (const pair of pairs) {
+        for (const pair of pairs2) {
           const key = await pair.key;
           const value = await pair.value;
           syncPairs.push({
@@ -2286,7 +2286,7 @@ var ZodObject = class _ZodObject extends ZodType {
         return ParseStatus.mergeObjectSync(status, syncPairs);
       });
     } else {
-      return ParseStatus.mergeObjectSync(status, pairs);
+      return ParseStatus.mergeObjectSync(status, pairs2);
     }
   }
   get shape() {
@@ -2900,20 +2900,20 @@ var ZodRecord = class _ZodRecord extends ZodType {
       });
       return INVALID;
     }
-    const pairs = [];
+    const pairs2 = [];
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
     for (const key in ctx.data) {
-      pairs.push({
+      pairs2.push({
         key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
         value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
         alwaysSet: key in ctx.data
       });
     }
     if (ctx.common.async) {
-      return ParseStatus.mergeObjectAsync(status, pairs);
+      return ParseStatus.mergeObjectAsync(status, pairs2);
     } else {
-      return ParseStatus.mergeObjectSync(status, pairs);
+      return ParseStatus.mergeObjectSync(status, pairs2);
     }
   }
   get element() {
@@ -2955,7 +2955,7 @@ var ZodMap = class extends ZodType {
     }
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
-    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
+    const pairs2 = [...ctx.data.entries()].map(([key, value], index) => {
       return {
         key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
         value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
@@ -2964,7 +2964,7 @@ var ZodMap = class extends ZodType {
     if (ctx.common.async) {
       const finalMap = /* @__PURE__ */ new Map();
       return Promise.resolve().then(async () => {
-        for (const pair of pairs) {
+        for (const pair of pairs2) {
           const key = await pair.key;
           const value = await pair.value;
           if (key.status === "aborted" || value.status === "aborted") {
@@ -2979,7 +2979,7 @@ var ZodMap = class extends ZodType {
       });
     } else {
       const finalMap = /* @__PURE__ */ new Map();
-      for (const pair of pairs) {
+      for (const pair of pairs2) {
         const key = pair.key;
         const value = pair.value;
         if (key.status === "aborted" || value.status === "aborted") {
@@ -4161,7 +4161,7 @@ var PrimitiveComponent = class extends Renderable {
    * components
    */
   computePcbPropsTransform() {
-    return (0, import_transformation_matrix.compose)((0, import_transformation_matrix.translate)(this.props.pcbX, this.props.pcbY));
+    return (0, import_transformation_matrix.compose)((0, import_transformation_matrix.translate)(this.props.pcbX ?? 0, this.props.pcbY ?? 0));
   }
   /**
    * Compute a transformation matrix combining all parent transforms for PCB
@@ -4293,6 +4293,16 @@ var PrimitiveComponent = class extends Renderable {
     }
     return this.selectAll(selector)[0] ?? null;
   }
+  getAvailablePcbLayers() {
+    if (this.isPcbPrimitive) {
+      if (this.props.layer) return [this.props.layer];
+      if (this.componentName === "PlatedHole") {
+        return ["top", "bottom"];
+      }
+      return [];
+    }
+    return [];
+  }
   getDescendants() {
     const descendants = [];
     for (const child of this.children) {
@@ -4406,6 +4416,11 @@ var Port = class extends PrimitiveComponent {
   getPortSelector() {
     return `.${this.parent?.props.name} > port.${this.props.name}`;
   }
+  getAvailablePcbLayers() {
+    return Array.from(
+      new Set(this.matchedComponents.flatMap((c) => c.getAvailablePcbLayers()))
+    );
+  }
   doInitialSourceRender() {
     const { db } = this.project;
     const { _parsedProps: props } = this;
@@ -5104,7 +5119,119 @@ var projectPointInDirection = (point, direction, distance) => {
   }
 };
 
+// lib/utils/autorouting/findPossibleTraceLayerCombinations.ts
+var LAYER_SELECTION_PREFERENCE = ["top", "bottom", "inner1", "inner2"];
+var findPossibleTraceLayerCombinations = (hints, layer_path = []) => {
+  const candidates = [];
+  if (layer_path.length === 0) {
+    const starting_layers = hints[0].layers;
+    for (const layer of starting_layers) {
+      candidates.push(
+        ...findPossibleTraceLayerCombinations(hints.slice(1), [layer])
+      );
+    }
+    return candidates;
+  }
+  if (hints.length === 0) return [];
+  const current_hint = hints[0];
+  const is_possibly_via = current_hint.via || current_hint.optional_via;
+  const last_layer = layer_path[layer_path.length - 1];
+  if (hints.length === 1) {
+    const last_hint = current_hint;
+    if (last_hint.layers && is_possibly_via) {
+      return last_hint.layers.map((layer) => ({
+        layer_path: [...layer_path, layer]
+      }));
+    }
+    if (last_hint.layers?.includes(last_layer)) {
+      return [{ layer_path: [...layer_path, last_layer] }];
+    }
+    return [];
+  }
+  if (!is_possibly_via) {
+    if (current_hint.layers) {
+      if (!current_hint.layers.includes(last_layer)) {
+        return [];
+      }
+    }
+    return findPossibleTraceLayerCombinations(
+      hints.slice(1),
+      layer_path.concat([last_layer])
+    );
+  }
+  const candidate_next_layers = (current_hint.optional_via ? LAYER_SELECTION_PREFERENCE : LAYER_SELECTION_PREFERENCE.filter((layer) => layer !== last_layer)).filter(
+    (layer) => !current_hint.layers || current_hint.layers?.includes(layer)
+  );
+  for (const candidate_next_layer of candidate_next_layers) {
+    candidates.push(
+      ...findPossibleTraceLayerCombinations(
+        hints.slice(1),
+        layer_path.concat(candidate_next_layer)
+      )
+    );
+  }
+  return candidates;
+};
+
+// lib/utils/pairs.ts
+function pairs(arr) {
+  const result = [];
+  for (let i = 0; i < arr.length - 1; i++) {
+    result.push([arr[i], arr[i + 1]]);
+  }
+  return result;
+}
+
+// lib/utils/autorouting/mergeRoutes.ts
+function pdist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+var mergeRoutes = (routes) => {
+  if (routes.some((r) => r.length === 0)) {
+    throw new Error("Cannot merge routes with zero length");
+  }
+  const merged = [];
+  const first_route_fp = routes[0][0];
+  const first_route_lp = routes[0][routes[0].length - 1];
+  const second_route_fp = routes[1][0];
+  const second_route_lp = routes[1][routes[1].length - 1];
+  const best_reverse_dist = Math.min(
+    pdist(first_route_fp, second_route_fp),
+    pdist(first_route_fp, second_route_lp)
+  );
+  const best_normal_dist = Math.min(
+    pdist(first_route_lp, second_route_fp),
+    pdist(first_route_lp, second_route_lp)
+  );
+  if (best_reverse_dist < best_normal_dist) {
+    merged.push(...routes[0].reverse());
+  } else {
+    merged.push(...routes[0]);
+  }
+  for (let i = 1; i < routes.length; i++) {
+    const last_merged_point = merged[merged.length - 1];
+    const next_route = routes[i];
+    const next_first_point = next_route[0];
+    const next_last_point = next_route[next_route.length - 1];
+    const distance_to_first = pdist(last_merged_point, next_first_point);
+    const distance_to_last = pdist(last_merged_point, next_last_point);
+    if (distance_to_first < distance_to_last) {
+      merged.push(...next_route);
+    } else {
+      merged.push(...next_route.reverse());
+    }
+  }
+  return merged;
+};
+
 // lib/components/primitive-components/Trace.ts
+var portToObjective = (port) => {
+  const portPosition = port.getGlobalPcbPosition();
+  return {
+    ...portPosition,
+    layers: port.getAvailablePcbLayers()
+  };
+};
 var Trace = class extends PrimitiveComponent {
   source_trace_id = null;
   pcb_trace_id = null;
@@ -5181,9 +5308,91 @@ searched component ${targetComponent.getString()}, which has ports:${targetCompo
       (elm) => elm.type === "pcb_smtpad" || elm.type === "pcb_trace" || elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "source_port" || elm.type === "pcb_port"
     );
     const source_trace = db.source_trace.get(this.source_trace_id);
-    const { solution } = (0, import_infgrid_ijump_astar.autoroute)(pcbElements.concat([source_trace]));
-    const pcb_trace = solution[0];
-    db.pcb_trace.insert(pcb_trace);
+    const hints = ports.flatMap(
+      ({ port }) => port.matchedComponents.filter((c) => c.componentName === "TraceHint")
+    );
+    const pcbRouteHints = (this._parsedProps.pcbRouteHints ?? []).concat(
+      hints.flatMap((h) => h.getPcbRouteHints())
+    );
+    if (ports.length > 2) {
+      this.renderError(
+        `Trace has more than two ports (${ports.map((p) => p.port.getString()).join(
+          ", "
+        )}), routing between more than two ports for a single trace is not implemented`
+      );
+      return;
+    }
+    if (pcbRouteHints.length === 0) {
+      const { solution } = (0, import_infgrid_ijump_astar.autoroute)(pcbElements.concat([source_trace]));
+      const pcb_trace2 = solution[0];
+      db.pcb_trace.insert(pcb_trace2);
+      this.pcb_trace_id = pcb_trace2.pcb_trace_id;
+      return;
+    }
+    const orderedRouteObjectives = [
+      portToObjective(ports[0].port),
+      ...pcbRouteHints,
+      portToObjective(ports[1].port)
+    ];
+    const candidateLayerCombinations = findPossibleTraceLayerCombinations(
+      orderedRouteObjectives
+    );
+    if (candidateLayerCombinations.length === 0) {
+      this.renderError(
+        `Could not find a common layer (using hints) for trace ${this.getString()}`
+      );
+    }
+    const obstacles = (0, import_infgrid_ijump_astar.getObstaclesFromSoup)(this.project.db.toArray());
+    (0, import_infgrid_ijump_astar.markObstaclesAsConnected)(
+      obstacles,
+      orderedRouteObjectives,
+      this.source_trace_id
+    );
+    const candidateLayerSelections = candidateLayerCombinations[0].layer_path;
+    const orderedRoutePoints = orderedRouteObjectives.map((t, idx) => {
+      if (t.via) {
+        return {
+          ...t,
+          via_to_layer: candidateLayerSelections[idx]
+        };
+      }
+      return { ...t, layers: [candidateLayerSelections[idx]] };
+    });
+    const routes = [];
+    for (const [a, b] of pairs(orderedRoutePoints)) {
+      const BOUNDS_MARGIN = 2;
+      const ijump = new import_infgrid_ijump_astar.IJumpAutorouter({
+        input: {
+          obstacles,
+          connections: [
+            {
+              name: this.source_trace_id,
+              pointsToConnect: [a, b]
+            }
+          ],
+          layerCount: 1,
+          bounds: {
+            minX: Math.min(a.x, b.x) - BOUNDS_MARGIN,
+            maxX: Math.max(a.x, b.x) + BOUNDS_MARGIN,
+            minY: Math.min(a.y, b.y) - BOUNDS_MARGIN,
+            maxY: Math.max(a.y, b.y) + BOUNDS_MARGIN
+          }
+        }
+      });
+      const traces = ijump.solveAndMapToTraces();
+      if (traces.length === 0) {
+        this.renderError(
+          `Could not find a route between ${a.x}, ${a.y} and ${b.x}, ${b.y}`
+        );
+        return;
+      }
+      const [trace] = traces;
+      routes.push(trace.route);
+    }
+    const pcb_trace = db.pcb_trace.insert({
+      route: mergeRoutes(routes),
+      source_trace_id: this.source_trace_id
+    });
     this.pcb_trace_id = pcb_trace.pcb_trace_id;
   }
   doInitialSchematicTraceRender() {
@@ -5252,7 +5461,47 @@ searched component ${targetComponent.getString()}, which has ports:${targetCompo
 
 // lib/components/primitive-components/TraceHint.ts
 var import_props7 = require("@tscircuit/props");
+var import_transformation_matrix4 = require("transformation-matrix");
 var TraceHint = class extends PrimitiveComponent {
+  matchedPort = null;
+  doInitialPortMatching() {
+    const { db } = this.project;
+    const { _parsedProps: props, parent } = this;
+    if (!parent) return;
+    if (parent.componentName === "Trace") {
+      this.renderError(
+        `Port inference inside trace is not yet supported (${this})`
+      );
+      return;
+    }
+    if (!parent) throw new Error("TraceHint has no parent");
+    if (!props.for) {
+      this.renderError(`TraceHint has no for property (${this})`);
+      return;
+    }
+    const port = parent.selectOne(props.for, { type: "port" });
+    if (!port) {
+      this.renderError(
+        `${this} could not find port for selector "${props.for}"`
+      );
+    }
+    this.matchedPort = port;
+    port.registerMatch(this);
+  }
+  getPcbRouteHints() {
+    const { _parsedProps: props } = this;
+    const offsets = props.offset ? [props.offset] : props.offsets;
+    if (!offsets) return [];
+    const globalTransform = this.computePcbGlobalTransform();
+    return offsets.map(
+      (offset) => ({
+        ...(0, import_transformation_matrix4.applyToPoint)(globalTransform, offset),
+        via: offset.via,
+        to_layer: offset.to_layer,
+        trace_width: offset.trace_width
+      })
+    );
+  }
 };
 
 // lib/components/primitive-components/Group.ts
@@ -5268,7 +5517,7 @@ var Group = class extends PrimitiveComponent {
 // lib/Project.ts
 var import_soup_util = require("@tscircuit/soup-util");
 var import_react4 = require("react");
-var import_transformation_matrix4 = require("transformation-matrix");
+var import_transformation_matrix5 = require("transformation-matrix");
 var Project = class {
   rootComponent = null;
   children;
@@ -5324,10 +5573,16 @@ var Project = class {
     return this.getSoup();
   }
   computeGlobalSchematicTransform() {
-    return (0, import_transformation_matrix4.identity)();
+    return (0, import_transformation_matrix5.identity)();
   }
   computeGlobalPcbTransform() {
-    return (0, import_transformation_matrix4.identity)();
+    return (0, import_transformation_matrix5.identity)();
+  }
+  selectAll(selector) {
+    return this.rootComponent?.selectAll(selector) ?? [];
+  }
+  selectOne(selector) {
+    return this.rootComponent?.selectOne(selector) ?? null;
   }
 };
 

package/lib/Project.ts

@@ -81,4 +81,12 @@ export class Project {
   computeGlobalPcbTransform(): Matrix {
     return identity()
   }
+
+  selectAll(selector: string): PrimitiveComponent[] {
+    return this.rootComponent?.selectAll(selector) ?? []
+  }
+
+  selectOne(selector: string): PrimitiveComponent | null {
+    return this.rootComponent?.selectOne(selector) ?? null
+  }
 }

package/lib/components/base-components/PrimitiveComponent.ts

@@ -95,7 +95,7 @@ export abstract class PrimitiveComponent<
    */
   computePcbPropsTransform(): Matrix {
     // TODO rotations
-    return compose(translate(this.props.pcbX, this.props.pcbY))
+    return compose(translate(this.props.pcbX ?? 0, this.props.pcbY ?? 0))
   }
 
   /**
@@ -268,6 +268,17 @@ export abstract class PrimitiveComponent<
     return this.selectAll(selector)[0] ?? null
   }
 
+  getAvailablePcbLayers(): string[] {
+    if (this.isPcbPrimitive) {
+      if (this.props.layer) return [this.props.layer]
+      if (this.componentName === "PlatedHole") {
+        return ["top", "bottom"] // TODO derive layers from parent
+      }
+      return []
+    }
+    return []
+  }
+
   getDescendants(): PrimitiveComponent[] {
     const descendants: PrimitiveComponent[] = []
     for (const child of this.children) {

package/lib/components/primitive-components/Port.ts

@@ -88,6 +88,11 @@ export class Port extends PrimitiveComponent<typeof portProps> {
     return `.${this.parent?.props.name} > port.${this.props.name}`
     // return `#${this.props.id}`
   }
+  getAvailablePcbLayers(): string[] {
+    return Array.from(
+      new Set(this.matchedComponents.flatMap((c) => c.getAvailablePcbLayers())),
+    )
+  }
 
   doInitialSourceRender(): void {
     const { db } = this.project!

package/lib/components/primitive-components/Trace.ts

@@ -1,8 +1,18 @@
 import { traceProps } from "@tscircuit/props"
 import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
 import type { Port } from "./Port"
-import { IJumpAutorouter, autoroute } from "@tscircuit/infgrid-ijump-astar"
-import type { AnySoupElement, SchematicTrace } from "@tscircuit/soup"
+import {
+  IJumpAutorouter,
+  autoroute,
+  getObstaclesFromSoup,
+  markObstaclesAsConnected,
+} from "@tscircuit/infgrid-ijump-astar"
+import type {
+  AnySoupElement,
+  PCBTrace,
+  RouteHintPoint,
+  SchematicTrace,
+} from "@tscircuit/soup"
 import type {
   Obstacle,
   SimpleRouteConnection,
@@ -10,6 +20,22 @@ import type {
 } from "lib/utils/autorouting/SimpleRouteJson"
 import { computeObstacleBounds } from "lib/utils/autorouting/computeObstacleBounds"
 import { projectPointInDirection } from "lib/utils/projectPointInDirection"
+import type { TraceHint } from "./TraceHint"
+import { findPossibleTraceLayerCombinations } from "lib/utils/autorouting/findPossibleTraceLayerCombinations"
+import { pairs } from "lib/utils/pairs"
+import { mergeRoutes } from "lib/utils/autorouting/mergeRoutes"
+
+type PcbRouteObjective =
+  | RouteHintPoint
+  | { layers: string[]; x: number; y: number; via?: boolean }
+
+const portToObjective = (port: Port): PcbRouteObjective => {
+  const portPosition = port.getGlobalPcbPosition()
+  return {
+    ...portPosition,
+    layers: port.getAvailablePcbLayers(),
+  }
+}
 
 export class Trace extends PrimitiveComponent<typeof traceProps> {
   source_trace_id: string | null = null
@@ -124,14 +150,119 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
 
     const source_trace = db.source_trace.get(this.source_trace_id!)!
 
-    const { solution } = autoroute(pcbElements.concat([source_trace]))
+    const hints = ports.flatMap(({ port }) =>
+      port.matchedComponents.filter((c) => c.componentName === "TraceHint"),
+    ) as TraceHint[]
+
+    const pcbRouteHints = (this._parsedProps.pcbRouteHints ?? []).concat(
+      hints.flatMap((h) => h.getPcbRouteHints()),
+    )
+
+    if (ports.length > 2) {
+      this.renderError(
+        `Trace has more than two ports (${ports
+          .map((p) => p.port.getString())
+          .join(
+            ", ",
+          )}), routing between more than two ports for a single trace is not implemented`,
+      )
+      return
+    }
 
-    // TODO for some reason, the solution gets duplicated. Seems to be an issue
-    // with the ijump-astar function
-    const pcb_trace = solution[0]
+    if (pcbRouteHints.length === 0) {
+      const { solution } = autoroute(pcbElements.concat([source_trace]))
+      // TODO for some reason, the solution gets duplicated inside ijump-astar
+      const pcb_trace = solution[0]
+      db.pcb_trace.insert(pcb_trace)
+      this.pcb_trace_id = pcb_trace.pcb_trace_id
+      return
+    }
 
-    db.pcb_trace.insert(pcb_trace)
+    // When we have hints, we have to order the hints then route between each
+    // terminal of the trace and the hints
+    // TODO order based on proximity to ports
+    const orderedRouteObjectives: PcbRouteObjective[] = [
+      portToObjective(ports[0].port),
+      ...pcbRouteHints,
+      portToObjective(ports[1].port),
+    ]
+
+    // Hints can indicate where there should be a via, but the layer is allowed
+    // to be unspecified, therefore we need to find possible layer combinations
+    // to go to each hint and still route to the start and end points
+    const candidateLayerCombinations = findPossibleTraceLayerCombinations(
+      orderedRouteObjectives,
+    )
+
+    if (candidateLayerCombinations.length === 0) {
+      this.renderError(
+        `Could not find a common layer (using hints) for trace ${this.getString()}`,
+      )
+    }
 
+    // Cache the PCB obstacles, they'll be needed for each segment between
+    // ports/hints
+    const obstacles = getObstaclesFromSoup(this.project!.db.toArray())
+    markObstaclesAsConnected(
+      obstacles,
+      orderedRouteObjectives,
+      this.source_trace_id!,
+    )
+
+    // TODO explore all candidate layer combinations if one fails
+    const candidateLayerSelections = candidateLayerCombinations[0].layer_path
+
+    /**
+     * Apply the candidate layer selections to the route objectives, now we
+     * have a set of points that have definite layers
+     */
+    const orderedRoutePoints = orderedRouteObjectives.map((t, idx) => {
+      if (t.via) {
+        return {
+          ...t,
+          via_to_layer: candidateLayerSelections[idx],
+        }
+      }
+      return { ...t, layers: [candidateLayerSelections[idx]] }
+    })
+
+    const routes: PCBTrace["route"][] = []
+    for (const [a, b] of pairs(orderedRoutePoints)) {
+      const BOUNDS_MARGIN = 2 //mm
+      const ijump = new IJumpAutorouter({
+        input: {
+          obstacles,
+          connections: [
+            {
+              name: this.source_trace_id!,
+              pointsToConnect: [a, b],
+            },
+          ],
+          layerCount: 1,
+          bounds: {
+            minX: Math.min(a.x, b.x) - BOUNDS_MARGIN,
+            maxX: Math.max(a.x, b.x) + BOUNDS_MARGIN,
+            minY: Math.min(a.y, b.y) - BOUNDS_MARGIN,
+            maxY: Math.max(a.y, b.y) + BOUNDS_MARGIN,
+          },
+        },
+      })
+      const traces = ijump.solveAndMapToTraces()
+      if (traces.length === 0) {
+        this.renderError(
+          `Could not find a route between ${a.x}, ${a.y} and ${b.x}, ${b.y}`,
+        )
+        return
+      }
+      // TODO ijump returns multiple traces for some reason
+      const [trace] = traces as PCBTrace[]
+      routes.push(trace.route)
+    }
+
+    const pcb_trace = db.pcb_trace.insert({
+      route: mergeRoutes(routes),
+      source_trace_id: this.source_trace_id!,
+    })
     this.pcb_trace_id = pcb_trace.pcb_trace_id
   }
 

package/lib/components/primitive-components/TraceHint.ts

@@ -1,4 +1,60 @@
 import { PrimitiveComponent } from "lib/components/base-components/PrimitiveComponent"
-import { traceProps } from "@tscircuit/props"
+import { traceHintProps } from "@tscircuit/props"
+import type { Port } from "./Port"
+import type { RouteHintPoint } from "@tscircuit/soup"
+import { applyToPoint } from "transformation-matrix"
 
-export class TraceHint extends PrimitiveComponent<typeof traceProps> {}
+export class TraceHint extends PrimitiveComponent<typeof traceHintProps> {
+  matchedPort: Port | null = null
+
+  doInitialPortMatching(): void {
+    const { db } = this.project!
+    const { _parsedProps: props, parent } = this
+
+    if (!parent) return
+
+    if (parent.componentName === "Trace") {
+      this.renderError(
+        `Port inference inside trace is not yet supported (${this})`,
+      )
+      return
+    }
+
+    if (!parent) throw new Error("TraceHint has no parent")
+
+    if (!props.for) {
+      this.renderError(`TraceHint has no for property (${this})`)
+      return
+    }
+
+    const port = parent.selectOne(props.for, { type: "port" }) as Port
+
+    if (!port) {
+      this.renderError(
+        `${this} could not find port for selector "${props.for}"`,
+      )
+    }
+
+    this.matchedPort = port
+    port.registerMatch(this)
+  }
+
+  getPcbRouteHints(): Array<RouteHintPoint> {
+    const { _parsedProps: props } = this
+
+    const offsets = props.offset ? [props.offset] : props.offsets
+
+    if (!offsets) return []
+
+    const globalTransform = this.computePcbGlobalTransform()
+
+    return offsets.map(
+      (offset): RouteHintPoint => ({
+        ...applyToPoint(globalTransform, offset),
+        via: offset.via,
+        to_layer: offset.to_layer,
+        trace_width: offset.trace_width,
+      }),
+    )
+  }
+}

package/lib/utils/autorouting/findPossibleTraceLayerCombinations.ts

@@ -0,0 +1,102 @@
+interface Hint {
+  via?: boolean
+  optional_via?: boolean
+  layers?: Array<string>
+}
+
+const LAYER_SELECTION_PREFERENCE = ["top", "bottom", "inner1", "inner2"]
+
+/**
+ * ORDERING OF CANDIDATES: Example:
+ * top    -> top    -> bottom -> bottom
+ * bottom -> bottom -> top    -> top
+ * top    -> bottom -> bottom -> top
+ * bottom -> top    -> top    -> bottom
+ */
+interface CandidateTraceLayerCombination {
+  layer_path: string[]
+}
+
+/**
+ * Given a set of hints that contain layers or indication there should be a via,
+ * this function returns all combinations of layers that could be traversed.
+ *
+ * EXAMPLE 1:
+ *   INPUT:
+ *   [top,bottom] -> unspecified -> unspecified/via -> [top, bottom]
+ *   OUTPUT:
+ *   top -> top -> bottom -> bottom
+ *   bottom -> bottom -> top -> top *
+ * EXAMPLE 2:
+ *   INPUT:
+ *   [top,bottom] -> unspecified -> unspecified/via -> unspecified/via -> [top, bottom]
+ *   OUTPUT:
+ *   top -> top -> bottom -> top -> top
+ *   bottom -> bottom -> top-> bottom -> bottom
+ *   bottom -> bottom -> inner-1 -> inner-1 -> bottom
+ */
+export const findPossibleTraceLayerCombinations = (
+  hints: Hint[],
+  layer_path: string[] = [],
+): CandidateTraceLayerCombination[] => {
+  const candidates: CandidateTraceLayerCombination[] = []
+  if (layer_path.length === 0) {
+    const starting_layers = hints[0].layers!
+    for (const layer of starting_layers) {
+      candidates.push(
+        ...findPossibleTraceLayerCombinations(hints.slice(1), [layer]),
+      )
+    }
+    return candidates
+  }
+
+  if (hints.length === 0) return []
+  const current_hint = hints[0]
+  const is_possibly_via = current_hint.via || current_hint.optional_via
+  const last_layer = layer_path[layer_path.length - 1]
+
+  if (hints.length === 1) {
+    const last_hint = current_hint
+    if (last_hint.layers && is_possibly_via) {
+      return last_hint.layers.map((layer) => ({
+        layer_path: [...layer_path, layer],
+      }))
+    }
+    if (last_hint.layers?.includes(last_layer)) {
+      return [{ layer_path: [...layer_path, last_layer] }]
+    }
+    return []
+  }
+
+  if (!is_possibly_via) {
+    if (current_hint.layers) {
+      if (!current_hint.layers.includes(last_layer)) {
+        return []
+      }
+    }
+
+    return findPossibleTraceLayerCombinations(
+      hints.slice(1),
+      layer_path.concat([last_layer]),
+    )
+  }
+
+  const candidate_next_layers = (
+    current_hint.optional_via
+      ? LAYER_SELECTION_PREFERENCE
+      : LAYER_SELECTION_PREFERENCE.filter((layer) => layer !== last_layer)
+  ).filter(
+    (layer) => !current_hint.layers || current_hint.layers?.includes(layer),
+  )
+
+  for (const candidate_next_layer of candidate_next_layers) {
+    candidates.push(
+      ...findPossibleTraceLayerCombinations(
+        hints.slice(1),
+        layer_path.concat(candidate_next_layer),
+      ),
+    )
+  }
+
+  return candidates
+}

package/lib/utils/autorouting/mergeRoutes.ts

@@ -0,0 +1,70 @@
+import type { PCBTrace } from "@tscircuit/soup"
+
+function pdist(a: any, b: any) {
+  return Math.hypot(a.x - b.x, a.y - b.y)
+}
+
+/**
+ * Merge multiple routes into a single route.
+ *
+ * If the end of the next route is closer to the end of the previous route,
+ * reverse the next route and append it to the previous route.
+ */
+export const mergeRoutes = (routes: PCBTrace["route"][]) => {
+  // routes = routes.filter((route) => route.length > 0)
+  if (routes.some((r) => r.length === 0)) {
+    throw new Error("Cannot merge routes with zero length")
+  }
+  // for (const route of routes) {
+  //   console.table(route)
+  // }
+  const merged: PCBTrace["route"] = []
+  // const reverse_log: boolean[] = []
+
+  // Determine if the first route should be reversed
+  const first_route_fp = routes[0][0]
+  const first_route_lp = routes[0][routes[0].length - 1]
+
+  const second_route_fp = routes[1][0]
+  const second_route_lp = routes[1][routes[1].length - 1]
+
+  const best_reverse_dist = Math.min(
+    pdist(first_route_fp, second_route_fp),
+    pdist(first_route_fp, second_route_lp),
+  )
+
+  const best_normal_dist = Math.min(
+    pdist(first_route_lp, second_route_fp),
+    pdist(first_route_lp, second_route_lp),
+  )
+
+  if (best_reverse_dist < best_normal_dist) {
+    merged.push(...routes[0].reverse())
+    // reverse_log.push(true)
+  } else {
+    merged.push(...routes[0])
+    // reverse_log.push(false)
+  }
+
+  for (let i = 1; i < routes.length; i++) {
+    const last_merged_point = merged[merged.length - 1]
+    const next_route = routes[i]
+
+    const next_first_point = next_route[0]
+    const next_last_point = next_route[next_route.length - 1]
+
+    const distance_to_first = pdist(last_merged_point, next_first_point)
+    const distance_to_last = pdist(last_merged_point, next_last_point)
+
+    if (distance_to_first < distance_to_last) {
+      // reverse_log.push(false)
+      merged.push(...next_route)
+    } else {
+      // reverse_log.push(true)
+      merged.push(...next_route.reverse())
+    }
+  }
+  // console.log(reverse_log)
+  // console.table(merged)
+  return merged
+}

package/lib/utils/pairs.ts

@@ -0,0 +1,10 @@
+/**
+ * Return pairs of adjacent elements in an array.
+ */
+export function pairs<T>(arr: Array<T>): Array<[T, T]> {
+  const result: Array<[T, T]> = []
+  for (let i = 0; i < arr.length - 1; i++) {
+    result.push([arr[i], arr[i + 1]])
+  }
+  return result
+}

package/package.json

@@ -3,7 +3,7 @@
   "module": "index.ts",
   "type": "module",
   "types": "index.ts",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "dist/index.cjs",
   "files": [
     "index.ts",
@@ -27,8 +27,8 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@tscircuit/infgrid-ijump-astar": "0.0.2",
-    "@tscircuit/props": "^0.0.36",
+    "@tscircuit/infgrid-ijump-astar": "0.0.4",
+    "@tscircuit/props": "^0.0.37",
     "@tscircuit/soup": "^0.0.52",
     "@tscircuit/soup-util": "0.0.18",
     "footprinter": "^0.0.44",