feat: allow element alignment based on ports for x analogue to y

Accept `(from: <anchor>, to: <port-id>)` for the `x` parameter of
elements, aligning the element's port with the anchor, analogous to the
existing form for `y`. Add a `ports-x` parameter for elements with
`auto-ports: false` and a `gallery/test_xalign` gallery entry.

doc/examples.typ

@@ -79,81 +79,6 @@ wire.stub("p", "south", name: "south", length: 15pt)
 wire.stub("p", "west", name: "west", length: 3em)
 ```)
 
-#let breakout = example(```
-// 16 breakouts: 4 directions × 4 label positions, laid out
-// two per row so the labels have room to breathe.
-let dirs = ("north-east", "north-west", "south-east", "south-west")
-let poss = ("north-east", "north-west", "south-east", "south-west")
-let short = (
-  "north-east": "NE", "north-west": "NW",
-  "south-east": "SE", "south-west": "SW",
-)
-let cols = 2
-let dx = 5
-let dy = 2
-for (i, dir) in dirs.enumerate() {
-  for (j, pos) in poss.enumerate() {
-    let n = i * poss.len() + j
-    let r = calc.floor(n / cols)
-    let c = calc.rem(n, cols)
-    draw.circle((c * dx, -r * dy), radius: .05)
-    wire.breakout("b" + str(n),
-      x: c * dx, y: -r * dy,
-      direction: dir,
-      port-side: if dir.ends-with("east") { "west" } else { "east" },
-      name: short.at(dir) + "/" + short.at(pos),
-      name-pos: pos)
-  }
-}
-```)
-
-#let breakout-label = example(```
-// name-pos matches direction → label sits at the end point.
-wire.breakout("b1", x: 0, y: 0, direction: "north-east",
-              port-side: "east",
-              name: "at end", name-pos: "north-east")
-
-// name-pos opposite to direction → label would cover the line, so
-// it falls back to the start point.
-wire.breakout("b2", x: 4, y: 0, direction: "north-east",
-              port-side: "east",
-              name: "at start", name-pos: "south-west")
-```, vertical: true)
-
-#let breakout-wire = example(```
-// Bus fan-out: a horizontal wire from the left block to the lower
-// right block carries the full 10-bit bus. A breakout in the middle
-// of that wire taps bits [9:5] and routes them to the upper right
-// block via an L-shaped zigzag (up, then right).
-element.block(x: 0, y: 0, w: 2, h: 2, id: "src",
-  fill: util.colors.blue,
-  ports: (east: ((id: "out"),)))
-element.block(x: 6, y: 0, w: 2, h: 2, id: "dstL",
-  fill: util.colors.green,
-  ports: (west: ((id: "in"),)))
-element.block(x: 6, y: 4, w: 2, h: 2, id: "dstU",
-  fill: util.colors.orange,
-  ports: (west: ((id: "in"),)))
-
-// Full bus wire, labelled "[9:0]" on the left.
-wire.wire("wbus", ("src-port-out", "dstL-port-in"),
-          name: "[9:0]", name-pos: "start")
-
-// Breakout tapped from the midpoint of the bus.
-wire.breakout("tap",
-  x: (rel: 2, to: "src-port-out"),
-  y: (from: "src-port-out"),
-  direction: "north-east",
-  port-side: "west",
-  name: "[9:5]", name-pos: "north-east")
-
-// L-shaped wire from the breakout up and then right to the upper
-// block's input.
-wire.wire("wtap", ("tap-port-tap", "dstU-port-in"),
-          style: "zigzag", zigzag-dir: "horizontal",
-          zigzag-ratio: 100%)
-```)
-
 #let gate-and = example(```
 gates.gate-and(x: 0, y: 0, w: 1.5, h: 1.5)
 gates.gate-and(x: 3, y: 0, w: 1.5, h: 1.5, inverted: "all")

gallery/test_breakout.typ

@@ -1,117 +0,0 @@
-// Demonstrates the wire.breakout element used to split off slices of a
-// bus that connects blocks. The main bus wires are always laid out
-// orthogonally; breakouts diagonally tap intermediate points on those
-// wires and route the sub-bus to another block via an L-shaped zigzag.
-#import "/src/lib.typ": circuit, element, util, wire
-
-#set page(width: auto, height: auto, margin: .5cm)
-
-#circuit({
-  // ---- Source block on the left, main sink on the right ----
-  element.block(x: 0, y: 0, w: 2, h: 2, id: "src", fill: util.colors.blue, ports: (
-    east: ((id: "out"),),
-  ))
-
-  element.block(x: 15, y: 0, w: 2, h: 2, id: "dstMain", fill: util.colors.green, ports: (
-    west: ((id: "in"),),
-  ))
-
-  // Full bus from src to dstMain, labelled [15:0] at the start.
-  wire.wire("wbus", ("src-port-out", "dstMain-port-in"), name: "[15:0]", name-pos: "start")
-
-  // ---- Upper-left sink: taps bits [11:8] via NW breakout ----
-  element.block(x: 0, y: 4, w: 2, h: 2, id: "dstNW", fill: util.colors.yellow, ports: (
-    east: ((id: "in"),),
-  ))
-
-  wire.breakout(
-    "tapNE",
-    x: (rel: 3, to: "src-port-out"),
-    y: (from: "src-port-out"),
-    direction: "north-east",
-    port-side: "west",
-    name: "[15:12]",
-    name-pos: "north-east",
-  )
-
-  // L-shape: up first, then left into dstNW.
-  wire.wire(
-    "wNW",
-    ("tapNE-port-tapNE", "dstNW-port-in"),
-    style: "zigzag",
-    zigzag-dir: "horizontal",
-    zigzag-ratio: 100%,
-  )
-
-  // ---- Upper-right sink: taps bits [15:12] via NE breakout ----
-  element.block(x: 15, y: 4, w: 2, h: 2, id: "dstNE", fill: util.colors.orange, ports: (
-    west: ((id: "in"),),
-  ))
-
-  wire.breakout(
-    "tapNW",
-    x: (rel: 7, to: "src-port-out"),
-    y: (from: "src-port-out"),
-    direction: "north-west",
-    port-side: "east",
-    name: "[11:8]",
-    name-pos: "north-east",
-  )
-
-  // L-shape: up first, then right into dstNE.
-  wire.wire(
-    "wNE",
-    ("tapNW-port-tapNW", "dstNE-port-in"),
-    style: "zigzag",
-    zigzag-dir: "horizontal",
-    zigzag-ratio: 100%,
-  )
-
-  // ---- Lower-left sink: taps bits [3:0] via SW breakout ----
-  element.block(x: 0, y: -4, w: 2, h: 2, id: "dstSW", fill: util.colors.purple, ports: (
-    east: ((id: "in"),),
-  ))
-
-  wire.breakout(
-    "tapSE",
-    x: (rel: 5, to: "src-port-out"),
-    y: (from: "src-port-out"),
-    direction: "south-east",
-    port-side: "west",
-    name: "[7:4]",
-    name-pos: "south-east",
-  )
-
-  // L-shape: down first, then left into dstSW.
-  wire.wire(
-    "wSW",
-    ("tapSE-port-tapSE", "dstSW-port-in"),
-    style: "zigzag",
-    zigzag-dir: "horizontal",
-    zigzag-ratio: 100%,
-  )
-
-  // ---- Lower-right sink: taps bits [7:4] via SE breakout ----
-  element.block(x: 15, y: -4, w: 2, h: 2, id: "dstSE", fill: util.colors.pink, ports: (
-    west: ((id: "in"),),
-  ))
-
-  wire.breakout(
-    "tapSW",
-    x: (rel: 11, to: "src-port-out"),
-    y: (from: "src-port-out"),
-    direction: "south-west",
-    port-side: "east",
-    name: "[3:0]",
-    name-pos: "south-west",
-  )
-
-  // L-shape: down first, then right into dstSE.
-  wire.wire(
-    "wSE",
-    ("tapSW-port-tapSW", "dstSE-port-in"),
-    style: "zigzag",
-    zigzag-dir: "horizontal",
-    zigzag-ratio: 100%,
-  )
-})

gallery/test_xalign.typ

@@ -0,0 +1,30 @@
+// Demonstrates the `(from: <anchor>, to: <port-id>)` port-alignment shorthand
+// for the `x` parameter (analogous to the existing shorthand for `y`).
+#import "/src/lib.typ": circuit, element, util, wire
+
+#set page(width: auto, height: auto, margin: .5cm)
+
+#circuit({
+  // Anchor block: absolute placement, with a single "addr" port on its
+  // north side (auto-centred horizontally by circuiteria).
+  element.block(
+    x: 0, y: 0, w: 2, h: 1.5,
+    id: "vcemem",
+    fill: util.colors.orange,
+    ports: (north: ((id: "addr"),), east: ((id: "out"),))
+  )
+
+  // This block's "addr" port (south side) is x-aligned with vcemem's "addr"
+  // port (north side), even though B is wider than vcemem and not
+  // horizontally aligned by default.
+  element.block(
+    x: (from: "vcemem-port-addr", to: "addr"),
+    y: (rel: 2, to: "vcemem.north"),
+    w: 4.5, h: 1,
+    id: "fsm",
+    fill: util.colors.yellow,
+    ports: (south: ((id: "addr"),), east: ((id: "out"),))
+  )
+
+  wire.wire("wAddr", ("vcemem-port-addr", "fsm-port-addr"), style: "zigzag")
+})

src/elements/element.typ

@@ -21,7 +21,9 @@
 /// - draw-shape (function): Draw function
 /// - x (number, dictionary): The x position (bottom-left corner).
 ///
-///   If it is a dictionary, it should be in the format `(rel: number, to: str)`, where `rel` is the offset and `to` the base anchor
+///   If it is a dictionary, it can take one of two forms:
+///     - `(rel: number, to: str)`: `rel` is the x offset and `to` the base anchor
+///     - `(from: str, to: str)`: `from` is the base anchor and `to` is the id of the port to align with the anchor (analogous to `y`)
 /// - y (number, dictionary): The y position (bottom-left corner).
 ///
 ///   If it is a dictionary, it can take one of two forms:
@@ -41,6 +43,7 @@
 /// - stroke (stroke): Border stroke
 /// - id (str): The block id (for future reference)
 /// - auto-ports (bool): Whether to use auto port placements or not. If false, `draw-shape` is responsible for adding the appropiate ports
+/// - ports-x (dictionary): Dictionary of the ports x offsets (used with `auto-ports: false`)
 /// - ports-y (dictionary): Dictionary of the ports y offsets (used with `auto-ports: false`)
 /// - debug (dictionary): Dictionary of debug options.
 ///
@@ -60,6 +63,7 @@
   stroke: black + 1pt,
   id: "",
   auto-ports: true,
+  ports-x: (:),
   ports-y: (:),
   debug: (
     ports: false
@@ -75,8 +79,40 @@
   if w == none { panic("Parameter w must be set") }
   if h == none { panic("Parameter h must be set") }
 
-  if (type(x) == dictionary) {
+  if (type(x) == dictionary and "rel" in x) {
     x = util.resolve-rel-coord(ctx, x, 0)
+  } else if (type(x) == dictionary) {
+    let from = x.from
+    let to = x.to
+    let (to-side, i) = find-port(ports, to)
+    let margins = (0%, 0%)
+    if to-side in ports-margins {
+      margins = ports-margins.at(to-side)
+    }
+
+    let dx
+    let left-margin
+    if to-side in ("north", "south") {
+      let used-pct = 100% - margins.at(0) - margins.at(1)
+      let used-width = width * used-pct / 100%
+      left-margin = width * margins.at(0) / 100%
+
+      dx = used-width * (i + 1) / (ports.at(to-side).len() + 1)
+
+      if not auto-ports {
+        left-margin = 0
+        dx = ports-x.at(to)(width)
+      }
+    } else if to-side == "west" {
+      dx = 0
+      left-margin = 0
+    } else if to-side == "east" {
+      dx = width
+      left-margin = 0
+    }
+
+    let (ctx, from-pos) = coordinate.resolve(ctx, from)
+    x = from-pos.at(0) + dx - width + left-margin
   }
   
   if (type(y) == dictionary and "rel" in y) {

src/wire.typ

@@ -1,5 +1,5 @@
 #import "/src/cetz.typ": draw, coordinate
-#import "util.typ": opposite-anchor, normalize-coord, resolve-rel-coord
+#import "util.typ": opposite-anchor, normalize-coord
 
 /// List of valid wire styles
 /// #examples.wires
@@ -403,141 +403,3 @@
     )
   }
 }
-
-/// Draws a wire breakout: a 45° diagonal line starting at (x, y) and
-/// ending 1 unit away in one of the four diagonal directions. The end
-/// point exposes a port anchor named `<id>-port-<id>` so wires can attach
-/// to it as if it were a block port. A synthesized `<id>.center` anchor
-/// is placed opposite `port-side`, so the cardinal side the port faces
-/// can be deduced by comparing the port with the `.center` anchor.
-///
-/// #examples.breakout
-///
-/// Label positions are anchored so that the label sits neatly next to the
-/// end point of the breakout. When the label direction matches the
-/// breakout direction (which would overlap the line) the label is
-/// automatically placed at the start point instead so the text does not
-/// cover the line.
-///
-/// #examples.breakout-label
-///
-/// The port anchor makes it easy to fan out a bus:
-///
-/// #examples.breakout-wire
-///
-/// - id (str): The breakout id (also used as the port id)
-/// - x (number, dictionary): The starting x position (same forms as `element.block`)
-/// - y (number, dictionary): The starting y position (same forms as `element.block`)
-/// - direction (str): One of `"north-east"`, `"north-west"`, `"south-east"`, `"south-west"`
-/// - length (length, number): The diagonal length (default `1em`, matches port size)
-/// - port-side (str): Cardinal side used for wire-attach behavior (`"north"`, `"east"`, `"south"`, `"west"`)
-/// - stroke (stroke): Line stroke (paint + thickness)
-/// - name (none, str): Optional label displayed near the breakout
-/// - name-pos (none, str): Label position, one of `"north-west"`, `"north-east"`, `"south-west"`, `"south-east"`
-/// - debug (bool): If true, shows a red dot at the port anchor
-#let breakout(
-  id,
-  x: none, y: none,
-  direction: "north-east",
-  length: 1em,
-  port-side: "east",
-  stroke: black + 1pt,
-  name: none,
-  name-pos: none,
-  debug: false,
-) = draw.get-ctx(ctx => {
-  if x == none { panic("breakout: parameter x must be set") }
-  if y == none { panic("breakout: parameter y must be set") }
-
-  let valid-directions = ("north-east", "north-west", "south-east", "south-west")
-  if not direction in valid-directions {
-    panic("breakout: invalid direction '" + repr(direction)
-          + "'; must be one of " + repr(valid-directions))
-  }
-  let valid-sides = ("north", "east", "south", "west")
-  if not port-side in valid-sides {
-    panic("breakout: invalid port-side '" + repr(port-side)
-          + "'; must be one of " + repr(valid-sides))
-  }
-
-  // Diagonal component: length / sqrt(2). Resolve to a canvas-space
-  // number so we can do arithmetic with anchor coordinates.
-  let d-raw = length / calc.sqrt(2)
-  let (_, d-vec) = coordinate.resolve(ctx, (d-raw, 0, 0))
-  let d = d-vec.at(0)
-
-  // Direction sign vector for (dx, dy).
-  let sx = if direction.ends-with("east") { 1 } else { -1 }
-  let sy = if direction.starts-with("north") { 1 } else { -1 }
-
-  // Resolve x.
-  let sx0 = x
-  if type(x) == dictionary {
-    if "rel" in x {
-      sx0 = resolve-rel-coord(ctx, x, 0)
-    } else if "from" in x {
-      let (_, from-pos) = coordinate.resolve(ctx, x.from)
-      sx0 = from-pos.at(0)
-    } else {
-      panic("breakout: unsupported x dictionary: " + repr(x))
-    }
-  }
-  // Resolve y.
-  let sy0 = y
-  if type(y) == dictionary {
-    if "rel" in y {
-      sy0 = resolve-rel-coord(ctx, y, 1)
-    } else if "from" in y {
-      let (_, from-pos) = coordinate.resolve(ctx, y.from)
-      sy0 = from-pos.at(1)
-    } else {
-      panic("breakout: unsupported y dictionary: " + repr(y))
-    }
-  }
-
-  let start = (sx0, sy0)
-  let end = (rel: (sx * d, sy * d), to: start)
-
-  // Offset used for the synthesized center anchor: opposite of port-side.
-  let center-offset = (
-    "north": (0, -1em),
-    "east":  (-1em, 0),
-    "south": (0, 1em),
-    "west":  (1em, 0),
-  ).at(port-side)
-
-  let port-anchor-name = id + "-port-" + id
-
-  draw.group(name: id, {
-    draw.line(start, end, stroke: stroke)
-    draw.anchor("start", start)
-    draw.anchor("end", end)
-    draw.anchor("center", (rel: center-offset, to: end))
-
-    if name != none and name-pos != none {
-      let label-anchor = (
-        "north-west": "south-east",
-        "north-east": "south-west",
-        "south-west": "north-east",
-        "south-east": "north-west",
-      ).at(name-pos)
-
-      // Overlap case: label direction is opposite to breakout direction,
-      // so the label at the end point would extend back over the line.
-      // Anchor it at the start point instead.
-      let label-pos = if name-pos == opposite-anchor(direction) { start } else { end }
-
-      draw.content(label-pos, anchor: label-anchor, padding: 3pt, name)
-    }
-  })
-
-  // Port anchor emitted at top level so it can be referenced by its
-  // bare name (mirrors add-port's approach in ports.typ).
-  if debug {
-    draw.circle(end, name: port-anchor-name,
-                radius: .1, stroke: none, fill: red)
-  } else {
-    draw.hide(draw.circle(end, name: port-anchor-name,
-                          radius: 0, stroke: none))
-  }
-})