Read the DSN's wiring as fixed copper of its nets

Tracks and vias already on the board were ignored, so other nets could
be routed straight through them (the flight controller's 82 GND
stitching vias and its guard tracks). They are now copper of their net:
other nets keep a pad's distance from them in the grid, the exact check
and the room engine, and they add no connections to route.

bench/diagnose.py

@@ -26,6 +26,7 @@ import sys
 from freeroute.board import build_board
 from freeroute.board.search_tree import ShapeSearchTree
 from freeroute.dsn import parse_dsn
+from freeroute.geometry.octagon import overlaps_2d
 from freeroute.route import grid_router
 from freeroute.route.exact_router import route_board_exact
 from freeroute.route.grid_router import GridRouter, _ends_of
@@ -80,13 +81,24 @@ def _capture_conflicts() -> list:
     def conflict(self, box, net_no, layer, clearance, kind="wire"):
         hit = original(self, box, net_no, layer, clearance, kind)
         if hit:
+            # the shape that tripped the check, found the way the check does
+            other = None
             expanded = box.offset(clearance)
-            other = next(
-                (s for s in self.overlapping(expanded)
-                 if s.net_no != net_no and s.on_layer(layer)
-                 and (s.blocks == "all" or s.blocks == kind + "s")),
-                None,
-            )
+            for s in self.overlapping(expanded):
+                if s.net_no == net_no or not s.on_layer(layer):
+                    continue
+                if s.blocks != "all" and s.blocks != kind + "s":
+                    continue
+                if not s.clearance:
+                    if s.tile.overlaps(box):
+                        other = s
+                        break
+                    continue
+                if (s.exact is not None and overlaps_2d(s.exact, expanded)) or (
+                    s.exact is None and s.tile.overlaps(expanded)
+                ):
+                    other = s
+                    break
             log.append((net_no, kind, layer, box, clearance, other))
         return hit
 
@@ -177,10 +189,11 @@ def diagnose(
         if other is None:
             what = "?"
         elif other.net_no == -1:
-            what = "keepout"
+            what = "keepout" if other.clearance else "rule area"
         else:
             what = ("trace/via of " if other.routed else "pad of ") + names.get(other.net_no, "?")
-        short = (clearance - _gap(box, other.tile)) / scale / 1000 if other is not None else 0
+        need = clearance if other is None or other.clearance else 0
+        short = (need - _gap(box, other.tile)) / scale / 1000 if other is not None else 0
         per_net.setdefault(net_no, []).append(
             {"copper": kind, "layer": layer, "against": what, "short_mm": round(short, 4)}
         )

src/freeroute/board/board.py

@@ -70,6 +70,27 @@ class BasicBoard:
     def get_traces(self) -> list[Trace]:
         return [it for it in self._items if isinstance(it, Trace)]
 
+    def get_fixed_copper(self) -> list[tuple[int, frozenset[int], IntBox]]:
+        """Copper already routed on the board (the DSN's ``wiring``), as
+        ``(net, layers, box)``. A track is its segments, its corners and the
+        round caps at its ends (as squares); a via is its largest pad."""
+        from freeroute.geometry.polyline import Polyline, PolylineShape, corner_box
+
+        out: list[tuple[int, frozenset[int], IntBox]] = []
+        for item in self._items:
+            if not item.fixed or not item.net_nos:
+                continue
+            net = item.net_nos[0]
+            if isinstance(item, Trace) and not item.is_empty():
+                layers = frozenset({item.layer})
+                for box in PolylineShape(Polyline(item.corners), item.half_width).tiles():
+                    out.append((net, layers, box))
+                for end in (item.corners[0], item.corners[-1]):
+                    out.append((net, layers, corner_box(end, item.half_width)))
+            elif isinstance(item, Via) and item.shape is not None:
+                out.append((net, frozenset(item.layers), item.shape.bounding_box()))
+        return out
+
     def get_vias(self) -> list[Via]:
         return [it for it in self._items if isinstance(it, Via)]
 

src/freeroute/board/build.py

@@ -31,7 +31,7 @@ from freeroute.geometry.polygon_shape import PolygonShape
 
 from .board import BasicBoard
 from .clearance import ClearanceMatrix
-from .items import ConductionArea, ObstacleArea, Pin
+from .items import ConductionArea, ObstacleArea, Pin, Trace, Via
 from .layer import Layer, LayerStructure
 from .net import Nets
 from .transform import CoordinateTransform
@@ -56,6 +56,7 @@ def build_board(dsn: DsnBoard) -> BasicBoard:
     _insert_keepouts(dsn, board, transform)
     _insert_image_keepouts(dsn, board, transform)
     _insert_zones(dsn, board, transform, nets)
+    _insert_wiring(dsn, board, transform, nets)
     return board
 
 
@@ -333,10 +334,20 @@ def _insert_keepouts(dsn: DsnBoard, board: BasicBoard, transform: CoordinateTran
                     tiles=tiles,
                     blocks_wires=keepout.kind != "via_keepout",
                     blocks_vias=keepout.kind != "wire_keepout",
+                    clearance=not is_rule_area(keepout.area.name),
                 )
             )
 
 
+#: a structure keepout named with this prefix is a KiCad rule area (mckicad
+#: names them on export); it is checked for overlap only
+RULE_AREA_PREFIX = "rule_area"
+
+
+def is_rule_area(name: str | None) -> bool:
+    return bool(name) and name.startswith(RULE_AREA_PREFIX)
+
+
 def _area_border_tiles(shape: Shape, transform: CoordinateTransform) -> list:
     """Convex board tiles covering a keepout border shape.
 
@@ -461,6 +472,47 @@ def _placed_area_tiles(shape: Shape, place, transform: CoordinateTransform) -> l
     return [tile for tile in PolygonShape(pts).split_to_convex() if not tile.is_empty()]
 
 
+def _insert_wiring(dsn: DsnBoard, board: BasicBoard, transform: CoordinateTransform, nets) -> None:
+    """Tracks and vias already on the board, as fixed copper of their nets."""
+    layer_no = {layer.name: i for i, layer in enumerate(dsn.layers)}
+    signal_layers = [i for i, layer in enumerate(dsn.layers) if layer.is_signal]
+    numbers = {net.name: net.net_number for net in nets}
+    for wire in dsn.wires:
+        if wire.net not in numbers or wire.layer not in layer_no:
+            continue
+        c = wire.coords
+        corners = [transform.dsn_to_board_point(c[i], c[i + 1]) for i in range(0, len(c) - 1, 2)]
+        if len(corners) < 2:
+            continue
+        board.insert(
+            Trace(
+                net_nos=[numbers[wire.net]], fixed=True, layer=layer_no[wire.layer],
+                half_width=max(round(transform.dsn_to_board(wire.width / 2)), 1), corners=corners,
+            )
+        )
+    for via in dsn.vias:
+        padstack = dsn.padstack(via.padstack)
+        if via.net not in numbers or padstack is None or not padstack.shapes:
+            continue
+        layers: set[int] = set()
+        for shape in padstack.shapes:
+            if shape.layer in ("signal", "pcb"):
+                layers.update(signal_layers)
+            elif shape.layer in layer_no:
+                layers.add(layer_no[shape.layer])
+        location = transform.dsn_to_board_point(via.x, via.y)
+        pad = _pad_tile(max(padstack.shapes, key=_shape_extent), transform)
+        box = pad.bounding_box()
+        board.insert(
+            Via(
+                net_nos=[numbers[via.net]], fixed=True, padstack_name=via.padstack,
+                location=location, layers=sorted(layers or signal_layers),
+                shape=IntBox(box.ll.x + location.x, box.ll.y + location.y,
+                             box.ur.x + location.x, box.ur.y + location.y),
+            )
+        )
+
+
 def _insert_zones(dsn: DsnBoard, board: BasicBoard, transform: CoordinateTransform, nets) -> None:
     """Each DSN plane as a ConductionArea of its net on its layer."""
     layer_no = {layer.name: i for i, layer in enumerate(dsn.layers)}

src/freeroute/board/items.py

@@ -76,6 +76,11 @@ class ObstacleArea(Item):
     #: tracks" rule area, where vias are allowed), via_keepout only vias
     blocks_wires: bool = True
     blocks_vias: bool = True
+    #: False for a KiCad rule area: copper may not overlap it but may touch
+    #: it, since KiCad's DRC applies no clearance to a rule area. Every other
+    #: keepout may stand for copper (a net tie, a track kept as it is), so it
+    #: keeps the clearance unless named as a rule area.
+    clearance: bool = True
 
     def is_obstacle(self) -> bool:
         return True
@@ -109,6 +114,9 @@ class Via(Item):
 
     padstack_name: str = ""
     location: IntPoint = field(default_factory=lambda: IntPoint(0, 0))
+    #: layer indices the via's pads occupy, and the largest pad as a box
+    layers: list[int] = field(default_factory=list)
+    shape: object = None
 
 
 @dataclass

src/freeroute/board/search_tree.py

@@ -50,6 +50,8 @@ class TreeShape:
     #: which copper a keepout tile stops: "all", "wires" (a wire_keepout,
     #: vias allowed) or "vias" (a via_keepout)
     blocks: str = "all"
+    #: False for a rule area: copper may touch it, only overlap counts
+    clearance: bool = True
 
     def on_layer(self, layer: int) -> bool:
         return layer in self.layers
@@ -129,6 +131,8 @@ class ShapeSearchTree:
 
         Uses a strict 2-D overlap of the ``clearance``-expanded box, so tiles
         exactly ``clearance`` apart (touching after expansion) are allowed.
+        A rule area (``clearance=False``) only has to be clear of the copper
+        itself.
         """
         expanded = box.offset(clearance)
         for shape in self.overlapping(expanded):
@@ -136,6 +140,10 @@ class ShapeSearchTree:
                 continue
             if shape.blocks != "all" and shape.blocks != kind + "s":
                 continue  # a wire-only keepout does not stop a via, and so on
+            if not shape.clearance:
+                if shape.tile.overlaps(box):
+                    return True
+                continue
             if shape.exact is not None:
                 if overlaps_2d(shape.exact, expanded):
                     return True
@@ -143,6 +151,17 @@ class ShapeSearchTree:
                 return True
         return False
 
+    def rule_area_overlap(self, box: IntBox, layer: int, kind: str = "wire") -> bool:
+        """True if ``box`` overlaps a rule area on ``layer`` that stops ``kind``."""
+        for shape in self.overlapping(box):
+            if shape.clearance or not shape.on_layer(layer):
+                continue
+            if shape.blocks != "all" and shape.blocks != kind + "s":
+                continue
+            if shape.tile.overlaps(box):
+                return True
+        return False
+
     def clearance_conflict_shape(
         self, region, net_no: int, layer: int
     ) -> bool:
@@ -178,6 +197,13 @@ class ShapeSearchTree:
                     continue  # static input pair (e.g. pad vs pad) — not a routing DRC
                 if not (shape.layers & other.layers):
                     continue
+                if not (shape.clearance and other.clearance):
+                    # a rule area: only an overlap is a violation
+                    mine = shape.exact if shape.exact is not None else shape.tile
+                    theirs = other.exact if other.exact is not None else other.tile
+                    if overlaps_2d(mine, theirs):
+                        return shape
+                    continue
                 if shape.exact is None and other.exact is None:
                     if other.tile.overlaps(expanded):  # byte-identical box path
                         return shape

src/freeroute/cli.py

@@ -30,8 +30,8 @@ from freeroute.ses import write_ses
 #: which optional flags each engine actually implements. Anything not listed for
 #: an engine is rejected by :func:`_validate` rather than quietly ignored.
 ENGINE_OPTIONS: dict[str, frozenset[str]] = {
-    "grid": frozenset({"rip_up", "max_passes", "seed", "orders", "promote", "access"}),
-    "exact": frozenset({"shove", "diagonal", "rip_up", "max_passes", "seed", "orders", "promote", "access"}),
+    "grid": frozenset({"rip_up", "max_passes", "seed", "orders", "promote", "access", "rollback"}),
+    "exact": frozenset({"shove", "diagonal", "rip_up", "max_passes", "seed", "orders", "promote", "access", "rollback"}),
     "room": frozenset({"shove", "pack"}),
 }
 
@@ -46,6 +46,7 @@ _FLAG_NAMES = {
     "orders": "--orders",
     "promote": "--promote-failures",
     "access": "--access-cost",
+    "rollback": "--no-rollback",
 }
 
 
@@ -166,6 +167,14 @@ def build_parser() -> argparse.ArgumentParser:
         help="grid and exact engines: extra cost for a route to pass where it would close "
         "another pin's way out while that pin still has connections to route (default 0: off)",
     )
+    parser.add_argument(
+        "--no-rollback",
+        dest="rollback",
+        action="store_false",
+        help="grid and exact engines: keep every rip-up, as before. By default the "
+        "connections a rip-up displaces are rerouted at once and the rip-up is undone "
+        "if fewer connections end up routed",
+    )
     parser.add_argument(
         "--jobs",
         type=int,
@@ -195,6 +204,7 @@ def main(argv: list[str] | None = None) -> int:
             ("orders", args.orders is not None),
             ("promote", args.promote_failures is not None),
             ("access", args.access_cost is not None),
+            ("rollback", not args.rollback),
         )
         if asked
     ]
@@ -229,6 +239,7 @@ def main(argv: list[str] | None = None) -> int:
             "resolution": 2 if args.grid_resolution is None else args.grid_resolution,
             "heuristic_weight": args.heuristic_weight,
             "access_cost": args.access_cost or 0.0,
+            "rollback": args.rollback,
         }
     elif args.engine == "grid":
         options = {
@@ -238,6 +249,7 @@ def main(argv: list[str] | None = None) -> int:
             "edge_clearance_mm": args.edge_clearance,
             "resolution": 1 if args.grid_resolution is None else args.grid_resolution,
             "access_cost": args.access_cost or 0.0,
+            "rollback": args.rollback,
         }
     if args.engine == "room":
         result = build_rooms_routing_result(

src/freeroute/dsn/model.py

@@ -27,6 +27,8 @@ __all__ = [
     "NetPin",
     "Net",
     "NetClass",
+    "WiringVia",
+    "WiringWire",
     "Keepout",
     "DsnBoard",
 ]
@@ -186,6 +188,26 @@ class Keepout:
     kind: str = "keepout"  # keepout | via_keepout | wire_keepout | place_keepout
 
 
+@dataclass
+class WiringWire:
+    """A track already on the board: ``(wire (path LAYER WIDTH x y ...) (net N))``."""
+
+    net: str
+    layer: str
+    width: float
+    coords: list[float] = field(default_factory=list)
+
+
+@dataclass
+class WiringVia:
+    """A via already on the board: ``(via PADSTACK x y (net N))``."""
+
+    net: str
+    padstack: str
+    x: float
+    y: float
+
+
 @dataclass
 class DsnBoard:
     """The fully parsed DSN file."""
@@ -197,6 +219,9 @@ class DsnBoard:
     layers: list[Layer] = field(default_factory=list)
     #: copper zones, as planes of a net
     planes: list[Plane] = field(default_factory=list)
+    #: copper already routed (the ``wiring`` scope), kept fixed
+    wires: list[WiringWire] = field(default_factory=list)
+    vias: list[WiringVia] = field(default_factory=list)
     #: bounding-box boundary shape (layer ``pcb``), if present
     boundary: Shape | None = None
     #: outline shapes (layer ``signal``)

src/freeroute/dsn/reader.py

@@ -9,6 +9,8 @@ tolerant ``skip_scope`` behaviour.
 
 from __future__ import annotations
 
+import re
+
 from .model import (
     ClearanceRule,
     ComponentPlace,
@@ -25,6 +27,8 @@ from .model import (
     Pin,
     Resolution,
     WidthRule,
+    WiringVia,
+    WiringWire,
 )
 from .sexp import SExp, parse
 from .shapes import Shape, read_area, read_shape
@@ -481,12 +485,26 @@ def _read_network(node: SExp, board: DsnBoard) -> None:
 # --- top level ---------------------------------------------------------------
 
 
+_STRING_QUOTE = re.compile(r"\(\s*string_quote\s+(\S)\s*\)")
+
+
+def _declared_quote(text: str) -> str:
+    """The quote character the file declares in ``(string_quote X)``.
+
+    Only that character opens a string. Without a declaration both kinds are
+    accepted, as before: KiCad declares ``"`` and then writes a bare ``'``
+    where a value is a single quote mark, e.g. a keycap part number.
+    """
+    found = _STRING_QUOTE.search(text[:4096])
+    return found.group(1) if found else "\"'"
+
+
 def parse_dsn(text: str) -> DsnBoard:
     """Parse DSN ``text`` into a :class:`DsnBoard`.
 
     Raises :class:`DsnParseError` if the top-level scope is not ``(pcb ...)``.
     """
-    top = parse(text)
+    top = parse(text, _declared_quote(text))
     if top.head != "pcb":
         raise DsnParseError(
             f"not a Specctra DSN file: expected top-level '(pcb ...)', got '({top.head} ...)'"
@@ -515,11 +533,45 @@ def parse_dsn(text: str) -> DsnBoard:
             _read_placement(it, board)
         elif head == "network":
             _read_network(it, board)
-        # `wiring` and unknown scopes are intentionally ignored for now.
+        elif head == "wiring":
+            _read_wiring(it, board)
+        # unknown scopes are ignored
 
     return board
 
 
+def _read_wiring(node: SExp, board: DsnBoard) -> None:
+    """Tracks and vias already on the board. They stay where they are: the
+    router treats them as copper of their net that other nets keep clear of."""
+    for it in node.items:
+        if not isinstance(it, SExp):
+            continue
+        net_scope = it.child("net")
+        net = _first_value(net_scope) if net_scope is not None else None
+        if not net:
+            continue  # netless copper would need a keepout, not a wire
+        if it.head == "wire":
+            path = it.child("path") or it.child("polyline_path")
+            vals = [v.text for v in path.values()] if path is not None else []
+            if len(vals) < 6:
+                continue
+            try:
+                width = float(vals[1])
+                coords = [float(v) for v in vals[2:]]
+            except ValueError:
+                continue
+            board.wires.append(WiringWire(net=net, layer=vals[0], width=width, coords=coords))
+        elif it.head == "via":
+            vals = [v.text for v in it.values()]
+            if len(vals) < 3:
+                continue
+            try:
+                x, y = float(vals[1]), float(vals[2])
+            except ValueError:
+                continue
+            board.vias.append(WiringVia(net=net, padstack=vals[0], x=x, y=y))
+
+
 def _read_plane(node: SExp):
     """``(plane <net> (polygon <layer> <width> x y ...))`` -> :class:`Plane`."""
     from .model import Plane

src/freeroute/route/exact_router.py

@@ -42,6 +42,7 @@ from freeroute.geometry import (
     segment_octagon,
     shove_segment,
 )
+from freeroute.geometry.polyline import corner_box
 
 from .grid_router import RouteResult, route_board
 
@@ -97,6 +98,7 @@ def route_board_exact(
     seed: int | None = None,
     route_first: frozenset | None = None,
     access_cost: float = 0.0,
+    rollback: bool = True,
 ) -> ExactRouteResult:
     """Route ``board`` orthogonally and verify the result with exact geometry.
 
@@ -128,6 +130,7 @@ def route_board_exact(
         seed=seed,
         route_first=route_first,
         access_cost=access_cost,
+        rollback=rollback,
     )
     edge = 0 if edge_clearance is None else edge_clearance
     outline = board.outline
@@ -146,6 +149,10 @@ def route_board_exact(
         pin_layers = frozenset(layer for layer in pin.layers if layer in signal_layers)
         if pin_layers:
             tree.insert(TreeShape(next(owner), net, pin_layers, box))
+    for net, copper_layers, box in board.get_fixed_copper():
+        on = frozenset(layer for layer in copper_layers if layer in signal_layers)
+        if on and not box.is_empty():
+            tree.insert(TreeShape(next(owner), net, on, box))
     for obstacle in board.get_obstacle_areas():
         if obstacle.layer not in signal_layers:
             continue
@@ -157,7 +164,10 @@ def route_board_exact(
             box = tile.bounding_box()
             if not box.is_empty():
                 tree.insert(
-                    TreeShape(next(owner), -1, frozenset({obstacle.layer}), box, blocks=blocks)
+                    TreeShape(
+                        next(owner), -1, frozenset({obstacle.layer}), box,
+                        blocks=blocks, clearance=obstacle.clearance,
+                    )
                 )
 
     via_layers = frozenset(signal_layers)
@@ -178,7 +188,9 @@ def route_board_exact(
             )
             for i, (box, box_layers) in enumerate(boxes)
             for layer in box_layers
-        ) or (outline is not None and not all(outline.box_clear(b, edge) for b, _ in boxes)):
+        ) or _end_in_rule_area(tree, wires, half_width) or (
+            outline is not None and not all(outline.box_clear(b, edge) for b, _ in boxes)
+        ):
             rejected.append((net_no, *ends))
             continue  # exact-clearance conflict -> drop (may be recovered by shove)
         acc = accepted.get(net_no)
@@ -592,6 +604,17 @@ def _net_boxes(result, net_no, half_width, via_layers, via_half=None):
     )
 
 
+def _end_in_rule_area(tree, wires, half_width) -> bool:
+    """A wire's tiles stop at its end points, but a track ends in a round cap
+    half its width beyond them. Against other copper the pad or via there
+    covers it; a rule area has no clearance to absorb it, so check it."""
+    for layer, points in wires:
+        for end in (points[0], points[-1]):
+            if tree.rule_area_overlap(corner_box(end, half_width), layer):
+                return True
+    return False
+
+
 def _copper_boxes(wires, vias, half_width, via_layers, via_half=None):
     via_half = via_half or half_width
     boxes: list[tuple[IntBox, frozenset[int]]] = []

src/freeroute/route/grid_router.py

@@ -33,6 +33,7 @@ import random
 from freeroute.board.board import BasicBoard
 from freeroute.board.items import ConductionArea, ObstacleArea, Pin
 from freeroute.geometry import IntBox, IntPoint
+from freeroute.geometry.polyline import corner_box
 
 __all__ = ["GridRouter", "RouteResult", "route_board"]
 
@@ -112,6 +113,7 @@ class _Connection:
         "b_group",
         "a_end",
         "b_end",
+        "path",
     )
 
     def __init__(self, index: int, net_no: int, a: Pin, b: Pin) -> None:
@@ -133,6 +135,8 @@ class _Connection:
         self.b_group: tuple[list[Pin], list] = ([b], [])
         self.a_end: Pin | None = a
         self.b_end: Pin | None = b
+        # the node path last committed, so a rip-up can be undone
+        self.path: list[Node] | None = None
 
 
 class GridRouter:
@@ -158,6 +162,7 @@ class GridRouter:
         seed: int | None = None,
         route_first: frozenset | None = None,
         access_cost: float = 0.0,
+        rollback: bool = True,
     ) -> None:
         self.board = board
         # Pin access: while a pin still has connections to route, the cells
@@ -167,6 +172,12 @@ class GridRouter:
         self.access_cost = max(float(access_cost), 0.0)
         self._doorways: dict[Node, list[tuple[int, int]]] = {}
         self._pending: dict[int, int] = {}
+        # Rip-up as a transaction: the connections a rip-up route crosses are
+        # rerouted at once, and if fewer connections are routed afterwards
+        # than before, everything goes back as it was. On by default: over
+        # 8 net orders it left 25 to 30 fewer connections unrouted on dense
+        # boards and was never clearly worse.
+        self.rollback = bool(rollback)
         # None keeps the deterministic order; a seed shuffles which connection
         # routes first, to measure how much a result owes to the order
         self.seed = seed
@@ -239,6 +250,7 @@ class GridRouter:
         # trace halos: node -> indices of the connections claiming it
         self._halo: dict[Node, list[int]] = {}
         self._rasterize_obstacles()
+        self._rasterize_fixed_copper()
 
     # --- grid helpers -------------------------------------------------------
 
@@ -298,7 +310,9 @@ class GridRouter:
         outline = self.board.outline
         self._via_edge_block: set[Cell] = set()
         # wire keepouts as boxes, to check a pin stub the way the exact engine will
-        self._keepout_boxes: dict[int, list[IntBox]] = {}
+        self._keepout_boxes: dict[int, list[tuple[IntBox, bool]]] = {}
+        # pin end nodes no wire can reach without entering a keepout
+        self._via_only: set[Node] = set()
         if outline is not None:
             # cells too close to the real outline (rounded corners included):
             # for a trace on every layer, and separately for a via's wider copper
@@ -336,13 +350,27 @@ class GridRouter:
                         continue
                     # the same distance the exact engine verifies against
                     if item.blocks_wires:
-                        self._keepout_boxes.setdefault(item.layer, []).append(box)
-                    for cell in self._cells_in_box(box, margin):
+                        self._keepout_boxes.setdefault(item.layer, []).append(
+                            (box, item.clearance)
+                        )
+                    # a rule area takes no clearance: a trace may touch it
+                    reach = margin if item.clearance else self.half_width
+                    for cell in self._cells_in_box(box, reach):
                         if item.blocks_wires:
                             self._keepout.add((*cell, item.layer))
                         if item.blocks_vias:
                             self._via_keepout.add((*cell, item.layer))
 
+    def _rasterize_fixed_copper(self) -> None:
+        """Tracks and vias already on the board: copper of their net, which
+        other nets keep the same distance from as from a pad."""
+        margin = self.clearance + self.half_width
+        for net, layers, box in self.board.get_fixed_copper():
+            on = [layer for layer in layers if layer in self.layers]
+            for cell in self._cells_in_box(box, margin):
+                for layer in on:
+                    self._pad_block.setdefault((*cell, layer), set()).add(net)
+
     # --- occupancy cost -----------------------------------------------------
 
     def _enter_cost(
@@ -434,10 +462,11 @@ class GridRouter:
         g_score: dict[Node, float] = {}
         came_from: dict[Node, Node] = {}
         # a stub costs its length, so the nearest cell wins unless it is blocked
-        goal_stub = {n: self._stub_cost(p, n) for n, p in goals.items() if p is not None}
+        # a pin end costs its stub; a zone or plane end is entered normally
+        goal_stub = {n: self._stub_cost(p, n) for n, p in goals.items() if isinstance(p, Pin)}
         for s in sorted(starts):
             pin = starts[s]
-            g_score[s] = self._stub_cost(pin, s) if pin is not None else 0.0
+            g_score[s] = self._stub_cost(pin, s) if isinstance(pin, Pin) else 0.0
             heapq.heappush(open_heap, (g_score[s] + self._h(s, goal_cell), s))
 
         # Via footprints are checked lazily: a layer change goes on the heap as
@@ -475,12 +504,19 @@ class GridRouter:
                     return path
             cx, cy, cl = current
             base = g_score[current]
-            for dx, dy in self._neighbours:
+            # A cell inside a wire keepout (a pin there, or where a via
+            # landed) may only be left by another via: a wire from it would
+            # start inside the keepout.
+            blocked = current in self._keepout or current in self._via_only
+            neighbours = () if blocked else self._neighbours
+            for dx, dy in neighbours:
                 cell = (cx + dx, cy + dy)
                 if not (0 <= cell[0] < self.cols and 0 <= cell[1] < self.rows):
                     continue
                 nxt = (*cell, cl)
                 if nxt in goal_stub:  # a pin end; a zone end is entered normally
+                    if nxt in self._keepout or nxt in self._via_only:
+                        continue  # a pin inside a keepout is reached by a via only
                     enter = goal_stub[nxt]
                 else:
                     enter = self._enter_cost(cell, cl, net_no, allow_ripup, conns)
@@ -528,7 +564,9 @@ class GridRouter:
             if _point_segment(self._cell_center(c), pin_location, end) < reach
         ]
 
-    def _stub_clear(self, pin: Pin, cell: Cell, layer: int, net_no: int, conns) -> bool:
+    def _stub_clear(
+        self, pin: Pin, cell: Cell, layer: int, net_no: int, conns, keepouts_only: bool = False
+    ) -> bool:
         keepouts = self._keepout_boxes.get(layer)
         if keepouts:
             # the stub is off the grid, so check it exactly, as the exact
@@ -539,8 +577,14 @@ class GridRouter:
             if end != pin.location:
                 for tile in PolylineShape(Polyline([pin.location, end]), self.half_width).tiles():
                     grown = tile.offset(self.clearance)
-                    if any(k.overlaps(grown) for k in keepouts):
+                    if any(k.overlaps(grown if needs else tile) for k, needs in keepouts):
                         return False
+                # the track's round end at the pin, for a rule area
+                cap = corner_box(pin.location, self.half_width)
+                if any(not needs and k.overlaps(cap) for k, needs in keepouts):
+                    return False
+        if keepouts_only:
+            return True
         for c in self._stub_cells(pin.location, cell):
             owner = self._cell_owner.get((*c, layer))
             if owner is not None and conns[owner].net_no != net_no:
@@ -646,6 +690,13 @@ class GridRouter:
             nodes |= self._escape_nodes(pin, net_no, conns, layers, (cx, cy))
         if not nodes:  # nothing clear: fall back to the nearest cell, as before
             nodes = {(cx, cy, layer) for layer in layers}
+            if self._keepout_boxes and not any(
+                self._stub_clear(pin, (cx, cy), layer, net_no, conns, keepouts_only=True)
+                for layer in layers
+            ):
+                # no wire can reach the pin without entering a keepout: the
+                # route has to arrive by a via, which goes in the pad
+                self._via_only.update(nodes)
         return nodes
 
     def _crowded(self, pin: Pin, net_no: int) -> bool:
@@ -759,6 +810,7 @@ class GridRouter:
     # --- commit / rip -------------------------------------------------------
 
     def _commit(self, conn: _Connection, path: list[Node]) -> None:
+        conn.path = list(path)
         wire_segs, via_cells = _split_path(path)
         via_cells = list(via_cells)
         if isinstance(conn.a_end, ConductionArea):
@@ -800,7 +852,9 @@ class GridRouter:
         if len(wire_segs) > 1:
             for idx, pin in ((0, conn.a_end), (len(wire_segs) - 1, conn.b_end)):
                 layer, cells = wire_segs[idx]
-                if isinstance(pin, Pin) and len(cells) == 1 and (*cells[0], layer) in self._keepout:
+                node = (*cells[0], layer)
+                walled = node in self._keepout or node in self._via_only
+                if isinstance(pin, Pin) and len(cells) == 1 and walled:
                     in_pad[idx] = pin.location
         conn.wires = []
         for idx, (layer, cells) in enumerate(wire_segs):
@@ -950,11 +1004,41 @@ class GridRouter:
             path = self._search(conn, allow_ripup=True, conns=conns)
             if path is None:
                 return False
-            for idx in sorted(self._crossed_owners(path, conn.net_no, conns)):
-                self._rip(conns[idx])
+            victims = [conns[i] for i in sorted(self._crossed_owners(path, conn.net_no, conns))]
+            if self.rollback:
+                return self._ripup_transaction(conn, path, victims, conns)
+            for victim in victims:
+                self._rip(victim)
         self._commit(conn, path)
         return True
 
+    def _ripup_transaction(self, conn, path, victims, conns) -> bool:
+        """Route ``conn`` through ``victims``, reroute them at once in free
+        space, and undo it all if fewer connections end up routed."""
+        saved = [(v, v.path, v.a_end, v.b_end, v.rip_count) for v in victims]
+        own_rips = conn.rip_count
+        for victim in victims:
+            self._rip(victim)
+        self._commit(conn, path)
+        rerouted = 0
+        for victim in victims:
+            again = self._search(victim, allow_ripup=False, conns=conns)
+            if again is not None:
+                self._commit(victim, again)
+                rerouted += 1
+        if 1 + rerouted >= len(victims):
+            return True  # a gain, or an even trade that may pay off later
+        for victim in victims:
+            if victim.routed:
+                self._rip(victim)
+        self._rip(conn)
+        conn.rip_count = own_rips
+        for victim, old_path, a_end, b_end, rips in saved:
+            victim.a_end, victim.b_end = a_end, b_end
+            self._commit(victim, old_path)
+            victim.rip_count = rips
+        return False
+
     def _build_connections(self) -> list[_Connection]:
         pins_by_net = self._pins_by_net()
         zones_by_net: dict[int, list] = {}
@@ -1158,6 +1242,7 @@ def route_board(
     seed: int | None = None,
     route_first: frozenset | None = None,
     access_cost: float = 0.0,
+    rollback: bool = True,
 ) -> RouteResult:
     """Convenience wrapper: build a :class:`GridRouter` and route the board."""
     router = GridRouter(
@@ -1176,5 +1261,6 @@ def route_board(
         seed=seed,
         route_first=route_first,
         access_cost=access_cost,
+        rollback=rollback,
     )
     return router.route()

src/freeroute/route/pipeline.py

@@ -83,6 +83,7 @@ def route_dsn_board(
     seed: int | None = None,
     route_first: frozenset | None = None,
     access_cost: float = 0.0,
+    rollback: bool = True,
 ) -> tuple[RouteResult, int, list[str]]:
     """Route a parsed :class:`DsnBoard`; return the board-unit result, the scale,
     and the layer names. ``layers`` restricts routing to those signal-layer
@@ -106,6 +107,7 @@ def route_dsn_board(
         seed=seed,
         route_first=route_first,
         access_cost=access_cost,
+        rollback=rollback,
     )
     return result, scale, [layer.name for layer in dsn.layers]
 
@@ -149,6 +151,7 @@ def build_routing_result(
     seed: int | None = None,
     route_first: frozenset | None = None,
     access_cost: float = 0.0,
+    rollback: bool = True,
 ) -> RoutingResult:
     """Route ``dsn`` (grid track) and convert to a DSN-unit RoutingResult."""
     route, scale, layer_names = route_dsn_board(
@@ -156,6 +159,7 @@ def build_routing_result(
         edge_clearance_mm=edge_clearance_mm, resolution=resolution, seed=seed,
         route_first=route_first,
         access_cost=access_cost,
+        rollback=rollback,
     )
     return _to_routing_result(route, dsn, scale, layer_names)
 
@@ -174,6 +178,7 @@ def route_dsn_board_exact(
     seed: int | None = None,
     route_first: frozenset | None = None,
     access_cost: float = 0.0,
+    rollback: bool = True,
 ) -> tuple[ExactRouteResult, int, list[str]]:
     """Route a parsed :class:`DsnBoard` with the exact-geometry (orthogonal,
     DRC-verified) track; return the exact result, the scale, and layer names.
@@ -201,6 +206,7 @@ def route_dsn_board_exact(
         seed=seed,
         route_first=route_first,
         access_cost=access_cost,
+        rollback=rollback,
     )
     return exact, scale, [layer.name for layer in dsn.layers]
 
@@ -219,6 +225,7 @@ def build_exact_routing_result(
     seed: int | None = None,
     route_first: frozenset | None = None,
     access_cost: float = 0.0,
+    rollback: bool = True,
 ) -> RoutingResult:
     """Route ``dsn`` (exact track) and convert to a DSN-unit RoutingResult."""
     exact, scale, layer_names = route_dsn_board_exact(
@@ -234,6 +241,7 @@ def build_exact_routing_result(
         seed=seed,
         route_first=route_first,
         access_cost=access_cost,
+        rollback=rollback,
     )
     return _to_routing_result(exact.result, dsn, scale, layer_names)
 

src/freeroute/route/room_router.py

@@ -515,6 +515,10 @@ def route_board_rooms(
         pin_layers = frozenset(layer for layer in pin.layers if layer in signal_layers)
         if pin_layers:
             tree.insert(TreeShape(next(owner), net, pin_layers, box))
+    for net, copper_layers, box in board.get_fixed_copper():
+        on = frozenset(layer for layer in copper_layers if layer in signal_layers)
+        if on and not box.is_empty():
+            tree.insert(TreeShape(next(owner), net, on, box))
     for obstacle in board.get_obstacle_areas():
         if obstacle.layer not in signal_layers:
             continue

tests/board/test_build.py

@@ -254,3 +254,37 @@ def test_via_size_comes_from_the_via_padstack():
     from freeroute.route.pipeline import _via_half_board
 
     assert _via_half_board(parse_dsn(_PAD_DSN), 10) == 3000   # 0.6 mm via, board units
+
+
+# --- rule areas: overlap only ------------------------------------------------
+
+_CHANNEL_DSN = """(pcb channel.dsn
+  (parser (string_quote ")) (resolution um 10) (unit um)
+  (structure
+    (layer F.Cu (type signal)) (layer B.Cu (type signal))
+    (boundary (path pcb 0  0 0  40000 0  40000 -30000  0 -30000  0 0))
+    (keepout "{name}top" (polygon signal 0  18000 0  22000 0  22000 -14750  18000 -14750))
+    (keepout "{name}bottom" (polygon signal 0  18000 -15250  22000 -15250  22000 -30000  18000 -30000))
+    (rule (width 250) (clearance 150)))
+  (placement (component P (place P1 5000 -15000 front 0) (place P2 35000 -15000 front 0)))
+  (library (image P (pin pad 1 0 0)) (padstack pad (shape (circle F.Cu 600)) (attach off)))
+  (network (net N (pins P1-1 P2-1))))"""
+
+
+def test_a_keepout_named_rule_area_takes_no_clearance():
+    named = _areas(_CHANNEL_DSN.format(name="rule_area_"))
+    plain = _areas(_CHANNEL_DSN.format(name=""))
+    assert named and not any(a.clearance for a in named)
+    assert plain and all(a.clearance for a in plain)
+
+
+def _route_channel(name):
+    from freeroute.route.pipeline import build_exact_routing_result
+
+    return build_exact_routing_result(parse_dsn(_CHANNEL_DSN.format(name=name)), resolution=2)
+
+
+def test_a_trace_may_run_beside_a_rule_area_closer_than_clearance():
+    # the 0.5 mm channel fits a 0.25 mm trace, but not with 0.15 mm each side
+    assert _route_channel("rule_area_").unrouted == []
+    assert _route_channel("").unrouted != []

tests/board/test_search_tree.py

@@ -62,3 +62,37 @@ def test_has_violation_ignores_static_pad_pairs():
     # a routed trace of net 3 within clearance of pad net 1 -> violation
     tree.insert(shape(2, 3, 0, IntBox(11, 0, 20, 10), routed=True))
     assert tree.has_violation(clearance=20) is not None
+
+
+def test_a_rule_area_conflicts_only_on_overlap():
+    tree = ShapeSearchTree()
+    tree.insert(TreeShape(1, -1, frozenset({0}), IntBox(100, 0, 200, 100), clearance=False))
+    near = IntBox(0, 0, 95, 100)  # 5 short of the area, well inside clearance 50
+    over = IntBox(0, 0, 105, 100)
+    assert not tree.clearance_conflict(near, 7, 0, 50)
+    assert tree.clearance_conflict(over, 7, 0, 50)
+
+
+def test_an_ordinary_keepout_still_needs_clearance():
+    tree = ShapeSearchTree()
+    tree.insert(TreeShape(1, -1, frozenset({0}), IntBox(100, 0, 200, 100)))
+    assert tree.clearance_conflict(IntBox(0, 0, 95, 100), 7, 0, 50)
+
+
+def test_the_routed_board_check_treats_a_rule_area_the_same_way():
+    tree = ShapeSearchTree()
+    tree.insert(TreeShape(1, -1, frozenset({0}), IntBox(100, 0, 200, 100), clearance=False))
+    tree.insert(TreeShape(2, 7, frozenset({0}), IntBox(0, 0, 95, 100), routed=True))
+    assert tree.has_violation(50) is None
+    tree.insert(TreeShape(3, 7, frozenset({0}), IntBox(150, 0, 160, 100), routed=True))
+    assert tree.has_violation(50) is not None
+
+
+
+def test_rule_area_overlap_sees_only_rule_areas():
+    tree = ShapeSearchTree()
+    tree.insert(TreeShape(1, -1, frozenset({0}), IntBox(100, 0, 200, 100), clearance=False))
+    tree.insert(TreeShape(2, -1, frozenset({0}), IntBox(300, 0, 400, 100)))
+    assert tree.rule_area_overlap(IntBox(90, 40, 110, 60), 0)
+    assert not tree.rule_area_overlap(IntBox(290, 40, 310, 60), 0)
+    assert not tree.rule_area_overlap(IntBox(90, 40, 110, 60), 1)

tests/dsn/test_reader.py

@@ -156,3 +156,26 @@ def test_unplaced_component_has_no_coords():
     place = board.placements[0].places[0]
     assert place.name == "U9"
     assert place.x is None and place.y is None
+
+
+# --- string_quote ----------------------------------------------------------
+
+_QUOTED = """(pcb q.dsn
+  (parser (string_quote {q}) (space_in_quoted_tokens on))
+  (resolution um 10) (unit um)
+  (structure (layer F.Cu (type signal)) (boundary (path pcb 0 0 0 1000 0 1000 1000 0 1000 0 0)))
+  (placement (component "SW1" (place SW1 100 100 front 0 (PN {pn}))))
+  (library)
+  (network)
+)"""
+
+
+def test_a_bare_apostrophe_is_an_atom_when_the_file_quotes_with_double_quotes():
+    # KiCad declares " and writes a keycap's part number as a bare '
+    board = parse_dsn(_QUOTED.format(q='"', pn="'"))
+    assert board.parser.string_quote == '"'
+
+
+def test_the_declared_quote_character_is_the_one_that_opens_strings():
+    board = parse_dsn(_QUOTED.format(q="'", pn="'10k 1%'").replace('"SW1"', "'SW1'"))
+    assert board.parser.string_quote == "'"

tests/route/test_fixed_wiring.py

@@ -0,0 +1,50 @@
+"""Tracks and vias already on the board (the DSN's wiring) are fixed copper."""
+
+from __future__ import annotations
+
+from freeroute.board import build_board
+from freeroute.dsn import parse_dsn
+from freeroute.route.pipeline import route_dsn_board_exact
+
+_DSN = """(pcb wired (parser) (resolution um 10) (unit um)
+  (structure
+    (layer F.Cu (type signal)) (layer B.Cu (type signal))
+    (boundary (path pcb 0  0 0  30000 0  30000 -20000  0 -20000  0 0))
+    (via "Via[0-1]_600:300_um") (rule (width 250) (clearance 200)))
+  (placement (component S (place A1 5000 -10000 front 0) (place A2 25000 -10000 front 0)))
+  (library
+    (image S (pin smd 1 0 0))
+    (padstack smd (shape (rect F.Cu -400 -400 400 400)) (attach off))
+    (padstack "Via[0-1]_600:300_um" (shape (circle F.Cu 600)) (shape (circle B.Cu 600)) (attach off)))
+  (network (net SIG (pins A1-1 A2-1)) (net GND))
+  (wiring
+    (wire (path F.Cu 400  15000 0  15000 -20000) (net GND) (type route))
+    (via "Via[0-1]_600:300_um"  8000 -14000 (net GND) (type route))))"""
+
+
+def test_wiring_is_read_with_its_nets():
+    dsn = parse_dsn(_DSN)
+    assert [(w.net, w.layer, w.width) for w in dsn.wires] == [("GND", "F.Cu", 400.0)]
+    assert [(v.net, v.x, v.y) for v in dsn.vias] == [("GND", 8000.0, -14000.0)]
+
+
+def test_wiring_is_fixed_copper_and_not_a_connection_to_route():
+    board = build_board(parse_dsn(_DSN))
+    copper = board.get_fixed_copper()
+    gnd = next(n.net_number for n in board.nets if n.name == "GND")
+    assert copper and all(net == gnd for net, _, _ in copper)
+    assert not any(gnd in p.net_nos for p in board.get_pins())
+
+
+def test_other_nets_route_around_a_fixed_track():
+    dsn = parse_dsn(_DSN)
+    exact, scale, names = route_dsn_board_exact(dsn, resolution=2)
+    sig = next(i + 1 for i, n in enumerate(dsn.nets) if n.name == "SIG")
+    assert sig in exact.result.routed_net_numbers
+    assert exact.drc_clean
+    wall = 15000 * scale
+    for layer, pts in exact.result.wires.get(sig, []):
+        if names[layer] != "F.Cu":
+            continue
+        for p, q in zip(pts, pts[1:], strict=False):
+            assert not (min(p.x, q.x) < wall < max(p.x, q.x)), "crossed the GND track on F.Cu"

tests/route/test_real_board_geometry.py

@@ -202,6 +202,18 @@ def test_smd_pads_reach_an_inner_plane_by_their_own_via():
     assert all(names[layer] in ("F.Cu", "B.Cu") for segs in result.result.wires.values() for layer, _ in segs)
 
 
+def test_a_pad_outside_the_plane_routes_to_it():
+    # G1 sits left of a plane that covers only the right half, so its route
+    # has to reach the plane's cells: those ends are the plane, not a pin
+    dsn_text = _four_layer_dsn().replace(
+        "(plane GND (polygon In1.Cu 0  500 -500  29500 -500  29500 -29500  500 -29500  500 -500))",
+        "(plane GND (polygon In1.Cu 0  15000 -500  29500 -500  29500 -29500  15000 -29500  15000 -500))",
+    )
+    result, _scale, _names = route_dsn_board_exact(parse_dsn(dsn_text))
+    gnd = next(i + 1 for i, n in enumerate(parse_dsn(dsn_text).nets) if n.name == "GND")
+    assert gnd in result.result.routed_net_numbers
+
+
 def test_a_through_hole_pad_inside_a_plane_needs_no_route():
     from freeroute.route.grid_router import _connected_groups
 

tests/route/test_rollback.py

@@ -0,0 +1,43 @@
+"""--rollback: a rip-up that loses connections is undone, leaving no trace."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from freeroute.board import build_board
+from freeroute.dsn import parse_dsn
+from freeroute.route.grid_router import GridRouter
+from freeroute.route.pipeline import _rule_clearance_dsn, _rule_width_dsn, route_dsn_board
+
+FIXTURES = Path(__file__).resolve().parent.parent / "dsn" / "fixtures"
+
+
+def _routed_router(name):
+    dsn = parse_dsn((FIXTURES / name).read_text())
+    s = dsn.resolution.value
+    router = GridRouter(
+        build_board(dsn),
+        trace_width=round(_rule_width_dsn(dsn) * s),
+        clearance=round(_rule_clearance_dsn(dsn) * s),
+        rollback=True,
+    )
+    return router, router.route()
+
+
+@pytest.mark.parametrize("name", ["ripup_needed.dsn", "true_density.dsn", "kicad_routable.dsn"])
+def test_occupancy_only_holds_routed_connections(name):
+    router, _ = _routed_router(name)
+    conns = router._conns
+    assert all(conns[i].routed for i in router._cell_owner.values())
+    assert all(conns[i].routed for i in router._via_owner.values())
+    assert all(conns[i].routed for claims in router._halo.values() for i in claims)
+
+
+@pytest.mark.parametrize("name", ["ripup_needed.dsn", "true_density.dsn", "kicad_routable.dsn"])
+def test_rollback_never_routes_fewer_than_plain_rip_up(name):
+    text = (FIXTURES / name).read_text()
+    plain, _, _ = route_dsn_board(parse_dsn(text), rollback=False)
+    undo, _, _ = route_dsn_board(parse_dsn(text))
+    assert undo.unrouted <= plain.unrouted

tests/test_cli.py

@@ -158,6 +158,7 @@ def test_cli_supported_combinations_are_accepted(tmp_path):
         "orders": ["--orders", "2"],
         "promote": ["--promote-failures", "2"],
         "access": ["--access-cost", "5"],
+        "rollback": ["--no-rollback"],
     }
     for engine, options in ENGINE_OPTIONS.items():
         for option in options: