AI Flow: Routing

@@ -0,0 +1,277 @@+# This file is automatically @generated by Cargo.+# It is not intended for manual editing.+version = 4++[[package]]+name = "adom-route"+version = "0.2.0"+dependencies = [+ "clap",+ "serde_json",+]++[[package]]+name = "anstream"+version = "1.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"+dependencies = [+ "anstyle",+ "anstyle-parse",+ "anstyle-query",+ "anstyle-wincon",+ "colorchoice",+ "is_terminal_polyfill",+ "utf8parse",+]++[[package]]+name = "anstyle"+version = "1.0.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"++[[package]]+name = "anstyle-parse"+version = "1.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"+dependencies = [+ "utf8parse",+]++[[package]]+name = "anstyle-query"+version = "1.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"+dependencies = [+ "windows-sys",+]++[[package]]+name = "anstyle-wincon"+version = "3.0.11"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"+dependencies = [+ "anstyle",+ "once_cell_polyfill",+ "windows-sys",+]++[[package]]+name = "clap"+version = "4.6.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"+dependencies = [+ "clap_builder",+ "clap_derive",+]++[[package]]+name = "clap_builder"+version = "4.6.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"+dependencies = [+ "anstream",+ "anstyle",+ "clap_lex",+ "strsim",+]++[[package]]+name = "clap_derive"+version = "4.6.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0"+dependencies = [+ "heck",+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "clap_lex"+version = "1.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"++[[package]]+name = "colorchoice"+version = "1.0.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"++[[package]]+name = "equivalent"+version = "1.0.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"++[[package]]+name = "foldhash"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"++[[package]]+name = "hashbrown"+version = "0.17.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"++[[package]]+name = "heck"+version = "0.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"++[[package]]+name = "indexmap"+version = "2.14.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"+dependencies = [+ "equivalent",+ "hashbrown",+]++[[package]]+name = "is_terminal_polyfill"+version = "1.70.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"++[[package]]+name = "itoa"+version = "1.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"++[[package]]+name = "memchr"+version = "2.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"++[[package]]+name = "once_cell_polyfill"+version = "1.70.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"++[[package]]+name = "proc-macro2"+version = "1.0.107"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "quote"+version = "1.0.47"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"+dependencies = [+ "proc-macro2",+]++[[package]]+name = "serde"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"+dependencies = [+ "serde_core",+]++[[package]]+name = "serde_core"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"+dependencies = [+ "serde_derive",+]++[[package]]+name = "serde_derive"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "serde_json"+version = "1.0.154"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"+dependencies = [+ "foldhash",+ "indexmap",+ "itoa",+ "memchr",+ "serde",+ "serde_core",+ "zmij",+]++[[package]]+name = "strsim"+version = "0.11.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"++[[package]]+name = "syn"+version = "3.0.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"+dependencies = [+ "proc-macro2",+ "quote",+ "unicode-ident",+]++[[package]]+name = "unicode-ident"+version = "1.0.27"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"++[[package]]+name = "utf8parse"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"++[[package]]+name = "windows-link"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"++[[package]]+name = "windows-sys"+version = "0.61.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"+dependencies = [+ "windows-link",+]++[[package]]+name = "zmij"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

@@ -0,0 +1,154 @@+# AI Flow: Routing++The routing stage of AI Flow: `adom-aiflow-routing` takes a placed KiCad board, routes every+connection in the designer's hierarchy, and reports what it made, what it could not and why. It is+a whole-board router written in Rust with an exact 0/45/90 degree search, not a grid. `adom-route`+is the same program under its older name.++## AI Flow: Routing is a dynamic skill++A **dynamic skill** is a small Rust binary that holds the AI's hand through a long job. It says+which step comes next, does the routine parts, checks the work with deterministic linters and+answers every command with hints. This app follows the same rules as AI Flow and every+`adom-aiflow-<stage>` app:++- **The AI does about 97 % of the work. The binary is about 3 %.** The binary is the guide and the+  checker. Reading the plan as a designer, finding the currents, deciding what to do about a+  connection that would not route and looking at the board belong to the AI.+- **A guide, never a gate.** No step is a hard gate. `next` suggests what to do; no command checks+  that an earlier step ran or decides whether the AI may continue.+- **Linters give feedback, gently.** `check` and `route` report what they found and suggest a next+  action. It is a suggestion, not a verdict: the AI and the human decide what to do with it.+- **It never tries to do the AI's job.** It encodes no rule about what may happen next.+- **The only error is "I could not run"** (a board that will not parse, nowhere to write), and+  that answer says what to try next. A board with open connections, a board with findings and a+  failed test all answer `OK:` with the facts and `Hint:` lines.++Anyone changing this app should hold it to that: a new requirement, a mandatory field or a step+that refuses is a sign the binary has started doing the AI's work.++## Use++```bash+adom-wiki pkg install adom/adom-aiflow-routing+```++```bash+adom-aiflow-routing init --board placed.kicad_pcb --spec spec.json --ai-thread "<conversation>"+adom-aiflow-routing next      # the suggested step and what to do in it+adom-aiflow-routing plan      # how every net was sorted, and why+adom-aiflow-routing route     # writes routing-flow/routed.kicad_pcb; the input is never changed+adom-aiflow-routing check     # grades the routed board against the routing standards+adom-aiflow-routing steps     # every step with its state+adom-aiflow-routing ledger    # one line per command: time, AI thread, what happened+```++Every command answers `OK:` or `ERROR:` and then `Hint:` lines that depend on this board and this+run. A project keeps its state in `<project>/routing-flow/`: `state.json`, `run.jsonl` and the file+each step leaves. The verbs also work with no project: `plan <board>`, `route <board> -o <out>`,+`check <board>`, `draw`, `compare`, `strip`.++| Step | Its file | What the AI does |+|---|---|---|+| intake | `state.json` | `init` on the placed board, with the spec if the design has one |+| plan | `plan.txt` | reads how the nets were sorted; puts currents, pairs and priorities in the spec |+| route | `routed.kicad_pcb` | `route`; reads why each open connection failed |+| check | `check.json` | `check`, then KiCad's DRC with zones refilled |+| review | `review.md` | looks at the board; decides and writes down what was done about each open item |+| handoff | `handoff.json` | what the next stage needs: the board, what is open, what a person must decide |++The steps live in `flows/flow.json`; the skill is `SKILL.md` (also `skills/adom-aiflow-routing/`).++## Results++22 boards from public wiki pages were stripped of their tracks and vias and routed again. A+board counts as clean when every connection is made, KiCad reports 0 open, and KiCad finds no copper+error that the original does not also have. KiCad's DRC ran with zones refilled, under each board's+own rule values with clearance and open connections forced on.++| | Boards clean in KiCad |+|---|---|+| First run | 9 of 22 |+| Current revision | 19 of 22 |++![Results table](docs/results/table.png)++Three benchmark boards are routed from bare before every change is kept:++| Board | Parts | Connections | KiCad errors beyond the original's | KiCad open |+|---|---|---|---|---|+| PiProbe v1.3 | 60 | 96 of 96 | 0 | 0 |+| Benchmark B | 113 | 107 of 107 | 0 | 0 |+| Benchmark C | 160 | 300 of 302 | 0 | 2 |++Not good yet: a two-layer power board with many small pours stops at 207 of 239 connections; a dense+microcontroller board and a large receiver board each have 4 or 5 connections open; ground pads on+some boards keep a single thermal spoke where KiCad wants two; at least one board does not come out+identical on every run (see Build and test).++## All-board run: every board beside its original++<table>+<tr>+<td width="104"><a href="docs/results/README.md"><img src="docs/results/results-icon.png" width="112" alt="All-board run"></a><br><sub>&nbsp;&nbsp;All-board&nbsp;run&nbsp;&nbsp;</sub></td>+<td>Each board was routed from bare and is pictured beside its original, with the connections KiCad reports open ringed in red. <strong><a href="docs/results/README.md">The all-board run</a></strong> shows where the router stands board by board, including the ones it does not finish. It also holds the run ledger and the lessons, one record per finding with the fix and how it was verified.<br><br><a href="docs/results/README.md">Pictures, table and data</a></td>+</tr>+</table>++## How the router is built++It handles one connection at a time, in this order:++1. **Read and bind**: `board.rs`, `rules.rs`, `project.rs`+2. **Classify** nets into the routing hierarchy (pairs, data, power, the rest): `classify.rs`+3. **Plan** the board coarsely, group buses and plan rated supply rails: `global.rs`, `bus.rs`, `power.rs`+4. **Route** each connection with an exact 0/45/90 degree search: `router.rs`, `search.rs`+5. **Repair** connections that failed, by moving lower-priority routes: `repair.rs`+6. **Post passes** on finished copper: `post.rs`, `spread.rs`, `pour.rs`+7. **Check** the result against the rules: `check.rs`, `current.rs`, `mask.rs`+8. **Guide**: the steps, the project folder and the ledger: `flow.rs`, `flows/flow.json`++Rules come from the board's `.kicad_pro` (net classes, clearances, minimums). A board with no+project file is routed to KiCad's own defaults. A spec (JSON) adds what the board file cannot say:+each supply rail's source, voltage and loads, and routing priorities.++## Build and test++```bash+./build.sh                 # tests, release build, bin/adom-aiflow-routing+cargo test --release       # unit tests only+adom-aiflow-routing fixtures <fixtures.json>    # fast tests on your own reference boards+```++A fixture routes a few nets of one reference board alone and judges one behaviour: joined, clean of+named rules, a width near a part, the voltage drop to a load, a via count, a pair's coupling.+Changes to the router are kept only when the fixtures, three whole benchmark boards with KiCad's+DRC, and the all-board run agree. The reference boards and their fixture files are not on this+page; some unit tests read them and are skipped in spirit without them (they fail to find the file).++Every budget runs on a work clock (`src/clock.rs`): a "second" is a fixed amount of search work, not+wall time, so a result does not depend on how fast the machine is. Two runs of the same board are+meant to give the same file byte for byte. That does not hold on every board yet: on one public board+with ground pours, a run gives one of two slightly different results (one via and a few tracks apart).++## Supply rails++`src/power.rs` plans each rail that has a current in the spec as a whole before any copper is+laid: a tree from the source with loads joined heaviest first, each branch's current, and each+branch's width as the larger of the current chart and its share of a 0.25 % voltage-drop limit. A+rail gives way to signals by changing layer, never by thinning. A rail with no current in the spec+is drawn at a 0.40 mm floor and `plan` says so.++## What is on this page++| Path | What it is |+|---|---|+| `src/`, `Cargo.toml`, `Cargo.lock` | the source |+| `flows/flow.json` | the stage's steps |+| `SKILL.md`, `skills/adom-aiflow-routing/SKILL.md` | the skill |+| `LICENSE` | MIT |+| `bin/adom-aiflow-routing` | a Linux build of the current revision |+| `build.sh`, `install.sh`, `uninstall.sh` | build from source; install and uninstall hooks |+| `docs/results/` | pictures and data from the run on public boards |++Board files are not stored here; the pictures in `docs/results/` are renders of public boards.

@@ -0,0 +1,101 @@+---+name: adom-aiflow-routing+description: >-+  The routing stage of AI Flow: takes a placed KiCad board (.kicad_pcb with its .kicad_pro) and routes+  every connection in the designer's hierarchy (pairs, data, power, the rest), then reports what it+  made, what it could not and why, graded against the routing standards and ready for KiCad's DRC.+  A dynamic skill: it suggests the next step and never blocks. Use when asked to route a board,+  autoroute a PCB, finish the routing, route the remaining nets, check a routed board against the+  routing standards, compare a routed board with a reference, or why a connection would not route.+  Trigger words: route the board, autoroute, adom-route, adom-aiflow-routing, routing stage, unrouted+  nets, ratsnest, differential pair routing, power rail width, routing check, strip and reroute.+---++# adom-aiflow-routing++The routing stage of AI Flow. `adom-route` is the same program under its older name.++## What a dynamic skill is (read this first)++adom-aiflow-routing is a **dynamic skill**: a small Rust binary that holds your hand through the+job. It tells you which step comes next, does the routine parts (the search, the bookkeeping, the+checks) and answers every command with hints.++- **You are about 97 % of the flow. The binary is about 3 %.** It is the guide and the checker; the+  thinking and the work are yours: reading the plan as a designer, finding the currents, deciding+  what to do about a connection that would not route, looking at the board.+- **It is never a hard gate, at any step.** `next` names a suggested step. No command checks that+  an earlier one ran. Take another route when you have a better one, and say what you did and why.+- **Findings are gentle suggestions.** `check` and `route` report what they saw and offer a next+  action. Weigh it, fix what is real, carry on. You and the human decide.+- **It does not do your job.** It encodes no rule about what you may do next, so a better model+  loses nothing by using it.+- **Its only error is "I could not run"** (a file that is missing or will not parse, nowhere to+  write), and that answer says what to try next. A board with open connections, a board with+  findings and a failed fixture all answer `OK:` with the facts and hints.++When you change this app, keep it this way: add hints and checks that report, never requirements,+mandatory fields or steps that refuse.++## Use++Run `adom-aiflow-routing next` whenever you are unsure what to do. Every command answers `OK:` or+`ERROR:` and then `Hint:` lines that depend on this board and this run. In a project, every command+adds a line to `<project>/routing-flow/run.jsonl`.++```+adom-aiflow-routing init --board <placed.kicad_pcb> [--spec <spec.json>] --ai-thread <you>+adom-aiflow-routing next          # the suggested step and what to do in it+adom-aiflow-routing plan          # how every net was sorted, and why+adom-aiflow-routing route         # writes routing-flow/routed.kicad_pcb; the input is never changed+adom-aiflow-routing check         # grades the routed board against the routing standards+adom-aiflow-routing steps         # every step with its state+adom-aiflow-routing ledger        # what was run, by whom, when+```++The verbs also work with no project: `plan <board>`, `route <board> -o <out>`, `check <board>`,+`draw <board> -o <svg> [--window x0,y0,x1,y1] [--highlight net,net]`,+`compare <board> <reference>`, `strip <board> -o <out>`.++## The steps++| Step | Its file | What you do |+|---|---|---|+| intake | `state.json` | `init` on the placed board, with the spec if the design has one |+| plan | `plan.txt` | read how the nets were sorted; put currents, pairs and priorities in the spec |+| route | `routed.kicad_pcb` | `route`; read why each open connection failed |+| check | `check.json` | `check`, then KiCad's DRC with zones refilled |+| review | `review.md` | look at the board; decide and write down what you did about each open item |+| handoff | `handoff.json` | what the next stage needs: the board, what is open, what a person must decide |++## What matters++- **KiCad is the judge.** Run its DRC with zones refilled (`kicad-cli pcb drc --refill-zones`)+  against the board's own project on the routed file. A project can turn clearance or open+  connections down to a warning or carry exclusions; judge with those checks on, and report the+  designer's own exceptions rather than hiding them.+- **Look at the board.** `draw` writes a picture; put it beside the reference or the earlier+  revision and show the human, with the open places marked. A count is a claim, a picture is evidence.+- **Supply rails need a current.** With no spec a rail is drawn at the 0.40 mm floor. A spec entry+  per rail (`rails`, by net name: `sources`, `volts`, `amps` and `loads` by part) lets the power+  stage plan its tree and size each branch by current and voltage drop. A rail the board makes+  itself is rated by its regulator. A rail the board only receives is sized by the draw of the parts+  that take it: look in the prompt and on those parts' wiki pages and datasheets. When nothing says,+  ask the human for the expected draw; do not guess it from a name or a pad.+- **A fixture mounted on the board keeps its side clear.** Where screw holes take a fixture, the+  copper layer that touches the fixture carries no tracks under it other than ground, wherever the+  board allows. The router does not know a hole is for a fixture: find that in the prompt or the+  design notes, check the routed board for it, and say what you found in the review.+- **An open connection has a reason.** `route` prints it: walled in by pads or fills, out of search+  budget, held by a protected route. Moving a part or giving a rail its current often does more+  than more time.+- **Local pad rules are proposals.** Where no track fits a pad under its class clearance, the+  router writes a rule beside the output (`.kicad_dru`) and marks it REVIEW. It is the human's to+  accept.+- **The input board is never changed.** Every result is a new file.++## Debug switches++`ADOM_ROUTE_TRACE=1` prints every search. `ADOM_ROUTE_SNAP_FAIL=<file>` with+`ADOM_ROUTE_SNAP_PAD=<U2.19>` writes the board as it stood when that pad's connection first failed.+`ADOM_ROUTE_DEBUG_VIA=x,y` prints what the checker sees round one via.

@@ -0,0 +1,83 @@+{+  "slug": "adom-aiflow-routing",+  "type": "app",+  "version": "0.2.0",+  "title": "AI Flow: Routing",+  "description": "The routing stage of AI Flow: adom-aiflow-routing takes a placed KiCad board, routes every connection in the designer's hierarchy (pairs, data, power, the rest) with an exact 0/45/90 degree search, and reports what it made, what it could not and why. A dynamic skill: it suggests the next step and never blocks. The full Rust source ships on this page; build it with ./build.sh.",+  "category": "Developer Tools",+  "bin": {+    "adom-aiflow-routing": "bin/adom-aiflow-routing"+  },+  "dependencies": {},+  "scripts": {+    "install": "./install.sh",+    "uninstall": "./uninstall.sh"+  },+  "bundled": true,+  "brief": "The routing stage of AI Flow: routes a placed KiCad board connection by connection and reports what it made, what it could not and why. A guide, never a gate.",+  "discovery_pitch": "Reach for this when a placed KiCad board needs its tracks: it sorts the nets as a designer would, routes them, grades the result against the routing standards and tells you what to look at next.",+  "discovery_triggers": [+    "route the board",+    "autoroute my pcb",+    "finish the routing",+    "route the remaining nets",+    "adom-aiflow-routing",+    "adom-route",+    "why will this net not route",+    "check the routing against the standards",+    "strip the board and route it again",+    "ai flow routing"+  ],+  "sample_prompts": [+    {+      "label": "Route a placed board",+      "prompt": "Route this placed KiCad board with adom-aiflow-routing, then show me the result beside the original with anything still open marked."+    },+    {+      "label": "Explain an open connection",+      "prompt": "Three connections did not route on this board. Find out why each one failed and what would fix it."+    },+    {+      "label": "Grade a routed board",+      "prompt": "Check this routed board against the routing standards and KiCad's DRC and tell me which findings are real."+    }+  ],+  "files": [+    "README.md",+    "SKILL.md",+    "LICENSE",+    "package.json",+    "Cargo.toml",+    "Cargo.lock",+    "build.sh",+    "install.sh",+    "uninstall.sh",+    "src/**",+    "flows/**",+    "skills/**",+    "bin/**",+    "docs/hero.png",+    "screenshots/showcase.png"+  ],+  "license": "MIT",+  "hero": {+    "type": "image",+    "path": "docs/hero.png"+  },+  "tags": [+    "pcb",+    "routing",+    "autorouter",+    "kicad",+    "ai-flow",+    "dynamic-skill",+    "rust",+    "cli"+  ],+  "visibility": "public",+  "org": "adom",+  "author": {+    "name": "Caleb",+    "email": "[email protected]"+  }+}\ No newline at end of file

@@ -0,0 +1,101 @@+---+name: adom-aiflow-routing+description: >-+  The routing stage of AI Flow: takes a placed KiCad board (.kicad_pcb with its .kicad_pro) and routes+  every connection in the designer's hierarchy (pairs, data, power, the rest), then reports what it+  made, what it could not and why, graded against the routing standards and ready for KiCad's DRC.+  A dynamic skill: it suggests the next step and never blocks. Use when asked to route a board,+  autoroute a PCB, finish the routing, route the remaining nets, check a routed board against the+  routing standards, compare a routed board with a reference, or why a connection would not route.+  Trigger words: route the board, autoroute, adom-route, adom-aiflow-routing, routing stage, unrouted+  nets, ratsnest, differential pair routing, power rail width, routing check, strip and reroute.+---++# adom-aiflow-routing++The routing stage of AI Flow. `adom-route` is the same program under its older name.++## What a dynamic skill is (read this first)++adom-aiflow-routing is a **dynamic skill**: a small Rust binary that holds your hand through the+job. It tells you which step comes next, does the routine parts (the search, the bookkeeping, the+checks) and answers every command with hints.++- **You are about 97 % of the flow. The binary is about 3 %.** It is the guide and the checker; the+  thinking and the work are yours: reading the plan as a designer, finding the currents, deciding+  what to do about a connection that would not route, looking at the board.+- **It is never a hard gate, at any step.** `next` names a suggested step. No command checks that+  an earlier one ran. Take another route when you have a better one, and say what you did and why.+- **Findings are gentle suggestions.** `check` and `route` report what they saw and offer a next+  action. Weigh it, fix what is real, carry on. You and the human decide.+- **It does not do your job.** It encodes no rule about what you may do next, so a better model+  loses nothing by using it.+- **Its only error is "I could not run"** (a file that is missing or will not parse, nowhere to+  write), and that answer says what to try next. A board with open connections, a board with+  findings and a failed fixture all answer `OK:` with the facts and hints.++When you change this app, keep it this way: add hints and checks that report, never requirements,+mandatory fields or steps that refuse.++## Use++Run `adom-aiflow-routing next` whenever you are unsure what to do. Every command answers `OK:` or+`ERROR:` and then `Hint:` lines that depend on this board and this run. In a project, every command+adds a line to `<project>/routing-flow/run.jsonl`.++```+adom-aiflow-routing init --board <placed.kicad_pcb> [--spec <spec.json>] --ai-thread <you>+adom-aiflow-routing next          # the suggested step and what to do in it+adom-aiflow-routing plan          # how every net was sorted, and why+adom-aiflow-routing route         # writes routing-flow/routed.kicad_pcb; the input is never changed+adom-aiflow-routing check         # grades the routed board against the routing standards+adom-aiflow-routing steps         # every step with its state+adom-aiflow-routing ledger        # what was run, by whom, when+```++The verbs also work with no project: `plan <board>`, `route <board> -o <out>`, `check <board>`,+`draw <board> -o <svg> [--window x0,y0,x1,y1] [--highlight net,net]`,+`compare <board> <reference>`, `strip <board> -o <out>`.++## The steps++| Step | Its file | What you do |+|---|---|---|+| intake | `state.json` | `init` on the placed board, with the spec if the design has one |+| plan | `plan.txt` | read how the nets were sorted; put currents, pairs and priorities in the spec |+| route | `routed.kicad_pcb` | `route`; read why each open connection failed |+| check | `check.json` | `check`, then KiCad's DRC with zones refilled |+| review | `review.md` | look at the board; decide and write down what you did about each open item |+| handoff | `handoff.json` | what the next stage needs: the board, what is open, what a person must decide |++## What matters++- **KiCad is the judge.** Run its DRC with zones refilled (`kicad-cli pcb drc --refill-zones`)+  against the board's own project on the routed file. A project can turn clearance or open+  connections down to a warning or carry exclusions; judge with those checks on, and report the+  designer's own exceptions rather than hiding them.+- **Look at the board.** `draw` writes a picture; put it beside the reference or the earlier+  revision and show the human, with the open places marked. A count is a claim, a picture is evidence.+- **Supply rails need a current.** With no spec a rail is drawn at the 0.40 mm floor. A spec entry+  per rail (`rails`, by net name: `sources`, `volts`, `amps` and `loads` by part) lets the power+  stage plan its tree and size each branch by current and voltage drop. A rail the board makes+  itself is rated by its regulator. A rail the board only receives is sized by the draw of the parts+  that take it: look in the prompt and on those parts' wiki pages and datasheets. When nothing says,+  ask the human for the expected draw; do not guess it from a name or a pad.+- **A fixture mounted on the board keeps its side clear.** Where screw holes take a fixture, the+  copper layer that touches the fixture carries no tracks under it other than ground, wherever the+  board allows. The router does not know a hole is for a fixture: find that in the prompt or the+  design notes, check the routed board for it, and say what you found in the review.+- **An open connection has a reason.** `route` prints it: walled in by pads or fills, out of search+  budget, held by a protected route. Moving a part or giving a rail its current often does more+  than more time.+- **Local pad rules are proposals.** Where no track fits a pad under its class clearance, the+  router writes a rule beside the output (`.kicad_dru`) and marks it REVIEW. It is the human's to+  accept.+- **The input board is never changed.** Every result is a new file.++## Debug switches++`ADOM_ROUTE_TRACE=1` prints every search. `ADOM_ROUTE_SNAP_FAIL=<file>` with+`ADOM_ROUTE_SNAP_PAD=<U2.19>` writes the board as it stood when that pad's connection first failed.+`ADOM_ROUTE_DEBUG_VIA=x,y` prints what the checker sees round one via.

@@ -0,0 +1,723 @@+//! The board as this router sees it: copper layers, nets, footprints and pads with their exact+//! outlines, tracks, vias, zones, the edge and every hole. Read straight from a `.kicad_pcb`.++use crate::geom::*;+use crate::sx::{self, Node};+use std::collections::{BTreeMap, HashMap};++pub type NetId = u32;+pub const NO_NET: NetId = 0;++#[derive(Clone, Debug)]+pub struct Layer {+    pub name: String,+    pub signal: bool,+}++#[derive(Clone, Debug)]+pub struct Pad {+    pub fp: usize,+    pub number: String,+    pub net: NetId,+    pub center: P,+    pub shape: Shape,+    /// Copper layers the pad exists on (indices into `Board::layers`).+    pub layers: Vec<usize>,+    pub drill: Option<f64>,+    pub npth: bool,+    /// The pad's own clearance override, else its footprint's, in nm (0 when it has none). KiCad's+    /// DRC holds other copper to it even where the net class allows less.+    pub local_clearance: f64,+    /// The pad's own way of joining a pour (`zone_connect`: 0 none, 1 thermal relief, 2 solid, 3+    /// thermal for through-hole only), its footprint's if it has none, else the zone decides.+    pub zone_connect: Option<u8>,+    pub size: (f64, f64),+    pub angle: f64,+    /// Mask opening beyond the copper, resolved the way KiCad does: the pad's own margin, else the+    /// footprint's, else the board's pad_to_mask_clearance.+    pub mask_margin: f64,+    /// Opening in F.Mask and in B.Mask. A pad listing no mask layer has no opening at all.+    pub mask: (bool, bool),+    pub paste: bool,+    /// The schematic's electrical type (power_in, input, ...), empty when the file has none.+    pub pintype: String,+    /// The schematic's pin name (VCC_5, IOVDD_1, ...), empty when the file has none.+    pub pinfunction: String,+}++#[derive(Clone, Debug)]+pub struct Footprint {+    pub reference: String,+    pub value: String,+    pub lib: String,+    pub at: P,+    pub bottom: bool,+    pub pads: Vec<usize>,+    /// Smallest centre-to-centre distance between two of its copper pads, nm.+    pub min_pitch: f64,+    pub dnp: bool,+}++#[derive(Clone, Debug)]+pub struct Track {+    pub net: NetId,+    pub layer: usize,+    pub a: P,+    pub b: P,+    pub width: i64,+    pub span: (usize, usize),+}++#[derive(Clone, Debug)]+pub struct Via {+    pub net: NetId,+    pub at: P,+    pub size: i64,+    pub drill: i64,+    pub span: (usize, usize),+    /// Mask over the via on the front and back (4.4: every via tented on both sides).+    pub tent: (bool, bool),+}++/// A teardrop's filled copper, as KiCad wrote it. It is not an obstacle to routing but it does+/// count for solder mask, so the mask check reads it.+#[derive(Clone, Debug)]+pub struct Teardrop {+    pub net: NetId,+    pub layer: usize,+    pub pts: Vec<V>,+}++/// Board-wide mask settings from `(setup ...)`.+#[derive(Clone, Debug)]+pub struct MaskSetup {+    pub pad_to_mask: f64,+    /// Smallest web of mask between two openings.+    pub web: f64,+    pub allow_bridges_in_footprints: bool,+    pub tent: (bool, bool),+}++#[derive(Clone, Debug)]+pub struct Zone {+    pub net: NetId,+    pub layers: Vec<usize>,+    pub outline: Vec<V>,+    /// Filled copper per layer, as read from the file (empty when the zone is not filled).+    pub fills: Vec<(usize, Vec<V>)>,+    pub keepout_tracks: bool,+    pub keepout_vias: bool,+    pub priority: i64,+    pub name: String,+    /// `(keepout (copperpour not_allowed))`: no zone fills here.+    pub keepout_pour: bool,+    /// The zone's own clearance, nm (`connect_pads (clearance x)`), 0 when it sets none.+    pub clearance: f64,+    /// `min_thickness`, nm: copper narrower than this does not survive a refill.+    pub min_thickness: f64,+    /// `connect_pads no`: the fill keeps clear of pads of its own net.+    pub joins_pads: bool,+    /// Thermal reliefs (the default `connect_pads`): the gap round a pad and the width of the spokes+    /// across it, nm. None: pads join the fill solid (`connect_pads yes`) or not at all.+    pub thermal: Option<(f64, f64)>,+    /// `connect_pads thru_hole_only`: reliefs for through-hole pads, solid for the rest.+    pub thermal_tht_only: bool,+}++#[derive(Clone, Debug)]+pub struct Board {+    pub text: String,+    pub layers: Vec<Layer>,+    pub nets: Vec<String>,+    pub net_ids: HashMap<String, NetId>,+    pub footprints: Vec<Footprint>,+    pub pads: Vec<Pad>,+    pub tracks: Vec<Track>,+    pub vias: Vec<Via>,+    pub zones: Vec<Zone>,+    pub edges: Vec<(V, V)>,+    pub bbox: (f64, f64, f64, f64),+    /// Teardrops are stored as small zones. They are copper KiCad regenerates from the routing,+    /// so they are not obstacles, and they go when the routing goes.+    pub teardrop_spans: Vec<(usize, usize)>,+    pub teardrops: Vec<Teardrop>,+    pub mask: MaskSetup,+}++fn xy(n: &Node) -> Option<V> {+    Some(V(n.num(1)? * NM, n.num(2)? * NM))+}++impl Board {+    pub fn read(path: &str) -> Result<Board, String> {+        let text = std::fs::read_to_string(path).map_err(|e| format!("{path}: {e}"))?;+        Board::parse(text)+    }++    pub fn parse(text: String) -> Result<Board, String> {+        let root = sx::parse(&text)?;+        if root.head() != "kicad_pcb" {+            return Err("not a kicad_pcb file".into());+        }+        let mut b = Board {+            text: String::new(),+            layers: Vec::new(),+            nets: vec![String::new()],+            net_ids: HashMap::new(),+            footprints: Vec::new(),+            pads: Vec::new(),+            tracks: Vec::new(),+            vias: Vec::new(),+            zones: Vec::new(),+            edges: Vec::new(),+            bbox: (f64::MAX, f64::MAX, f64::MIN, f64::MIN),+            teardrop_spans: Vec::new(),+            teardrops: Vec::new(),+            mask: MaskSetup { pad_to_mask: 0.0, web: 0.0, allow_bridges_in_footprints: false, tent: (true, true) },+        };+        if let Some(s) = root.child("setup") {+            let num = |k: &str| s.child(k).and_then(|x| x.num(1)).unwrap_or(0.0) * NM;+            b.mask.pad_to_mask = num("pad_to_mask_clearance");+            b.mask.web = num("solder_mask_min_width");+            b.mask.allow_bridges_in_footprints = s.child("allow_soldermask_bridges_in_footprints").and_then(|x| x.atom(1)) == Some("yes");+            b.mask.tent = tent_of(s, (true, true));+        }+        b.net_ids.insert(String::new(), NO_NET);++        // Copper layers in stack order: F.Cu, inner layers by number, B.Cu.+        let mut inner: BTreeMap<u32, Layer> = BTreeMap::new();+        let (mut top, mut bot) = (None, None);+        if let Some(ls) = root.child("layers") {+            for l in ls.items() {+                let (Some(name), Some(kind)) = (l.atom(1), l.atom(2)) else { continue };+                if !name.ends_with(".Cu") {+                    continue;+                }+                let layer = Layer { name: name.to_string(), signal: kind == "signal" || kind == "mixed" };+                if name == "F.Cu" {+                    top = Some(layer);+                } else if name == "B.Cu" {+                    bot = Some(layer);+                } else if let Some(n) = name.strip_prefix("In").and_then(|s| s.strip_suffix(".Cu")).and_then(|s| s.parse().ok()) {+                    inner.insert(n, layer);+                }+            }+        }+        b.layers.extend(top);+        b.layers.extend(inner.into_values());+        b.layers.extend(bot);+        if b.layers.len() < 2 {+            return Err("board has fewer than two copper layers".into());+        }++        // Older files carry a net table; KiCad 10 writes the net by name on each item.+        let mut table: HashMap<i64, String> = HashMap::new();+        for n in root.children("net") {+            if let (Some(id), Some(name)) = (n.num(1), n.atom(2)) {+                table.insert(id as i64, name.to_string());+            }+        }+        let net_of = |b: &mut Board, node: &Node| -> NetId {+            let Some(n) = node.child("net") else { return NO_NET };+            let name = match (n.atom(1), n.atom(2)) {+                (_, Some(name)) => name.to_string(),+                (Some(a), None) => {+                    if let Some(name) = a.parse::<i64>().ok().and_then(|id| table.get(&id)) {+                        name.clone()+                    } else {+                        a.to_string()+                    }+                }+                _ => String::new(),+            };+            b.intern(&name)+        };++        for n in root.items() {+            match n.head() {+                "footprint" | "module" => b.read_footprint(n, &net_of)?,+                "segment" => {+                    let (Some(s), Some(e)) = (n.child("start").and_then(xy), n.child("end").and_then(xy)) else { continue };+                    let Some(layer) = n.child("layer").and_then(|l| l.atom(1)).and_then(|l| b.layer_index(l)) else { continue };+                    let width = mm(n.child("width").and_then(|w| w.num(1)).unwrap_or(0.0));+                    let net = net_of(&mut b, n);+                    b.tracks.push(Track { net, layer, a: to_p(s), b: to_p(e), width, span: n.span() });+                }+                "arc" => {+                    let (Some(s), Some(m), Some(e)) = (n.child("start").and_then(xy), n.child("mid").and_then(xy), n.child("end").and_then(xy)) else { continue };+                    let Some(layer) = n.child("layer").and_then(|l| l.atom(1)).and_then(|l| b.layer_index(l)) else { continue };+                    let width = mm(n.child("width").and_then(|w| w.num(1)).unwrap_or(0.0));+                    let net = net_of(&mut b, n);+                    let pts = arc_points(s, m, e, 50_000.0);+                    for w in pts.windows(2) {+                        b.tracks.push(Track { net, layer, a: to_p(w[0]), b: to_p(w[1]), width, span: n.span() });+                    }+                }+                "via" => {+                    let Some(at) = n.child("at").and_then(xy) else { continue };+                    let size = mm(n.child("size").and_then(|w| w.num(1)).unwrap_or(0.0));+                    let drill = mm(n.child("drill").and_then(|w| w.num(1)).unwrap_or(0.0));+                    let net = net_of(&mut b, n);+                    let tent = tent_of(n, b.mask.tent);+                    b.vias.push(Via { net, at: to_p(at), size, drill, span: n.span(), tent });+                }+                "zone" => b.read_zone(n, &net_of),+                "gr_line" | "gr_arc" | "gr_rect" | "gr_circle" | "gr_poly" => b.read_edge(n, &|v| v),+                _ => {}+            }+        }+        for e in b.edges.clone() {+            b.bbox = (b.bbox.0.min(e.0 .0).min(e.1 .0), b.bbox.1.min(e.0 .1).min(e.1 .1), b.bbox.2.max(e.0 .0).max(e.1 .0), b.bbox.3.max(e.0 .1).max(e.1 .1));+        }+        b.text = text;+        Ok(b)+    }++    pub fn intern(&mut self, name: &str) -> NetId {+        if let Some(&i) = self.net_ids.get(name) {+            return i;+        }+        let i = self.nets.len() as NetId;+        self.nets.push(name.to_string());+        self.net_ids.insert(name.to_string(), i);+        i+    }++    pub fn layer_index(&self, name: &str) -> Option<usize> {+        self.layers.iter().position(|l| l.name == name)+    }++    pub fn net_name(&self, n: NetId) -> &str {+        &self.nets[n as usize]+    }++    pub fn pad_name(&self, i: usize) -> String {+        let p = &self.pads[i];+        format!("{}.{}", self.footprints[p.fp].reference, p.number)+    }++    /// Layer indices named by a `(layers ...)` list, wildcards expanded.+    fn expand_layers(&self, names: &[&str]) -> Vec<usize> {+        let mut out = Vec::new();+        for n in names {+            match *n {+                "*.Cu" => out.extend(0..self.layers.len()),+                "F&B.Cu" => {+                    out.push(0);+                    out.push(self.layers.len() - 1);+                }+                other => out.extend(self.layer_index(other)),+            }+        }+        out.sort_unstable();+        out.dedup();+        out+    }++    fn read_footprint(&mut self, n: &Node, net_of: &dyn Fn(&mut Board, &Node) -> NetId) -> Result<(), String> {+        let at = n.child("at").ok_or("footprint without (at)")?;+        let (fx, fy) = (at.num(1).unwrap_or(0.0) * NM, at.num(2).unwrap_or(0.0) * NM);+        let frot = at.num(3).unwrap_or(0.0);+        let bottom = n.child("layer").and_then(|l| l.atom(1)) == Some("B.Cu");+        let mut reference = String::new();+        let mut value = String::new();+        for p in n.children("property") {+            match p.atom(1) {+                Some("Reference") => reference = p.atom(2).unwrap_or("").to_string(),+                Some("Value") => value = p.atom(2).unwrap_or("").to_string(),+                _ => {}+            }+        }+        for t in n.children("fp_text") {+            match t.atom(1) {+                Some("reference") if reference.is_empty() => reference = t.atom(2).unwrap_or("").to_string(),+                Some("value") if value.is_empty() => value = t.atom(2).unwrap_or("").to_string(),+                _ => {}+            }+        }+        let dnp = n.child("attr").map(|a| a.atoms().contains(&"dnp")).unwrap_or(false);+        let fp_idx = self.footprints.len();+        let lib = n.atom(1).unwrap_or("").to_string();+        let fp_margin = n.child("solder_mask_margin").and_then(|m| m.num(1));+        let mut fp = Footprint { reference, value, lib, at: (fx as i64, fy as i64), bottom, pads: Vec::new(), min_pitch: f64::INFINITY, dnp };+        for p in n.children("pad") {+            let kind = p.atom(2).unwrap_or("smd");+            let shape_name = p.atom(3).unwrap_or("rect");+            let pat = p.child("at").ok_or("pad without (at)")?;+            let (lx, ly) = (pat.num(1).unwrap_or(0.0) * NM, pat.num(2).unwrap_or(0.0) * NM);+            let pang = pat.num(3).unwrap_or(0.0);+            let (rx, ry) = rot(lx, ly, frot);+            let (cx, cy) = (fx + rx, fy + ry);+            let size = p.child("size").map(|s| (s.num(1).unwrap_or(0.0) * NM, s.num(2).unwrap_or(0.0) * NM)).unwrap_or((0.0, 0.0));+            let names = p.child("layers").map(|l| l.atoms().into_iter().skip(1).collect::<Vec<_>>()).unwrap_or_default();+            let layers = self.expand_layers(&names);+            let drill_node = p.child("drill");+            let drill = drill_node.and_then(|d| d.atoms().iter().skip(1).find_map(|a| a.parse::<f64>().ok())).map(|d| d * NM);+            let off = drill_node.and_then(|d| d.child("offset")).map(|o| (o.num(1).unwrap_or(0.0) * NM, o.num(2).unwrap_or(0.0) * NM)).unwrap_or((0.0, 0.0));+            let (ox, oy) = rot(off.0, off.1, pang);+            let center = V(cx + ox, cy + oy);+            let rr = p.child("roundrect_rratio").and_then(|r| r.num(1)).unwrap_or(0.0);+            let delta = p.child("rect_delta").map(|d| (d.num(1).unwrap_or(0.0) * NM, d.num(2).unwrap_or(0.0) * NM));+            let shape = pad_shape(shape_name, center, size, pang, rr, delta, p, kind);+            let net = net_of(self, p);+            let npth = kind == "np_thru_hole";+            let pi = self.pads.len();+            let mask_margin = p.child("solder_mask_margin").and_then(|m| m.num(1)).or(fp_margin).map(|m| m * NM).unwrap_or(self.mask.pad_to_mask);+            let has = |l: &str| names.iter().any(|n| *n == l || *n == "*.Mask" && l.ends_with(".Mask") || *n == "F&B.Mask" && l.ends_with(".Mask"));+            let mask = (has("F.Mask"), has("B.Mask"));+            let paste = names.iter().any(|n| n.ends_with(".Paste"));+            self.pads.push(Pad { fp: fp_idx, number: p.atom(1).unwrap_or("").to_string(), net, center: to_p(V(cx, cy)), shape, layers: if npth { Vec::new() } else { layers }, drill, npth, local_clearance: p.child("clearance").or(n.child("clearance")).and_then(|c| c.num(1)).unwrap_or(0.0) * NM, zone_connect: p.child("zone_connect").or(n.child("zone_connect")).and_then(|c| c.num(1)).map(|v| v as u8), size, angle: pang, mask_margin, mask, paste, pintype: p.child("pintype").and_then(|t| t.atom(1)).unwrap_or("").to_string(), pinfunction: p.child("pinfunction").and_then(|t| t.atom(1)).unwrap_or("").to_string() });+            fp.pads.push(pi);+        }+        for i in 0..fp.pads.len() {+            for j in i + 1..fp.pads.len() {+                let (a, b) = (&self.pads[fp.pads[i]], &self.pads[fp.pads[j]]);+                if a.layers.is_empty() || b.layers.is_empty() {+                    continue;+                }+                let d = hypot(sub(a.center.into(), b.center.into()));+                if d > 1.0 {+                    fp.min_pitch = fp.min_pitch.min(d);+                }+            }+        }+        self.footprints.push(fp);+        for z in n.children("zone") {+            self.read_zone(z, net_of);+        }+        let xf = |v: V| {+            let (x, y) = rot(v.0, v.1, frot);+            V(fx + x, fy + y)+        };+        for k in ["fp_line", "fp_arc", "fp_rect", "fp_circle", "fp_poly"] {+            for g in n.children(k) {+                self.read_edge(g, &xf);+            }+        }+        Ok(())+    }++    fn read_edge(&mut self, n: &Node, xf: &dyn Fn(V) -> V) {+        if n.child("layer").and_then(|l| l.atom(1)) != Some("Edge.Cuts") {+            return;+        }+        let head = n.head();+        if head.ends_with("_line") {+            if let (Some(a), Some(b)) = (n.child("start").and_then(xy), n.child("end").and_then(xy)) {+                self.edges.push((xf(a), xf(b)));+            }+        } else if head.ends_with("_arc") {+            if let (Some(a), Some(m), Some(b)) = (n.child("start").and_then(xy), n.child("mid").and_then(xy), n.child("end").and_then(xy)) {+                let pts = arc_points(xf(a), xf(m), xf(b), 100_000.0);+                for w in pts.windows(2) {+                    self.edges.push((w[0], w[1]));+                }+            }+        } else if head.ends_with("_rect") {+            if let (Some(a), Some(b)) = (n.child("start").and_then(xy), n.child("end").and_then(xy)) {+                let c = [a, V(b.0, a.1), b, V(a.0, b.1)];+                for i in 0..4 {+                    self.edges.push((xf(c[i]), xf(c[(i + 1) % 4])));+                }+            }+        } else if head.ends_with("_circle") {+            if let (Some(c), Some(e)) = (n.child("center").and_then(xy), n.child("end").and_then(xy)) {+                let r = hypot(sub(e, c));+                let pts: Vec<V> = (0..=48).map(|i| {+                    let a = i as f64 / 48.0 * std::f64::consts::TAU;+                    xf(V(c.0 + r * a.cos(), c.1 + r * a.sin()))+                }).collect();+                for w in pts.windows(2) {+                    self.edges.push((w[0], w[1]));+                }+            }+        } else if head.ends_with("_poly") {+            if let Some(pts) = n.child("pts") {+                let v: Vec<V> = pts.children("xy").filter_map(xy).map(xf).collect();+                for i in 0..v.len() {+                    self.edges.push((v[i], v[(i + 1) % v.len()]));+                }+            }+        }+    }++    fn read_zone(&mut self, n: &Node, net_of: &dyn Fn(&mut Board, &Node) -> NetId) {+        if n.child("attr").and_then(|a| a.child("teardrop")).is_some() {+            self.teardrop_spans.push(n.span());+            let net = net_of(self, n);+            for f in n.children("filled_polygon") {+                let Some(layer) = f.child("layer").and_then(|l| l.atom(1)).and_then(|l| self.layer_index(l)) else { continue };+                if let Some(p) = f.child("pts") {+                    self.teardrops.push(Teardrop { net, layer, pts: pts_of(p) });+                }+            }+            return;+        }+        let net = net_of(self, n);+        let mut names: Vec<&str> = Vec::new();+        if let Some(l) = n.child("layer") {+            names.extend(l.atoms().into_iter().skip(1));+        }+        if let Some(l) = n.child("layers") {+            names.extend(l.atoms().into_iter().skip(1));+        }+        let layers = self.expand_layers(&names);+        let outline: Vec<V> = n.child("polygon").and_then(|p| p.child("pts")).map(pts_of).unwrap_or_default();+        let mut fills = Vec::new();+        for f in n.children("filled_polygon") {+            let Some(l) = f.child("layer").and_then(|l| l.atom(1)).and_then(|l| self.layer_index(l)) else { continue };+            if let Some(p) = f.child("pts") {+                fills.push((l, pts_of(p)));+            }+        }+        let ko = n.child("keepout");+        let na = |k: &str| ko.and_then(|o| o.child(k)).and_then(|c| c.atom(1)) == Some("not_allowed");+        let priority = n.child("priority").and_then(|p| p.num(1)).unwrap_or(0.0) as i64;+        let name = n.child("name").and_then(|p| p.atom(1)).unwrap_or("").to_string();+        let pads = n.child("connect_pads");+        let clearance = pads.and_then(|c| c.child("clearance")).and_then(|c| c.num(1)).unwrap_or(0.0) * NM;+        let min_thickness = n.child("min_thickness").and_then(|c| c.num(1)).unwrap_or(0.25) * NM;+        let joins_pads = pads.and_then(|c| c.atom(1)) != Some("no");+        let mode = pads.and_then(|c| c.atom(1));+        let fill = n.child("fill");+        let relief = (fill.and_then(|f| f.child("thermal_gap")).and_then(|c| c.num(1)).unwrap_or(0.5) * NM, fill.and_then(|f| f.child("thermal_bridge_width")).and_then(|c| c.num(1)).unwrap_or(0.5) * NM);+        let thermal = if mode.is_none() || mode == Some("thru_hole_only") { Some(relief) } else { None };+        let thermal_tht_only = mode == Some("thru_hole_only");+        self.zones.push(Zone { net, layers, outline, fills, keepout_tracks: na("tracks"), keepout_vias: na("vias"), priority, name, keepout_pour: na("copperpour"), clearance, min_thickness, joins_pads, thermal, thermal_tht_only });+    }++    /// Whether a point lies inside the board outline (holes in the outline count as outside).+    pub fn inside(&self, p: V) -> bool {+        let mut inside = false;+        for (a, b) in &self.edges {+            if (a.1 > p.1) != (b.1 > p.1) && p.0 < (b.0 - a.0) * (p.1 - a.1) / (b.1 - a.1) + a.0 {+                inside = !inside;+            }+        }+        inside+    }++    /// Inner layers given over to a reference plane: a zone of one net covers most of the board.+    /// KiCad's layer type doesn't tell: his benchmark C and benchmark B mark GND planes "signal". Routing+    /// through a plane cuts the return path (2.2, 4.2), so these never take a track.+    pub fn plane_layers(&self) -> Vec<usize> {+        let last = self.layers.len() - 1;+        let board_area = (self.bbox.2 - self.bbox.0).max(0.0) * (self.bbox.3 - self.bbox.1).max(0.0);+        let mut out = Vec::new();+        for l in 1..last {+            // Added up per net: benchmark B's GND plane is two zones, 48% and 13% of the board.+            let mut per_net: HashMap<NetId, f64> = HashMap::new();+            for z in self.zones.iter().filter(|z| z.net != NO_NET && !z.keepout_tracks && z.layers.contains(&l)) {+                let n = z.outline.len();+                let mut a = 0.0;+                for i in 0..n {+                    let (p, q) = (z.outline[i], z.outline[(i + 1) % n]);+                    a += p.0 * q.1 - q.0 * p.1;+                }+                *per_net.entry(z.net).or_insert(0.0) += (a / 2.0).abs();+            }+            let covered = per_net.values().copied().fold(0.0, f64::max);+            if board_area > 0.0 && covered >= 0.5 * board_area {+                out.push(l);+            }+        }+        out+    }++    /// Nets with a copper plane on an inner layer: zone net to its plane layers.+    pub fn plane_nets(&self) -> HashMap<NetId, Vec<usize>> {+        let mut out: HashMap<NetId, Vec<usize>> = HashMap::new();+        let last = self.layers.len() - 1;+        for z in &self.zones {+            if z.net == NO_NET || z.keepout_tracks {+                continue;+            }+            for &l in &z.layers {+                if l != 0 && l != last {+                    out.entry(z.net).or_default().push(l);+                }+            }+        }+        out+    }+}++fn pts_of(p: &Node) -> Vec<V> {+    let mut out = Vec::new();+    for c in p.items() {+        match c.head() {+            "xy" => out.extend(xy(c)),+            "arc" => {+                if let (Some(a), Some(m), Some(b)) = (c.child("start").and_then(xy), c.child("mid").and_then(xy), c.child("end").and_then(xy)) {+                    out.extend(arc_points(a, m, b, 100_000.0));+                }+            }+            _ => {}+        }+    }+    out+}++/// A `(tenting ...)` block on a via or in the setup, or the default when it has none.+fn tent_of(n: &Node, default: (bool, bool)) -> (bool, bool) {+    let Some(t) = n.child("tenting") else { return default };+    let side = |k: &str, d: bool| match t.child(k).and_then(|x| x.atom(1)) {+        Some("yes") => true,+        Some("no") => false,+        _ => d,+    };+    (side("front", default.0), side("back", default.1))+}++pub fn to_p(v: V) -> P {+    (v.0.round() as i64, v.1.round() as i64)+}++fn rect_pts(center: V, w: f64, h: f64, ang: f64, rr: f64) -> Vec<V> {+    let (hw, hh) = (w / 2.0, h / 2.0);+    let mut local: Vec<(f64, f64)> = Vec::new();+    if rr <= 0.0 {+        local.extend([(-hw, -hh), (hw, -hh), (hw, hh), (-hw, hh)]);+    } else {+        // Corner arcs with enough facets that the polygon stays within a micron of the true outline.+        let n = 12;+        for (cx, cy, a0) in [(hw - rr, -hh + rr, -90.0f64), (hw - rr, hh - rr, 0.0), (-hw + rr, hh - rr, 90.0), (-hw + rr, -hh + rr, 180.0)] {+            for i in 0..=n {+                let a = (a0 + 90.0 * i as f64 / n as f64).to_radians();+                local.push((cx + rr * a.cos(), cy + rr * a.sin()));+            }+        }+    }+    local+        .into_iter()+        .map(|(x, y)| {+            let (rx, ry) = rot(x, y, ang);+            V(center.0 + rx, center.1 + ry)+        })+        .collect()+}++#[allow(clippy::too_many_arguments)]+fn pad_shape(name: &str, center: V, size: (f64, f64), ang: f64, rr: f64, delta: Option<(f64, f64)>, p: &Node, kind: &str) -> Shape {+    let (w, h) = size;+    match name {+        "circle" => Shape::Circle { c: center, r: w / 2.0 },+        "oval" => {+            if (w - h).abs() < 1.0 {+                Shape::Circle { c: center, r: w / 2.0 }+            } else if w > h {+                let d = (w - h) / 2.0;+                let (x, y) = rot(d, 0.0, ang);+                Shape::Capsule { a: V(center.0 - x, center.1 - y), b: V(center.0 + x, center.1 + y), r: h / 2.0 }+            } else {+                let d = (h - w) / 2.0;+                let (x, y) = rot(0.0, d, ang);+                Shape::Capsule { a: V(center.0 - x, center.1 - y), b: V(center.0 + x, center.1 + y), r: w / 2.0 }+            }+        }+        "roundrect" => Shape::Poly { pts: rect_pts(center, w, h, ang, rr * w.min(h)), r: 0.0 },+        "trapezoid" => {+            let (dx, dy) = delta.unwrap_or((0.0, 0.0));+            let (hw, hh) = (w / 2.0, h / 2.0);+            let local = [(-hw - dy / 2.0, -hh + dx / 2.0), (hw + dy / 2.0, -hh - dx / 2.0), (hw - dy / 2.0, hh + dx / 2.0), (-hw + dy / 2.0, hh - dx / 2.0)];+            let pts = local.iter().map(|&(x, y)| {+                let (rx, ry) = rot(x, y, ang);+                V(center.0 + rx, center.1 + ry)+            }).collect();+            Shape::Poly { pts, r: 0.0 }+        }+        "custom" => {+            // A custom pad is its anchor plus every primitive, all one piece of copper. KiCad's DRC+            // and connectivity see the union, so all of it is kept, not only the largest piece.+            let anchor_circle = p.child("options").and_then(|o| o.child("anchor")).and_then(|a| a.atom(1)) == Some("circle");+            let mut parts = vec![if anchor_circle { Shape::Circle { c: center, r: w / 2.0 } } else { Shape::Poly { pts: rect_pts(center, w, h, ang, 0.0), r: 0.0 } }];+            let xf = |v: V| {+                let (rx, ry) = rot(v.0, v.1, ang);+                V(center.0 + rx, center.1 + ry)+            };+            if let Some(prims) = p.child("primitives") {+                for g in prims.items() {+                    let half = g.child("width").and_then(|w| w.num(1)).unwrap_or(0.0) * NM / 2.0;+                    let filled = g.child("fill").and_then(|f| f.atom(1)).map(|f| f != "no" && f != "none").unwrap_or(true);+                    match g.head() {+                        "gr_poly" => {+                            if let Some(pp) = g.child("pts") {+                                parts.push(Shape::Poly { pts: pts_of(pp).into_iter().map(xf).collect(), r: half });+                            }+                        }+                        "gr_line" => {+                            if let (Some(a), Some(e)) = (g.child("start").and_then(xy), g.child("end").and_then(xy)) {+                                parts.push(Shape::Capsule { a: xf(a), b: xf(e), r: half });+                            }+                        }+                        "gr_arc" => {+                            if let (Some(a), Some(m), Some(e)) = (g.child("start").and_then(xy), g.child("mid").and_then(xy), g.child("end").and_then(xy)) {+                                for s in arc_points(a, m, e, 50_000.0).windows(2) {+                                    parts.push(Shape::Capsule { a: xf(s[0]), b: xf(s[1]), r: half });+                                }+                            }+                        }+                        "gr_rect" => {+                            if let (Some(a), Some(e)) = (g.child("start").and_then(xy), g.child("end").and_then(xy)) {+                                let pts: Vec<V> = [a, V(e.0, a.1), e, V(a.0, e.1)].into_iter().map(xf).collect();+                                parts.push(Shape::Poly { pts, r: half });+                            }+                        }+                        "gr_circle" => {+                            if let (Some(c), Some(e)) = (g.child("center").and_then(xy), g.child("end").and_then(xy)) {+                                let r = hypot(sub(e, c));+                                if filled {+                                    parts.push(Shape::Circle { c: xf(c), r: r + half });+                                } else {+                                    let ring: Vec<V> = (0..=48).map(|i| {+                                        let a = i as f64 / 48.0 * std::f64::consts::TAU;+                                        V(c.0 + r * a.cos(), c.1 + r * a.sin())+                                    }).collect();+                                    for s in ring.windows(2) {+                                        parts.push(Shape::Capsule { a: xf(s[0]), b: xf(s[1]), r: half });+                                    }+                                }+                            }+                        }+                        _ => {}+                    }+                }+            }+            if parts.len() == 1 { parts.pop().unwrap() } else { Shape::Multi(parts) }+        }+        _ => {+            let _ = kind;+            Shape::Poly { pts: rect_pts(center, w, h, ang, 0.0), r: 0.0 }+        }+    }+}++#[cfg(test)]+mod tests {+    use super::*;++    /// A 100 x 100 board with rectangles on In1.Cu: (net, width, height) of each zone.+    fn with_zones(zones: &[(&str, f64, f64)]) -> Board {+        let mut t = String::from(r#"(kicad_pcb (layers (0 "F.Cu" signal) (4 "In1.Cu" signal) (6 "In2.Cu" signal) (2 "B.Cu" signal)) (gr_rect (start 0 0) (end 100 100) (layer "Edge.Cuts"))"#);+        let mut y0 = 0.0;+        for (net, w, h) in zones {+            t.push_str(&format!(r#"(zone (net "{net}") (layer "In1.Cu") (polygon (pts (xy 0 {y0}) (xy {w} {y0}) (xy {w} {}) (xy 0 {}))))"#, y0 + h, y0 + h));+            y0 += h;+        }+        t.push(')');+        Board::parse(t).unwrap()+    }++    #[test]+    fn a_plane_split_into_two_zones_counts() {+        // Benchmark B's shape: neither zone is half the board, together they are 61%.+        assert_eq!(with_zones(&[("GND", 100.0, 48.0), ("GND", 100.0, 13.0)]).plane_layers(), vec![1]);+        assert_eq!(with_zones(&[("GND", 100.0, 60.0)]).plane_layers(), vec![1]);+    }++    #[test]+    fn zones_of_two_nets_do_not_add_up_to_a_plane() {+        assert!(with_zones(&[("GND", 100.0, 30.0), ("+3V3", 100.0, 30.0)]).plane_layers().is_empty());+        assert!(with_zones(&[("GND", 100.0, 40.0)]).plane_layers().is_empty());+    }+}

@@ -0,0 +1,410 @@+//! Buses: what makes hand routing look hand-routed, and what road navigation has no reason to do.+//! Connections between the same two parts are planned as a group: the ones that don't cross share a+//! layer and run side by side in pin order, and the ones that would cross them take the other layer+//! on purpose instead of finding that out one at a time.+//!+//! Adapted from KiCadRoutingTools (MIT, Copyright (c) 2026 drandyhaas), docs/bus-routing.md and+//! docs/net-ordering.md: its maximum-planar-subset greedy (fewest active conflicts first, then shorter),+//! routing a bus's members middle-out, and each member following its routed neighbour. Two things+//! differ. Its crossings come from unrolling each chip's boundary, which assumes copper can't pass+//! through a part; benchmark B's runs eighteen lines through the pins of a module, so chords+//! are compared directly. And its attraction is a discount around the neighbour's path, where here a+//! member is drawn to the neighbour's shape carried over to its own pins: "each line leaves its+//! pin straight out, parallel to its neighbours at the pin pitch" (4.7, QSPI on PiProbe).+//!+//! The hierarchy isn't touched: this only orders connections inside one level (4.2), and the layer+//! and the neighbour's shape are preferences the search can overrule.++use crate::board::*;+use crate::classify::*;+use crate::geom::*;+use crate::global::chords_cross;+use crate::router::{dir_of, Plan, Router};+use crate::rules::Rules;+use crate::search::{Profile, Query, World};+use std::collections::{BTreeMap, HashMap};++/// Contacts and two-pad parts this close count as one row, the way a connector's pins do. KRT's+/// default detection radius.+const ROW_REACH: f64 = 5.0 * NM;+const ROW_BAND: f64 = 0.5 * NM;+/// Fewest connections that make a bus (KRT's strict filter).+const MIN_MEMBERS: usize = 3;++#[derive(Clone, Debug)]+pub struct Member {+    /// Which bus, and this member's turn inside it; buses go first within their level.+    pub group: usize,+    pub seq: usize,+    /// Preferred layer (index into Board::layers), by crossing count.+    pub layer: usize,+    /// Both pads reach that layer, so it costs no via to use.+    pub free: bool,+    /// The routed neighbour to follow, and whether its ends are swapped relative to this one's.+    pub follow: Option<((usize, usize), bool)>,+}++#[derive(Default)]+pub struct BusPlan {+    pub members: HashMap<(usize, usize), Member>,+    /// Each bus's lines that don't cross, in their order across the bus, and their layer: what can+    /// be laid as one band.+    pub bands: Vec<(usize, Vec<(usize, usize)>)>,+    pub notes: Vec<String>,+}++impl BusPlan {+    /// Sort key inside a level: buses first, biggest first, each member in its turn.+    pub fn order_of(&self, t: &crate::classify::Task) -> (usize, usize) {+        self.members.get(&(t.a, t.b)).map(|m| (m.group, m.seq)).unwrap_or((usize::MAX, 0))+    }+}++/// One end of a bus: a part with a row of pins, or a row of separate contacts or passives.+fn clusters(board: &Board) -> Vec<usize> {+    let n = board.footprints.len();+    let mut uf = crate::conn::Uf::new(n);+    let small: Vec<bool> = board.footprints.iter().map(|f| f.pads.iter().filter(|&&p| !board.pads[p].layers.is_empty()).count() <= 2).collect();+    for i in 0..n {+        if !small[i] {+            continue;+        }+        for j in i + 1..n {+            if small[j] && ref_prefix(&board.footprints[i].reference) == ref_prefix(&board.footprints[j].reference) {+                let (pi, pj): (V, V) = (board.footprints[i].at.into(), board.footprints[j].at.into());+                // In line with each other: a row. Parts merely near each other aren't one end of a bus.+                let aligned = (pi.0 - pj.0).abs() < ROW_BAND || (pi.1 - pj.1).abs() < ROW_BAND;+                if aligned && hypot(sub(pi, pj)) <= ROW_REACH {+                    uf.union(i as u32, j as u32);+                }+            }+        }+    }+    (0..n).map(|i| uf.find(i as u32) as usize).collect()+}++/// Find the buses among this pass's connections, and give each member its layer, turn and neighbour.+/// A row this long or longer goes down as one band (lines back to back, each beside the last, kept+/// out of optimise). Benchmark B's 15- and 11-line rows look like the designer's that way; on benchmark C the+/// same treatment of its 4-line rows cost 11 joins (290 against 301 of 302, four runs each way,+/// 2026-11-09), so short rows route as before.+const BAND_MIN: usize = 6;++pub fn plan(board: &Board, world: &World, _rules: &Rules, plan: &Plan) -> BusPlan {+    let mut out = BusPlan::default();+    let cluster = clusters(board);+    let mut by: BTreeMap<(Level, usize, usize), Vec<usize>> = BTreeMap::new();+    let tasks = &plan.tasks;+    for (i, t) in tasks.iter().enumerate() {+        // Data only: non-priority lines may via often without a noticeable effect (4.2 item 4), and+        // holding them to a plan shut GPIO2's pin on piprobe_v13 for no gain in the board's looks.+        if t.a == t.b || t.zone.is_some() || t.level != Level::Data {+            continue;+        }+        let (x, y) = (cluster[board.pads[t.a].fp], cluster[board.pads[t.b].fp]);+        if x == y {+            continue;+        }+        by.entry((t.level, x.min(y), x.max(y))).or_default().push(i);+    }+    let mut groups: Vec<((Level, usize, usize), Vec<usize>)> = by.into_iter().filter(|(_, v)| v.len() >= MIN_MEMBERS).collect();+    // Biggest first: within a level the largest bus has the least room to move. Stable, so the+    // order is the same on every run.+    groups.sort_by_key(|(k, v)| (k.0, std::cmp::Reverse(v.len())));+    let chord = |i: usize| -> (V, V) { (board.pads[tasks[i].a].center.into(), board.pads[tasks[i].b].center.into()) };+    let free_on = |i: usize, l: usize| board.pads[tasks[i].a].layers.contains(&l) && board.pads[tasks[i].b].layers.contains(&l);+    let layers = &world.route_layers;+    // What each layer already holds, for counting crossings between buses.+    let mut placed: HashMap<usize, Vec<(V, V)>> = HashMap::new();+    for (gi, (key, members)) in groups.iter().enumerate() {+        let m = members.len();+        let conflict: Vec<Vec<bool>> = (0..m).map(|a| (0..m).map(|b| a != b && { let (p, q) = (chord(members[a]), chord(members[b])); chords_cross(p.0, p.1, q.0, q.1) }).collect()).collect();+        // The largest set that doesn't cross: fewest active conflicts first, shorter on a tie (KRT).+        let mut left: Vec<usize> = (0..m).collect();+        let mut planar: Vec<usize> = Vec::new();+        let len = |a: usize| { let c = chord(members[a]); hypot(sub(c.0, c.1)) };+        while !left.is_empty() {+            let &pick = left.iter().min_by(|&&a, &&b| {+                let count = |x: usize| left.iter().filter(|&&o| conflict[x][o]).count();+                count(a).cmp(&count(b)).then(len(a).total_cmp(&len(b)))+            }).unwrap();+            planar.push(pick);+            left.retain(|&o| o != pick && !conflict[pick][o]);+        }+        let others: Vec<usize> = (0..m).filter(|a| !planar.contains(a)).collect();+        // Which layer for the planar set? A via is dearest, then crossing other buses, then the+        // bottom: "don't hop to the bottom layer where the top works" (4.2).+        let score = |a_layer: usize, b_layer: usize| -> f64 {+            let mut s = 0.0;+            for (set, l) in [(&planar, a_layer), (&others, b_layer)] {+                for &a in set.iter() {+                    let c = chord(members[a]);+                    if !free_on(members[a], l) {+                        s += 100.0;+                    }+                    if let Some(v) = placed.get(&l) {+                        s += v.iter().filter(|q| chords_cross(c.0, c.1, q.0, q.1)).count() as f64;+                    }+                    if l != 0 {+                        s += 0.01 * (1.0 + hypot(sub(c.0, c.1)) / NM);+                    }+                }+            }+            s+        };+        let mut best: Option<(f64, usize, usize)> = None;+        for &la in layers {+            for &lb in layers {+                if layers.len() > 1 && la == lb {+                    continue;+                }+                let s = score(la, lb);+                if best.map(|b| s < b.0).unwrap_or(true) {+                    best = Some((s, la, lb));+                }+            }+        }+        let Some((_, la, lb)) = best else { continue };+        // Physical order across the bus, so each member's neighbour really is beside it.+        let (dx, dy) = planar.iter().fold((0.0, 0.0), |acc, &a| {+            let c = chord(members[a]);+            let (mut x, mut y) = (c.1 .0 - c.0 .0, c.1 .1 - c.0 .1);+            // Chords can be listed either way round; add them all facing the same way.+            if x * (acc.0 as f64) + y * (acc.1 as f64) < 0.0 {+                x = -x;+                y = -y;+            }+            (acc.0 + x, acc.1 + y)+        });+        let norm = (dx * dx + dy * dy).sqrt().max(1.0);+        let across = |a: usize| {+            let c = chord(members[a]);+            ((c.0 .0 + c.1 .0) / 2.0 * -dy + (c.0 .1 + c.1 .1) / 2.0 * dx) / norm+        };+        let mut row = planar.clone();+        row.sort_by(|&a, &b| across(a).total_cmp(&across(b)));+        if row.len() >= BAND_MIN {+    out.bands.push((la, row.iter().map(|&a| (tasks[members[a]].a, tasks[members[a]].b)).collect()));+        }+        // Middle out: each member's neighbour is the one before it, toward the middle, and no+        // member is ever walled off from its pins by the order.+        let mid = row.len() / 2;+        let mut turns: Vec<(usize, Option<usize>)> = vec![(row[mid], None)];+        for k in 1..=row.len() {+            if mid + k < row.len() {+                turns.push((row[mid + k], Some(row[mid + k - 1])));+            }+            if k <= mid {+                turns.push((row[mid - k], Some(row[mid - k + 1])));+            }+        }+        // The rest go shortest first: a line that must wrap round another's pin goes after it, so+        // they nest, as the bottom row of benchmark B's bus does.+        let mut rest = others.clone();+        rest.sort_by(|&a, &b| len(a).total_cmp(&len(b)));+        // They nest, so they run beside each other too: the next one out follows the one inside it.+        if rest.len() >= BAND_MIN {+            out.bands.push((lb, rest.iter().map(|&a| (tasks[members[a]].a, tasks[members[a]].b)).collect()));+        }+        for a in rest {+            turns.push((a, None));+        }+        let same_way = |a: usize, b: usize| {+            let (ta, tb) = (&tasks[members[a]], &tasks[members[b]]);+            cluster[board.pads[ta.a].fp] == cluster[board.pads[tb.a].fp]+        };+        for (seq, (a, near)) in turns.iter().enumerate() {+            let t = &tasks[members[*a]];+            let layer = if planar.contains(a) { la } else { lb };+            let follow = near.map(|n| {+                let o = &tasks[members[n]];+                ((o.a, o.b), !same_way(*a, n))+            });+            out.members.insert((t.a, t.b), Member { group: gi, seq, layer, free: free_on(members[*a], layer), follow });+            placed.entry(layer).or_default().push(chord(members[*a]));+        }+        let name = |c: usize| {+            let f = board.footprints.iter().enumerate().find(|(i, _)| cluster[*i] == c).map(|(_, f)| f.reference.clone()).unwrap_or_default();+            if board.footprints.iter().enumerate().filter(|(i, _)| cluster[*i] == c).count() > 1 { format!("{}..", f) } else { f }+        };+        out.notes.push(format!("bus {} to {}: {} lines, {} level, {} side by side on {}, {} on {}", name(key.1), name(key.2), m, key.0.name(), planar.len(), board.layers[la].name, others.len(), board.layers[lb].name));+    }+    out+}++/// How much of a bus's line length runs beside its neighbour in the bus: same layer, parallel, within+/// `BESIDE` of another line of the same bus. His buses move as one band of lines at 3W; lines routed one at a time fan out and cross,+/// which bends and vias don't show (benchmark B: ours had fewer bends than his and looked worse).+/// Returns (lines measured, share beside, mm measured).+pub fn coherence(board: &Board, rules: &Rules) -> (usize, f64, f64) {+    const BESIDE: f64 = 1.5 * NM;+    const STEP: f64 = 0.2 * NM;+    let mut bare = board.clone();+    bare.tracks.clear();+    bare.vias.clear();+    let mut r = rules.clone();+    r.bind(&bare);+    let p = crate::router::make_plan(&bare, &r);+    let w = crate::router::build_world(&bare, &r);+    let bp = plan(&bare, &w, &r, &p);+    let net_of = |a: usize| board.pads[a].net;+    let (mut lines, mut beside, mut total) = (0usize, 0.0, 0.0);+    for ((a, _), m) in &bp.members {+        let mine = net_of(*a);+        // Any other line of the same bus counts: the order he routes them in is his, not the plan's.+        let others: Vec<NetId> = bp.members.iter().filter(|((x, _), o)| o.group == m.group && net_of(*x) != mine).map(|((x, _), _)| net_of(*x)).collect();+        let segs_of = |n: NetId| board.tracks.iter().filter(move |t| t.net == n);+        let theirs: Vec<&Track> = board.tracks.iter().filter(|t| others.contains(&t.net)).collect();+        lines += 1;+        for s in segs_of(mine) {+            let (sa, sb): (V, V) = (s.a.into(), s.b.into());+            let len = hypot(sub(sa, sb));+            if len < 1.0 {+                continue;+            }+            let d = dir_of(s.a, s.b);+            let k = (len / STEP).ceil().max(1.0) as usize;+            for i in 0..k {+                let t = (i as f64 + 0.5) / k as f64;+                let pt = V(sa.0 + (sb.0 - sa.0) * t, sa.1 + (sb.1 - sa.1) * t);+                total += len / k as f64;+                let near = theirs.iter().any(|o| {+                    o.layer == s.layer && pt_seg(pt, o.a.into(), o.b.into()) <= BESIDE && match (d, dir_of(o.a, o.b)) {+                        (Some(x), Some(y)) => x % 4 == y % 4,+                        _ => false,+                    }+                });+                if near {+                    beside += len / k as f64;+                }+            }+        }+    }+    (lines, if total > 0.0 { beside / total } else { 0.0 }, total / NM)+}++/// How close a GND via counts as close by. His benchmark C has one within this of 48 of its 61 signal vias.+const RETURN_REACH: f64 = 1.5 * NM;++impl<'a> Router<'a> {+    /// "Any signal via benefits from a GND via close by, when possible" (4.4): once every route is+    /// done, so nothing moved for it (lowest priority, like stitching), a GND via next to each signal+    /// via that lacks one, wherever one fits. It reaches the plane by itself.+    pub(crate) fn return_vias(&mut self) {+        let planes = self.board.plane_nets();+        let Some(&gnd) = planes.keys().find(|&&n| looks_ground(self.board.net_name(n))) else { return };+        let Some(pad) = self.board.pads.iter().position(|p| p.net == gnd && !p.layers.is_empty()) else { return };+        let plane_at = |p: V, world: &World| world.zones.iter().any(|(n, _, poly)| *n == gnd && in_poly(p, poly));+        let task = Task { net: gnd, level: Level::PlaneFanout, a: pad, b: pad, main: false, zone: None };+        // A through pin on the plane is a return path as good as a via.+        let mut returns: Vec<V> = self.board.pads.iter().filter(|p| p.net == gnd && p.drill.is_some() && !p.npth).map(|p| p.center.into()).collect();+        let mut gnd_vias: Vec<V> = self.board.vias.iter().filter(|v| v.net == gnd).map(|v| v.at.into()).collect();+        let mut signal: Vec<(u32, P)> = Vec::new();+        for r in self.routes.values() {+            if r.task.net == gnd {+                gnd_vias.extend(r.vias.iter().map(|&v| V::from(v)));+            } else if !matches!(r.task.level, Level::Power) {+                signal.extend(r.vias.iter().map(|&v| (r.id, v)));+            }+        }+        signal.sort();+        returns.extend(gnd_vias.iter().copied());+        let close = |set: &[V], v: P| set.iter().any(|g| hypot(sub(*g, v.into())) <= RETURN_REACH);+        let total = signal.len();+        let before = signal.iter().filter(|(_, v)| close(&gnd_vias, *v)).count();+        let vr = self.rules.via as f64 / 2.0;+        let mut added = 0;+        let mut boxed = 0;+        for (_, v) in &signal {+            if close(&returns, *v) {+                continue;+            }+            let c: V = (*v).into();+            let profile = Profile { width: 0, neck: 0, clearance: self.rules.clearance_for(gnd, gnd), target_gap: 0, max_vias: 0, margin: 0.0, layer_bias: None };+            let q = Query { net: gnd, also: None, sources: &[], targets: &[], profile, rules: &self.rules, soft: None, via_in: None, history: None, free: &[], arrive: None };+            let mut site = None;+            let mut radius = 2.0 * vr + self.rules.hole_hole as f64;+            'look: while radius <= RETURN_REACH {+                for k in 0..16 {+                    let a = k as f64 / 16.0 * std::f64::consts::TAU;+                    let at = crate::search::snap(to_p(V(c.0 + radius * a.cos(), c.1 + radius * a.sin())));+                    let (mut b, mut sc) = (Vec::new(), 0.0);+                    if plane_at(at.into(), &self.world) && self.world.via_ok(at, &q, None, &mut b, &mut sc) {+                        site = Some(at);+                        break 'look;+                    }+                }+                radius += 0.05 * NM;+            }+            let Some(at) = site else {+                boxed += 1;+                continue;+            };+            let id = self.fresh_id();+            self.place(id, task.clone(), Vec::new(), vec![at]);+            returns.push(at.into());+            gnd_vias.push(at.into());+            added += 1;+        }+        let after = signal.iter().filter(|(_, v)| close(&gnd_vias, *v)).count();+        self.log.push(format!("return vias: {after} of {total} signal vias have a GND via within {:.1} mm ({before} before; {added} added, {boxed} with no room)", RETURN_REACH / NM));+    }+}++#[cfg(test)]+mod tests {+    use super::*;++    /// His benchmark B: 26 lines from the module to the contact row. The lines that keep their order run+    /// together; the bottom row, which is reversed against the contacts, goes on the other layer, as+    /// he routed it.+    #[test]+    fn benchmark_b_splits_its_bus_the_way_the_designer_did() {+        let path = format!("{}/bench/boards/benchb_v210.ref.kicad_pcb", env!("CARGO_MANIFEST_DIR"));+        if !std::path::Path::new(&path).exists() {+            eprintln!("skipped: {path} is not here (the reference boards do not ship with the source)");+            return;+        }+        let mut b = Board::read(&path).unwrap();+        b.tracks.clear();+        b.vias.clear();+        let mut r = Rules::default();+        crate::project::apply(&path, &mut r);+        let p = crate::router::make_plan(&b, &r);+        let w = crate::router::build_world(&b, &r);+        let bus = plan(&b, &w, &r, &p);+        let layer_of = |net: &str| {+            let id = b.net_ids[net];+            let t = p.tasks.iter().find(|t| t.net == id).unwrap();+            bus.members[&(t.a, t.b)].layer+        };+        for n in ["/USER_IO.13", "/USER_IO.16", "/USER_IO.22", "/USER_IO.27"] {+            assert_eq!(layer_of(n), 0, "{n} should be with the bus on F.Cu");+        }+        // Everything with its pins in the reversed order is not on the bus's layer, bar the one it+        // can keep. Pairwise reversal means at most one stays.+        let top = ["/USER_IO.0", "/USER_IO.1", "/USER_IO.2", "/USER_IO.3", "/USER_IO.4", "/USER_IO.5"].iter().filter(|n| layer_of(n) == 0).count();+        assert!(top <= 1, "{top} of the reversed lines stayed on the top");+    }++    #[test]+    fn piprobe_finds_the_qspi_bus() {+        let path = format!("{}/bench/boards/piprobe_v13.ref.kicad_pcb", env!("CARGO_MANIFEST_DIR"));+        if !std::path::Path::new(&path).exists() {+            eprintln!("skipped: {path} is not here (the reference boards do not ship with the source)");+            return;+        }+        let mut b = Board::read(&path).unwrap();+        b.tracks.clear();+        b.vias.clear();+        let mut r = Rules::default();+        crate::project::apply(&path, &mut r);+        let p = crate::router::make_plan(&b, &r);+        let w = crate::router::build_world(&b, &r);+        let bus = plan(&b, &w, &r, &p);+        let qspi: Vec<_> = p.tasks.iter().filter(|t| b.net_name(t.net).starts_with("QSPI_") && bus.members.contains_key(&(t.a, t.b))).collect();+        assert!(qspi.len() >= 6, "{} QSPI lines in a bus", qspi.len());+        // SMD on one side: no line may be pushed to the other layer without a via, so none is held.+        assert!(qspi.iter().all(|t| bus.members[&(t.a, t.b)].layer == 0 || !bus.members[&(t.a, t.b)].free));+    }+}

@@ -0,0 +1,1182 @@+//! The standards checker. Reads any .kicad_pcb and reports what breaks the designer's routing rules, with+//! the place. It trusts nothing from the router: it reads the written file from scratch.++use crate::board::*;+use crate::classify::*;+use crate::conn;+use crate::geom::*;+use crate::index::*;+use crate::mask::MaskMap;+use crate::rules::Rules;+use crate::router::build_world;+use serde_json::{json, Value};+use std::collections::{BTreeMap, HashMap};++#[derive(Clone, Debug)]+pub struct Finding {+    pub rule: &'static str,+    /// error: breaks a hard rule. warn: a preference or something to read by eye.+    pub severity: &'static str,+    pub at: (f64, f64),+    pub text: String,+}++#[derive(Default, Debug)]+pub struct Score {+    pub nets_open: usize,+    pub pads_open: usize,+    pub length_mm: f64,+    pub length_top_mm: f64,+    pub length_bottom_mm: f64,+    pub length_inner_mm: f64,+    pub vias: usize,+    pub segments: usize,+    pub bends45: usize,+    pub bends90: usize,+    pub widths: BTreeMap<String, usize>,+    pub min_gap_mm: f64,+    pub tight_mm: f64,+    pub spacing: Spacing,+    pub pairs: Vec<PairStat>,+    /// Distance from each signal via to its nearest GND via, mm (4.4), sorted.+    pub signal_via_gnd_mm: Vec<f64>,+    /// Per net: what its route costs against how far apart its pads are.+    pub nets: Vec<NetStat>,+    pub width_steps: usize,+    pub rails: Vec<RailStat>,+    pub cap_first: CapFirst,+    pub entries: Entries,+    /// Each supply pin's own cap, pad edge to pad edge, farthest first.+    pub own_cap_mm: Vec<(f64, String)>,+}++/// Every track end on its own pad (4.2): how it comes in.+#[derive(Default, Debug)]+pub struct Entries {+    pub total: usize,+    pub centre: usize,+    pub corner: usize,+    pub side: usize,+    /// Not square to the edge it crosses.+    pub oblique: usize,+}++/// How each supply pin of an IC reaches its net (4.2), walked on the copper.+#[derive(Default, Debug)]+pub struct CapFirst {+    pub pins: usize,+    /// Its own pad shares copper with the cap's.+    pub direct: usize,+    /// A track or via path with nothing on the way.+    pub cap: usize,+    /// It reaches a fill first, which is the rail: v1.3's rings.+    pub on_fill: usize,+    pub junction: usize,+}++#[derive(Default, Debug)]+pub struct NetStat {+    pub name: String,+    pub level: &'static str,+    pub pads: usize,+    pub len_mm: f64,+    /// Straight-line length of the shortest tree over its pads.+    pub tree_mm: f64,+    pub vias: usize,+    pub width_steps: usize,+    pub fill: bool,+}++/// One power net's record (4.2: main run and branches, found from the copper actually connected).+#[derive(Default, Debug)]+pub struct RailStat {+    pub name: String,+    pub main_width_mm: f64,+    pub main_len_mm: f64,+    pub fed_by_fill: bool,+    /// Narrower widths and how much of each, the branch analysis he asked for.+    pub branches: Vec<(f64, f64)>,+}++/// Track length by spacing to the nearest other-net copper (4.2). 3W is centre to centre, a gap of 2W.+/// Length inside a fine-pitch escape is counted apart, since spacing may tighten there.+#[derive(Default, Debug)]+pub struct Spacing {+    pub at_3w_mm: f64,+    pub at_2w_mm: f64,+    pub under_2w_mm: f64,+    pub escape_mm: f64,+}++#[derive(Default, Debug)]+pub struct PairStat {+    pub p: String,+    pub n: String,+    pub len_p_mm: f64,+    pub len_n_mm: f64,+    /// Length of P with N running parallel on the same layer at the gap, mm.+    pub coupled_mm: f64,+    pub gap_mm: f64,+    pub vias: usize,+}++/// A clearance is broken when it is short by more than this. KiCad flagged 0.1991 against 0.2 mm+/// on the benchmark C, so the tolerance has to sit below 0.9 microns.+const TOL: f64 = 500.0;++/// Segments this short (nm) are a width step or a stray join, not a direction change: the benchmark C has+/// 4 micron jogs where one width meets another. Same length the off-45 check ignores.+const JOG: f64 = 20_000.0;++/// Rules a finished board must pass on geometry alone: `grade` holds the designer's boards to these.+pub const GEOMETRY_RULES: &[&str] = &[+    "clearance", "hole-clearance", "hole-to-hole", "keepout", "edge", "width", "width-setup", "via-min", "off-45", "corner-90", "corner-acute", "square-t", "crystal-chain", "via-in-pad", "mask-bridge", "mask-web", "xtal-series-line", "xtal-load-cap-line", "decoupling-pin", "inner-tie-no-fill", "inner-route", "fold-back", "same-net-parallel", "cap-first", "fill-unfed", "rail-floor", "kelvin",+];++fn key(p: P) -> P {+    // Endpoints that meet to within 2 microns are one node.+    ((p.0 + 1000).div_euclid(2000), (p.1 + 1000).div_euclid(2000))+}++/// Angle in degrees of a segment's direction out of a node.+fn out_angle(from: P, to: P) -> f64 {+    ((to.1 - from.1) as f64).atan2((to.0 - from.0) as f64).to_degrees()+}++fn diff(a: f64, b: f64) -> f64 {+    let d = (a - b).rem_euclid(360.0);+    d.min(360.0 - d)+}++fn pad_at(board: &Board, p: P, layer: usize, net: NetId) -> Option<usize> {+    let v: V = p.into();+    board.pads.iter().position(|q| q.net == net && q.layers.contains(&layer) && q.shape.dist_pt(v) <= 1.0)+}++/// A package's heat pad: thermal vias belong in it (4.4). Measured on the copper, since a custom+/// pad's anchor can be tiny (U5.10 on the benchmark C: anchor 0.38 mm, pad 2.4 mm).+fn is_exposed(board: &Board, i: usize) -> bool {+    let p = &board.pads[i];+    let b = p.shape.bbox();+    board.footprints[p.fp].pads.len() > 4 && b.2 - b.0 >= 1.0 * NM && b.3 - b.1 >= 1.0 * NM+}++/// Pads against pads: KiCad's DRC holds them to the clearance too, inside a footprint as well, and+/// a pad's copper and hole to the board edge and to other holes.+fn pad_pad_rules(board: &Board, rules: &Rules, world: &crate::search::World, f: &mut Vec<Finding>) {+    let reach = rules.max_clearance() as f64;+    let mm_at = |p: P| (to_mm(p.0), to_mm(p.1));+    for (i, p) in board.pads.iter().enumerate() {+        let b = p.shape.bbox();+        let bb = (b.0 - reach, b.1 - reach, b.2 + reach, b.3 + reach);+        let mut worst: Option<(f64, f64, usize)> = None;+        for &l in &p.layers {+            world.layers[l].visit(bb, |o| {+                let Owner::Pad(j) = o.owner else { return true };+                let j = j as usize;+                if j <= i || (o.net == p.net && p.net != NO_NET) {+                    return true;+                }+                let clr = rules.clearance_for(p.net, o.net) as f64;+                let d = p.shape.dist_shape(&o.shape);+                if d < clr - TOL && worst.map(|w| d - clr < w.0 - w.1).unwrap_or(true) {+                    worst = Some((d, clr, j));+                }+                true+            });+        }+        if let Some((d, clr, j)) = worst {+            f.push(Finding { rule: "clearance", severity: "error", at: mm_at(p.center), text: format!("pad {} is {:.3} mm from pad {} (minimum {:.3})", board.pad_name(i), d.max(0.0) / NM, board.pad_name(j), clr / NM) });+        }+        // Holes of two footprints; holes inside one footprint are its drawing, not the layout's.+        if let Some(dr) = p.drill {+            let (c, r): (V, f64) = (p.center.into(), dr / 2.0);+            let hh = rules.hole_to_hole() as f64;+            let span = r + hh + 1.0 * NM;+            world.holes.visit((c.0 - span, c.1 - span, c.0 + span, c.1 + span), |o| {+                let Owner::Pad(j) = o.owner else { return true };+                let j = j as usize;+                if j <= i || board.pads[j].fp == p.fp {+                    return true;+                }+                let d = o.shape.dist_pt(c) - r;+                if d < hh - TOL {+                    f.push(Finding { rule: "hole-to-hole", severity: rules.severity("hole_to_hole"), at: mm_at(p.center), text: format!("hole of pad {} is {:.3} mm from the hole of pad {} (minimum {:.3})", board.pad_name(i), d.max(0.0) / NM, board.pad_name(j), hh / NM) });+                }+                true+            });+        }+    }+}++/// An entry shallower than this to the pad's edge is the acute one 4.2 warns about. An octilinear+/// track reaches a square-on pad at 90 or 45, so this needs a rotated pad or an off-45 track.+const ACUTE_ENTRY: f64 = 44.0;++/// The angle in degrees between a track and the pad edge it crosses coming in from `o`, or None for+/// a round pad, whose edge has no direction to be acute to.+fn entry_angle(p: &Pad, o: V, e: V) -> Option<f64> {+    if matches!(p.shape, Shape::Circle { .. } | Shape::Multi(_)) {+        return None;+    }+    let c = p.shape.center();+    let (ox, oy) = rot(o.0 - c.0, o.1 - c.1, -p.angle);+    let (ex, ey) = rot(e.0 - c.0, e.1 - c.1, -p.angle);+    let (hw, hh) = (p.size.0 / 2.0, p.size.1 / 2.0);+    let (dx, dy) = (ex - ox, ey - oy);+    let l = (dx * dx + dy * dy).sqrt().max(1.0);+    // The track comes in across whichever side it is latest to pass, slab by slab.+    let tx = if dx.abs() > 1e-9 { ((if dx > 0.0 { -hw } else { hw }) - ox) / dx } else { f64::NEG_INFINITY };+    let ty = if dy.abs() > 1e-9 { ((if dy > 0.0 { -hh } else { hh }) - oy) / dy } else { f64::NEG_INFINITY };+    let normal = if tx >= ty { dx } else { dy };+    Some((normal.abs() / l).asin().to_degrees())+}++/// Pad entry (4.2): at the pad's centre or a corner, with no acute angle. Pairs may enter at the+/// side to keep their spacing, and a large pad or a rail width has no entry to speak of.+fn pad_entry_rules(board: &Board, rules: &Rules, f: &mut Vec<Finding>, s: &mut Score) {+    let pair_nets: std::collections::HashSet<&str> = rules.pairs.iter().flat_map(|p| [p.p.as_str(), p.n.as_str()]).collect();+    for t in &board.tracks {+        if pair_nets.contains(board.net_name(t.net)) || hypot(sub(t.a.into(), t.b.into())) <= JOG {+            continue;+        }+        for (e, o) in [(t.a, t.b), (t.b, t.a)] {+            let (ev, ov): (V, V) = (e.into(), o.into());+            let Some(i) = board.pads.iter().position(|q| q.net == t.net && q.layers.contains(&t.layer) && q.shape.dist_pt(ev) <= 1.0) else { continue };+            let p = &board.pads[i];+            if p.shape.dist_pt(ov) <= 1.0 {+                continue;+            }+            let half = t.width as f64 / 2.0;+            // Wider than the pad's short side: the track covers the whole entry.+            let (hw, hh) = (p.size.0 / 2.0, p.size.1 / 2.0);+            if t.width as f64 >= 2.0 * hw.min(hh) || matches!(p.shape, Shape::Multi(_)) {+                continue;+            }+            let c = p.shape.center();+            let dir = sub(ev, ov);+            let len = hypot(dir).max(1.0);+            let off = (dir.0 * (c.1 - ov.1) - dir.1 * (c.0 - ov.0)).abs() / len;+            let tol = half.max(0.02 * NM);+            s.entries.total += 1;+            let incidence = entry_angle(p, ov, ev);+            if let Some(a) = incidence {+                if a < 88.0 {+                    s.entries.oblique += 1;+                }+                if a < ACUTE_ENTRY {+                    f.push(Finding { rule: "pad-entry-acute", severity: "warn", at: (ev.0 / NM, ev.1 / NM), text: format!("{}: enters pad {} at {:.0} degrees to its edge (4.2: no acute angles)", board.net_name(t.net), board.pad_name(i), a) });+                }+            }+            if off <= tol {+                s.entries.centre += 1;+                continue;+            }+            let corners = [(-hw, -hh), (hw, -hh), (hw, hh), (-hw, hh)];+            let at_corner = corners.iter().any(|&(x, y)| {+                let (rx, ry) = rot(x, y, p.angle);+                pt_seg(V(c.0 + rx, c.1 + ry), ov, V(ev.0 + dir.0 / len * 0.3 * NM, ev.1 + dir.1 / len * 0.3 * NM)) <= tol+            });+            if at_corner {+                s.entries.corner += 1;+                continue;+            }+            s.entries.side += 1;+            f.push(Finding { rule: "pad-entry", severity: "warn", at: (ev.0 / NM, ev.1 / NM), text: format!("{}: enters pad {} {:.3} mm off its centre and away from its corners (4.2)", board.net_name(t.net), board.pad_name(i), off / NM) });+        }+    }+}++/// More of a board's pad entries oblique to the pad's edge than this: the reference boards' worst is 17 of 110+/// (v1.3). Our routes on the same boards ran 30%, 21% and 10% where he has 15%, 6% and 6%.+const OBLIQUE_RATE: f64 = 0.16;++/// Vias (4.4). A pad's own via sits just clear of the pad, about 0.1 mm. A signal via benefits from+/// a GND via close by: his document gives no number, so the distances are recorded, not gated.+fn via_rules(board: &Board, rules: &Rules, infos: &[NetInfo], f: &mut Vec<Finding>, s: &mut Score) {+    let gnd: Vec<V> = board.vias.iter().filter(|v| looks_ground(board.net_name(v.net))).map(|v| v.at.into()).collect();+    for v in &board.vias {+        let c: V = v.at.into();+        let r = v.size as f64 / 2.0;+        let name = board.net_name(v.net);+        for (i, p) in board.pads.iter().enumerate() {+            if p.net != v.net || p.layers.is_empty() || p.drill.is_some() {+                continue;+            }+            let d = p.shape.dist_pt(c);+            // The land overlaps the pad's edge while its centre stays out: neither in the pad nor+            // clear of it, and the hole can sit in the pad's mask opening.+            if d > 0.0 && d - r < rules.pad_via_gap as f64 / 2.0 && !is_exposed(board, i) {+                f.push(Finding { rule: "via-stand-off", severity: "warn", at: (c.0 / NM, c.1 / NM), text: format!("via on {name} is {:.3} mm from its pad {}; 4.4 puts it about {:.1} mm clear", (d - r) / NM, board.pad_name(i), rules.pad_via_gap as f64 / NM) });+            }+        }+        let level = infos.iter().find(|i| i.net == v.net).map(|i| i.level);+        if matches!(level, Some(Level::Pair) | Some(Level::Data) | Some(Level::Crystal) | Some(Level::Kelvin)) {+            let near = gnd.iter().map(|g| hypot(sub(*g, c))).fold(f64::INFINITY, f64::min);+            if near.is_finite() {+                s.signal_via_gnd_mm.push(near / NM);+            }+        }+    }+    s.signal_via_gnd_mm.sort_by(|a, b| a.total_cmp(b));+    let _ = f;+}++/// Hops (4.2: don't hop to the bottom where the top works): a run off the component layer that+/// starts and ends at vias of one net and comes straight back, under 3 mm in all. A hop that long+/// or shorter crosses at most a track or two; a longer one is routing. Warning only.+fn hop_rule(board: &Board, f: &mut Vec<Finding>) {+    let top = 0usize;+    let mut by: HashMap<(NetId, usize), Vec<&Track>> = HashMap::new();+    for t in &board.tracks {+        if t.layer != top {+            by.entry((t.net, t.layer)).or_default().push(t);+        }+    }+    for ((net, layer), tracks) in by {+        // Group into connected runs.+        let n = tracks.len();+        let mut uf = conn::Uf::new(n);+        for i in 0..n {+            for j in i + 1..n {+                if key(tracks[i].a) == key(tracks[j].a) || key(tracks[i].a) == key(tracks[j].b) || key(tracks[i].b) == key(tracks[j].a) || key(tracks[i].b) == key(tracks[j].b) {+                    uf.union(i as u32, j as u32);+                }+            }+        }+        let mut runs: HashMap<u32, Vec<&Track>> = HashMap::new();+        for (i, t) in tracks.iter().enumerate() {+            runs.entry(uf.find(i as u32)).or_default().push(*t);+        }+        for run in runs.values() {+            let len: f64 = run.iter().map(|t| hypot(sub(t.a.into(), t.b.into()))).sum();+            let ends: Vec<P> = board.vias.iter().filter(|v| v.net == net && run.iter().any(|t| key(t.a) == key(v.at) || key(t.b) == key(v.at))).map(|v| v.at).collect();+            let touches_pad = run.iter().any(|t| board.pads.iter().any(|p| p.net == net && p.layers.contains(&layer) && p.shape.dist_seg(t.a.into(), t.b.into()) <= t.width as f64 / 2.0));+            if ends.len() == 2 && !touches_pad && len < 3.0 * NM {+                f.push(Finding { rule: "layer-hop", severity: "warn", at: (to_mm(ends[0].0), to_mm(ends[0].1)), text: format!("{}: hops to {} for {:.2} mm between two vias (4.2)", board.net_name(net), board.layers[layer].name, len / NM) });+            }+        }+    }+}++/// Kelvin nets a spec lists (4.2): one dedicated thin trace from the sense pad to its shunt pad, no+/// branch, about 0.25 mm wide, and no via on the ground-side tap. DRC can't see these.+fn kelvin_rules(board: &Board, rules: &Rules, f: &mut Vec<Finding>) {+    for name in &rules.kelvin {+        let Some(&net) = board.net_ids.get(name) else { continue };+        let pads: Vec<usize> = (0..board.pads.len()).filter(|&i| board.pads[i].net == net).collect();+        let tracks: Vec<&Track> = board.tracks.iter().filter(|t| t.net == net).collect();+        if tracks.is_empty() {+            continue;+        }+        // Each sense pad runs its own trace to the shunt pad (benchmark C +3V3_EXT_SENS: Vbus and Vin- each+        // have one, side by side), so several pads are fine; a junction out in the open is not.+        let mut count: HashMap<P, (usize, P)> = HashMap::new();+        for t in &tracks {+            for e in [t.a, t.b] {+                let c = count.entry(key(e)).or_insert((0, e));+                c.0 += 1;+            }+        }+        for (c, e) in count.values() {+            let v: V = (*e).into();+            let in_copper = board.pads.iter().any(|p| p.net == net && p.shape.dist_pt(v) <= 0.25 * NM);+            if *c >= 3 && !in_copper {+                f.push(Finding { rule: "kelvin", severity: "error", at: (to_mm(e.0), to_mm(e.1)), text: format!("{name}: a Kelvin tap has no branches (4.2)") });+            }+        }+        for t in &tracks {+            if !(mm(0.15)..=mm(0.3)).contains(&t.width) {+                f.push(Finding { rule: "kelvin", severity: "warn", at: (to_mm(t.a.0), to_mm(t.a.1)), text: format!("{name}: {:.3} mm wide; a Kelvin tap is a dedicated thin trace, about 0.25 mm", to_mm(t.width)) });+            }+        }+        // The ground-side tap: its shunt's other pad is a ground, or the name says return or GND.+        let grounded = looks_ground(name) || pads.iter().any(|&p| {+            let fp = &board.footprints[board.pads[p].fp];+            fp.pads.len() == 2 && fp.pads.iter().any(|&q| q != p && looks_ground(board.net_name(board.pads[q].net)))+        });+        if grounded {+            if let Some(v) = board.vias.iter().find(|v| v.net == net) {+                f.push(Finding { rule: "kelvin", severity: "error", at: (to_mm(v.at.0), to_mm(v.at.1)), text: format!("{name}: a via on the ground-side tap (4.2 forbids it)") });+            }+        }+    }+}++/// Differential pairs (4.2): how much of the length actually runs coupled, at what gap, with what+/// skew and how many vias. Recorded for every pair; a pair with almost none coupled gets a warning.+fn pair_stats(board: &Board, rules: &Rules, f: &mut Vec<Finding>, s: &mut Score) {+    for pr in &rules.pairs {+        let (Some(&p), Some(&n)) = (board.net_ids.get(&pr.p), board.net_ids.get(&pr.n)) else { continue };+        let (tp, tn): (Vec<&Track>, Vec<&Track>) = (board.tracks.iter().filter(|t| t.net == p).collect(), board.tracks.iter().filter(|t| t.net == n).collect());+        if tp.is_empty() || tn.is_empty() {+            continue;+        }+        let length = |v: &[&Track]| v.iter().map(|t| hypot(sub(t.a.into(), t.b.into()))).sum::<f64>();+        let mut st = PairStat { p: pr.p.clone(), n: pr.n.clone(), len_p_mm: length(&tp) / NM, len_n_mm: length(&tn) / NM, vias: board.vias.iter().filter(|v| v.net == p || v.net == n).count(), ..Default::default() };+        // Sample P every 50 microns: coupled where a parallel N segment on the layer lies at a gap+        // no more than twice the width of the pair's own, the far limit of edge coupling.+        let mut gaps: Vec<f64> = Vec::new();+        for t in &tp {+            let (a, b): (V, V) = (t.a.into(), t.b.into());+            let d = sub(b, a);+            let l = hypot(d);+            if l <= JOG {+                continue;+            }+            let steps = (l / 50_000.0).ceil() as usize;+            for i in 0..steps {+                let u = (i as f64 + 0.5) / steps as f64;+                let q = V(a.0 + d.0 * u, a.1 + d.1 * u);+                let mut best = f64::INFINITY;+                for o in &tn {+                    if o.layer != t.layer {+                        continue;+                    }+                    let e = sub(o.b.into(), o.a.into());+                    let cross = (e.0 * d.1 - e.1 * d.0).abs() / (hypot(e) * l).max(1.0);+                    if cross > 0.02 {+                        continue;+                    }+                    let g = pt_seg(q, o.a.into(), o.b.into()) - (t.width + o.width) as f64 / 2.0;+                    best = best.min(g);+                }+                if best < 2.0 * t.width as f64 {+                    st.coupled_mm += l / steps as f64 / NM;+                    gaps.push(best);+                }+            }+        }+        if !gaps.is_empty() {+            gaps.sort_by(|a, b| a.total_cmp(b));+            st.gap_mm = gaps[gaps.len() / 2] / NM;+        }+        let at = (to_mm(tp[0].a.0), to_mm(tp[0].a.1));+        if st.len_p_mm >= 1.0 && st.coupled_mm < 0.25 * st.len_p_mm {+            f.push(Finding { rule: "pair-coupling", severity: "warn", at, text: format!("{} / {}: {:.1} mm of {:.1} mm runs coupled (4.2)", pr.p, pr.n, st.coupled_mm, st.len_p_mm) });+        }+        s.pairs.push(st);+    }+}++/// 3W and 2W spacing (4.2), as length: a statistic, since the rule is a target with exceptions.+fn spacing_stats(board: &Board, rules: &Rules, world: &crate::search::World, s: &mut Score) {+    let step = 250_000.0;+    for t in &board.tracks {+        let (a, b): (V, V) = (t.a.into(), t.b.into());+        let d = sub(b, a);+        let l = hypot(d);+        if l <= JOG {+            continue;+        }+        let w = t.width as f64;+        let steps = (l / step).ceil() as usize;+        let piece = l / steps as f64 / NM;+        for i in 0..steps {+            let u = (i as f64 + 0.5) / steps as f64;+            let q = V(a.0 + d.0 * u, a.1 + d.1 * u);+            if world.escapes.iter().any(|e| q.0 >= e.0 && q.0 <= e.2 && q.1 >= e.1 && q.1 <= e.3) {+                s.spacing.escape_mm += piece;+                continue;+            }+            let reach = w / 2.0 + 2.0 * w;+            let mut near = f64::INFINITY;+            world.layers[t.layer].visit((q.0 - reach, q.1 - reach, q.0 + reach, q.1 + reach), |o| {+                if o.net != t.net && !matches!(o.owner, Owner::Zone(_)) {+                    near = near.min(o.shape.dist_pt(q) - w / 2.0);+                }+                true+            });+            // 3W and 2W are centre to centre: 3W leaves a gap of 2W, 2W a gap of 1W (4.2).+            if near >= 2.0 * w - 1000.0 {+                s.spacing.at_3w_mm += piece;+            } else if near >= w - 1000.0 {+                s.spacing.at_2w_mm += piece;+            } else {+                s.spacing.under_2w_mm += piece;+            }+        }+    }+}++/// Solder mask bridges and webs (see mask.rs for what was measured).+fn mask_rules(board: &Board, rules: &Rules, f: &mut Vec<Finding>) {+    let map = MaskMap::new(board, rules);+    let sev = rules.severity("solder_mask_bridge");+    let mm_at = |p: P| (to_mm(p.0), to_mm(p.1));+    let side = |l: usize| &board.layers[l].name;+    for t in &board.tracks {+        if let Some((i, d)) = map.seg_hit(t.net, t.layer, t.a.into(), t.b.into(), t.width as f64 / 2.0) {+            f.push(Finding { rule: "mask-bridge", severity: sev, at: mm_at(t.a), text: format!("{} on {} is {:.3} mm from pad {} ({}): it bridges that pad's mask opening", board.net_name(t.net), side(t.layer), d / NM, board.pad_name(i), board.net_name(board.pads[i].net)) });+        }+    }+    for v in &board.vias {+        if let Some((i, d)) = map.via_hit(v.net, v.at.into(), v.size as f64 / 2.0) {+            f.push(Finding { rule: "mask-bridge", severity: sev, at: mm_at(v.at), text: format!("via on {} is {:.3} mm from pad {} ({}): it bridges that pad's mask opening", board.net_name(v.net), d / NM, board.pad_name(i), board.net_name(board.pads[i].net)) });+        }+    }+    for td in &board.teardrops {+        if let Some((i, d)) = map.poly_hit(td.net, td.layer, &td.pts) {+            let at = td.pts.first().map(|p| (p.0 / NM, p.1 / NM)).unwrap_or((0.0, 0.0));+            f.push(Finding { rule: "mask-bridge", severity: sev, at, text: format!("teardrop on {} is {:.3} mm from pad {} ({}): it bridges that pad's mask opening", board.net_name(td.net), d / NM, board.pad_name(i), board.net_name(board.pads[i].net)) });+        }+    }+    // Pads of two footprints: copper in an opening, and the web between two openings.+    let web = board.mask.web;+    let extra = rules.min.mask_to_copper as f64;+    for (i, p) in board.pads.iter().enumerate() {+        for (j, q) in board.pads.iter().enumerate().skip(i + 1) {+            if p.net == q.net && p.net != NO_NET {+                continue;+            }+            if p.fp == q.fp && board.mask.allow_bridges_in_footprints {+                continue;+            }+            let front = p.mask.0 && q.mask.0;+            let back = p.mask.1 && q.mask.1;+            if !(front || back) {+                continue;+            }+            let (pb, qb) = (p.shape.bbox(), q.shape.bbox());+            let m = p.mask_margin.max(0.0) + q.mask_margin.max(0.0) + web.max(extra);+            if pb.0 > qb.2 + m || qb.0 > pb.2 + m || pb.1 > qb.3 + m || qb.1 > pb.3 + m {+                continue;+            }+            let d = p.shape.dist_shape(&q.shape);+            let limit = p.mask_margin + q.mask_margin + web;+            if d < limit - TOL {+                f.push(Finding { rule: "mask-web", severity: rules.severity("solder_mask_bridge"), at: mm_at(p.center), text: format!("mask openings of pads {} and {} leave a web of {:.3} mm (minimum {:.3})", board.pad_name(i), board.pad_name(j), (d - p.mask_margin - q.mask_margin) / NM, web / NM) });+            }+        }+    }+}++pub fn check(board: &Board, rules: &Rules) -> (Vec<Finding>, Score) {+    let mut f: Vec<Finding> = Vec::new();+    let mut s = Score { min_gap_mm: f64::INFINITY, ..Default::default() };+    let mm_at = |p: P| (to_mm(p.0), to_mm(p.1));+    // Net ids belong to the parsed file, and a written board is parsed afresh.+    let mut bound = rules.clone();+    bound.bind(board);+    let rules = &bound;+    let world = build_world(board, rules);++    // Connections.+    let infos = classify(board, rules);+    let groups = conn::pad_groups(board, &[]);+    let planes = board.plane_nets();+    for info in &infos {+        let Some(g) = groups.get(&info.net) else { continue };+        let live: Vec<&Vec<usize>> = g.iter().filter(|grp| grp.iter().any(|p| info.pads.contains(p))).collect();+        if live.len() > 1 {+            s.nets_open += 1;+            s.pads_open += live.len() - 1;+            let names: Vec<String> = live.iter().map(|grp| board.pad_name(grp[0])).collect();+            let at = board.pads[live[1][0]].center;+            f.push(Finding { rule: "unconnected", severity: "error", at: mm_at(at), text: format!("{}: {} separate islands, e.g. {}", board.net_name(info.net), live.len(), names.join(", ")) });+        }+    }++    // 4.2: every track against the current through it, found from the connected copper.+    for (name, rail) in &rules.rails {+        let Some(net) = board.net_ids.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| *v) else { continue };+        if std::env::var_os("ADOM_ROUTE_DROPS").is_some() {+            for d in crate::current::rail_drops(board, rules, net, rail) {+                eprintln!("  drop {} to {}: {:.3} A, {:.1} mV, {:.2}% of {:.1} V (limit {:.1} mV)", board.net_name(net), d.load, d.amps, d.volts * 1000.0, d.volts / (d.limit / crate::current::DROP_LIMIT) * 100.0, d.limit / crate::current::DROP_LIMIT, d.limit * 1000.0);+            }+        }+        let mut short: std::collections::BTreeMap<(i64, bool), (f64, f64, i64, P)> = Default::default();+        for x in crate::current::rate_rail(board, rules, net, rail) {+            let t = &board.tracks[x.track];+            if t.width + 1000 < x.need {+                let e = short.entry((t.width, x.by_drop)).or_insert((0.0, 0.0, 0, t.a));+                e.0 += hypot(sub(t.a.into(), t.b.into())) / NM;+                if x.amps > e.1 || x.need > e.2 {+                    e.1 = x.amps.max(e.1);+                    e.2 = x.need.max(e.2);+                    e.3 = t.a;+                }+            }+        }+        for ((width, by_drop), (len, amps, need, at)) in short {+            let why = if by_drop { format!("which needs {:.2} mm to keep the copper's drop to its load under {:.2}% of the rail (the designer's limit)", to_mm(need), crate::current::DROP_LIMIT * 100.0) } else { format!("which needs {:.2} mm (4.2)", to_mm(need)) };+            f.push(Finding { rule: "rail-current", severity: "error", at: mm_at(at), text: format!("{}: {:.1} mm at {:.2} mm carries up to {:.3} A, {why}", board.net_name(net), len, to_mm(width), amps) });+        }+    }++    // An exception stays in front of whoever reads the report until they have decided on it.+    for ((net, pad), min) in &rules.pad_exit {+        let p = &board.pads[*pad as usize];+        f.push(Finding { rule: "pad-rule", severity: "warn", at: mm_at(p.center), text: format!("{} may pass pad {} at {:.3} mm under a local .kicad_dru rule (its class asks {:.3}): review it", board.net_name(*net), board.pad_name(*pad as usize), to_mm(*min), to_mm(rules.clearance_for(*net, p.net))) });+    }+    // A pour is only as connected as its refill leaves it, whatever shape the file saved.+    for sp in crate::pour::splits(board, rules, &world) {+        let by = if sp.cutters.is_empty() { String::new() } else { format!(", cut by {}", sp.cutters.iter().map(|&n| board.net_name(n)).collect::<Vec<_>>().join(", ")) };+        s.nets_open += 1;+        s.pads_open += sp.extra;+        f.push(Finding { rule: "pour-split", severity: "error", at: (sp.at.0 / NM, sp.at.1 / NM), text: format!("{}: refilling its pour on {} leaves {} extra separate pieces{by}", board.net_name(sp.net), board.layers[sp.layer].name, sp.extra) });+    }++    // Copper clearance: tracks and vias against everything of another net, on each layer, by the+    // two nets' classes. Zones refill around tracks, so they are the DRC's job after refill, not+    // this check's. Holes and keep-outs have their own rules below, as KiCad has.+    let reach_clr = rules.max_clearance() as f64;+    let mut gap_note = |gap: f64, s: &mut Score| {+        if gap < s.min_gap_mm {+            s.min_gap_mm = gap;+        }+    };+    let hole_clr = rules.hole_clearance() as f64;+    let sev_hole = rules.severity("hole_clearance");+    let plane_layers = board.plane_layers();+    for t in board.tracks.iter() {+        let (a, b): (V, V) = (t.a.into(), t.b.into());+        let half = t.width as f64 / 2.0;+        let reach = half + reach_clr * 2.0;+        let bb = (a.0.min(b.0) - reach, a.1.min(b.1) - reach, a.0.max(b.0) + reach, a.1.max(b.1) + reach);+        let mut worst: Option<(f64, f64, String)> = None;+        world.layers[t.layer].visit(bb, |o| {+            if o.net == t.net && t.net != NO_NET {+                return true;+            }+            match o.owner {+                Owner::Zone(_) => return true,+                Owner::Keepout => {+                    // A keep-out area has no clearance of its own. A hole is the hole rule's job.+                    if matches!(o.shape, Shape::Poly { .. }) && o.shape.dist_seg(a, b) <= 0.0 {+                        f.push(Finding { rule: "keepout", severity: rules.severity("items_not_allowed"), at: mm_at(t.a), text: format!("{} on {} enters a keep-out area", board.net_name(t.net), board.layers[t.layer].name) });+                    }+                    return true;+                }+                _ => {}+            }+            let local = if let Owner::Pad(i) = o.owner { world.pad_clearance[i as usize] } else { 0.0 };+            let pad = if let Owner::Pad(i) = o.owner { Some(i) } else { None };+            let clr = (rules.clearance_at(t.net, o.net, pad) as f64).max(local);+            let d = o.shape.dist_seg(a, b) - half;+            if d < clr * 2.0 {+                gap_note(d.max(0.0) / NM, &mut s);+            }+            if d < clr - TOL && worst.as_ref().map(|w| d - clr < w.0 - w.1).unwrap_or(true) {+                let who = match o.owner {+                    Owner::Pad(i) => format!("pad {}", board.pad_name(i as usize)),+                    _ => board.net_name(o.net).to_string(),+                };+                worst = Some((d, clr, who));+            }+            true+        });+        if let Some((d, clr, who)) = worst {+            f.push(Finding { rule: "clearance", severity: "error", at: mm_at(t.a), text: format!("{} on {} is {:.3} mm from {} (minimum {:.3})", board.net_name(t.net), board.layers[t.layer].name, d.max(0.0) / NM, who, clr / NM) });+        }+        // Copper to a hole of another net: every layer sees every through hole.+        let hr = half + hole_clr + world.max_local + 1.0 * NM;+        world.holes.visit((a.0.min(b.0) - hr, a.1.min(b.1) - hr, a.0.max(b.0) + hr, a.1.max(b.1) + hr), |o| {+            if (o.net == t.net && t.net != NO_NET) || matches!(o.shape, Shape::Poly { .. }) {+                return true;+            }+            let d = o.shape.dist_seg(a, b) - half;+            let hole_local = if let Owner::Pad(i) = o.owner { world.pad_clearance[i as usize] } else { 0.0 };+            if d < hole_clr.max(hole_local) - TOL {+                f.push(Finding { rule: "hole-clearance", severity: sev_hole, at: mm_at(t.a), text: format!("{} on {} is {:.3} mm from a hole (minimum {:.3})", board.net_name(t.net), board.layers[t.layer].name, d.max(0.0) / NM, hole_clr / NM) });+                return false;+            }+            true+        });+        let e = half + rules.edge as f64;+        let mut near = f64::INFINITY;+        world.edge.visit((a.0.min(b.0) - e, a.1.min(b.1) - e, a.0.max(b.0) + e, a.1.max(b.1) + e), |o| {+            near = near.min(o.shape.dist_seg(a, b));+            true+        });+        if near < e - TOL {+            f.push(Finding { rule: "edge", severity: rules.severity("copper_edge_clearance"), at: mm_at(t.a), text: format!("{}: track {:.3} mm from the board edge (minimum {:.3})", board.net_name(t.net), (near - half).max(0.0) / NM, rules.edge as f64 / NM) });+        }+        // Narrow copper: his 0.15 mm (2.2), and the board setup's own minimum, which KiCad enforces.+        if t.width < rules.neck - 1000 {+            f.push(Finding { rule: "width", severity: "error", at: mm_at(t.a), text: format!("{}: track {:.3} mm is under the {:.3} mm minimum", board.net_name(t.net), t.width as f64 / NM, rules.neck as f64 / NM) });+        }+        if rules.min.track > 0 && t.width < rules.min.track - 1000 {+            f.push(Finding { rule: "width-setup", severity: rules.severity("track_width"), at: mm_at(t.a), text: format!("{}: track {:.3} mm is under the board setup's {:.3} mm minimum (2.2: the setup should allow the 0.15 mm necks)", board.net_name(t.net), t.width as f64 / NM, rules.min.track as f64 / NM) });+        }+        *s.widths.entry(format!("{:.3}", t.width as f64 / NM)).or_insert(0) += 1;+        let len = hypot(sub(a, b));+        s.length_mm += len / NM;+        if t.layer == 0 {+            s.length_top_mm += len / NM;+        } else if t.layer == board.layers.len() - 1 {+            s.length_bottom_mm += len / NM;+        } else {+            s.length_inner_mm += len / NM;+            if plane_layers.contains(&t.layer) && t.width > 0 {+                f.push(Finding { rule: "inner-route", severity: "error", at: mm_at(t.a), text: format!("{}: track inside the plane layer {}; it cuts the return path (2.2, 4.2)", board.net_name(t.net), board.layers[t.layer].name) });+            }+        }+        s.segments += 1;+        // Direction: 0, 45 or 90 degrees only; anything else is an error (4.2).+        if len > JOG {+            let ang = out_angle(t.a, t.b).rem_euclid(45.0);+            let off = ang.min(45.0 - ang);+            if off > 0.5 {+                f.push(Finding { rule: "off-45", severity: "error", at: mm_at(t.a), text: format!("{}: segment {:.3} mm long is {:.1} degrees off the 45-degree directions", board.net_name(t.net), len / NM, off) });+            }+        }+    }+    let hole_hole = rules.hole_to_hole() as f64;+    let sev_hh = rules.severity("hole_to_hole");+    for (vi, v) in board.vias.iter().enumerate() {+        let c: V = v.at.into();+        let r = v.size as f64 / 2.0;+        let reach = r + reach_clr;+        let mut worst: Option<(f64, f64, String)> = None;+        let dbg = std::env::var("ADOM_ROUTE_DEBUG_VIA").ok().and_then(|s| { let mut it = s.split(',').filter_map(|x| x.parse::<f64>().ok()); Some((it.next()?, it.next()?)) }).map_or(false, |(x, y)| (to_mm(v.at.0) - x).abs() < 0.02 && (to_mm(v.at.1) - y).abs() < 0.02);+        for l in 0..board.layers.len() {+            world.layers[l].visit((c.0 - reach, c.1 - reach, c.0 + reach, c.1 + reach), |o| {+                if dbg {+                    eprintln!("debug via {} layer {}: obstacle net {} owner {:?} dist {:.4} mm", board.net_name(v.net), board.layers[l].name, board.net_name(o.net), o.owner, (o.shape.dist_pt(c) - r) / NM);+                }+                if (o.net == v.net && v.net != NO_NET) || matches!(o.owner, Owner::Zone(_) | Owner::Keepout) {+                    return true;+                }+                let local = if let Owner::Pad(i) = o.owner { world.pad_clearance[i as usize] } else { 0.0 };+                let pad = if let Owner::Pad(i) = o.owner { Some(i) } else { None };+                let clr = (rules.clearance_at(v.net, o.net, pad) as f64).max(local);+                let d = o.shape.dist_pt(c) - r;+                if d < clr - TOL && worst.as_ref().map(|w| d - clr < w.0 - w.1).unwrap_or(true) {+                    worst = Some((d, clr, format!("{} on {}", board.net_name(o.net), board.layers[l].name)));+                }+                true+            });+        }+        if let Some((d, clr, who)) = worst {+            f.push(Finding { rule: "clearance", severity: "error", at: mm_at(v.at), text: format!("via on {} is {:.3} mm from {} (minimum {:.3})", board.net_name(v.net), d.max(0.0) / NM, who, clr / NM) });+        }+        // The via's copper and its hole against every other hole. The hole-to-hole rule covers+        // any net (2.2); a same-net via pair is judged on holes only, as KiCad does (R11).+        let hd = v.drill as f64 / 2.0;+        let span = r + hole_clr.max(hole_hole) + 1.0 * NM;+        world.holes.visit((c.0 - span, c.1 - span, c.0 + span, c.1 + span), |o| {+            if let Shape::Poly { .. } = o.shape {+                if o.shape.dist_pt(c) <= 0.0 {+                    f.push(Finding { rule: "keepout", severity: rules.severity("items_not_allowed"), at: mm_at(v.at), text: format!("via on {} in a keep-out area", board.net_name(v.net)) });+                }+                return true;+            }+            let dc = o.shape.dist_pt(c);+            if dc <= 0.0 && matches!(o.owner, Owner::Fixed) && hypot(sub(o.shape.center(), c)) < 1.0 {+                return true; // its own hole+            }+            if o.net != v.net || v.net == NO_NET {+                if dc - r < hole_clr - TOL {+                    f.push(Finding { rule: "hole-clearance", severity: sev_hole, at: mm_at(v.at), text: format!("via on {} is {:.3} mm from a hole (minimum {:.3})", board.net_name(v.net), (dc - r).max(0.0) / NM, hole_clr / NM) });+                }+            }+            if dc - hd < hole_hole - TOL {+                f.push(Finding { rule: "hole-to-hole", severity: sev_hh, at: mm_at(v.at), text: format!("via hole on {} is {:.3} mm from another hole (minimum {:.3})", board.net_name(v.net), (dc - hd).max(0.0) / NM, hole_hole / NM) });+            }+            true+        });+        let e = r + rules.edge as f64;+        let mut near = f64::INFINITY;+        world.edge.visit((c.0 - e, c.1 - e, c.0 + e, c.1 + e), |o| {+            near = near.min(o.shape.dist_pt(c));+            true+        });+        if near < e - TOL {+            f.push(Finding { rule: "edge", severity: rules.severity("copper_edge_clearance"), at: mm_at(v.at), text: format!("{}: via {:.3} mm from the board edge (minimum {:.3})", board.net_name(v.net), (near - r).max(0.0) / NM, rules.edge as f64 / NM) });+        }+        // KiCad's own limits on a via, from the board setup.+        let annular = (v.size - v.drill) / 2;+        if v.size < rules.min.via_dia - 1000 || v.drill < rules.min.through_drill - 1000 || annular < rules.min.annular - 1000 {+            f.push(Finding { rule: "via-min", severity: "error", at: mm_at(v.at), text: format!("via {:.2}/{:.2} on {} is under the board setup's minimum", v.drill as f64 / NM, v.size as f64 / NM, board.net_name(v.net)) });+        }+        // 4.4: 0.3/0.6 is the only size; larger on a high-current net "when the current calculation+        // calls for it", so a current on record for that net in the spec, not just any 0.4/0.8.+        let standard = v.size == rules.via && v.drill == rules.drill;+        let earned = v.size > rules.via && rules.has_load(board.net_name(v.net));+        if !standard && !earned {+            f.push(Finding { rule: "via-size", severity: "warn", at: mm_at(v.at), text: format!("via {:.2}/{:.2} (drill/diameter) on {}: 0.3/0.6 is the only size unless one is specified, or a current on record for the net calls for more (4.4)", v.drill as f64 / NM, v.size as f64 / NM, board.net_name(v.net)) });+        }+        if !(v.tent.0 && v.tent.1) {+            f.push(Finding { rule: "via-tent", severity: "warn", at: mm_at(v.at), text: format!("via on {} is not tented on both sides (4.4)", board.net_name(v.net)) });+        }+        for (i, p) in board.pads.iter().enumerate() {+            if p.layers.is_empty() || p.drill.is_some() {+                continue;+            }+            // The rule is about solder paste: a pad with no paste layer (benchmark C U5.10, a ground bar+            // meant to carry vias) is free of it, and a heat pad takes thermal vias on purpose.+            if p.paste && p.shape.dist_pt(c) <= 0.0 && !is_exposed(board, i) {+                f.push(Finding { rule: "via-in-pad", severity: "error", at: mm_at(v.at), text: format!("via in pad {}: plan for capped vias or keep it off the paste (4.4)", board.pad_name(i)) });+            }+        }+        let _ = vi;+    }+    crate::placement::crystal_rules(board, &mut f);+    crate::placement::decoupling_rules(board, rules, &mut f, &mut s.own_cap_mm);+    s.own_cap_mm.sort_by(|a, b| b.0.total_cmp(&a.0));+    crate::placement::inner_fill_rule(board, rules, &mut f);+    pad_pad_rules(board, rules, &world, &mut f);+    mask_rules(board, rules, &mut f);+    pad_entry_rules(board, rules, &mut f, &mut s);+    if s.entries.total >= 20 && s.entries.oblique as f64 / s.entries.total as f64 > OBLIQUE_RATE {+        f.push(Finding { rule: "pad-entry-oblique", severity: "warn", at: (0.0, 0.0), text: format!("{} of {} pad entries come in at an angle to the pad's edge; the reference boards' worst is 15% (4.2: no acute angles, when possible)", s.entries.oblique, s.entries.total) });+    }+    via_rules(board, rules, &infos, &mut f, &mut s);+    hop_rule(board, &mut f);+    kelvin_rules(board, rules, &mut f);+    pair_stats(board, rules, &mut f, &mut s);+    spacing_stats(board, rules, &world, &mut s);+    let copper_nodes = crate::quality::Nodes::new(board);+    crate::quality::shape_rules(board, &copper_nodes, &mut f);+    crate::quality::net_rules(board, rules, &infos, &copper_nodes, &mut f, &mut s);+    crate::quality::island_rules(board, &mut f);+    s.vias = board.vias.len();++    let rail = rules.power_floor - 1000;+    // 4.2 allows one 90-degree shape: a stub off a large power rail. Width alone doesn't make a rail+    // (never judge current from a width), and two equal sides are a bend in the rail, not a stub.+    let powered = |net: NetId| looks_power(board.net_name(net)) || rules.wide.contains_key(board.net_name(net));+    // Shape: corners and junctions, per net and layer. A jog of a few microns where two widths meet+    // is one node, not two bends, so its ends are merged first.+    let mut link: HashMap<(NetId, usize, P), P> = HashMap::new();+    fn root(link: &HashMap<(NetId, usize, P), P>, net: NetId, layer: usize, mut k: P) -> P {+        while let Some(&n) = link.get(&(net, layer, k)) {+            k = n;+        }+        k+    }+    for t in &board.tracks {+        if hypot(sub(t.a.into(), t.b.into())) <= JOG {+            let (x, y) = (root(&link, t.net, t.layer, key(t.a)), root(&link, t.net, t.layer, key(t.b)));+            if x != y {+                link.insert((t.net, t.layer, x), y);+            }+        }+    }+    let rep = |net: NetId, layer: usize, p: P| root(&link, net, layer, key(p));+    let mut nodes: HashMap<(NetId, usize, P), Vec<usize>> = HashMap::new();+    for (i, t) in board.tracks.iter().enumerate() {+        if hypot(sub(t.a.into(), t.b.into())) <= JOG {+            continue;+        }+        nodes.entry((t.net, t.layer, rep(t.net, t.layer, t.a))).or_default().push(i);+        nodes.entry((t.net, t.layer, rep(t.net, t.layer, t.b))).or_default().push(i);+    }+    let far = |t: &Track, n: P| if rep(t.net, t.layer, t.a) == n { (t.a, t.b) } else { (t.b, t.a) };+    // Copper of the net's own that hides a corner: a pad (or the quarter millimetre the teardrop+    // covers), a via's land, or a same-net fill. No bend exists there.+    let hidden = |net: NetId, layer: usize, v: V| {+        board.pads.iter().any(|q| q.net == net && q.layers.contains(&layer) && q.shape.dist_pt(v) <= 0.25 * NM)+            || board.vias.iter().any(|w| w.net == net && hypot(sub(w.at.into(), v)) <= w.size as f64 / 2.0)+            || world.zones.iter().any(|(zn, zl, poly)| *zn == net && *zl == layer && in_poly(v, poly))+            // Inside a same-net rail wide enough to swallow the corner (benchmark C +3V3_EXT 218.00, 93.26:+            // a 0.2 mm stub landing square on the 0.5 mm run, the rail exception in 4.2).+            || powered(net) && board.tracks.iter().any(|o| o.net == net && o.layer == layer && o.width >= rail && key(o.a) != key(to_p(v)) && key(o.b) != key(to_p(v)) && pt_seg(v, o.a.into(), o.b.into()) <= o.width as f64 / 2.0)+    };+    for ((net, layer, n), list) in &nodes {+        let mut dirs: Vec<(f64, usize, i64)> = list+            .iter()+            .map(|&i| {+                let t = &board.tracks[i];+                let (a, b) = far(t, *n);+                (out_angle(a, b), i, t.width)+            })+            .collect();+        dirs.sort_by(|a, b| a.0.total_cmp(&b.0));+        let at_p = far(&board.tracks[list[0]], *n).0;+        let v: V = at_p.into();+        let in_pad = hidden(*net, *layer, v);+        if dirs.len() == 2 {+            let between = diff(dirs[0].0, dirs[1].0);+            let turn = 180.0 - between;+            if turn < 1.0 {+                continue;+            }+            if !in_pad {+                if (turn - 45.0).abs() < 3.0 {+                    s.bends45 += 1;+                } else if (turn - 90.0).abs() < 3.0 {+                    s.bends90 += 1;+                    let is_rail_stub = powered(*net) && dirs[0].2.max(dirs[1].2) >= rail && dirs[0].2 != dirs[1].2;+                    if !is_rail_stub {+                        f.push(Finding { rule: "corner-90", severity: "error", at: mm_at(at_p), text: format!("{}: 90-degree bend on {} (only a stub off a large power rail may)", board.net_name(*net), board.layers[*layer].name) });+                    }+                } else if between < 88.0 && between > 3.0 {+                    f.push(Finding { rule: "corner-acute", severity: "error", at: mm_at(at_p), text: format!("{}: acute corner of {:.0} degrees on {}", board.net_name(*net), between, board.layers[*layer].name) });+                }+            }+        } else if dirs.len() >= 3 && !in_pad {+            // A branch joins as a Y (45/135), never a square T (4.2).+            for a in 0..dirs.len() {+                for b in a + 1..dirs.len() {+                    if (diff(dirs[a].0, dirs[b].0) - 180.0).abs() < 2.0 {+                        for c in 0..dirs.len() {+                            if c != a && c != b && (diff(dirs[c].0, dirs[a].0) - 90.0).abs() < 3.0 && !(powered(*net) && dirs[a].2 >= rail && dirs[c].2 <= dirs[a].2) {+                                f.push(Finding { rule: "square-t", severity: "error", at: mm_at(at_p), text: format!("{}: square T on {}; signal branches join as a Y", board.net_name(*net), board.layers[*layer].name) });+                            }+                        }+                    }+                }+            }+            if infos.iter().any(|i| i.net == *net && i.level == Level::Crystal) {+                f.push(Finding { rule: "crystal-chain", severity: "error", at: mm_at(at_p), text: format!("{}: junction on a crystal line; XIN/XOUT run as a daisy chain (4.2)", board.net_name(*net)) });+            }+        }+    }++    // T junctions onto the middle of a track.+    for (i, t) in board.tracks.iter().enumerate() {+        for end in [t.a, t.b] {+            let e: V = end.into();+            if hypot(sub(t.a.into(), t.b.into())) <= JOG || hidden(t.net, t.layer, e) {+                continue;+            }+            for (j, o) in board.tracks.iter().enumerate() {+                if i == j || o.net != t.net || o.layer != t.layer {+                    continue;+                }+                let n = rep(t.net, t.layer, end);+                if rep(o.net, o.layer, o.a) == n || rep(o.net, o.layer, o.b) == n {+                    continue;+                }+                if pt_seg(e, o.a.into(), o.b.into()) > 2000.0 {+                    continue;+                }+                let (a1, a2) = (out_angle(end, if key(t.a) == key(end) { t.b } else { t.a }), out_angle(o.a, o.b));+                let d = diff(a1, a2);+                if (d - 90.0).abs() < 3.0 && !(powered(t.net) && o.width >= rail && t.width <= o.width) {+                    f.push(Finding { rule: "square-t", severity: "error", at: mm_at(end), text: format!("{}: square T onto a track on {}; signal branches join as a Y", board.net_name(t.net), board.layers[t.layer].name) });+                }+            }+        }+    }++    // A via inside a straight run (4.4: no via inside a trace).+    for v in &board.vias {+        for l in 0..board.layers.len() {+            let n = rep(v.net, l, v.at);+            if let Some(list) = nodes.get(&(v.net, l, n)) {+                if list.len() == 2 {+                    let (t1, t2) = (&board.tracks[list[0]], &board.tracks[list[1]]);+                    let (a1, b1) = far(t1, n);+                    let (a2, b2) = far(t2, n);+                    if (diff(out_angle(a1, b1), out_angle(a2, b2)) - 180.0).abs() < 2.0 {+                        f.push(Finding { rule: "via-in-trace", severity: "warn", at: mm_at(v.at), text: format!("{}: via inside a straight run on {}", board.net_name(v.net), board.layers[l].name) });+                    }+                }+            }+        }+    }++    // Plane nets: pads the plane doesn't reach get their own via (4.2). Sharing is reported.+    let _ = &planes;+    if !s.min_gap_mm.is_finite() {+        s.min_gap_mm = 0.0;+    }+    f.sort_by(|a, b| (a.severity != "error", a.rule).cmp(&(b.severity != "error", b.rule)));+    (f, s)+}++fn r2(x: f64) -> f64 {+    (x * 100.0).round() / 100.0+}++pub fn to_json(f: &[Finding], s: &Score) -> Value {+    let mut per: BTreeMap<&str, usize> = BTreeMap::new();+    for x in f {+        *per.entry(x.rule).or_insert(0) += 1;+    }+    json!({+        "errors": f.iter().filter(|x| x.severity == "error").count(),+        "warnings": f.iter().filter(|x| x.severity != "error").count(),+        "perRule": per,+        "score": {+            "netsOpen": s.nets_open, "padsOpen": s.pads_open,+            "lengthMm": (s.length_mm * 100.0).round() / 100.0,+            "topMm": (s.length_top_mm * 100.0).round() / 100.0,+            "bottomMm": (s.length_bottom_mm * 100.0).round() / 100.0,+            "innerMm": (s.length_inner_mm * 100.0).round() / 100.0,+            "vias": s.vias, "segments": s.segments, "bends45": s.bends45, "bends90": s.bends90,+            "widths": s.widths, "minGapMm": (s.min_gap_mm * 1000.0).round() / 1000.0,+            "spacingMm": {+                "at3W": r2(s.spacing.at_3w_mm), "at2W": r2(s.spacing.at_2w_mm), "tighter": r2(s.spacing.under_2w_mm), "inEscape": r2(s.spacing.escape_mm)+            },+            "pairs": s.pairs.iter().map(|p| json!({"p": p.p, "n": p.n, "lenP": r2(p.len_p_mm), "lenN": r2(p.len_n_mm), "coupled": r2(p.coupled_mm), "gapMm": (p.gap_mm * 1000.0).round() / 1000.0, "vias": p.vias})).collect::<Vec<_>>(),+            "signalViaGndMm": s.signal_via_gnd_mm.iter().map(|x| r2(*x)).collect::<Vec<_>>(),+            "widthSteps": s.width_steps,+            "ownCapMm": s.own_cap_mm.iter().take(5).map(|x| json!([r2(x.0), x.1])).collect::<Vec<_>>(),+            "padEntries": {"total": s.entries.total, "centre": s.entries.centre, "corner": s.entries.corner, "side": s.entries.side, "oblique": s.entries.oblique},+            "capFirst": {"pins": s.cap_first.pins, "direct": s.cap_first.direct, "cap": s.cap_first.cap, "onFill": s.cap_first.on_fill, "junction": s.cap_first.junction},+            "nets": s.nets.iter().map(|n| json!({"net": n.name, "level": n.level, "pads": n.pads, "lenMm": r2(n.len_mm), "treeMm": r2(n.tree_mm), "vias": n.vias, "widthSteps": n.width_steps, "fill": n.fill})).collect::<Vec<_>>(),+            "rails": s.rails.iter().map(|n| json!({"net": n.name, "mainWidthMm": n.main_width_mm, "mainLenMm": r2(n.main_len_mm), "fedByFill": n.fed_by_fill, "branches": n.branches})).collect::<Vec<_>>()+        },+        "findings": f.iter().map(|x| json!({"rule": x.rule, "severity": x.severity, "atMm": [x.at.0, x.at.1], "text": x.text})).collect::<Vec<_>>()+    })+}++#[cfg(test)]+mod tests {+    use super::*;+    use crate::project;++    fn board(extra: &str) -> Board {+        let head = r#"(kicad_pcb (layers (0 "F.Cu" signal) (2 "B.Cu" signal)) (setup (pad_to_mask_clearance 0.05))+            (gr_rect (start 0 0) (end 30 30) (layer "Edge.Cuts"))+            (footprint "x" (layer "F.Cu") (at 10 10) (property "Reference" "R1")+              (pad "1" smd rect (at 0 0) (size 1 1) (layers "F.Cu" "F.Mask") (net "A") (solder_mask_margin 0.102))+              (pad "2" smd rect (at 5 0) (size 1 1) (layers "F.Cu" "F.Mask") (net "B")))"#;+        Board::parse(format!("{head}{extra})")).unwrap()+    }++    fn track(y: f64, net: &str) -> String {+        format!(r#"(segment (start 8 {y}) (end 12 {y}) (width 0.2) (layer "F.Cu") (net "{net}"))"#)+    }++    fn rules(mask_to_copper: f64) -> Rules {+        let mut r = Rules::default();+        r.min.mask_to_copper = mm(mask_to_copper);+        r+    }++    fn count(f: &[Finding], rule: &str) -> usize {+        f.iter().filter(|x| x.rule == rule).count()+    }++    #[test]+    fn mask_bridge_is_margin_plus_mask_to_copper() {+        // Pad edge at y 10.5, so the track edge is y - 0.1 - 10.5 from the pad.+        let near = board(&track(10.771, "C")); // 0.171: under 0.102 + 0.1, as on the routed PiProbe+        let (f, _) = check(&near, &rules(0.1));+        assert_eq!(count(&f, "mask-bridge"), 1);+        let far = board(&track(10.82, "C")); // 0.22: clear of 0.202+        let (f, _) = check(&far, &rules(0.1));+        assert_eq!(count(&f, "mask-bridge"), 0);+        // With no mask-to-copper setting, as on the benchmark C, only the margin counts.+        let (f, _) = check(&near, &rules(0.0));+        assert_eq!(count(&f, "mask-bridge"), 0);+        // Same net never bridges.+        let own = board(&track(10.771, "A"));+        let (f, _) = check(&own, &rules(0.1));+        assert_eq!(count(&f, "mask-bridge"), 0);+    }++    #[test]+    fn pad_margin_falls_back_to_the_board() {+        let b = board("");+        assert_eq!(b.pads[0].mask_margin, 0.102 * NM);+        assert_eq!(b.pads[1].mask_margin, 0.05 * NM);+    }++    #[test]+    fn a_micro_jog_is_not_a_bend_and_a_real_one_is() {+        let jog = r#"(segment (start 2 5) (end 6 5) (width 0.2) (layer "F.Cu") (net "C"))+            (segment (start 6 5) (end 6 5.004) (width 0.2) (layer "F.Cu") (net "C"))+            (segment (start 6 5.004) (end 10 5.004) (width 0.2) (layer "F.Cu") (net "C"))"#;+        let (f, s) = check(&board(jog), &rules(0.0));+        assert_eq!(count(&f, "corner-90"), 0);+        assert_eq!(s.bends90, 0);+        let bend = r#"(segment (start 2 5) (end 6 5) (width 0.2) (layer "F.Cu") (net "C"))+            (segment (start 6 5) (end 6 8) (width 0.2) (layer "F.Cu") (net "C"))"#;+        let (f, _) = check(&board(bend), &rules(0.0));+        assert_eq!(count(&f, "corner-90"), 1);+    }++    #[test]+    fn overlapping_fills_join_a_net() {+        // Two pads each reached by their own zone; the zones overlap but neither's first vertex is+        // inside the other, which the old one-vertex test missed.+        let z = |x0: f64, x1: f64| format!(r#"(zone (net "A") (layer "F.Cu") (polygon (pts (xy {x0} 8) (xy {x1} 8) (xy {x1} 12) (xy {x0} 12))) (filled_polygon (layer "F.Cu") (pts (xy {x0} 8) (xy {x1} 8) (xy {x1} 12) (xy {x0} 12))))"#);+        let text = format!(r#"(footprint "y" (layer "F.Cu") (at 20 10) (property "Reference" "R2") (pad "1" smd rect (at 0 0) (size 1 1) (layers "F.Cu") (net "A"))){}{}"#, z(9.0, 15.0), z(14.0, 21.0));+        let b = board(&text);+        let groups = conn::pad_groups(&b, &[]);+        assert_eq!(groups[&b.net_ids["A"]].len(), 1);+    }++    #[test]+    fn hole_rules_fire() {+        let hole = r#"(footprint "h" (layer "F.Cu") (at 20 20) (property "Reference" "H1") (pad "" np_thru_hole circle (at 0 0) (size 1 1) (drill 1) (layers "*.Cu" "*.Mask")))"#;+        // Track edge 0.2 mm from a 0.5 mm radius hole, against 0.25 mm hole clearance.+        let text = format!(r#"{hole}(segment (start 18 20.8) (end 22 20.8) (width 0.2) (layer "F.Cu") (net "C"))"#);+        let (f, _) = check(&board(&text), &rules(0.0));+        assert_eq!(count(&f, "hole-clearance"), 1);+        // Two vias with 0.2 mm between their holes, against 0.25 mm hole to hole, same net.+        let vias = r#"(via (at 5 5) (size 0.6) (drill 0.3) (layers "F.Cu" "B.Cu") (net "C")) (via (at 5.5 5) (size 0.6) (drill 0.3) (layers "F.Cu" "B.Cu") (net "C"))"#;+        let (f, _) = check(&board(vias), &rules(0.0));+        assert!(count(&f, "hole-to-hole") >= 1);+        // A via 0.1 mm from the edge against 0.3 mm.+        let edge = r#"(via (at 0.4 5) (size 0.6) (drill 0.3) (layers "F.Cu" "B.Cu") (net "C"))"#;+        let (f, _) = check(&board(edge), &rules(0.0));+        assert_eq!(count(&f, "edge"), 1);+    }++    #[test]+    fn entry_angle_reads_the_edge_crossed() {+        let pad = |angle: f64| Pad { fp: 0, number: String::new(), net: 1, center: (0, 0), shape: Shape::Poly { pts: vec![V(-NM, -NM / 2.0), V(NM, -NM / 2.0), V(NM, NM / 2.0), V(-NM, NM / 2.0)], r: 0.0 }, layers: vec![0], drill: None, npth: false, size: (2.0 * NM, NM), angle, mask_margin: 0.0, mask: (true, false), paste: true, pintype: String::new(), pinfunction: String::new(), zone_connect: None, local_clearance: 0.0 };+        // Straight down onto a 2 x 1 pad: square to its long edge.+        let a = entry_angle(&pad(0.0), V(0.0, -3.0 * NM), V(0.0, 0.0)).unwrap();+        assert!((a - 90.0).abs() < 0.01);+        // In at 45 degrees.+        let a = entry_angle(&pad(0.0), V(3.0 * NM, -3.0 * NM), V(0.0, 0.0)).unwrap();+        assert!((a - 45.0).abs() < 0.01);+    }++    #[test]+    fn a_kelvin_branch_fails_and_a_clean_tap_does_not() {+        let mut r = rules(0.0);+        r.kelvin = vec!["K".to_string()];+        let clean = r#"(segment (start 2 5) (end 6 5) (width 0.25) (layer "F.Cu") (net "K"))"#;+        let (f, _) = check(&board(clean), &r);+        assert_eq!(count(&f, "kelvin"), 0);+        let branch = r#"(segment (start 2 5) (end 6 5) (width 0.25) (layer "F.Cu") (net "K"))+            (segment (start 6 5) (end 9 5) (width 0.25) (layer "F.Cu") (net "K"))+            (segment (start 6 5) (end 8 7) (width 0.25) (layer "F.Cu") (net "K"))"#;+        let (f, _) = check(&board(branch), &r);+        assert_eq!(count(&f, "kelvin"), 1);+    }++    #[test]+    fn the_chart_gives_his_example_and_margin_is_small_boards_only() {+        let w = crate::current::conservative_mm(3.0, 20.0, 35.0);+        assert!((w - 2.335).abs() < 0.01, "{w}");+        let mut r = Rules::default();+        r.small_board = false;+        assert_eq!(r.rail_width(3.0, true), mm(2.34));+        assert_eq!(r.rail_width(0.2, true), mm(0.06));+        r.small_board = true;+        assert_eq!(r.rail_width(3.0, true), mm(2.92));+        assert_eq!(r.rail_width(0.2, true), mm(0.40));+        assert_eq!(r.rail_width(0.2, false), mm(0.06));+    }++    #[test]+    fn pad_rule_survives_the_file_and_the_standing_minimum_holds() {+        let rule = crate::rules::PadRule { net: "+PS4_SENS".into(), reference: "U3".into(), pad: "11".into(), min: mm(0.225) };+        assert_eq!(crate::rules::PadRule::parse(&rule.condition(), rule.min), Some(rule.clone()));+        assert_eq!(crate::rules::PadRule::parse("A.NetClass == 'USB'", 1), None);+        let dir = std::env::temp_dir().join(format!("adom-route-padrule-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let (a, b) = (dir.join("in.kicad_pcb"), dir.join("out.kicad_pcb"));+        let path = project::write_dru(a.to_str().unwrap(), b.to_str().unwrap(), std::slice::from_ref(&rule)).unwrap().unwrap();+        let mut r = Rules::default();+        project::apply_files(&dir.join("missing.kicad_pro"), std::path::Path::new(&path), &mut r);+        assert_eq!(r.pad_rules, vec![rule]);+        let _ = std::fs::remove_file(&path);+    }++    #[test]+    fn dru_only_raises_limits_and_says_what_it_skips() {+        let dir = std::env::temp_dir().join(format!("adom-route-dru-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let dru = dir.join("t.kicad_dru");+        std::fs::write(&dru, "(version 1)\n# comment\n(rule a (constraint clearance (min 0.09mm)))\n(rule b (constraint track_width (min 0.127mm)))\n(rule c (condition \"A.Type == 'Via'\") (constraint hole_size (min 0.3mm)))\n").unwrap();+        let mut r = Rules::default();+        let notes = project::apply_files(&dir.join("missing.kicad_pro"), &dru, &mut r);+        // No project: KiCad's defaults (0.2 mm track and clearance) stand, and the rule file's lower+        // minimums cannot loosen them.+        assert_eq!(r.min.track, mm(0.2));+        assert_eq!(r.clearance_for(1, 2), mm(0.2));+        assert!(notes.iter().any(|n| n.contains("rule \"c\"") && n.contains("not honoured")));+        let _ = std::fs::remove_file(&dru);+    }+}

@@ -0,0 +1,752 @@+//! Sort nets into the designer's routing hierarchy (4.2) and work out each net's topology: the order its+//! pads are joined in. Decoupling is cap first, crystals are daisy chains, data prefers a chain.++use crate::board::*;+use crate::geom::*;+use crate::rules::Rules;+use std::collections::{BTreeMap, HashMap, HashSet};++#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]+pub enum Level {+    Kelvin = 0,+    Pair = 1,+    Crystal = 2,+    Data = 3,+    Power = 4,+    PlaneFanout = 5,+    Other = 6,+}++impl Level {+    pub fn name(self) -> &'static str {+        match self {+            Level::Kelvin => "kelvin",+            Level::Pair => "differential pair",+            Level::Crystal => "crystal",+            Level::Data => "data",+            Level::Power => "power",+            Level::PlaneFanout => "plane via",+            Level::Other => "non-priority",+        }+    }+}++pub struct NetInfo {+    pub net: NetId,+    pub level: Level,+    pub pads: Vec<usize>,+    /// Why this level, from the pins and parts on the net. Printed by `plan`, because a wrong class+    /// means wrong widths and the wrong turn in the hierarchy, and the designer has to be able to see it.+    pub why: String,+    /// A switch node (4.2 Switching loops): keep it compact, never pour it, MCU outside the loop.+    pub switching: bool,+    /// Kelvin taps on this net, each a chain of pads ending on the shunt (4.2): dedicated copper,+    /// routed apart from the rest of the net, which is planned without the amplifier's pins.+    pub taps: Vec<Vec<usize>>,+}++pub fn ref_prefix(r: &str) -> &str {+    let end = r.find(|c: char| c.is_ascii_digit()).unwrap_or(r.len());+    &r[..end]+}++/// A power rail by name: +3v3, +5V, VBUS, VCC, VDD... (never by width, 4.2).+pub fn looks_power(name: &str) -> bool {+    let n = name.trim_start_matches('/').to_ascii_uppercase();+    n.starts_with('+') || n.starts_with("VCC") || n.starts_with("VDD") || n.starts_with("VBUS") || n.starts_with("VIN") || n.starts_with("VSYS") || n.starts_with("PWR") || n == "VBAT"+}++pub fn looks_ground(name: &str) -> bool {+    let n = name.trim_start_matches('/').to_ascii_uppercase();+    n == "GND" || n.starts_with("GND") || n == "VSS" || n == "AGND" || n == "DGND" || n == "PGND"+}++/// Non-switching signals that can via often without a noticeable effect (4.2 item 4).+pub fn looks_low_priority(name: &str) -> bool {+    let n = name.trim_start_matches('/').to_ascii_uppercase();+    n.contains("LED") || n.contains("RST") || n.contains("RESET") || n == "RUN" || n.contains("BOOT") || n.contains("SW_") || n.contains("BTN")+}++/// The 90-ohm figures in PCB_Troubleshooting ("A USB pair fails"), measured for one JLC 4-layer stack.+/// Only a last resort when neither the spec nor the project sets a pair: every use is reported.+const TROUBLESHOOTING_PAIR: (f64, f64) = (0.2817, 0.15);++/// Pairs by name when the spec does not list them: ..D+/..D-, .._P/.._N, ..DP/..DN, then the width+/// and gap of every pair (4.2: specs are predetermined, not chosen here): the spec's, else the net+/// class's (`Rules::bind` must have run). Returns a note for each figure that came from neither.+pub fn find_pairs(board: &Board, rules: &mut Rules) -> Vec<String> {+    let names: HashSet<&str> = board.nets.iter().map(|s| s.as_str()).collect();+    let listed: HashSet<String> = rules.pairs.iter().flat_map(|p| [p.p.clone(), p.n.clone()]).collect();+    let mut found = Vec::new();+    for name in board.nets.iter() {+        for (a, b) in [("D+", "D-"), ("_P", "_N"), ("_DP", "_DN"), ("+", "-")] {+            if let Some(stem) = name.strip_suffix(a) {+                let other = format!("{stem}{b}");+                if names.contains(other.as_str()) && !listed.contains(name) && !(a == "+" && stem.is_empty()) {+                    if a == "+" && !stem.to_ascii_uppercase().ends_with("USB") && !stem.to_ascii_uppercase().ends_with('D') {+                        continue;+                    }+                    found.push((name.clone(), other));+                    break;+                }+            }+        }+    }+    found.sort();+    found.dedup();+    for (p, n) in found {+        rules.pairs.push(crate::rules::Pair { p, n, width: 0, gap: 0 });+    }+    let mut notes = Vec::new();+    let mut pairs = std::mem::take(&mut rules.pairs);+    for p in pairs.iter_mut() {+        let class = board.net_ids.get(&p.p).and_then(|&id| rules.pair_for(id));+        if p.width == 0 {+            p.width = class.map(|c| c.0).unwrap_or(0);+        }+        if p.gap == 0 {+            p.gap = class.map(|c| c.1).unwrap_or(0);+        }+        if p.width == 0 || p.gap == 0 {+            if p.width == 0 {+                p.width = mm(TROUBLESHOOTING_PAIR.0);+            }+            if p.gap == 0 {+                p.gap = mm(TROUBLESHOOTING_PAIR.1);+            }+            notes.push(format!("DEFAULT: pair {}/{} has no width or gap in the spec or a net class, so it takes {:.4}/{:.3} mm from PCB_Troubleshooting's JLC 4-layer table. Confirm it with the fab's calculator for this stack (2.2)", p.p, p.n, to_mm(p.width), to_mm(p.gap)));+        }+    }+    rules.pairs = pairs;+    notes+}++pub fn is_crystal(board: &Board, fp: usize) -> bool {+    let f = &board.footprints[fp];+    let r = ref_prefix(&f.reference);+    (r == "Y" || r == "X" || f.lib.to_ascii_lowercase().contains("crystal")) && f.pads.len() >= 2 && f.pads.len() <= 6+}++/// An LED by its part, not its net name: the reference says LED, or the library part does.+pub fn is_led(board: &Board, fp: usize) -> bool {+    let f = &board.footprints[fp];+    let r = ref_prefix(&f.reference);+    r == "LED" || (r == "D" && f.lib.to_ascii_lowercase().contains("led"))+}++/// A net that drives an LED, directly or through a series resistor: non-switching, may via often+/// (4.2 item 4). A diode that isn't an LED doesn't count: an ESD array on a terminal line is on the+/// line for a reason, and benchmark C's TI/TO lines were going last because of one.+pub fn drives_led(board: &Board, pads: &[usize]) -> bool {+    pads.iter().any(|&p| {+        let fp = board.pads[p].fp;+        if is_led(board, fp) {+            return true;+        }+        let f = &board.footprints[fp];+        if ref_prefix(&f.reference) != "R" || f.pads.len() != 2 {+            return false;+        }+        let other = f.pads.iter().copied().find(|&o| o != p);+        let Some(other) = other else { return false };+        let net = board.pads[other].net;+        // A resistor to GND or a rail also reaches some LED: that's a pull or a set resistor.+        let name = board.net_name(net);+        net != NO_NET && !looks_ground(name) && (!looks_power(name) || name.to_ascii_uppercase().contains("LED")) && board.pads.iter().any(|q| q.net == net && is_led(board, q.fp))+    })+}++/// A part value as ohms: R068, 0R1, 10m, 100mR, 4k7, 22, 0.05. None when it isn't a plain resistance.+pub fn ohms(value: &str) -> Option<f64> {+    let v = value.trim().to_ascii_lowercase().replace("ohms", "").replace("ohm", "").replace('\u{3a9}', "");+    let v = v.split_whitespace().next()?.to_string();+    for (mark, scale) in [('m', 1e-3), ('k', 1e3), ('r', 1.0)] {+        if let Some(i) = v.find(mark) {+            let (head, tail) = (&v[..i], &v[i + 1..]);+            // "100mr" is 100 milliohms: the trailing r only repeats the unit.+            let tail = tail.strip_suffix('r').unwrap_or(tail);+            let head = if head.is_empty() { "0" } else { head };+            let text = if tail.is_empty() { head.to_string() } else { format!("{head}.{tail}") };+            return text.parse::<f64>().ok().map(|x| x * scale);+        }+    }+    v.parse().ok()+}++/// A current-sense shunt: a low-value two-pad resistor. His standard parts read R068 and the like.+fn is_shunt(board: &Board, fp: usize) -> bool {+    let f = &board.footprints[fp];+    ref_prefix(&f.reference).starts_with('R') && f.pads.iter().filter(|&&p| !board.pads[p].layers.is_empty()).count() == 2 && ohms(&f.value).map(|x| x > 0.0 && x < 1.0).unwrap_or(false)+}++/// Each shunt with an amplifier's sense pins across it: (footprint of the shunt, then for each side+/// its pad and the amplifier pins on that side). The nets are rails, so the name says nothing: what+/// makes these Kelvin taps is the amplifier's input pins on both sides of a milliohm resistor.+pub fn kelvin_taps(board: &Board) -> Vec<Vec<usize>> {+    let mut out = Vec::new();+    for (fi, f) in board.footprints.iter().enumerate() {+        if !is_shunt(board, fi) || f.dnp {+            continue;+        }+        let pads: Vec<usize> = f.pads.iter().copied().filter(|&p| !board.pads[p].layers.is_empty()).collect();+        let (a, b) = (pads[0], pads[1]);+        let (na, nb) = (board.pads[a].net, board.pads[b].net);+        if na == NO_NET || nb == NO_NET || na == nb {+            continue;+        }+        for (gi, g) in board.footprints.iter().enumerate() {+            if gi == fi || g.pads.len() < 5 || !matches!(ref_prefix(&g.reference), "U" | "IC") {+                continue;+            }+            // A power pin on the rail is just the part being fed; sense pins are inputs.+            let sense = |net: NetId| -> Vec<usize> { g.pads.iter().copied().filter(|&p| board.pads[p].net == net && !board.pads[p].layers.is_empty() && matches!(board.pads[p].pintype.as_str(), "input" | "passive")).collect() };+            let (sa, sb) = (sense(na), sense(nb));+            if sa.is_empty() || sb.is_empty() {+                continue;+            }+            for (shunt_pad, mut pins) in [(a, sa), (b, sb)] {+                pins.push(shunt_pad);+                out.push(pins);+            }+        }+    }+    out+}++/// Is this a switch node? Topology first: an inductor meeting a diode, a transistor or an IC pin at+/// one net (4.2 Switching loops). A converter module hides its inductor, so a net that is only pins of+/// one IC that also has power pins, and is named for a switch node, counts too (benchmark C's U5 SW).+fn is_switch_node(board: &Board, name: &str, pads: &[usize]) -> Option<String> {+    let prefix = |p: usize| ref_prefix(&board.footprints[board.pads[p].fp].reference).to_string();+    let inductor = pads.iter().find(|&&p| prefix(p) == "L");+    let active = pads.iter().find(|&&p| match prefix(p).as_str() {+        "D" => !is_led(board, board.pads[p].fp),+        "Q" | "U" | "IC" => board.pads[p].pintype != "input",+        _ => false,+    });+    if let (Some(&l), Some(&x)) = (inductor, active) {+        return Some(format!("inductor {} meets {}", board.pad_name(l), board.pad_name(x)));+    }+    let tail = name.rsplit('/').next().unwrap_or(name).to_ascii_uppercase();+    let named = matches!(tail.as_str(), "SW" | "LX" | "PHASE") || tail.starts_with("SW_NODE");+    let first = board.pads[*pads.first()?].fp;+    let one_part = pads.iter().all(|&p| board.pads[p].fp == first);+    let powered = board.footprints[first].pads.iter().any(|&p| matches!(board.pads[p].pintype.as_str(), "power_in" | "power_out"));+    if named && one_part && powered {+        return Some(format!("only pins of {}, a part with power pins, named {tail}", board.footprints[first].reference));+    }+    None+}++/// Which nets carry power, and why, from the pins and parts rather than from names or widths (4.2:+/// never judge current from a net name or a trace width alone). A name counts only where nothing on+/// the net contradicts it: /VBUS_G is named like a rail and is two FET gates.+fn power_nets(board: &Board, rules: &Rules, by_net: &BTreeMap<NetId, Vec<usize>>) -> HashMap<NetId, String> {+    let mut power: HashMap<NetId, String> = HashMap::new();+    let ground = |n: NetId| looks_ground(board.net_name(n));+    let prefix = |p: usize| ref_prefix(&board.footprints[board.pads[p].fp].reference).to_string();+    let is_gate = |p: usize| prefix(p) == "Q" && board.pads[p].pintype == "input";+    let is_power_pin = |p: usize| matches!(board.pads[p].pintype.as_str(), "power_in" | "power_out");+    for (&net, pads) in by_net {+        let name = board.net_name(net);+        if ground(net) {+            continue;+        }+        if rules.wide.contains_key(name) {+            power.insert(net, "listed in the spec's wideNets".to_string());+        } else if let Some(&p) = pads.iter().find(|&&p| is_power_pin(p)) {+            power.insert(net, format!("power pin {} ({})", board.pad_name(p), board.pads[p].pintype));+        } else if looks_power(name) && !pads.iter().any(|&p| is_gate(p)) && !drives_led(board, pads) {+            power.insert(net, "named as a rail, and no gate or LED on it says otherwise".to_string());+        } else {+            // An output pin with only bypass capacitors on it is a regulator's own supply, not a+            // signal: nothing receives it (benchmark C's U5 VCC).+            let outputs = pads.iter().filter(|&&p| board.pads[p].pintype == "output").count();+            let caps_to_ground = pads.iter().all(|&p| {+                board.pads[p].pintype == "output" || (prefix(p) == "C" && board.footprints[board.pads[p].fp].pads.iter().any(|&o| o != p && ground(board.pads[o].net)))+            });+            if outputs > 0 && pads.len() > outputs && caps_to_ground {+                power.insert(net, "an output pin with only bypass capacitors on it".to_string());+            }+        }+    }+    // Power carries through what is in series with it: fuses, ferrites, inductors, shunts, and the+    // channel of a power FET (several pins tied on each side, the gate typed input).+    let mut links: Vec<(NetId, NetId, String)> = Vec::new();+    for (fi, f) in board.footprints.iter().enumerate() {+        let copper: Vec<usize> = f.pads.iter().copied().filter(|&p| !board.pads[p].layers.is_empty() && board.pads[p].net != NO_NET).collect();+        let r = ref_prefix(&f.reference);+        if copper.len() == 2 && (matches!(r, "F" | "FB" | "L") || is_shunt(board, fi)) {+            links.push((board.pads[copper[0]].net, board.pads[copper[1]].net, f.reference.clone()));+        }+        if r == "Q" {+            let mut sides: BTreeMap<NetId, usize> = BTreeMap::new();+            for &p in &copper {+                if !is_gate(p) {+                    *sides.entry(board.pads[p].net).or_insert(0) += 1;+                }+            }+            let tied: Vec<NetId> = sides.iter().filter(|(_, &c)| c >= 2).map(|(&n, _)| n).collect();+            for w in tied.iter().enumerate().flat_map(|(i, a)| tied[i + 1..].iter().map(move |b| (*a, *b))) {+                links.push((w.0, w.1, format!("{} channel", f.reference)));+            }+        }+    }+    loop {+        let mut changed = false;+        for (a, b, via) in &links {+            for (from, to) in [(*a, *b), (*b, *a)] {+                if power.contains_key(&from) && !power.contains_key(&to) && !ground(to) && by_net.contains_key(&to) {+                    power.insert(to, format!("in series with {} through {via}", board.net_name(from)));+                    changed = true;+                }+            }+        }+        if !changed {+            return power;+        }+    }+}++/// Is this footprint fine pitch? 4.2 only says "fine-pitch MCU", so this asks what that means for+/// routing: between two neighbouring pads of different nets, does a straight lane at the neck fit+/// with more than the minimum spacing either side? If it doesn't, spacing inside the escape has to+/// tighten to the minimum, which is what 4.2 allows a fine-pitch escape to do. Two-pad parts have no+/// pin row to escape from.+pub fn is_fine_pitch(board: &Board, rules: &Rules, fp: usize) -> bool {+    let f = &board.footprints[fp];+    let copper: Vec<usize> = f.pads.iter().copied().filter(|&p| !board.pads[p].layers.is_empty()).collect();+    if copper.len() < 3 {+        return false;+    }+    let lane = (rules.neck + 2 * rules.clearance_for(NO_NET, NO_NET).max(rules.floor)) as f64;+    for (i, &a) in copper.iter().enumerate() {+        for &b in &copper[i + 1..] {+            let (pa, pb) = (&board.pads[a], &board.pads[b]);+            if pa.net != pb.net && pa.shape.dist_shape(&pb.shape) < lane {+                return true;+            }+        }+    }+    false+}++pub fn is_passive2(board: &Board, fp: usize) -> bool {+    let f = &board.footprints[fp];+    f.pads.iter().filter(|&&p| !board.pads[p].layers.is_empty()).count() == 2 && matches!(ref_prefix(&f.reference), "C" | "R" | "L" | "FB" | "D")+}++pub fn classify(board: &Board, rules: &Rules) -> Vec<NetInfo> {+    let planes = board.plane_nets();+    let plane_names: HashSet<&str> = rules.plane_nets.iter().map(|s| s.as_str()).collect();+    let pair_nets: HashSet<&str> = rules.pairs.iter().flat_map(|p| [p.p.as_str(), p.n.as_str()]).collect();+    let kelvin: HashSet<&str> = rules.kelvin.iter().map(|s| s.as_str()).collect();+    let skip: HashSet<&str> = rules.skip_refs.iter().map(|s| s.as_str()).collect();+    let mut by_net: BTreeMap<NetId, Vec<usize>> = BTreeMap::new();+    for (i, p) in board.pads.iter().enumerate() {+        if p.net == NO_NET || p.layers.is_empty() {+            continue;+        }+        let f = &board.footprints[p.fp];+        // A part marked do-not-populate is still copper on the board: an option resistor has to be+        // wired or it is no option, and KiCad counts its pads as open (on a current-monitor board, three+        // unpopulated address resistors left five joins open while the router reported all made).+        // Only the spec's skipRefs leave a part out.+        if skip.contains(f.reference.as_str()) {+            continue;+        }+        by_net.entry(p.net).or_default().push(i);+    }+    let power = power_nets(board, rules, &by_net);+    let mut taps: HashMap<NetId, Vec<Vec<usize>>> = HashMap::new();+    for t in kelvin_taps(board) {+        taps.entry(board.pads[t[0]].net).or_default().push(t);+    }+    let mut out = Vec::new();+    for (net, pads) in by_net {+        let name = board.net_name(net);+        // KiCad names a net "unconnected-" when no schematic wire reaches it, but two pads on one+        // such net are one pin brought out twice, and its DRC wants them joined (benchmark C's U2).+        if name.is_empty() || (name.starts_with("unconnected-") && pads.len() < 2) {+            continue;+        }+        let switch = is_switch_node(board, name, &pads);+        let (level, why) = if kelvin.contains(name) {+            (Level::Kelvin, "listed as Kelvin in the spec".to_string())+        } else if pair_nets.contains(name) {+            (Level::Pair, "a differential pair".to_string())+        } else if planes.contains_key(&net) || plane_names.contains(name) || looks_ground(name) && !planes.is_empty() {+            (Level::PlaneFanout, "has a plane".to_string())+        } else if let Some(s) = &switch {+            (Level::Power, format!("switch node: {s}"))+        } else if let Some(p) = power.get(&net) {+            (Level::Power, p.clone())+        } else if drives_led(board, &pads) {+            (Level::Other, "drives an LED".to_string())+        } else if looks_low_priority(name) {+            (Level::Other, "reset, boot or button line by name".to_string())+        } else if pads.iter().any(|&p| is_crystal(board, board.pads[p].fp)) {+            (Level::Crystal, "on a crystal".to_string())+        } else {+            (Level::Data, "signal pins only".to_string())+        };+        let taps = taps.remove(&net).unwrap_or_default();+        out.push(NetInfo { net, level, pads, why, switching: switch.is_some(), taps });+    }+    out+}++/// A connection the router must make: pad to pad, inside one net.+#[derive(Clone, Debug)]+pub struct Task {+    pub net: NetId,+    pub level: Level,+    pub a: usize,+    pub b: usize,+    /// Main rail run rather than a stub to a pin.+    pub main: bool,+    /// Join this pad to its net's copper fill (index into World::zones) instead of another pad.+    pub zone: Option<usize>,+}++/// `Task::zone` value meaning: join pad `a` to the net's rail copper, or, when `a != b`, to pad `b`+/// and whatever copper it already has. The targets are worked out from the copper at route time.+pub const RAIL_TAP: usize = usize::MAX;++fn dist(board: &Board, a: usize, b: usize) -> f64 {+    hypot(sub(board.pads[a].center.into(), board.pads[b].center.into()))+}++/// Daisy chain through `pads`, starting from the end that makes the chain shortest (4.2).+fn chain(board: &Board, pads: &[usize]) -> Vec<usize> {+    if pads.len() <= 2 {+        return pads.to_vec();+    }+    let mut best: Option<(f64, Vec<usize>)> = None;+    for &start in pads {+        let mut left: Vec<usize> = pads.iter().copied().filter(|&p| p != start).collect();+        let mut seq = vec![start];+        let mut total = 0.0;+        while !left.is_empty() {+            let cur = *seq.last().unwrap();+            let (i, d) = left.iter().enumerate().map(|(i, &p)| (i, dist(board, cur, p))).min_by(|a, b| a.1.total_cmp(&b.1)).unwrap();+            total += d;+            seq.push(left.swap_remove(i));+        }+        if best.as_ref().map(|b| total < b.0).unwrap_or(true) {+            best = Some((total, seq));+        }+    }+    best.unwrap().1+}++/// Minimum spanning tree edges between groups, nearest pads first (Prim).+fn tree(board: &Board, groups: &[Vec<usize>]) -> Vec<(usize, usize)> {+    let mut joined = vec![0usize];+    let mut out = Vec::new();+    while joined.len() < groups.len() {+        let mut best: Option<(f64, usize, usize, usize)> = None;+        for &g in &joined {+            for h in 0..groups.len() {+                if joined.contains(&h) {+                    continue;+                }+                for &a in &groups[g] {+                    for &b in &groups[h] {+                        let d = dist(board, a, b);+                        if best.map(|x| d < x.0).unwrap_or(true) {+                            best = Some((d, a, b, h));+                        }+                    }+                }+            }+        }+        let (_, a, b, h) = best.unwrap();+        out.push((a, b));+        joined.push(h);+    }+    out+}++/// Plan the pad-to-pad connections for one signal or power net, given which pads the board's+/// copper already joins.+pub fn plan_net(board: &Board, info: &NetInfo, groups: &[Vec<usize>]) -> Vec<Task> {+    let mk = |a, b, main| Task { net: info.net, level: info.level, a, b, main, zone: None };+    let live: Vec<Vec<usize>> = groups+        .iter()+        .map(|g| g.iter().copied().filter(|p| info.pads.contains(p)).collect::<Vec<_>>())+        .filter(|g: &Vec<usize>| !g.is_empty())+        .collect();+    if live.len() < 2 {+        return Vec::new();+    }+    let singles = live.iter().all(|g| g.len() == 1);+    match info.level {+        Level::Crystal if singles => {+            // IC pin -> load-cap pad -> crystal pad (4.2 crystal routing).+            let pads: Vec<usize> = live.iter().map(|g| g[0]).collect();+            let mut xtal: Vec<usize> = pads.iter().copied().filter(|&p| is_crystal(board, board.pads[p].fp)).collect();+            let mut caps: Vec<usize> = pads.iter().copied().filter(|&p| ref_prefix(&board.footprints[board.pads[p].fp].reference) == "C").collect();+            let mut rest: Vec<usize> = pads.iter().copied().filter(|p| !xtal.contains(p) && !caps.contains(p)).collect();+            let far = xtal.first().copied();+            if let Some(f) = far {+                caps.sort_by(|a, b| dist(board, *b, f).total_cmp(&dist(board, *a, f)));+                rest.sort_by(|a, b| dist(board, *b, f).total_cmp(&dist(board, *a, f)));+            }+            let mut seq = Vec::new();+            seq.append(&mut rest);+            seq.append(&mut caps);+            seq.append(&mut xtal);+            seq.windows(2).map(|w| mk(w[0], w[1], false)).collect()+        }+        Level::Power => plan_rail(board, info, &live, &[], &|_, _| false, f64::INFINITY),+        _ if singles => {+            let pads: Vec<usize> = live.iter().map(|g| g[0]).collect();+            // Each new pad joins what is already laid, so it starts as one pad and a route has no+            // copper of its own behind it to double back along. `targets_of` lets it land on any of+            // that copper, weighed against reaching the previous pad (4.2: a daisy chain preferred).+            chain(board, &pads).windows(2).map(|w| mk(w[1], w[0], false)).collect()+        }+        _ => tree(board, &live).into_iter().map(|(a, b)| mk(a, b, false)).collect(),+    }+}++/// Plan one rail (4.2 power): supply pins join their own fill or their cap first (never pin ->+/// junction -> cap), then each resulting cluster joins the rail on the bus layer, tapping onto+/// whatever rail copper is nearest when its turn comes. `zones`: this net's fills, as (index in World::zones,+/// layer, outline). `stub_clear`: can this pad reach this fill straight, on its own layer? A fill+/// behind another net's copper is reached from the bus instead (4.7: DVDD pins go out to their caps).+/// `cap_reach`: how far a pin's stub to its cap may run. Past where a stub on the pad layer costs more+/// than going down to the bus and back up, the pin and the cap each join the rail on their own.+pub fn plan_rail(board: &Board, info: &NetInfo, live: &[Vec<usize>], zones: &[(usize, usize, &Vec<V>)], stub_clear: &dyn Fn(usize, usize) -> bool, cap_reach: f64) -> Vec<Task> {+    let mut tasks = Vec::new();+    let is_ic_pin = |p: usize| {+        let f = &board.footprints[board.pads[p].fp];+        f.pads.len() > 4 && matches!(ref_prefix(&f.reference), "U" | "IC" | "Q")+    };+    let is_cap = |p: usize| is_passive2(board, board.pads[p].fp) && ref_prefix(&board.footprints[board.pads[p].fp].reference) == "C";+    let (ng, nz) = (live.len(), zones.len());+    let mut uf = crate::conn::Uf::new(ng + nz);+    let mut group_of: HashMap<usize, usize> = HashMap::new();+    for (i, g) in live.iter().enumerate() {+        for &p in g {+            group_of.insert(p, i);+        }+    }+    let edge_dist = |p: usize, poly: &Vec<V>| -> f64 {+        let n = poly.len();+        if in_poly(board.pads[p].center.into(), poly) {+            return 0.0;+        }+        (0..n).map(|i| board.pads[p].shape.dist_seg(poly[i], poly[(i + 1) % n])).fold(f64::INFINITY, f64::min)+    };+    for &p in &info.pads {+        let Some(&g) = group_of.get(&p) else { continue };+        for (zi, (_, layer, poly)) in zones.iter().enumerate() {+            if board.pads[p].layers.contains(layer) && edge_dist(p, poly) <= 1.0 {+                uf.union(g as u32, (ng + zi) as u32);+            }+        }+    }+    // A pin next to its net's fill stubs into it (4.7's method, where the designer drew the fill).+    for &p in &info.pads {+        let Some(&g) = group_of.get(&p) else { continue };+        if !is_ic_pin(p) {+            continue;+        }+        for (zi, (z, layer, poly)) in zones.iter().enumerate() {+            let same = uf.find(g as u32) == uf.find((ng + zi) as u32);+            if !same && board.pads[p].layers.contains(layer) && edge_dist(p, poly) <= 1.0 * NM && stub_clear(p, *z) {+                tasks.push(Task { net: info.net, level: info.level, a: p, b: p, main: false, zone: Some(*z) });+                uf.union(g as u32, (ng + zi) as u32);+                break;+            }+        }+    }+    let caps: Vec<usize> = info.pads.iter().copied().filter(|&p| is_cap(p)).collect();+    let mut pins: Vec<usize> = info.pads.iter().copied().filter(|&p| is_ic_pin(p)).collect();+    pins.sort_by(|&a, &b| {+        let da = caps.iter().map(|&c| dist(board, a, c)).fold(f64::INFINITY, f64::min);+        let db = caps.iter().map(|&c| dist(board, b, c)).fold(f64::INFINITY, f64::min);+        da.total_cmp(&db)+    });+    for pin in pins {+        let Some(&cap) = caps.iter().min_by(|&&a, &&b| dist(board, pin, a).total_cmp(&dist(board, pin, b))) else { continue };+        if dist(board, pin, cap) > cap_reach {+            continue;+        }+        let (Some(&ga), Some(&gb)) = (group_of.get(&pin), group_of.get(&cap)) else { continue };+        if uf.find(ga as u32) != uf.find(gb as u32) {+            uf.union(ga as u32, gb as u32);+            // Rail-routed, so the search itself weighs a long stub against the bus. `main: false`+            // holds it to the cap's own pad: cap first, never a junction on the way (4.2).+            tasks.push(Task { net: info.net, level: info.level, a: pin, b: cap, main: false, zone: Some(RAIL_TAP) });+        }+    }+    // Clusters, and the pads each one is fed from: a cap if it has one (cap first), else a passive+    // or connector pad, else the pin.+    let mut clusters: BTreeMap<u32, Vec<usize>> = BTreeMap::new();+    for (i, g) in live.iter().enumerate() {+        clusters.entry(uf.find(i as u32)).or_default().extend(g.iter().copied());+    }+    let feeds: Vec<Vec<usize>> = clusters+        .values()+        .map(|pads| {+            let c: Vec<usize> = pads.iter().copied().filter(|&p| is_cap(p)).collect();+            if !c.is_empty() {+                return c;+            }+            let o: Vec<usize> = pads.iter().copied().filter(|&p| !is_ic_pin(p)).collect();+            if !o.is_empty() { o } else { pads.clone() }+        })+        .collect();+    // With a fill on the net, the fill is the hub and every cluster taps toward it at the main width.+    // Without one, the two clusters farthest apart make the trunk and the rest tap onto it. Nearest+    // to what is already joined goes next either way, so each tap finds rail close by.+    let mut joined: Vec<usize> = Vec::new();+    let mut left: Vec<usize> = (0..feeds.len()).collect();+    if zones.is_empty() && feeds.len() >= 2 {+        let mut far: Option<(f64, usize, usize, usize, usize)> = None;+        for i in 0..feeds.len() {+            for j in i + 1..feeds.len() {+                for &a in &feeds[i] {+                    for &b in &feeds[j] {+                        let d = dist(board, a, b);+                        if far.map(|x| d > x.0).unwrap_or(true) {+                            far = Some((d, i, j, a, b));+                        }+                    }+                }+            }+        }+        let (_, i, j, a, b) = far.unwrap();+        tasks.push(Task { net: info.net, level: info.level, a, b, main: true, zone: Some(RAIL_TAP) });+        joined = vec![a, b];+        left.retain(|&k| k != i && k != j);+    }+    let hub = !zones.is_empty();+    while !left.is_empty() {+        let near = |p: usize| -> f64 {+            let to_pads = joined.iter().map(|&q| dist(board, p, q)).fold(f64::INFINITY, f64::min);+            zones.iter().map(|(_, _, poly)| edge_dist(p, poly)).fold(to_pads, f64::min)+        };+        let (pos, pad) = left+            .iter()+            .enumerate()+            .flat_map(|(pos, &k)| feeds[k].iter().map(move |&p| (pos, p)))+            .min_by(|x, y| near(x.1).total_cmp(&near(y.1)))+            .unwrap();+        left.swap_remove(pos);+        joined.push(pad);+        tasks.push(Task { net: info.net, level: info.level, a: pad, b: pad, main: hub, zone: Some(RAIL_TAP) });+    }+    // A fill with no pad of its own still has to be fed: an island is never acceptable (4.3). These+    // go last: by then the pads are one piece, so the tap's only target is the fill itself.+    let reps: Vec<usize> = feeds.iter().flatten().copied().collect();+    for (zi, (_, _, poly)) in zones.iter().enumerate() {+        let root = uf.find((ng + zi) as u32);+        let has_pad = (0..ng).any(|g| uf.find(g as u32) == root);+        if !has_pad && !poly.is_empty() {+            let c = V(poly.iter().map(|p| p.0).sum::<f64>() / poly.len() as f64, poly.iter().map(|p| p.1).sum::<f64>() / poly.len() as f64);+            if let Some(&near) = reps.iter().min_by(|&&x, &&y| hypot(sub(board.pads[x].center.into(), c)).total_cmp(&hypot(sub(board.pads[y].center.into(), c)))) {+                tasks.push(Task { net: info.net, level: info.level, a: near, b: near, main: false, zone: Some(RAIL_TAP) });+            }+        }+    }+    tasks+}++#[cfg(test)]+mod tests {+    use super::*;++    /// A reference board, or None where the reference boards are not present (they do not ship with+    /// the source): the test that asked is then skipped.+    fn load(name: &str) -> Option<(Board, Rules)> {+        let path = format!("{}/bench/boards/{name}.ref.kicad_pcb", env!("CARGO_MANIFEST_DIR"));+        if !std::path::Path::new(&path).exists() {+            eprintln!("skipped: {path} is not here");+            return None;+        }+        let b = Board::read(&path).unwrap();+        let mut r = Rules::default();+        crate::project::apply(&path, &mut r);+        Some((b, r))+    }++    fn level_of(b: &Board, infos: &[NetInfo], name: &str) -> Level {+        infos.iter().find(|i| b.net_name(i.net) == name).unwrap_or_else(|| panic!("{name} not classified")).level+    }++    #[test]+    fn values_read_as_ohms() {+        for (text, ohm) in [("R068", 0.068), ("0R1", 0.1), ("10m", 0.01), ("100mR", 0.1), ("4k7", 4700.0), ("22", 22.0), ("0.05", 0.05), ("100mOhm", 0.1), ("1k", 1000.0)] {+            assert!((ohms(text).unwrap() - ohm).abs() < 1e-9, "{text}");+        }+        assert_eq!(ohms("BLU"), None);+    }++    /// The reviewer's list on benchmark C, and what the parts on those nets say.+    #[test]+    fn benchmark_c_classes_come_from_its_parts() {+        let Some((b, r)) = load("benchc_v10") else { return };+        let infos = classify(&b, &r);+        assert_eq!(level_of(&b, &infos, "/MCU_Upstream/5V_VCC"), Level::Power);+        assert_eq!(level_of(&b, &infos, "/MCU_Upstream/SW"), Level::Power);+        assert!(infos.iter().find(|i| b.net_name(i.net) == "/MCU_Upstream/SW").unwrap().switching);+        assert_eq!(level_of(&b, &infos, "Net-(D3-K)"), Level::Power);+        assert_eq!(level_of(&b, &infos, "Net-(D3-A)"), Level::Power);+        // An ESD array on a terminal line isn't an LED; a real LED's anode net is low priority.+        assert_eq!(level_of(&b, &infos, "/TI_0_J"), Level::Data);+        assert_eq!(level_of(&b, &infos, "/MCU_Upstream/+3V3_AN"), Level::Other);+        // A set resistor to GND doesn't drive an LED just because GND reaches one.+        assert_eq!(level_of(&b, &infos, "/MCU_Downstream/ILIM"), Level::Data);+        // RS1 is the shunt, U11 the amplifier, and its two tied pins on the far side share one tap.+        let tap = |name: &str| infos.iter().find(|i| b.net_name(i.net) == name).unwrap().taps.iter().map(|t| t.iter().map(|&p| b.pad_name(p)).collect::<Vec<_>>()).collect::<Vec<_>>();+        assert_eq!(tap("+3V3_EXT"), vec![vec!["U11.10".to_string(), "RS1.1".to_string()]]);+        assert_eq!(tap("+3V3_EXT_SENS"), vec![vec!["U11.8".to_string(), "U11.9".to_string(), "RS1.2".to_string()]]);+    }++    #[test]+    fn benchmark_b_classes_come_from_its_parts() {+        let Some((b, r)) = load("benchb_v210") else { return };+        let infos = classify(&b, &r);+        assert_eq!(level_of(&b, &infos, "-PS1"), Level::Power);+        assert_eq!(level_of(&b, &infos, "/USB2_RLY"), Level::Power);+        // Named like a rail, and is two FET gates.+        assert_eq!(level_of(&b, &infos, "/VBUS_G"), Level::Data);+        // Through the FET's channel from a power pin; the name says nothing.+        assert_eq!(level_of(&b, &infos, "/USB2_VBUS"), Level::Power);+        assert_eq!(level_of(&b, &infos, "/VBUS_CS"), Level::Power);+        assert_eq!(level_of(&b, &infos, "/USER_IO.0"), Level::Data);+    }++    #[test]+    fn piprobe_classes_come_from_its_parts() {+        let Some((b, r)) = load("piprobe_v13") else { return };+        let infos = classify(&b, &r);+        assert_eq!(level_of(&b, &infos, "+1V1"), Level::Power);+        assert_eq!(level_of(&b, &infos, "QSPI_SD0"), Level::Data);+        // Through R4 to /PWR_LED: the name of that net starts like a rail, and it's an LED.+        assert_eq!(level_of(&b, &infos, "GPIO2"), Level::Other);+        assert_eq!(level_of(&b, &infos, "XIN"), Level::Crystal);+    }++    /// Fine pitch from the pads, against the reference's parts: 0.4 and 0.5 mm QFNs are, a 2 mm module and a+    /// 1.27 mm SOIC aren't.+    #[test]+    fn fine_pitch_comes_from_the_pad_gap() {+        let fine = |b: &Board, r: &Rules, name: &str| is_fine_pitch(b, r, b.footprints.iter().position(|f| f.reference == name).unwrap());+        let Some((b, r)) = load("piprobe_v13") else { return };+        assert!(fine(&b, &r, "U1"));+        assert!(fine(&b, &r, "U2"));+        assert!(!fine(&b, &r, "C4"));+        let Some((b, r)) = load("benchb_v210") else { return };+        assert!(fine(&b, &r, "U3"));+        assert!(!fine(&b, &r, "U2"));+        assert!(!fine(&b, &r, "Q1"));+        let Some((b, r)) = load("benchc_v10") else { return };+        assert!(fine(&b, &r, "U6"));+        assert!(fine(&b, &r, "U11"));+    }+}

@@ -0,0 +1,368 @@+//! Net by net against a reference board: length, vias, layers, widths, bends and spacing. The designer's+//! finished boards are the grade (4.6), so this is how cost weights are calibrated: change a weight,+//! route, compare, and keep it only if the board moves toward the reference copper. Reads only the two files.++use crate::board::*;+use crate::classify::*;+use crate::conn;+use crate::geom::*;+use crate::index::*;+use crate::router::build_world;+use crate::rules::Rules;+use serde_json::{json, Value};+use std::collections::{BTreeMap, HashMap};++#[derive(Default, Clone, Debug)]+pub struct NetStat {+    pub level: String,+    pub len: f64,+    pub top: f64,+    pub bottom: f64,+    pub vias: usize,+    pub bends45: usize,+    pub bends90: usize,+    /// Copper length per width in mm, keyed by the width in microns.+    pub widths: BTreeMap<i64, f64>,+    /// The shortest octilinear tree over the net's pads (lower bound for its copper).+    pub tree: f64,+    pub open: usize,+    /// Places where the width changes along a run.+    pub steps: usize,+    /// Same-net tracks running side by side: within 0.4 mm centre to centre, for 0.3 mm or more.+    pub doubled: usize,+}++/// Length-weighted spacing, over copper outside fine-pitch escapes and inside them.+#[derive(Default, Clone, Debug)]+pub struct Spacing {+    pub open_total: f64,+    pub open_3w: f64,+    pub open_2w: f64,+    pub open_min: f64,+    pub esc_total: f64,+    pub data_open_total: f64,+    pub data_open_in_band: f64,+    pub data_open_neck: f64,+}++fn octile(a: V, b: V) -> f64 {+    let (dx, dy) = ((a.0 - b.0).abs(), (a.1 - b.1).abs());+    let (hi, lo) = if dx > dy { (dx, dy) } else { (dy, dx) };+    (hi - lo) + lo * SQRT2+}++fn key(p: P) -> P {+    ((p.0 + 1000).div_euclid(2000), (p.1 + 1000).div_euclid(2000))+}++/// Prim over the net's pads, octile metric: the length a straight daisy chain could not beat by much.+fn tree_len(board: &Board, pads: &[usize]) -> f64 {+    if pads.len() < 2 {+        return 0.0;+    }+    let c: Vec<V> = pads.iter().map(|&p| board.pads[p].center.into()).collect();+    let mut best: Vec<f64> = c.iter().map(|&x| octile(x, c[0])).collect();+    let mut done = vec![false; c.len()];+    done[0] = true;+    let mut total = 0.0;+    for _ in 1..c.len() {+        let (i, d) = best.iter().enumerate().filter(|(i, _)| !done[*i]).map(|(i, d)| (i, *d)).min_by(|a, b| a.1.total_cmp(&b.1)).unwrap();+        total += d;+        done[i] = true;+        for j in 0..c.len() {+            best[j] = best[j].min(octile(c[i], c[j]));+        }+    }+    total+}++pub fn measure(board: &Board, rules: &Rules) -> (BTreeMap<String, NetStat>, Spacing) {+    let infos = classify(board, rules);+    let groups = conn::pad_groups(board, &[]);+    let world = build_world(board, rules);+    let mut out: BTreeMap<String, NetStat> = BTreeMap::new();+    let mut level_of: HashMap<NetId, Level> = HashMap::new();+    for i in &infos {+        let live = groups.get(&i.net).map(|g| g.iter().filter(|grp| grp.iter().any(|p| i.pads.contains(p))).count()).unwrap_or(0);+        level_of.insert(i.net, i.level);+        out.insert(board.net_name(i.net).to_string(), NetStat { level: i.level.name().to_string(), tree: tree_len(board, &i.pads) / NM, open: live.saturating_sub(1), ..Default::default() });+    }+    let last = board.layers.len() - 1;+    for t in &board.tracks {+        let e = out.entry(board.net_name(t.net).to_string()).or_default();+        let l = hypot(sub(t.a.into(), t.b.into())) / NM;+        e.len += l;+        if t.layer == 0 {+            e.top += l;+        } else if t.layer == last {+            e.bottom += l;+        }+        *e.widths.entry(t.width / 1000).or_insert(0.0) += l;+    }+    for v in &board.vias {+        out.entry(board.net_name(v.net).to_string()).or_default().vias += 1;+    }+    // Bends: a node on one layer with exactly two tracks, not hidden in a pad or its own fill.+    let mut nodes: HashMap<(NetId, usize, P), Vec<(P, P)>> = HashMap::new();+    let mut widths: HashMap<(NetId, usize, P), Vec<i64>> = HashMap::new();+    for t in &board.tracks {+        if t.a != t.b {+            nodes.entry((t.net, t.layer, key(t.a))).or_default().push((t.a, t.b));+            nodes.entry((t.net, t.layer, key(t.b))).or_default().push((t.b, t.a));+            widths.entry((t.net, t.layer, key(t.a))).or_default().push(t.width);+            widths.entry((t.net, t.layer, key(t.b))).or_default().push(t.width);+        }+    }+    for (k, w) in &widths {+        if w.len() == 2 && w[0] != w[1] {+            out.entry(board.net_name(k.0).to_string()).or_default().steps += 1;+        }+    }+    for (i, t) in board.tracks.iter().enumerate() {+        for o in board.tracks[i + 1..].iter().filter(|o| o.net == t.net && o.layer == t.layer) {+            if side_by_side(t, o) {+                out.entry(board.net_name(t.net).to_string()).or_default().doubled += 1;+            }+        }+    }+    for ((net, layer, _), list) in &nodes {+        if list.len() != 2 {+            continue;+        }+        let at: V = list[0].0.into();+        let hidden = board.pads.iter().any(|q| q.net == *net && q.layers.contains(layer) && q.shape.dist_pt(at) <= 0.25 * NM) || world.zones.iter().any(|(zn, zl, poly)| zn == net && zl == layer && in_poly(at, poly));+        if hidden {+            continue;+        }+        let ang = |x: (P, P)| ((x.1 .1 - x.0 .1) as f64).atan2((x.1 .0 - x.0 .0) as f64).to_degrees();+        let d = (ang(list[0]) - ang(list[1])).rem_euclid(360.0);+        let turn = 180.0 - d.min(360.0 - d);+        let e = out.entry(board.net_name(*net).to_string()).or_default();+        if (turn - 45.0).abs() < 3.0 {+            e.bends45 += 1;+        } else if (turn - 90.0).abs() < 3.0 {+            e.bends90 += 1;+        }+    }+    (out, spacing(board, rules, &world, &level_of))+}++/// Of the signal vias, how many have a via of a plane net within `reach` (4.4: any signal via benefits+/// from a GND via close by). Returns (with one close by, all signal vias).+pub fn vias_near_ground(board: &Board, reach: f64) -> (usize, usize) {+    let planes = board.plane_nets();+    let ground: Vec<V> = board.vias.iter().filter(|v| planes.contains_key(&v.net)).map(|v| v.at.into()).collect();+    let power: Vec<&Via> = board.vias.iter().filter(|v| !planes.contains_key(&v.net) && !looks_power(board.net_name(v.net))).collect();+    let near = power.iter().filter(|v| ground.iter().any(|g| hypot(sub(*g, v.at.into())) <= reach)).count();+    (near, power.len())+}++fn side_by_side(t: &Track, o: &Track) -> bool {+    let (a, b): (V, V) = (t.a.into(), t.b.into());+    let (c, d): (V, V) = (o.a.into(), o.b.into());+    let (l, m) = (hypot(sub(b, a)), hypot(sub(d, c)));+    if l < 1.0 || m < 1.0 {+        return false;+    }+    let u = V((b.0 - a.0) / l, (b.1 - a.1) / l);+    if ((d.1 - c.1) / m * u.0 - (d.0 - c.0) / m * u.1).abs() > 0.02 {+        return false;+    }+    let off = ((c.0 - a.0) * -u.1 + (c.1 - a.1) * u.0).abs();+    let t0 = (c.0 - a.0) * u.0 + (c.1 - a.1) * u.1;+    let t1 = (d.0 - a.0) * u.0 + (d.1 - a.1) * u.1;+    off <= 0.4 * NM && l.min(t0.max(t1)) - t0.min(t1).max(0.0) >= 0.3 * NM+}++/// Walks all copper in small steps and buckets each step by its distance to other nets. 3W and 2W+/// are measured on the track's own width, as 4.2 states them. Fills are skipped: they refill around+/// tracks, so a gap to one says nothing about the routing.+fn spacing(board: &Board, rules: &Rules, world: &crate::search::World, level_of: &HashMap<NetId, Level>) -> Spacing {+    let mut s = Spacing::default();+    let step = 0.2 * NM;+    for t in &board.tracks {+        let (a, b): (V, V) = (t.a.into(), t.b.into());+        let len = hypot(sub(a, b));+        let n = (len / step).ceil().max(1.0) as usize;+        let half = t.width as f64 / 2.0;+        for i in 0..n {+            let (u, v) = (i as f64 / n as f64, (i + 1) as f64 / n as f64);+            let p = V(a.0 + (b.0 - a.0) * u, a.1 + (b.1 - a.1) * u);+            let q = V(a.0 + (b.0 - a.0) * v, a.1 + (b.1 - a.1) * v);+            let piece = len / n as f64 / NM;+            let m = V((p.0 + q.0) / 2.0, (p.1 + q.1) / 2.0);+            if world.in_escape(m) {+                s.esc_total += piece;+                continue;+            }+            let reach = half + t.width as f64 * 3.0 + 1000.0;+            let bb = (p.0.min(q.0) - reach, p.1.min(q.1) - reach, p.0.max(q.0) + reach, p.1.max(q.1) + reach);+            let mut gap = f64::INFINITY;+            world.layers[t.layer].visit(bb, |o| {+                if o.net != t.net && !matches!(o.owner, Owner::Zone(_)) {+                    gap = gap.min(o.shape.dist_seg(p, q) - half);+                }+                true+            });+            s.open_total += piece;+            let w = t.width as f64;+            // 3W and 2W are centre to centre: 3W leaves a gap of 2W, 2W a gap of 1W (4.2).+            if gap >= w * 2.0 - 1000.0 {+                s.open_3w += piece;+            } else if gap >= w - 1000.0 {+                s.open_2w += piece;+            } else {+                s.open_min += piece;+            }+            if matches!(level_of.get(&t.net), Some(Level::Data) | Some(Level::Other)) {+                s.data_open_total += piece;+                if t.width >= rules.track - 1000 && t.width <= mm(0.3) + 1000 {+                    s.data_open_in_band += piece;+                } else if t.width <= rules.neck + 1000 {+                    s.data_open_neck += piece;+                }+            }+        }+    }+    s+}++/// Per pair: length each side, skew, and how much of the positive net runs coupled to the negative+/// one (edge to edge within 0.35 mm on the same layer; 4.2 wants the spec held but at pad and via).+pub fn pairs(board: &Board, rules: &Rules) -> Vec<(String, f64, f64, f64, f64)> {+    let mut out = Vec::new();+    for pr in &rules.pairs {+        let (Some(&p), Some(&n)) = (board.net_ids.get(&pr.p), board.net_ids.get(&pr.n)) else { continue };+        let len = |net: NetId| -> f64 { board.tracks.iter().filter(|t| t.net == net).map(|t| hypot(sub(t.a.into(), t.b.into()))).sum::<f64>() / NM };+        let mut coupled = 0.0;+        let mut gap_sum = 0.0;+        for t in board.tracks.iter().filter(|t| t.net == p) {+            let (a, b): (V, V) = (t.a.into(), t.b.into());+            let l = hypot(sub(a, b));+            let steps = (l / (0.05 * NM)).ceil().max(1.0) as usize;+            for i in 0..steps {+                let u = (i as f64 + 0.5) / steps as f64;+                let c = V(a.0 + (b.0 - a.0) * u, a.1 + (b.1 - a.1) * u);+                let mut near = f64::INFINITY;+                for o in board.tracks.iter().filter(|o| o.net == n && o.layer == t.layer) {+                    near = near.min(pt_seg(c, o.a.into(), o.b.into()) - (t.width + o.width) as f64 / 2.0);+                }+                if near <= 0.35 * NM {+                    coupled += l / steps as f64 / NM;+                    gap_sum += near * (l / steps as f64) / NM / NM;+                }+            }+        }+        out.push((format!("{}/{}", pr.p, pr.n), len(p), len(n), coupled, if coupled > 0.0 { gap_sum / coupled } else { 0.0 }));+    }+    out+}++fn widths_text(w: &BTreeMap<i64, f64>) -> String {+    let mut v: Vec<(&i64, &f64)> = w.iter().collect();+    v.sort_by(|a, b| b.1.total_cmp(a.1));+    v.iter().take(3).map(|(k, l)| format!("{:.2}:{:.1}", **k as f64 / 1000.0, l)).collect::<Vec<_>>().join(" ")+}++fn pct(a: f64, t: f64) -> f64 {+    if t > 0.0 { 100.0 * a / t } else { 0.0 }+}++fn spacing_json(s: &Spacing) -> Value {+    json!({+        "openMm": s.open_total, "escapeMm": s.esc_total,+        "at3wPct": pct(s.open_3w, s.open_total), "at2wPct": pct(s.open_2w, s.open_total), "tighterPct": pct(s.open_min, s.open_total),+        "dataOpenMm": s.data_open_total, "dataInBandPct": pct(s.data_open_in_band, s.data_open_total), "dataAtNeckPct": pct(s.data_open_neck, s.data_open_total),+    })+}++/// Prints the comparison, biggest length difference first. The summary line carries the one number+/// to minimise when calibrating: the sum over nets of |ours - his| length, plus 3 mm per via off.+pub fn report(ours: &Board, reference: &Board, rules: &Rules, as_json: bool) -> Value {+    let (a, sa) = measure(ours, rules);+    let (b, sb) = measure(reference, rules);+    let (bus_n, bus_ours, bus_mm) = crate::bus::coherence(ours, rules);+    let (_, bus_his, bus_his_mm) = crate::bus::coherence(reference, rules);+    if !as_json {+        println!("  buses: {bus_n} bus lines; {:.0}% of their length runs beside the next line in the bus (reference {:.0}%), over {:.0} mm (reference {:.0} mm).", bus_ours * 100.0, bus_his * 100.0, bus_mm, bus_his_mm);+    }+    let mut rows: Vec<(String, NetStat, NetStat)> = Vec::new();+    for (n, x) in &b {+        if x.len > 0.0 || x.vias > 0 || a.get(n).map(|y| y.len > 0.0).unwrap_or(false) {+            rows.push((n.clone(), a.get(n).cloned().unwrap_or_default(), x.clone()));+        }+    }+    rows.sort_by(|p, q| (q.1.len - q.2.len).abs().total_cmp(&(p.1.len - p.2.len).abs()));+    let mut score = 0.0;+    let (mut la, mut lb, mut va, mut vb, mut ba, mut bb, mut open) = (0.0, 0.0, 0, 0, 0, 0, 0);+    let mut per_net = Vec::new();+    // The same distance over only the nets we closed, bends included, so a calibration run isn't+    // judged by how far the clock let it get.+    let (mut closed, mut closed_nets) = (0.0, 0);+    for (n, x, y) in &rows {+        score += (x.len - y.len).abs() + 3.0 * (x.vias as f64 - y.vias as f64).abs();+        if x.open == 0 {+            closed += (x.len - y.len).abs() + 3.0 * (x.vias as f64 - y.vias as f64).abs() + 0.3 * ((x.bends45 + x.bends90) as f64 - (y.bends45 + y.bends90) as f64).abs();+            closed_nets += 1;+        }+        la += x.len;+        lb += y.len;+        va += x.vias;+        vb += y.vias;+        ba += x.bends45 + x.bends90;+        bb += y.bends45 + y.bends90;+        open += x.open;+        per_net.push(json!({"net": n, "level": y.level, "treeMm": y.tree, "open": x.open,+            "ours": {"mm": x.len, "top": x.top, "bottom": x.bottom, "vias": x.vias, "bends45": x.bends45, "bends90": x.bends90, "widths": widths_text(&x.widths)},+            "his": {"mm": y.len, "top": y.top, "bottom": y.bottom, "vias": y.vias, "bends45": y.bends45, "bends90": y.bends90, "widths": widths_text(&y.widths)}}));+    }+    let tally = |m: &BTreeMap<String, NetStat>| (m.values().map(|n| n.steps).sum::<usize>(), m.values().map(|n| n.doubled).sum::<usize>());+    let (ta, tb) = (tally(&a), tally(&b));+    let v = json!({"widthSteps": [ta.0, tb.0], "doubledRuns": [ta.1, tb.1], "score": score, "closedScore": closed, "closedNets": closed_nets, "lengthMm": [la, lb], "vias": [va, vb], "bends": [ba, bb], "open": open, "spacing": {"ours": spacing_json(&sa), "his": spacing_json(&sb)}, "nets": per_net});+    if !as_json {+        println!("OK: distance from the reference copper {:.1} (sum of |length diff| + 3 per via off); {:.1} mm against the reference's {:.1}, {} vias against {}, {} bends against {}, {} joins open. On the {} nets closed: {:.1} with bends at 0.3 each.", score, la, lb, va, vb, ba, bb, open, closed_nets, closed);+        println!("  width steps {} against the reference's {}; same-net doubled runs {} against the reference's {}.", ta.0, tb.0, ta.1, tb.1);+        for (who, s) in [("ours", &sa), ("ref ", &sb)] {+            println!("  spacing {who}: outside escapes {:.1} mm: {:.0}% at 3W, {:.0}% at 2W, {:.0}% tighter; in escapes {:.1} mm. Data outside escapes {:.1} mm: {:.0}% at 0.2-0.3 wide, {:.0}% at the neck.", s.open_total, pct(s.open_3w, s.open_total), pct(s.open_2w, s.open_total), pct(s.open_min, s.open_total), s.esc_total, s.data_open_total, pct(s.data_open_in_band, s.data_open_total), pct(s.data_open_neck, s.data_open_total));+        }+        let long = |pick: &dyn Fn(&(String, NetStat, NetStat)) -> f64| rows.iter().filter(|r| r.2.tree > 1.0 * NM / NM && r.2.level != "plane via" && pick(r) > r.2.tree * 1.4 + 2.5).map(|r| r.0.as_str()).collect::<Vec<_>>().join(" ");+        println!("  over 1.4 x tree + 2.5 mm, ours: [{}]; reference: [{}].", long(&|r| r.1.len), long(&|r| r.2.len));+        for (who, b) in [("ours", ours), ("ref ", reference)] {+            let (n, t) = vias_near_ground(b, 1.5 * NM);+            println!("  signal vias {who}: {n} of {t} have a plane via within 1.5 mm.");+        }+        for (who, list) in [("ours", pairs(ours, rules)), ("ref ", pairs(reference, rules))] {+            for (name, lp, ln, c, g) in list {+                println!("  pair {who} {name}: {lp:.2} / {ln:.2} mm, skew {:.3} mm, coupled {c:.2} mm ({:.0}% of the positive net), mean gap {g:.3} mm.", (lp - ln).abs(), if lp > 0.0 { 100.0 * c / lp } else { 0.0 });+            }+        }+        println!("  {:<16} {:<10} {:>6} | {:>7} {:>7} {:>6} {:>6} {:>4} {:>5} {:<22} | {:>7} {:>7} {:>6} {:>6} {:>4} {:>5} {}", "net", "level", "tree", "mm", "ratio", "top", "bot", "via", "bends", "widths mm:len", "ref mm", "ratio", "top", "bot", "via", "bends", "widths");+        for (n, x, y) in &rows {+            let r = |l: f64| if y.tree > 0.0 { l / y.tree } else { 0.0 };+            println!(+                "  {:<16} {:<10} {:>6.1} | {:>7.1} {:>7.2} {:>6.1} {:>6.1} {:>4} {:>2}/{:<2} {:<22} | {:>7.1} {:>7.2} {:>6.1} {:>6.1} {:>4} {:>2}/{:<2} {}{}",+                n.chars().take(16).collect::<String>(),+                y.level.chars().take(10).collect::<String>(),+                y.tree,+                x.len,+                r(x.len),+                x.top,+                x.bottom,+                x.vias,+                x.bends45,+                x.bends90,+                widths_text(&x.widths),+                y.len,+                r(y.len),+                y.top,+                y.bottom,+                y.vias,+                y.bends45,+                y.bends90,+                widths_text(&y.widths),+                if x.open > 0 { format!("  OPEN {}", x.open) } else { String::new() }+            );+        }+    }+    v+}

@@ -0,0 +1,315 @@+//! Connectivity from copper alone: which pads of a net are joined by tracks, vias and zones.+//! Used by the checker and to find what still has to be routed on a partly routed board.++use crate::board::*;+use crate::geom::*;+use std::collections::HashMap;++#[derive(Clone)]+pub struct Uf(Vec<u32>);+impl Uf {+    pub fn new(n: usize) -> Uf {+        Uf((0..n as u32).collect())+    }+    pub fn find(&mut self, a: u32) -> u32 {+        let mut r = a;+        while self.0[r as usize] != r {+            r = self.0[r as usize];+        }+        let mut c = a;+        while self.0[c as usize] != r {+            let n = self.0[c as usize];+            self.0[c as usize] = r;+            c = n;+        }+        r+    }+    pub fn union(&mut self, a: u32, b: u32) {+        let (x, y) = (self.find(a), self.find(b));+        if x != y {+            self.0[x as usize] = y;+        }+    }+}++/// One piece of copper on one or more layers, for connectivity.+pub enum Piece {+    Pad(usize),+    Seg { layer: usize, a: V, b: V, r: f64 },+    Via { at: V, r: f64 },+    Fill { layer: usize, pts: Vec<V> },+}++pub fn touches(p: &Piece, q: &Piece, board: &Board) -> bool {+    use Piece::*;+    match (p, q) {+        (Pad(i), Pad(j)) => {+            let (a, b) = (&board.pads[*i], &board.pads[*j]);+            a.layers.iter().any(|l| b.layers.contains(l)) && a.shape.dist_shape(&b.shape) <= 1.0+        }+        (Pad(i), Seg { layer, a, b, r }) | (Seg { layer, a, b, r }, Pad(i)) => {+            let pad = &board.pads[*i];+            pad.layers.contains(layer) && pad.shape.dist_seg(*a, *b) <= r + 1.0+        }+        (Pad(i), Via { at, r }) | (Via { at, r }, Pad(i)) => board.pads[*i].shape.dist_pt(*at) <= r + 1.0 && !board.pads[*i].layers.is_empty(),+        (Pad(i), Fill { layer, pts }) | (Fill { layer, pts }, Pad(i)) => {+            let pad = &board.pads[*i];+            pad.layers.contains(layer) && shape_meets_poly(&pad.shape, pts)+        }+        (Seg { layer: l1, a, b, r }, Seg { layer: l2, a: c, b: d, r: s }) => l1 == l2 && seg_seg(*a, *b, *c, *d) <= r + s + 1.0,+        (Seg { a, b, r, .. }, Via { at, r: s }) | (Via { at, r: s }, Seg { a, b, r, .. }) => pt_seg(*at, *a, *b) <= r + s + 1.0,+        (Seg { layer: l1, a, b, r }, Fill { layer: l2, pts }) | (Fill { layer: l2, pts }, Seg { layer: l1, a, b, r }) => {+            l1 == l2 && (in_poly(*a, pts) || in_poly(*b, pts) || poly_seg_dist(pts, *a, *b) <= *r + 1.0)+        }+        (Via { at: a, r }, Via { at: b, r: s }) => hypot(sub(*a, *b)) <= r + s + 1.0,+        (Via { at, r }, Fill { pts, .. }) | (Fill { pts, .. }, Via { at, r }) => in_poly(*at, pts) || poly_seg_dist(pts, *at, *at) <= *r,+        (Fill { layer: l1, pts: a }, Fill { layer: l2, pts: b }) => l1 == l2 && polys_meet(a, b),+    }+}++/// Two fills are one piece of copper as soon as they overlap anywhere. Testing a single vertex+/// missed overlapping zones whose first vertices lie outside each other, which split nets KiCad+/// sees as joined (benchmark B's GND, +PS1_SENS, -PS1 and +PS2_RLY fills).+fn polys_meet(a: &[V], b: &[V]) -> bool {+    let bb = |p: &[V]| p.iter().fold((f64::MAX, f64::MAX, f64::MIN, f64::MIN), |m, v| (m.0.min(v.0), m.1.min(v.1), m.2.max(v.0), m.3.max(v.1)));+    let (ba, bc) = (bb(a), bb(b));+    if ba.0 > bc.2 + 1.0 || bc.0 > ba.2 + 1.0 || ba.1 > bc.3 + 1.0 || bc.1 > ba.3 + 1.0 {+        return false;+    }+    if a.iter().any(|p| in_poly(*p, b)) || b.iter().any(|p| in_poly(*p, a)) {+        return true;+    }+    let (n, m) = (a.len(), b.len());+    for i in 0..n {+        let (p, q) = (a[i], a[(i + 1) % n]);+        if p.0.max(q.0) < bc.0 || p.0.min(q.0) > bc.2 || p.1.max(q.1) < bc.1 || p.1.min(q.1) > bc.3 {+            continue;+        }+        for j in 0..m {+            if seg_seg(p, q, b[j], b[(j + 1) % m]) <= 1.0 {+                return true;+            }+        }+    }+    false+}++fn poly_seg_dist(pts: &[V], a: V, b: V) -> f64 {+    let n = pts.len();+    let mut d = f64::INFINITY;+    for i in 0..n {+        d = d.min(seg_seg(a, b, pts[i], pts[(i + 1) % n]));+    }+    d+}++pub(crate) fn shape_meets_poly(s: &Shape, pts: &[V]) -> bool {+    let c = s.center();+    if in_poly(c, pts) {+        return true;+    }+    let n = pts.len();+    for i in 0..n {+        if s.dist_seg(pts[i], pts[(i + 1) % n]) <= 1.0 {+            return true;+        }+    }+    false+}++/// Groups of pad indices per net that the copper on `board` already joins. `extra` adds copper+/// from a route in progress, as (net, piece).+/// One connected piece of a net's copper.+pub struct Island {+    pub net: NetId,+    pub has_pad: bool,+    pub fill_pieces: usize,+    pub tracks: usize,+    pub vias: usize,+    pub layer: usize,+    pub at: V,+    pub area: f64,+}++/// Every connected piece of copper on the board, net by net, pads or none. `pad_groups` keeps only+/// what touches a pad, so a fill nothing feeds is invisible to it.+pub fn islands(board: &Board) -> Vec<Island> {+    let mut by_net: HashMap<NetId, Vec<Piece>> = HashMap::new();+    for (i, p) in board.pads.iter().enumerate() {+        if p.net != NO_NET && !p.layers.is_empty() {+            by_net.entry(p.net).or_default().push(Piece::Pad(i));+        }+    }+    for t in &board.tracks {+        if t.net != NO_NET {+            by_net.entry(t.net).or_default().push(Piece::Seg { layer: t.layer, a: t.a.into(), b: t.b.into(), r: t.width as f64 / 2.0 });+        }+    }+    for v in &board.vias {+        if v.net != NO_NET {+            by_net.entry(v.net).or_default().push(Piece::Via { at: v.at.into(), r: v.size as f64 / 2.0 });+        }+    }+    for z in &board.zones {+        if z.net == NO_NET || z.keepout_tracks {+            continue;+        }+        if z.fills.is_empty() {+            for &l in &z.layers {+                by_net.entry(z.net).or_default().push(Piece::Fill { layer: l, pts: z.outline.clone() });+            }+        } else {+            for (l, pts) in &z.fills {+                by_net.entry(z.net).or_default().push(Piece::Fill { layer: *l, pts: pts.clone() });+            }+        }+    }+    let mut out = Vec::new();+    for (net, pieces) in by_net {+        let mut uf = Uf::new(pieces.len());+        for i in 0..pieces.len() {+            for j in i + 1..pieces.len() {+                if uf.find(i as u32) != uf.find(j as u32) && touches(&pieces[i], &pieces[j], board) {+                    uf.union(i as u32, j as u32);+                }+            }+        }+        let mut groups: HashMap<u32, Island> = HashMap::new();+        for (i, p) in pieces.iter().enumerate() {+            let isl = groups.entry(uf.find(i as u32)).or_insert(Island { net, has_pad: false, fill_pieces: 0, tracks: 0, vias: 0, layer: 0, at: V(0.0, 0.0), area: 0.0 });+            match p {+                Piece::Pad(_) => isl.has_pad = true,+                Piece::Seg { layer, a, .. } => {+                    isl.tracks += 1;+                    if isl.fill_pieces == 0 {+                        isl.layer = *layer;+                        isl.at = *a;+                    }+                }+                Piece::Via { at, .. } => {+                    isl.vias += 1;+                    if isl.fill_pieces == 0 && isl.tracks == 0 {+                        isl.at = *at;+                    }+                }+                Piece::Fill { layer, pts } => {+                    isl.fill_pieces += 1;+                    isl.layer = *layer;+                    isl.at = pts.first().copied().unwrap_or(V(0.0, 0.0));+                    let n = pts.len();+                    let a: f64 = (0..n).map(|k| pts[k].0 * pts[(k + 1) % n].1 - pts[(k + 1) % n].0 * pts[k].1).sum();+                    isl.area += (a / 2.0).abs();+                }+            }+        }+        out.extend(groups.into_values());+    }+    out.sort_by(|a, b| (a.net, a.at.0.to_bits()).cmp(&(b.net, b.at.0.to_bits())));+    out+}++pub fn pad_groups(board: &Board, extra: &[(NetId, Piece)]) -> HashMap<NetId, Vec<Vec<usize>>> {+    let mut by_net: HashMap<NetId, Vec<Piece>> = HashMap::new();+    for (i, p) in board.pads.iter().enumerate() {+        if p.net != NO_NET && !p.layers.is_empty() {+            by_net.entry(p.net).or_default().push(Piece::Pad(i));+        }+    }+    for t in &board.tracks {+        by_net.entry(t.net).or_default().push(Piece::Seg { layer: t.layer, a: t.a.into(), b: t.b.into(), r: t.width as f64 / 2.0 });+    }+    for v in &board.vias {+        by_net.entry(v.net).or_default().push(Piece::Via { at: v.at.into(), r: v.size as f64 / 2.0 });+    }+    for z in &board.zones {+        if z.net == NO_NET || z.keepout_tracks {+            continue;+        }+        if z.fills.is_empty() {+            for &l in &z.layers {+                by_net.entry(z.net).or_default().push(Piece::Fill { layer: l, pts: z.outline.clone() });+            }+        } else {+            for (l, pts) in &z.fills {+                by_net.entry(z.net).or_default().push(Piece::Fill { layer: *l, pts: pts.clone() });+            }+        }+    }+    for (n, p) in extra {+        let q = match p {+            Piece::Pad(i) => Piece::Pad(*i),+            Piece::Seg { layer, a, b, r } => Piece::Seg { layer: *layer, a: *a, b: *b, r: *r },+            Piece::Via { at, r } => Piece::Via { at: *at, r: *r },+            Piece::Fill { layer, pts } => Piece::Fill { layer: *layer, pts: pts.clone() },+        };+        by_net.entry(*n).or_default().push(q);+    }+    let mut out = HashMap::new();+    for (net, pieces) in by_net {+        let mut uf = Uf::new(pieces.len());+        for i in 0..pieces.len() {+            for j in i + 1..pieces.len() {+                if uf.find(i as u32) != uf.find(j as u32) && touches(&pieces[i], &pieces[j], board) {+                    uf.union(i as u32, j as u32);+                }+            }+        }+        let mut groups: HashMap<u32, Vec<usize>> = HashMap::new();+        for (i, p) in pieces.iter().enumerate() {+            if let Piece::Pad(k) = p {+                groups.entry(uf.find(i as u32)).or_default().push(*k);+            }+        }+        let mut v: Vec<Vec<usize>> = groups.into_values().collect();+        v.sort();+        out.insert(net, v);+    }+    out+}++/// `pad_groups` for one net, with routed copper in progress: cheap enough to ask during routing.+pub fn net_groups(board: &Board, net: NetId, extra: &[(NetId, Piece)]) -> Vec<Vec<usize>> {+    let mut pieces: Vec<&Piece> = Vec::new();+    let mut own: Vec<Piece> = Vec::new();+    for (i, p) in board.pads.iter().enumerate() {+        if p.net == net && !p.layers.is_empty() {+            own.push(Piece::Pad(i));+        }+    }+    for t in board.tracks.iter().filter(|t| t.net == net) {+        own.push(Piece::Seg { layer: t.layer, a: t.a.into(), b: t.b.into(), r: t.width as f64 / 2.0 });+    }+    for v in board.vias.iter().filter(|v| v.net == net) {+        own.push(Piece::Via { at: v.at.into(), r: v.size as f64 / 2.0 });+    }+    for z in board.zones.iter().filter(|z| z.net == net && !z.keepout_tracks) {+        if z.fills.is_empty() {+            for &l in &z.layers {+                own.push(Piece::Fill { layer: l, pts: z.outline.clone() });+            }+        } else {+            for (l, pts) in &z.fills {+                own.push(Piece::Fill { layer: *l, pts: pts.clone() });+            }+        }+    }+    pieces.extend(own.iter());+    pieces.extend(extra.iter().filter(|(n, _)| *n == net).map(|(_, p)| p));+    let mut uf = Uf::new(pieces.len());+    for i in 0..pieces.len() {+        for j in i + 1..pieces.len() {+            if uf.find(i as u32) != uf.find(j as u32) && touches(pieces[i], pieces[j], board) {+                uf.union(i as u32, j as u32);+            }+        }+    }+    let mut groups: HashMap<u32, Vec<usize>> = HashMap::new();+    for (i, p) in pieces.iter().enumerate() {+        if let Piece::Pad(k) = p {+            groups.entry(uf.find(i as u32)).or_default().push(*k);+        }+    }+    let mut v: Vec<Vec<usize>> = groups.into_values().collect();+    v.sort();+    v+}

@@ -0,0 +1,327 @@+//! What a rail's copper must carry (4.2 Current capacity). The chart, and the current through each+//! track found from the copper actually connected: pours included, sources at one end and each+//! part's own draw at the other, so a thin track to a pull-up is a branch and not the feed.+//!+//! The chart is IPC-2152's conservative chart, which is the old IPC-2221 internal-conductor chart,+//! as a published curve fit: I = 0.024 dT^0.44 A^0.725, A in square mils. Checked in this repo's+//! work against MIL-STD-275E Figure 4b within 5% at 1 A and above at 20 C; 3 A at 20 C in 35 um gives+//! 2.34 mm against the reference's 2.3 mm. IPC-2152 itself is paywalled and was not read. A board of 3 x 3 in or+//! more with such a plane under the trace may use the universal chart with modifiers; that chart+//! is not sourced here, so it gets this one, which is wider and so safe.++use crate::board::*;+use crate::conn::{touches, Piece};+use crate::geom::*;+use crate::rules::{RailSpec, Rules};++const MIL2_PER_MM2: f64 = 1550.0031;++/// The most of a rail's voltage its copper may lose between a source and a load: the designer's limit,+/// 2026-11-09 (0.25% of the rail). Currents as the rail spec rates them: an off-board contact by+/// what its supply can deliver, an internal rail by the most its devices can pull.+pub const DROP_LIMIT: f64 = 0.0025;+/// Copper's resistivity at 20 C, ohm metres (the International Annealed Copper Standard).+pub const RHO_CU: f64 = 1.7241e-8;+/// Hole wall copper: JLCPCB's capability table, "Average Hole Plating Thickness 18 um"+/// (jlcpcb.com/capabilities/pcb-capabilities, read 2026-11-09).+pub const VIA_PLATING_UM: f64 = 18.0;+/// A via's length for its resistance: a standard 1.6 mm board (the stackup isn't read here).+const VIA_LENGTH_MM: f64 = 1.6;++/// What one load loses in the copper from its source.+pub struct Drop {+    pub load: String,+    pub amps: f64,+    pub volts: f64,+    pub limit: f64,+}++pub fn conservative_mm(amps: f64, rise_c: f64, copper_um: f64) -> f64 {+    if amps <= 0.0 || rise_c <= 0.0 || copper_um <= 0.0 {+        return 0.0;+    }+    (amps / (0.024 * rise_c.powf(0.44))).powf(1.0 / 0.725) / MIL2_PER_MM2 / (copper_um / 1000.0)+}++/// The board's F.Cu thickness from its stackup, 35 um when it states none.+pub fn outer_copper_um(text: &str) -> f64 {+    let Some(st) = text.find("(stackup") else { return 35.0 };+    let rest = &text[st..];+    let Some(l) = rest.find("(layer \"F.Cu\"") else { return 35.0 };+    let rest = &rest[l..];+    let Some(t) = rest.find("(thickness ") else { return 35.0 };+    let rest = &rest[t + 11..];+    rest.split(|c: char| c == ')' || c.is_whitespace()).next().and_then(|x| x.parse::<f64>().ok()).filter(|x| *x > 0.0).map(|x| x * 1000.0).unwrap_or(35.0)+}++/// One track's rating: index into `board.tracks`, what flows through it, and the width that needs.+pub struct Rated {+    pub track: usize,+    pub amps: f64,+    pub need: i64,+    /// The width comes from the voltage-drop limit, not the chart.+    pub by_drop: bool,+}++/// Each track of one rail that current has to pass through. A track in a loop has another way+/// round, so nothing here says it alone carries the load: it is left out rather than guessed at.+pub fn rate_rail(board: &Board, rules: &Rules, net: NetId, rail: &RailSpec) -> Vec<Rated> {+    analyse(board, rules, net, rail).0+}++/// What each load of a rail loses in its copper from the source, where the spec gives the rail's+/// voltage. Tracks and vias count; a pour on the way counts as no loss (it is far wider).+pub fn rail_drops(board: &Board, rules: &Rules, net: NetId, rail: &RailSpec) -> Vec<Drop> {+    analyse(board, rules, net, rail).1+}++fn analyse(board: &Board, rules: &Rules, net: NetId, rail: &RailSpec) -> (Vec<Rated>, Vec<Drop>) {+    let mut pieces: Vec<Piece> = Vec::new();+    let mut pad_of: Vec<Option<usize>> = Vec::new();+    let mut track_of: Vec<Option<usize>> = Vec::new();+    for (i, p) in board.pads.iter().enumerate().filter(|(_, p)| p.net == net && !p.layers.is_empty()) {+        pieces.push(Piece::Pad(i));+        pad_of.push(Some(i));+        track_of.push(None);+    }+    for (i, t) in board.tracks.iter().enumerate().filter(|(_, t)| t.net == net) {+        pieces.push(Piece::Seg { layer: t.layer, a: t.a.into(), b: t.b.into(), r: t.width as f64 / 2.0 });+        pad_of.push(None);+        track_of.push(Some(i));+    }+    for v in board.vias.iter().filter(|v| v.net == net) {+        pieces.push(Piece::Via { at: v.at.into(), r: v.size as f64 / 2.0 });+        pad_of.push(None);+        track_of.push(None);+    }+    for z in board.zones.iter().filter(|z| z.net == net && !z.keepout_tracks) {+        if z.fills.is_empty() {+            for &l in &z.layers {+                pieces.push(Piece::Fill { layer: l, pts: z.outline.clone() });+                pad_of.push(None);+                track_of.push(None);+            }+        } else {+            for (l, f) in &z.fills {+                pieces.push(Piece::Fill { layer: *l, pts: f.clone() });+                pad_of.push(None);+                track_of.push(None);+            }+        }+    }+    let n = pieces.len();+    let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];+    for i in 0..n {+        for j in i + 1..n {+            if touches(&pieces[i], &pieces[j], board) {+                adj[i].push(j);+                adj[j].push(i);+            }+        }+    }+    let reference = |k: usize| pad_of[k].map(|p| board.footprints[board.pads[p].fp].reference.as_str());+    let sources: Vec<usize> = (0..n).filter(|&k| reference(k).map(|r| rail.sources.iter().any(|s| s == r)).unwrap_or(false)).collect();+    if sources.is_empty() {+        return (Vec::new(), Vec::new());+    }+    let reach = |skip: Option<usize>| -> Vec<bool> {+        let mut seen = vec![false; n];+        let mut stack: Vec<usize> = sources.clone();+        for &s in &sources {+            seen[s] = true;+        }+        while let Some(k) = stack.pop() {+            for &m in &adj[k] {+                if !seen[m] && Some(m) != skip {+                    seen[m] = true;+                    stack.push(m);+                }+            }+        }+        seen+    };+    let all = reach(None);+    let mut out = Vec::new();+    for k in 0..n {+        let Some(t) = track_of[k] else { continue };+        if !all[k] {+            continue;+        }+        let seen = reach(Some(k));+        // A part is cut off when none of its pads on this net can still be reached.+        let mut flowing = 0.0;+        for (name, amps) in &rail.loads {+            let mine: Vec<usize> = (0..n).filter(|&m| reference(m) == Some(name.as_str())).collect();+            if !mine.is_empty() && mine.iter().all(|&m| !seen[m]) && mine.iter().any(|&m| all[m]) {+                flowing += *amps;+            }+        }+        let amps = flowing.min(rail.amps);+        if amps > 0.0 {+            let main = amps >= rail.amps - 1e-9;+            out.push(Rated { track: t, amps, need: rules.rail_width(amps, main), by_drop: false });+        }+    }+    // The drop to each load, along the copper that joins it to a source; where it is over the+    // limit, every track on the way widens by the same factor.+    let mut drops = Vec::new();+    if let Some(volts) = rail.volts.filter(|v| *v > 0.0) {+        let limit = volts * DROP_LIMIT;+        let mut parent: Vec<Option<usize>> = vec![None; n];+        let mut depth: Vec<usize> = vec![usize::MAX; n];+        let mut queue: std::collections::VecDeque<usize> = sources.iter().copied().collect();+        for &s in &sources {+            depth[s] = 0;+        }+        while let Some(k) = queue.pop_front() {+            for &m in &adj[k] {+                if depth[m] == usize::MAX {+                    depth[m] = depth[k] + 1;+                    parent[m] = Some(k);+                    queue.push_back(m);+                }+            }+        }+        let t_cu = rules.copper_um * 1e-6;+        let (plate, drill) = (VIA_PLATING_UM * 1e-6, to_mm(rules.via_for(net).1) * 1e-3);+        let r_via = RHO_CU * VIA_LENGTH_MM * 1e-3 / (std::f64::consts::PI * (drill + plate) * plate);+        let mut loads: Vec<(&String, &f64)> = rail.loads.iter().filter(|(_, a)| **a > 0.0).collect();+        // Heaviest first, each seeing the widths the ones before it asked for: a pull-up at the end+        // of a trunk loses what the trunk loses, and is put right by the trunk, not by widening+        // its own thin branch.+        loads.sort_by(|x, y| y.1.total_cmp(x.1).then(x.0.cmp(y.0)));+        let mut eff: std::collections::HashMap<usize, i64> = Default::default();+        for (name, amps) in loads {+            let Some(end) = (0..n).filter(|&m| depth[m] != usize::MAX && reference(m) == Some(name.as_str())).min_by_key(|&m| depth[m]) else { continue };+            let (mut v_tracks, mut v_vias, mut v_drawn) = (0.0, 0.0, 0.0);+            let mut on: Vec<(usize, f64)> = Vec::new();+            let mut k = end;+            while let Some(p) = parent[k] {+                match &pieces[k] {+                    Piece::Seg { a, b, r, .. } => {+                        if let Some(t) = track_of[k] {+                            let i = out.iter().find(|x| x.track == t).map(|x| x.amps).unwrap_or(*amps).max(*amps).min(rail.amps);+                            let (len, w) = (hypot(sub(*a, *b)) * 1e-9, eff.get(&t).map(|w| *w as f64).unwrap_or(2.0 * r) * 1e-9);+                            if w > 0.0 {+                                v_drawn += i * RHO_CU * len / (2.0 * r * 1e-9 * t_cu);+                                v_tracks += i * RHO_CU * len / (w * t_cu);+                                on.push((t, i));+                            }+                        }+                    }+                    // Vias of the net side by side share the current.+                    Piece::Via { at, .. } => {+                        let group = board.vias.iter().filter(|v| v.net == net && hypot(sub(V::from(v.at), *at)) <= 1.5 * NM).count().max(1);+                        v_vias += amps * r_via / group as f64;+                    }+                    _ => {}+                }+                k = p;+            }+            let total = v_tracks + v_vias;+            drops.push(Drop { load: name.clone(), amps: *amps, volts: v_drawn + v_vias, limit });+            if total > limit && v_tracks > 0.0 && limit > v_vias {+                // Only the stretches that matter widen: one that loses under a twentieth of the+                // path's drop (a thin branch carrying milliamps at the end of a trunk) stays.+                let lost = |t: usize, i: f64| -> f64 {+                    let tr = &board.tracks[t];+                    let w = eff.get(&t).copied().unwrap_or(tr.width) as f64 * 1e-9;+                    i * RHO_CU * hypot(sub(tr.a.into(), tr.b.into())) * 1e-9 / (w * t_cu)+                };+                let (big, small): (Vec<(usize, f64)>, Vec<(usize, f64)>) = on.iter().copied().partition(|&(t, i)| lost(t, i) >= v_tracks / 20.0);+                let (v_big, v_small): (f64, f64) = (big.iter().map(|&(t, i)| lost(t, i)).sum(), small.iter().map(|&(t, i)| lost(t, i)).sum());+                let room = limit - v_vias - v_small;+                let (on, f) = if room > 0.0 && v_big > 0.0 { (big, v_big / room) } else { (on, v_tracks / (limit - v_vias)) };+                for (t, i) in on {+                    let need = mm((to_mm(eff.get(&t).copied().unwrap_or(board.tracks[t].width)) * f * 100.0).ceil() / 100.0);+                    eff.insert(t, need);+                    match out.iter_mut().find(|x| x.track == t) {+                        Some(x) => {+                            if need > x.need {+                                x.need = need;+                                x.by_drop = true;+                            }+                        }+                        None => out.push(Rated { track: t, amps: i, need, by_drop: true }),+                    }+                }+            }+        }+    }+    (out, drops)+}++/// What pad `pad` itself draws from its rail, if its net has one and its part is listed.+pub fn pad_load(board: &Board, rules: &Rules, pad: usize) -> Option<f64> {+    let p = &board.pads[pad];+    let rail = rules.rail(board.net_name(p.net))?;+    let name = board.footprints[p.fp].reference.as_str();+    if rail.sources.iter().any(|s| s == name) {+        return Some(rail.amps);+    }+    Some(rail.loads.get(name).copied().unwrap_or(0.0).min(rail.amps))+}++/// What flows into each pad's branch of a rail: its own draw plus everything the rail feeds through+/// it. Parts are joined in the shortest tree from the sources (each part to the nearest one already+/// joined, as the router lays a rail's taps), and a part's branch carries its own load and the loads+/// of the parts hanging off it. A decoupling capacitor draws nothing itself, but the tap that reaches+/// it first carries its IC too: sized by the capacitor's own 0 A, benchmark C's +5V ran 33.6 mm at+/// 0.20 mm to U10, which draws 1.24 A (2026-11-06 to 11-09). Never more than the rail's current.+/// Empty when no source part of the rail is on the board.+pub fn branch_amps(board: &Board, net: NetId, rail: &RailSpec) -> std::collections::HashMap<usize, f64> {+    let mut parts: Vec<(usize, Vec<usize>)> = Vec::new();+    for (i, p) in board.pads.iter().enumerate().filter(|(_, p)| p.net == net && !p.layers.is_empty()) {+        match parts.iter_mut().find(|(fp, _)| *fp == p.fp) {+            Some((_, pads)) => pads.push(i),+            None => parts.push((p.fp, vec![i])),+        }+    }+    let n = parts.len();+    let name = |k: usize| board.footprints[parts[k].0].reference.as_str();+    let is_source = |k: usize| rail.sources.iter().any(|s| s == name(k));+    let mut out = std::collections::HashMap::new();+    if !(0..n).any(is_source) {+        return out;+    }+    let apart = |a: usize, b: usize| -> f64 {+        let mut best = f64::INFINITY;+        for &x in &parts[a].1 {+            for &y in &parts[b].1 {+                best = best.min(hypot(sub(board.pads[x].center.into(), board.pads[y].center.into())));+            }+        }+        best+    };+    let mut parent: Vec<Option<usize>> = vec![None; n];+    let mut joined: Vec<bool> = (0..n).map(is_source).collect();+    let mut order: Vec<usize> = Vec::new();+    loop {+        let mut best: Option<(f64, usize, usize)> = None;+        for k in (0..n).filter(|&k| !joined[k]) {+            for j in (0..n).filter(|&j| joined[j]) {+                let d = apart(k, j);+                if best.map(|b| d < b.0).unwrap_or(true) {+                    best = Some((d, k, j));+                }+            }+        }+        let Some((_, k, j)) = best else { break };+        joined[k] = true;+        parent[k] = Some(j);+        order.push(k);+    }+    let mut amps: Vec<f64> = (0..n).map(|k| if is_source(k) { 0.0 } else { rail.loads.get(name(k)).copied().unwrap_or(0.0) }).collect();+    for &k in order.iter().rev() {+        if let Some(p) = parent[k] {+            amps[p] += amps[k];+        }+    }+    for k in 0..n {+        let a = if is_source(k) { rail.amps } else { amps[k].min(rail.amps) };+        for &p in &parts[k].1 {+            out.insert(p, a);+        }+    }+    out+}

@@ -0,0 +1,207 @@+//! Fast tests cut from the reference boards: a few nets of a reference board routed alone, in seconds, with+//! pass/fail checks on the result. The whole-board benchmark takes 13 minutes on benchmark C and says+//! only how many joins were made; a fixture says whether one behaviour is right (the feed to U10+//! holds its width, the trunk does not run wide to a part that draws 3 mA) and says it at once.+//!+//! A fixture strips the board, keeps every pad and pour as it is, and routes only the nets it+//! names. The other nets stay unrouted, so it tests a behaviour, not congestion: the whole-board+//! benchmark is still what says the board routes.+//!+//! `known_fail` marks a fixture that records a target the router does not meet yet. It is reported+//! and does not fail the run; when it starts passing the run says so, and the mark comes off.++use crate::board::*;+use crate::geom::*;+use serde_json::Value;+use std::path::Path;++struct Outcome {+    pass: bool,+    lines: Vec<String>,+}++/// Every fixture at once, each in its own process (each has its own work clock, so running side by+/// side changes no result), reported in the file's order. The set takes as long as its slowest one.+pub fn run_all(file: &str, only: Option<&str>, keep: Option<&str>) -> bool {+    let text = std::fs::read_to_string(file).unwrap_or_else(|e| crate::fail(format!("{file}: {e}"), "Pass the fixtures JSON, e.g. bench/fixtures.json."));+    let v: Value = serde_json::from_str(&text).unwrap_or_else(|e| crate::fail(format!("{file}: {e}"), ""));+    let names: Vec<String> = v["fixtures"].as_array().map(|a| a.iter().filter_map(|x| x["name"].as_str().map(String::from)).collect()).unwrap_or_default();+    let names: Vec<String> = names.into_iter().filter(|n| only.map(|o| n.contains(o)).unwrap_or(true)).collect();+    let exe = std::env::current_exe().unwrap_or_else(|e| crate::fail(e, ""));+    let t0 = std::time::Instant::now();+    let kids: Vec<(String, std::process::Child)> = names.iter().map(|n| {+        let mut c = std::process::Command::new(&exe);+        c.args(["fixtures", file, "--one", n]);+        if let Some(k) = keep {+            c.args(["--keep", k]);+        }+        (n.clone(), c.stdout(std::process::Stdio::piped()).spawn().unwrap_or_else(|e| crate::fail(e, "")))+    }).collect();+    let (mut ok, mut skipped) = (true, 0usize);+    for (n, kid) in kids {+        let out = kid.wait_with_output().unwrap_or_else(|e| crate::fail(e, ""));+        let text = String::from_utf8_lossy(&out.stdout);+        for l in text.lines().filter(|l| !l.starts_with("OK: ") && !l.starts_with("ERROR: ")) {+            println!("{l}");+        }+        if text.contains("SKIP ") {+            skipped += 1;+        }+        if !out.status.success() {+            ok = false;+            if text.trim().is_empty() {+                println!("FAIL {n}: it stopped without a result");+            }+        }+    }+    println!("OK: {} fixtures run in {:.0} s, {skipped} skipped{}", names.len() - skipped, t0.elapsed().as_secs_f64(), if ok { "." } else { "; at least one FAIL above." });+    ok+}++pub fn run(file: &str, only: Option<&str>, keep: Option<&str>) -> bool {+    let text = std::fs::read_to_string(file).unwrap_or_else(|e| crate::fail(format!("{file}: {e}"), "Pass the fixtures JSON, e.g. bench/fixtures.json."));+    let v: Value = serde_json::from_str(&text).unwrap_or_else(|e| crate::fail(format!("{file}: {e}"), ""));+    let base = Path::new(file).parent().unwrap_or(Path::new("."));+    let work = keep.map(std::path::PathBuf::from).unwrap_or_else(|| std::env::temp_dir().join("adom-route-fixtures"));+    std::fs::create_dir_all(&work).unwrap_or_else(|e| crate::fail(e, ""));+    let (mut ok, mut ran, mut skipped) = (true, 0usize, 0usize);+    for fx in v["fixtures"].as_array().cloned().unwrap_or_default() {+        let name = fx["name"].as_str().unwrap_or("?").to_string();+        if only.map(|o| name != o).unwrap_or(false) {+            continue;+        }+        let board = base.join(fx["board"].as_str().unwrap_or(""));+        if !board.exists() {+            println!("SKIP {name}: its board is not here ({})", board.display());+            skipped += 1;+            continue;+        }+        let t0 = std::time::Instant::now();+        let out = one(&fx, &name, &board, base, &work);+        let known = fx["known_fail"].as_bool().unwrap_or(false);+        let secs = t0.elapsed().as_secs_f64();+        ran += 1;+        match (out.pass, known) {+            (true, false) => println!("PASS {name} ({secs:.1} s)"),+            (true, true) => println!("FIXED {name} ({secs:.1} s): it passes now, take its known_fail mark off"),+            (false, true) => println!("KNOWN FAIL {name} ({secs:.1} s): a target the router does not meet yet"),+            (false, false) => {+                println!("FAIL {name} ({secs:.1} s)");+                ok = false;+            }+        }+        for l in &out.lines {+            println!("  {l}");+        }+    }+    println!("{} {ran} fixtures run, {skipped} skipped.", if ok { "OK:" } else { "ERROR:" });+    ok+}++fn one(fx: &Value, name: &str, board: &Path, base: &Path, work: &Path) -> Outcome {+    let mut lines: Vec<String> = Vec::new();+    let spec: Option<String> = fx["spec"].as_str().map(|s| base.join(s).to_string_lossy().to_string());+    let nets: Vec<String> = fx["nets"].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(String::from)).collect()).unwrap_or_default();+    // Strip, with the project beside it so the same rules bind.+    let src = Board::read(&board.to_string_lossy()).unwrap_or_else(|e| crate::fail(e, ""));+    let stripped = work.join(format!("{name}.stripped.kicad_pcb"));+    let routed = work.join(format!("{name}.routed.kicad_pcb"));+    std::fs::write(&stripped, crate::write::strip(&src)).unwrap_or_else(|e| crate::fail(e, ""));+    let pro = board.with_extension("kicad_pro");+    if pro.exists() {+        for p in [&stripped, &routed] {+            let _ = std::fs::copy(&pro, p.with_extension("kicad_pro"));+        }+    }+    let (b, mut r) = crate::load(&stripped.to_string_lossy(), &spec);+    let missing: Vec<&String> = nets.iter().filter(|n| !b.net_ids.contains_key(n.as_str())).collect();+    if !missing.is_empty() {+        return Outcome { pass: false, lines: vec![format!("not on the board: {missing:?}")] };+    }+    let mut plan = crate::router::make_plan(&b, &r);+    let wanted = |n: NetId| nets.iter().any(|x| x == b.net_name(n));+    plan.tasks.retain(|t| wanted(t.net));+    plan.pairs.retain(|p| wanted(p.0) && wanted(p.1));+    r.time_limit = fx["limit"].as_f64().unwrap_or(60.0);+    let mut rt = crate::router::Router::new(&b, r.clone());+    rt.only = Some(nets.iter().filter_map(|n| b.net_ids.get(n.as_str()).copied()).collect());+    let o = rt.run(&plan);+    let mut routes: Vec<&crate::router::Route> = rt.routes.values().collect();+    routes.sort_by_key(|x| x.id);+    std::fs::write(&routed, crate::write::render(&b, &routes, &r)).unwrap_or_else(|e| crate::fail(e, ""));+    let _ = crate::project::write_dru(&stripped.to_string_lossy(), &routed.to_string_lossy(), &rt.rules.pad_rules);+    let _ = o;+    let _ = std::fs::write(work.join(format!("{name}.log")), rt.log.join("\n") + "\n" + &rt.notes.join("\n"));+    lines.push(format!("board kept at {}", routed.display()));+    // Judge the written board, as `check` would.+    let (rb, rr) = crate::load(&routed.to_string_lossy(), &spec);+    let (findings, _) = crate::check::check(&rb, &rr);+    let mine = |text: &str| nets.iter().any(|n| text.starts_with(&format!("{n}:")));+    let mut pass = true;+    let mut say = |ok: bool, what: String, lines: &mut Vec<String>| {+        lines.push(format!("{} {what}", if ok { "ok  " } else { "FAIL" }));+        if !ok {+            pass = false;+        }+    };+    for e in fx["expect"].as_array().cloned().unwrap_or_default() {+        if e.get("joined").is_some() {+            let open: Vec<&str> = findings.iter().filter(|f| f.rule == "unconnected" && mine(&f.text)).map(|f| f.text.as_str()).collect();+            say(open.is_empty(), format!("joined: every named net is one piece{}", if open.is_empty() { String::new() } else { format!(" ({})", open.join("; ")) }), &mut lines);+        }+        if let Some(rules) = e.get("clean").and_then(|x| x.as_array()) {+            for rule in rules.iter().filter_map(|x| x.as_str()) {+                let hits: Vec<&str> = findings.iter().filter(|f| f.rule == rule && mine(&f.text)).map(|f| f.text.as_str()).collect();+                say(hits.is_empty(), format!("clean {rule}{}", if hits.is_empty() { String::new() } else { format!(": {}", hits.join("; ")) }), &mut lines);+            }+        }+        if let Some(w) = e.get("width_near") {+            let (net, part) = (w["net"].as_str().unwrap_or(""), w["part"].as_str().unwrap_or(""));+            let radius = w["radius"].as_f64().unwrap_or(3.0) * NM;+            let id = rb.net_ids.get(net).copied();+            let pads: Vec<V> = rb.pads.iter().filter(|p| Some(p.net) == id && rb.footprints[p.fp].reference == part).map(|p| V::from(p.center)).collect();+            // Runs, not links: a track shorter than `min_len` (2 mm unless given) is a tie between a+            // pad and its via or capacitor, not the run to the part that this check is about.+            let min_len = w["min_len"].as_f64().unwrap_or(2.0) * NM;+            let near: Vec<i64> = rb.tracks.iter().filter(|t| Some(t.net) == id && hypot(sub(t.a.into(), t.b.into())) >= min_len && pads.iter().any(|c| pt_seg(*c, t.a.into(), t.b.into()) <= radius)).map(|t| t.width).collect();+            if near.is_empty() {+                say(false, format!("width near {part} on {net}: no track of the net within {:.1} mm of it", radius / NM), &mut lines);+                continue;+            }+            let (lo, hi) = (to_mm(*near.iter().min().unwrap()), to_mm(*near.iter().max().unwrap()));+            if let Some(m) = w["max"].as_f64() {+                say(hi <= m + 1e-6, format!("width near {part} on {net}: widest {hi:.2} mm, at most {m:.2} mm allowed"), &mut lines);+            }+            if let Some(m) = w["min"].as_f64() {+                say(lo >= m - 1e-6, format!("width near {part} on {net}: narrowest {lo:.2} mm, at least {m:.2} mm wanted"), &mut lines);+            }+        }+        if let Some(d) = e.get("drop_max") {+            let (net, load, pct) = (d["net"].as_str().unwrap_or(""), d["load"].as_str().unwrap_or(""), d["pct"].as_f64().unwrap_or(0.25));+            let found = rr.rails.iter().find(|(k, _)| k.eq_ignore_ascii_case(net)).and_then(|(_, rail)| {+                let id = rb.net_ids.iter().find(|(k, _)| k.eq_ignore_ascii_case(net)).map(|(_, v)| *v)?;+                let v = rail.volts?;+                crate::current::rail_drops(&rb, &rr, id, rail).into_iter().find(|x| x.load == load).map(|x| (x.volts, v))+            });+            match found {+                Some((volts, v)) => say(volts / v * 100.0 <= pct + 1e-6, format!("drop on {net} to {load}: {:.1} mV, {:.2}% of {v} V, at most {pct:.2}% allowed", volts * 1000.0, volts / v * 100.0), &mut lines),+                None => say(false, format!("drop on {net} to {load}: not found (no rail, voltage or path)"), &mut lines),+            }+        }+        if let Some(m) = e.get("max_vias").and_then(|x| x.as_u64()) {+            let n = rb.vias.iter().filter(|v| nets.iter().any(|x| x == rb.net_name(v.net))).count();+            say(n as u64 <= m, format!("vias on the named nets: {n}, at most {m} allowed"), &mut lines);+        }+        if let Some(p) = e.get("pair_coupled") {+            let (want, min) = (p["pair"].as_str().unwrap_or(""), p["min_pct"].as_f64().unwrap_or(80.0));+            match crate::compare::pairs(&rb, &rr).into_iter().find(|x| x.0 == want) {+                Some((_, lp, _, c, _)) => {+                    let pct = if lp > 0.0 { 100.0 * c / lp } else { 0.0 };+                    say(pct >= min, format!("pair {want}: {pct:.0}% coupled, at least {min:.0}% wanted"), &mut lines);+                }+                None => say(false, format!("pair {want}: not found on the routed board"), &mut lines),+            }+        }+    }+    Outcome { pass, lines }+}

@@ -0,0 +1,143 @@+//! The routing stage as a guided flow. `flows/flow.json` (compiled in) holds the steps in order, the+//! file that shows each one was done, and what the AI does in it. `next` names the first step whose+//! file is missing. It is a guide and never a gate: no command checks that an earlier step was done,+//! and a step may be skipped or done another way.+//!+//! A project keeps its state in `<project>/routing-flow/`: `state.json` (the board and spec it was+//! started on), `run.jsonl` (one line per command: time, the AI thread, what happened) and the files+//! the steps leave. Earlier ledger lines are never rewritten.+use serde_json::{json, Value};+use std::io::Write;+use std::path::{Path, PathBuf};++pub const FLOW_DIR: &str = "routing-flow";++pub struct Step {+    pub name: String,+    pub done: Vec<String>,+    pub todo: String,+}++pub fn steps() -> Vec<Step> {+    let v: Value = serde_json::from_str(include_str!("../flows/flow.json")).expect("flows/flow.json is valid JSON");+    v["steps"]+        .as_array()+        .map(|a| {+            a.iter()+                .map(|s| Step {+                    name: s["name"].as_str().unwrap_or("").to_string(),+                    done: s["done"].as_array().map(|d| d.iter().filter_map(|x| x.as_str().map(String::from)).collect()).unwrap_or_default(),+                    todo: s["do"].as_str().unwrap_or("").to_string(),+                })+                .collect()+        })+        .unwrap_or_default()+}++pub struct Project {+    pub dir: PathBuf,+    pub flow_dir: PathBuf,+    pub state: Value,+}++impl Project {+    /// The nearest folder at or above `start` that holds `routing-flow/state.json`.+    pub fn find(start: &Path) -> Option<Project> {+        let mut d = std::fs::canonicalize(start).ok().or_else(|| Some(start.to_path_buf()));+        while let Some(p) = d {+            let s = p.join(FLOW_DIR).join("state.json");+            if s.is_file() {+                let state = std::fs::read_to_string(&s).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or(json!({}));+                return Some(Project { flow_dir: p.join(FLOW_DIR), dir: p, state });+            }+            d = p.parent().map(Path::to_path_buf);+        }+        None+    }++    pub fn create(dir: &Path, state: Value) -> std::io::Result<Project> {+        let flow_dir = dir.join(FLOW_DIR);+        std::fs::create_dir_all(&flow_dir)?;+        let p = Project { dir: dir.to_path_buf(), flow_dir, state };+        std::fs::write(p.flow_dir.join("state.json"), serde_json::to_string_pretty(&p.state)? + "\n")?;+        Ok(p)+    }++    pub fn path(&self, rel: &str) -> PathBuf {+        self.flow_dir.join(rel)+    }++    /// One line in the ledger. A ledger that cannot be written never stops a command.+    pub fn log(&self, thread: &str, ev: &str, data: Value) {+        let line = json!({"t": now(), "aiThread": thread, "ev": ev, "data": data});+        if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(self.flow_dir.join("run.jsonl")) {+            let _ = writeln!(f, "{line}");+        }+    }++    pub fn is_done(&self, step: &Step) -> bool {+        step.done.iter().all(|p| self.flow_dir.join(p).exists())+    }++    /// The first step whose file is missing, with its place in the list (1-based).+    pub fn current<'a>(&self, steps: &'a [Step]) -> Option<(usize, &'a Step)> {+        steps.iter().enumerate().find(|(_, s)| !self.is_done(s)).map(|(i, s)| (i + 1, s))+    }+}++/// UTC now as 2026-11-10T12:00:00Z, from the system clock (no outside program).+pub fn now() -> String {+    let secs = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0) as i64;+    let (days, rem) = (secs.div_euclid(86_400), secs.rem_euclid(86_400));+    // Days since 1970-01-01 to a civil date (Howard Hinnant's algorithm).+    let z = days + 719_468;+    let era = z.div_euclid(146_097);+    let doe = z.rem_euclid(146_097);+    let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);+    let mp = (5 * doy + 2) / 153;+    let d = doy - (153 * mp + 2) / 5 + 1;+    let m = if mp < 10 { mp + 3 } else { mp - 9 };+    let y = yoe + era * 400 + if m <= 2 { 1 } else { 0 };+    format!("{y:04}-{m:02}-{d:02}T{:02}:{:02}:{:02}Z", rem / 3_600, rem % 3_600 / 60, rem % 60)+}++/// The file's sha256 where `sha256sum` is installed; empty otherwise (it is a record, not a lock).+pub fn sha256(p: &Path) -> String {+    std::process::Command::new("sha256sum")+        .arg(p)+        .output()+        .ok()+        .and_then(|o| String::from_utf8_lossy(&o.stdout).split_whitespace().next().map(str::to_string))+        .unwrap_or_default()+}++#[cfg(test)]+mod tests {+    use super::*;++    #[test]+    fn the_flow_file_reads_and_next_is_the_first_step_with_no_file() {+        let s = steps();+        assert!(s.len() >= 4 && s[0].name == "intake" && s.iter().all(|x| !x.done.is_empty() && !x.todo.is_empty()));+        let d = std::env::temp_dir().join(format!("adom-route-flow-{}", std::process::id()));+        let _ = std::fs::remove_dir_all(&d);+        let p = Project::create(&d, json!({"board": "b.kicad_pcb"})).unwrap();+        assert_eq!(p.current(&s).map(|(i, x)| (i, x.name.as_str())), Some((2, "plan")));+        std::fs::write(p.path("plan.txt"), "x").unwrap();+        assert_eq!(p.current(&s).map(|(_, x)| x.name.as_str()), Some("route"));+        // A later step done first is fine: next still names the first one missing, and nothing refuses.+        std::fs::write(p.path("check.json"), "{}").unwrap();+        assert_eq!(p.current(&s).map(|(_, x)| x.name.as_str()), Some("route"));+        p.log("t", "test", json!({}));+        assert!(std::fs::read_to_string(p.path("run.jsonl")).unwrap().contains("\"ev\":\"test\""));+        assert!(Project::find(&d.join(FLOW_DIR)).is_some());+        let _ = std::fs::remove_dir_all(&d);+    }++    #[test]+    fn now_is_a_utc_stamp() {+        let n = now();+        assert!(n.len() == 20 && n.ends_with('Z') && n.as_bytes()[10] == b'T', "{n}");+    }+}

@@ -0,0 +1,211 @@+//! Exact geometry. Coordinates are integer nanometres on the board; distances are f64 nanometres.++pub type P = (i64, i64);+pub const NM: f64 = 1e6; // nanometres per millimetre+pub const SQRT2: f64 = std::f64::consts::SQRT_2;+/// How far under a clearance copper may land by coordinate rounding alone, nm. KiCad tolerates about+/// 500 nm (it flagged 0.1991 against 0.2 on the benchmark C). His benchmark C's 0.2 mm stub down the middle of U5.9+/// sits exactly 0.200 mm from both neighbours; without this, a few nm of rounding called it illegal.+pub const DRC_TOL: f64 = 400.0;++pub fn mm(v: f64) -> i64 {+    (v * NM).round() as i64+}+pub fn to_mm(v: i64) -> f64 {+    v as f64 / NM+}++#[derive(Clone, Copy, Debug, PartialEq)]+pub struct V(pub f64, pub f64);++impl From<P> for V {+    fn from(p: P) -> V {+        V(p.0 as f64, p.1 as f64)+    }+}++#[inline]+pub fn dot(a: V, b: V) -> f64 {+    a.0 * b.0 + a.1 * b.1+}+#[inline]+pub fn sub(a: V, b: V) -> V {+    V(a.0 - b.0, a.1 - b.1)+}+#[inline]+pub fn hypot(a: V) -> f64 {+    (a.0 * a.0 + a.1 * a.1).sqrt()+}++pub fn pt_seg(p: V, a: V, b: V) -> f64 {+    let ab = sub(b, a);+    let l2 = dot(ab, ab);+    if l2 <= 0.0 {+        return hypot(sub(p, a));+    }+    let t = (dot(sub(p, a), ab) / l2).clamp(0.0, 1.0);+    hypot(sub(p, V(a.0 + ab.0 * t, a.1 + ab.1 * t)))+}++fn orient(a: V, b: V, c: V) -> f64 {+    (b.0 - a.0) * (c.1 - a.1) - (b.1 - a.1) * (c.0 - a.0)+}++pub fn seg_cross(a: V, b: V, c: V, d: V) -> bool {+    let (o1, o2, o3, o4) = (orient(a, b, c), orient(a, b, d), orient(c, d, a), orient(c, d, b));+    (o1 > 0.0) != (o2 > 0.0) && (o3 > 0.0) != (o4 > 0.0)+}++pub fn seg_seg(a: V, b: V, c: V, d: V) -> f64 {+    if seg_cross(a, b, c, d) {+        return 0.0;+    }+    pt_seg(a, c, d).min(pt_seg(b, c, d)).min(pt_seg(c, a, b)).min(pt_seg(d, a, b))+}++pub fn in_poly(p: V, pts: &[V]) -> bool {+    let mut inside = false;+    let n = pts.len();+    let mut j = n.wrapping_sub(1);+    for i in 0..n {+        let (a, b) = (pts[i], pts[j]);+        if (a.1 > p.1) != (b.1 > p.1) && p.0 < (b.0 - a.0) * (p.1 - a.1) / (b.1 - a.1) + a.0 {+            inside = !inside;+        }+        j = i;+    }+    inside+}++/// Copper or a hole, as an exact outline. `Poly` carries an outward inflation (zero for most).+#[derive(Clone, Debug)]+pub enum Shape {+    Circle { c: V, r: f64 },+    Capsule { a: V, b: V, r: f64 },+    Poly { pts: Vec<V>, r: f64 },+    /// Several outlines that are one piece of copper: a custom pad's anchor and its primitives.+    Multi(Vec<Shape>),+}++impl Shape {+    /// Edge-to-edge distance from a zero-width segment to this outline; 0 when they touch.+    pub fn dist_seg(&self, a: V, b: V) -> f64 {+        match self {+            Shape::Circle { c, r } => (pt_seg(*c, a, b) - r).max(0.0),+            Shape::Capsule { a: p, b: q, r } => (seg_seg(a, b, *p, *q) - r).max(0.0),+            Shape::Poly { pts, r } => {+                if in_poly(a, pts) || in_poly(b, pts) {+                    return 0.0;+                }+                let n = pts.len();+                let mut d = f64::INFINITY;+                for i in 0..n {+                    d = d.min(seg_seg(a, b, pts[i], pts[(i + 1) % n]));+                    if d <= 0.0 {+                        return 0.0;+                    }+                }+                (d - r).max(0.0)+            }+            Shape::Multi(v) => v.iter().map(|s| s.dist_seg(a, b)).fold(f64::INFINITY, f64::min),+        }+    }+    pub fn dist_pt(&self, p: V) -> f64 {+        self.dist_seg(p, p)+    }+    /// Edge-to-edge distance between two outlines.+    pub fn dist_shape(&self, o: &Shape) -> f64 {+        match o {+            Shape::Circle { c, r } => (self.dist_pt(*c) - r).max(0.0),+            Shape::Capsule { a, b, r } => (self.dist_seg(*a, *b) - r).max(0.0),+            Shape::Poly { pts, r } => match self {+                Shape::Poly { pts: mine, r: mr } => {+                    if pts.iter().any(|p| in_poly(*p, mine)) || mine.iter().any(|p| in_poly(*p, pts)) {+                        return 0.0;+                    }+                    let mut d = f64::INFINITY;+                    let n = pts.len();+                    let m = mine.len();+                    for i in 0..n {+                        for j in 0..m {+                            d = d.min(seg_seg(pts[i], pts[(i + 1) % n], mine[j], mine[(j + 1) % m]));+                        }+                    }+                    (d - r - mr).max(0.0)+                }+                _ => o.dist_shape(self),+            },+            Shape::Multi(v) => v.iter().map(|s| self.dist_shape(s)).fold(f64::INFINITY, f64::min),+        }+    }+    pub fn bbox(&self) -> (f64, f64, f64, f64) {+        match self {+            Shape::Circle { c, r } => (c.0 - r, c.1 - r, c.0 + r, c.1 + r),+            Shape::Capsule { a, b, r } => (a.0.min(b.0) - r, a.1.min(b.1) - r, a.0.max(b.0) + r, a.1.max(b.1) + r),+            Shape::Poly { pts, r } => {+                let mut bb = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+                for p in pts {+                    bb = (bb.0.min(p.0), bb.1.min(p.1), bb.2.max(p.0), bb.3.max(p.1));+                }+                (bb.0 - r, bb.1 - r, bb.2 + r, bb.3 + r)+            }+            Shape::Multi(v) => {+                let mut bb = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+                for s in v {+                    let b = s.bbox();+                    bb = (bb.0.min(b.0), bb.1.min(b.1), bb.2.max(b.2), bb.3.max(b.3));+                }+                bb+            }+        }+    }+    /// Largest value of `ux*x + uy*y` over the outline, for tangent lines in any direction.+    pub fn support(&self, ux: f64, uy: f64) -> f64 {+        let len = (ux * ux + uy * uy).sqrt();+        match self {+            Shape::Circle { c, r } => ux * c.0 + uy * c.1 + r * len,+            Shape::Capsule { a, b, r } => (ux * a.0 + uy * a.1).max(ux * b.0 + uy * b.1) + r * len,+            Shape::Poly { pts, r } => pts.iter().map(|p| ux * p.0 + uy * p.1).fold(f64::MIN, f64::max) + r * len,+            Shape::Multi(v) => v.iter().map(|s| s.support(ux, uy)).fold(f64::MIN, f64::max),+        }+    }+    pub fn center(&self) -> V {+        let b = self.bbox();+        V((b.0 + b.2) / 2.0, (b.1 + b.3) / 2.0)+    }+}++/// Rotate a local point the way KiCad does (y down, positive angle counter-clockwise on screen).+pub fn rot(x: f64, y: f64, deg: f64) -> (f64, f64) {+    if deg == 0.0 {+        return (x, y);+    }+    let (s, c) = deg.to_radians().sin_cos();+    (x * c + y * s, -x * s + y * c)+}++pub fn arc_points(s: V, m: V, e: V, step_nm: f64) -> Vec<V> {+    let d = 2.0 * (s.0 * (m.1 - e.1) + m.0 * (e.1 - s.1) + e.0 * (s.1 - m.1));+    if d.abs() < 1.0 {+        return vec![s, e];+    }+    let sq = |p: V| p.0 * p.0 + p.1 * p.1;+    let ux = (sq(s) * (m.1 - e.1) + sq(m) * (e.1 - s.1) + sq(e) * (s.1 - m.1)) / d;+    let uy = (sq(s) * (e.0 - m.0) + sq(m) * (s.0 - e.0) + sq(e) * (m.0 - s.0)) / d;+    let r = ((s.0 - ux).powi(2) + (s.1 - uy).powi(2)).sqrt();+    let a0 = (s.1 - uy).atan2(s.0 - ux);+    let am = (m.1 - uy).atan2(m.0 - ux);+    let a1 = (e.1 - uy).atan2(e.0 - ux);+    let tau = std::f64::consts::TAU;+    let norm = |x: f64| ((x % tau) + tau) % tau;+    let ccw_m = norm(am - a0);+    let ccw_e = norm(a1 - a0);+    let sweep = if ccw_m <= ccw_e { ccw_e } else { ccw_e - tau };+    let n = ((sweep.abs() * r / step_nm).ceil() as usize).clamp(2, 64);+    (0..=n)+        .map(|i| {+            let a = a0 + sweep * i as f64 / n as f64;+            V(ux + r * a.cos(), uy + r * a.sin())+        })+        .collect()+}

@@ -0,0 +1,1444 @@+//! The coarse view of the board: what a detailed search can't see from where it stands.+//!+//! Two jobs share one map. First, a backward search from the target over coarse cells on each+//! routing layer, with vias as edges (VTR's router lookahead, Navit's search from the destination),+//! resumed only as far as the detailed search asks (reverse resumable A*). That gives the detailed+//! A* the true way round obstacles, and a quick "no path" when the map is closed. Second, the global+//! stage further down, which uses the same boundaries as capacities.+//!+//! The map must stay optimistic: "closed" is only ever a proof. A boundary between two cells is cut+//! into short samples; a sample is closed only when one obstacle is closer to its middle than the+//! narrowest legal centreline allows, by more than half the sample's length, so no point of that+//! sample could carry a legal track. A fine-pitch lane therefore can't be closed by rounding: The designer's+//! rule that a router's "no path" at fine pitch is not evidence (Troubleshooting, "Routing practices")+//! is why the map has no slop. Copper of the query's own net never closes anything.++use crate::board::*;+use crate::geom::*;+use crate::index::*;+use crate::rules::Rules;+use crate::search::{Query, Terminal, World};+use std::cmp::Reverse;+use std::collections::BinaryHeap;++/// A sample closed by copper of more than one net, or by something with no net.+const MANY: u16 = u16::MAX;+/// Samples per boundary. Must fit the u16 masks.+const K: usize = 5;+const FULL: u16 = (1u16 << K) - 1;+/// A track's keep-out at the neck is about 0.6 mm across, or 0.85 mm along an axis at 45 degrees,+/// so at this size no boundary line can slip through a wall of tracks at any angle.+const CELL: f64 = 0.25 * NM;+const VIA_SUB: usize = 2;+/// How much dearer the estimate makes a step off the planned corridor. Swept 0.3 and 1.0: the same+/// completion on all three boards within one connection, fewer bends at 0.3 (piprobe_v13 66 to 72).+const CORRIDOR_BIAS: f32 = 0.3;+/// What the coarse estimate charges a soft search per crossing of committed copper (the router's+/// cheapest price for taking a route's place).+const SOFT_CROSSING: f64 = 2.0 * NM;++#[inline]+fn net16(n: NetId) -> u16 {+    if n == NO_NET { MANY } else { n.min(MANY as u32 - 1) as u16 }+}++pub struct Coarse {+    pub x0: f64,+    pub y0: f64,+    pub cell: f64,+    s: f64,+    pub w: usize,+    pub h: usize,+    /// World layer of each coarse layer, and back.+    pub route: Vec<usize>,+    index: Vec<usize>,+    /// Narrowest legal centreline's distance to copper, and to the board edge.+    need: f64,+    need_edge: f64,+    /// Closed samples per boundary, as a bit mask: copper that stays, and committed routes.+    mask_s: Vec<u16>,+    mask_d: Vec<u16>,+    /// Who closes each sample: 0 nobody, otherwise one net, or MANY.+    blk_s: Vec<u16>,+    blk_d: Vec<u16>,+    /// Bumped when committed copper changes, and when anything else does.+    pub rev_d: u64,+    pub rev_s: u64,+}++impl Coarse {+    pub fn build(w: &World, r: &Rules) -> Coarse {+        let mut bb = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+        let mut grow = |b: (f64, f64, f64, f64)| {+            bb = (bb.0.min(b.0), bb.1.min(b.1), bb.2.max(b.2), bb.3.max(b.3));+        };+        for o in w.edge.iter() {+            grow(o.bb);+        }+        for g in &w.layers {+            for o in g.iter() {+                if matches!(o.owner, Owner::Pad(_)) {+                    grow(o.bb);+                }+            }+        }+        let cell = CELL;+        let s = cell / K as f64;+        let x0 = bb.0 - 2.0 * cell;+        let y0 = bb.1 - 2.0 * cell;+        let cw = ((bb.2 - bb.0) / cell).ceil() as usize + 4;+        let ch = ((bb.3 - bb.1) / cell).ceil() as usize + 4;+        let route = w.route_layers.clone();+        let mut index = vec![usize::MAX; w.layers.len()];+        for (i, &l) in route.iter().enumerate() {+            index[l] = i;+        }+        let n = route.len() * 2 * cw * ch;+        let mut c = Coarse {+            x0,+            y0,+            cell,+            s,+            w: cw,+            h: ch,+            route,+            index,+            need: r.neck as f64 / 2.0 + r.clearance as f64,+            need_edge: r.neck as f64 / 2.0 + r.edge as f64,+            mask_s: vec![0; n],+            mask_d: vec![0; n],+            blk_s: vec![0; n * K],+            blk_d: vec![0; n * K],+            rev_d: 1,+            rev_s: 1,+        };+        for l in 0..c.route.len() {+            let g = &w.layers[c.route[l]];+            g.drain_log();+            for o in g.iter() {+                // "Closed" is a proof, and a pour some nets may cross proves nothing about them.+                if let Owner::Zone(z) = o.owner {+                    if w.pour_open.get(z as usize).map(|v| !v.is_empty()).unwrap_or(false) {+                        continue;+                    }+                }+                c.mark(l, &o.shape, o.net, o.owner, c.need);+            }+            for o in w.edge.iter() {+                c.mark(l, &o.shape, NO_NET, Owner::Edge, c.need_edge);+            }+        }+        c+    }++    /// Bring the map up to date with what was committed and ripped since last time.+    pub fn sync(&mut self, w: &World) {+        for l in 0..self.route.len() {+            let log = w.layers[self.route[l]].drain_log();+            for (added, o) in log {+                if added {+                    self.mark(l, &o.shape, o.net, o.owner, self.need);+                } else {+                    self.unmark(w, l, &o.shape);+                }+                if matches!(o.owner, Owner::Conn(_)) {+                    self.rev_d += 1;+                } else {+                    self.rev_s += 1;+                    self.rev_d += 1;+                }+            }+        }+    }++    #[inline]+    fn boundary(&self, l: usize, d: usize, i: usize, j: usize) -> usize {+        ((l * 2 + d) * self.h + j) * self.w + i+    }++    /// Visit the samples any obstacle piece could close. `d` 0: the boundary from (i,j) to+    /// (i+1,j); 1: from (i,j) to (i,j+1).+    fn near_samples(&self, bb: (f64, f64, f64, f64), mut f: impl FnMut(usize, usize, usize, usize, V)) {+        let (w, h, cell, s, x0, y0) = (self.w as i64, self.h as i64, self.cell, self.s, self.x0, self.y0);+        let lo = |v: f64, o: f64, st: f64| ((v - o) / st).ceil() as i64;+        let hi = |v: f64, o: f64, st: f64| ((v - o) / st).floor() as i64;+        let k = K as i64;+        // Vertical boundary lines x = x0 + (i+1) cell, samples along y.+        for line in lo(bb.0, x0, cell)..=hi(bb.2, x0, cell) {+            let i = line - 1;+            if i < 0 || i >= w {+                continue;+            }+            for n in (hi(bb.1, y0, s)).max(0)..=(hi(bb.3, y0, s)).min(h * k - 1) {+                let m = V(x0 + line as f64 * cell, y0 + (n as f64 + 0.5) * s);+                f(0, i as usize, (n / k) as usize, (n % k) as usize, m);+            }+        }+        for line in lo(bb.1, y0, cell)..=hi(bb.3, y0, cell) {+            let j = line - 1;+            if j < 0 || j >= h {+                continue;+            }+            for n in (hi(bb.0, x0, s)).max(0)..=(hi(bb.2, x0, s)).min(w * k - 1) {+                let m = V(x0 + (n as f64 + 0.5) * s, y0 + line as f64 * cell);+                f(1, (n / k) as usize, j as usize, (n % k) as usize, m);+            }+        }+    }++    /// Long diagonal tracks have huge boxes, so a capsule is walked in short pieces.+    fn pieces(&self, shape: &Shape, reach: f64) -> Vec<(f64, f64, f64, f64)> {+        if let Shape::Capsule { a, b, r } = shape {+            let len = hypot(sub(*a, *b));+            let n = (len / (2.0 * self.cell)).ceil().max(1.0) as usize;+            let rr = r + reach;+            return (0..n)+                .map(|i| {+                    let (t0, t1) = (i as f64 / n as f64, (i + 1) as f64 / n as f64);+                    let p = V(a.0 + (b.0 - a.0) * t0, a.1 + (b.1 - a.1) * t0);+                    let q = V(a.0 + (b.0 - a.0) * t1, a.1 + (b.1 - a.1) * t1);+                    (p.0.min(q.0) - rr, p.1.min(q.1) - rr, p.0.max(q.0) + rr, p.1.max(q.1) + rr)+                })+                .collect();+        }+        let b = shape.bbox();+        vec![(b.0 - reach, b.1 - reach, b.2 + reach, b.3 + reach)]+    }++    fn mark(&mut self, l: usize, shape: &Shape, net: NetId, owner: Owner, need: f64) {+        let half = self.s / 2.0;+        let who = net16(net);+        let dynamic = matches!(owner, Owner::Conn(_));+        let mut hits: Vec<(usize, usize)> = Vec::new();+        if let Shape::Poly { pts, r } = shape {+            // A pour can have thousands of points, and testing every sample in its box against all+            // of them took 10 s on benchmark B. Its inside comes from scanlines, its rim from its+            // edges as thin capsules.+            self.poly_inside(l, pts, &mut hits);+            let n = pts.len();+            for i in 0..n {+                let seg = Shape::Capsule { a: pts[i], b: pts[(i + 1) % n], r: *r };+                for bb in self.pieces(&seg, need) {+                    self.near_samples(bb, |d, a, b, bit, m| {+                        if seg.dist_pt(m) + half < need {+                            hits.push((self.boundary(l, d, a, b), bit));+                        }+                    });+                }+            }+        } else {+            for bb in self.pieces(shape, need) {+                self.near_samples(bb, |d, i, j, bit, m| {+                    if shape.dist_pt(m) + half < need {+                        hits.push((self.boundary(l, d, i, j), bit));+                    }+                });+            }+        }+        for (b, bit) in hits {+            let (blk, mask) = if dynamic { (&mut self.blk_d, &mut self.mask_d) } else { (&mut self.blk_s, &mut self.mask_s) };+            let v = &mut blk[b * K + bit];+            *v = if *v == 0 || *v == who { who } else { MANY };+            mask[b] |= 1 << bit;+        }+    }++    /// Samples strictly inside a polygon, boundary line by boundary line.+    fn poly_inside(&self, l: usize, pts: &[V], hits: &mut Vec<(usize, usize)>) {+        let n = pts.len();+        let k = K as i64;+        let mut xs: Vec<f64> = Vec::new();+        let mut bb = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+        for p in pts {+            bb = (bb.0.min(p.0), bb.1.min(p.1), bb.2.max(p.0), bb.3.max(p.1));+        }+        // d 0: lines of constant x, walking y; d 1: the other way round.+        for d in 0..2usize {+            let (lo, hi, o, t_o, t_n, l_n) = if d == 0 { (bb.0, bb.2, self.x0, self.y0, self.h as i64, self.w as i64) } else { (bb.1, bb.3, self.y0, self.x0, self.w as i64, self.h as i64) };+            let first = ((lo - o) / self.cell).ceil() as i64;+            let last = ((hi - o) / self.cell).floor() as i64;+            for line in first..=last {+                let idx = line - 1;+                if idx < 0 || idx >= l_n {+                    continue;+                }+                let at = o + line as f64 * self.cell;+                xs.clear();+                for i in 0..n {+                    let (a, b) = (pts[i], pts[(i + 1) % n]);+                    let (ax, ay, bx, by) = if d == 0 { (a.0, a.1, b.0, b.1) } else { (a.1, a.0, b.1, b.0) };+                    if (ax > at) != (bx > at) {+                        xs.push(ay + (at - ax) / (bx - ax) * (by - ay));+                    }+                }+                xs.sort_by(f64::total_cmp);+                for w in xs.chunks_exact(2) {+                    let from = (((w[0] - t_o) / self.s).ceil() as i64).max(0);+                    let to = (((w[1] - t_o) / self.s).floor() as i64 - 1).min(t_n * k - 1);+                    for m in from..=to {+                        let (a, b) = if d == 0 { (idx as usize, (m / k) as usize) } else { ((m / k) as usize, idx as usize) };+                        hits.push((self.boundary(l, d, a, b), (m % k) as usize));+                    }+                }+            }+        }+    }++    /// Something went away: work out again who closes each sample it could have closed.+    fn unmark(&mut self, w: &World, l: usize, shape: &Shape) {+        let (half, need) = (self.s / 2.0, self.need);+        let mut todo: Vec<(usize, usize, V)> = Vec::new();+        for bb in self.pieces(shape, need) {+            self.near_samples(bb, |d, i, j, bit, m| {+                if shape.dist_pt(m) + half < need {+                    todo.push((self.boundary(l, d, i, j), bit, m));+                }+            });+        }+        let g = &w.layers[self.route[l]];+        for (b, bit, m) in todo {+            let (mut sv, mut dv) = (0u16, 0u16);+            let box_ = (m.0 - need, m.1 - need, m.0 + need, m.1 + need);+            g.visit(box_, |o| {+                if o.shape.dist_pt(m) + half < need {+                    let who = net16(o.net);+                    let v = if matches!(o.owner, Owner::Conn(_)) { &mut dv } else { &mut sv };+                    *v = if *v == 0 || *v == who { who } else { MANY };+                }+                true+            });+            let e = self.need_edge;+            w.edge.visit((m.0 - e, m.1 - e, m.0 + e, m.1 + e), |o| {+                if o.shape.dist_pt(m) + half < e {+                    sv = MANY;+                }+                true+            });+            self.blk_s[b * K + bit] = sv;+            self.blk_d[b * K + bit] = dv;+            let set = |mask: &mut u16, on: bool| {+                if on { *mask |= 1 << bit } else { *mask &= !(1 << bit) }+            };+            set(&mut self.mask_s[b], sv != 0);+            set(&mut self.mask_d[b], dv != 0);+        }+    }++    /// Can a centreline of this net cross this boundary at all?+    #[inline]+    pub fn open(&self, b: usize, who: u16, soft: bool) -> bool {+        let m = if soft { self.mask_s[b] } else { self.mask_s[b] | self.mask_d[b] };+        if m != FULL {+            return true;+        }+        for i in 0..K {+            let (s, d) = (self.blk_s[b * K + i], self.blk_d[b * K + i]);+            if (s == 0 || s == who) && (soft || d == 0 || d == who) {+                return true;+            }+        }+        false+    }++    #[inline]+    pub fn cell_of(&self, p: V) -> (i64, i64) {+        (((p.0 - self.x0) / self.cell).floor() as i64, ((p.1 - self.y0) / self.cell).floor() as i64)+    }+    #[inline]+    pub fn layer_index(&self, l: usize) -> usize {+        self.index[l]+    }++    /// Can a via stand anywhere in this cell? Same logic as the samples: only a proof counts.+    fn via_open(&self, w: &World, r: &Rules, net: NetId, soft: bool, i: usize, j: usize) -> bool {+        let sub = self.cell / VIA_SUB as f64;+        let hd = sub * 0.7072;+        let need = r.via as f64 / 2.0 + r.clearance as f64;+        let edge = r.via as f64 / 2.0 + r.edge as f64;+        for a in 0..VIA_SUB {+            'sq: for b in 0..VIA_SUB {+                let c = V(self.x0 + (i as f64 + (a as f64 + 0.5) / VIA_SUB as f64) * self.cell, self.y0 + (j as f64 + (b as f64 + 0.5) / VIA_SUB as f64) * self.cell);+                let bb = (c.0 - need, c.1 - need, c.0 + need, c.1 + need);+                for g in &w.layers {+                    let mut closed = false;+                    g.visit(bb, |o| {+                        if (o.net == net && net != NO_NET) || (soft && matches!(o.owner, Owner::Conn(_))) {+                            return true;+                        }+                        if o.shape.dist_pt(c) + hd < need {+                            closed = true;+                            return false;+                        }+                        true+                    });+                    if closed {+                        continue 'sq;+                    }+                }+                let mut closed = false;+                w.edge.visit((c.0 - edge, c.1 - edge, c.0 + edge, c.1 + edge), |o| {+                    if o.shape.dist_pt(c) + hd < edge {+                        closed = true;+                        return false;+                    }+                    true+                });+                if closed {+                    continue 'sq;+                }+                return true;+            }+        }+        false+    }+}++/// One backward search, resumed as the detailed search asks. Keyed on everything that changes its+/// answer, so a later attempt for the same target with the same window and via rule reuses it.+pub struct Back {+    key: (NetId, u64, bool, bool, (i64, i64, i64, i64), u64),+    corridor: Option<Rc<Corridor>>,+    rev: u64,+    i0: i64,+    j0: i64,+    cw: usize,+    ch: usize,+    nl: usize,+    g: Vec<f32>,+    closed: Vec<bool>,+    via: Vec<u8>,+    heap: BinaryHeap<Reverse<(u32, u32)>>,+    src: (i64, i64),+    net: NetId,+    soft: bool,+    no_vias: bool,+    pub pops: u64,+}++/// Terminals by where they are, whichever layers a search allows them on: a bus member's first+/// tries are held to its layer, and it should still find its corridor.+fn ends_hash(ts: &[Terminal]) -> u64 {+    let mut h = 0xcbf2_9ce4_8422_2325u64;+    for t in ts {+        if let Terminal::Point { p, .. } = t {+            h = (h ^ p.0 as u64).wrapping_mul(0x0000_0100_0000_01b3);+            h = (h ^ p.1 as u64).wrapping_mul(0x0000_0100_0000_01b3);+        }+    }+    h+}++fn terminal_hash(ts: &[Terminal]) -> u64 {+    let mut h = 0xcbf2_9ce4_8422_2325u64;+    let mut mix = |v: u64| h = (h ^ v).wrapping_mul(0x0000_0100_0000_01b3);+    for t in ts {+        match t {+            Terminal::Point { p, layers } => {+                mix(p.0 as u64);+                mix(p.1 as u64);+                for &l in layers {+                    mix(l as u64 + 1);+                }+            }+            Terminal::Zone { layer, poly } => {+                mix(*layer as u64 + 100);+                mix(poly.len() as u64);+                if let Some(p) = poly.first() {+                    mix(p.0.to_bits());+                    mix(p.1.to_bits());+                }+            }+            Terminal::Track { a, b, layer, .. } => {+                mix(*layer as u64 + 200);+                mix(a.0 as u64);+                mix(a.1 as u64);+                mix(b.0 as u64);+                mix(b.1 as u64);+            }+        }+    }+    h+}++impl Back {+    fn state(&self, i: i64, j: i64, l: usize) -> Option<usize> {+        let (a, b) = (i - self.i0, j - self.j0);+        if a < 0 || b < 0 || a >= self.cw as i64 || b >= self.ch as i64 {+            return None;+        }+        Some((l * self.ch + b as usize) * self.cw + a as usize)+    }++    #[inline]+    fn est(&self, i: i64, j: i64, cell: f64) -> f32 {+        let (dx, dy) = ((i - self.src.0).abs() as f64, (j - self.src.1).abs() as f64);+        let (hi, lo) = if dx > dy { (dx, dy) } else { (dy, dx) };+        (((hi - lo) + lo * SQRT2) * cell) as f32+    }++    fn relax(&mut self, cell: f64, s: usize, i: i64, j: i64, g: f32) {+        if g < self.g[s] {+            self.g[s] = g;+            let f = g + self.est(i, j, cell);+            // Micrometres: enough to order cells of half a millimetre.+            self.heap.push(Reverse(((f / 1000.0) as u32, s as u32)));+        }+    }++    /// Settle states until this one is settled, or nothing is left.+    fn lookup(&mut self, c: &Coarse, w: &World, r: &Rules, i: i64, j: i64, l: usize) -> f32 {+        let Some(want) = self.state(i, j, l) else { return f32::INFINITY };+        if self.closed[want] {+            return self.g[want];+        }+        let who = net16(self.net);+        let soft = self.soft;+        while let Some(Reverse((_, s))) = self.heap.pop() {+            let s = s as usize;+            if self.closed[s] {+                continue;+            }+            self.closed[s] = true;+            self.pops += 1;+            let (ci, cj, cl) = (s % self.cw, (s / self.cw) % self.ch, s / (self.cw * self.ch));+            let (ai, aj) = (ci as i64 + self.i0, cj as i64 + self.j0);+            let g = self.g[s];+            let mut unit = c.cell as f32 * if c.route[cl] == 0 { 1.0 } else { r.cost_bottom as f32 };+            // Off the planned corridor costs more in the estimate only: a preference, not a wall.+            if let Some(cr) = &self.corridor {+                if !cr.contains(ai, aj, cl) {+                    unit *= 1.0 + CORRIDOR_BIAS;+                }+            }+            // What crossing a boundary adds, or infinity when it is closed. A soft search may cross+            // committed routes at a price, and an estimate that knows this heads straight for the+            // crossing instead of flooding everything cheaper first.+            let cross = |d: usize, a: i64, b: i64| -> f32 {+                if a < 0 || b < 0 || a as usize >= c.w || b as usize >= c.h {+                    return f32::INFINITY;+                }+                let e = c.boundary(cl, d, a as usize, b as usize);+                if c.open(e, who, false) {+                    0.0+                } else if soft && c.open(e, who, true) {+                    SOFT_CROSSING as f32+                } else {+                    f32::INFINITY+                }+            };+            let e = cross(0, ai, aj);+            let wst = cross(0, ai - 1, aj);+            let so = cross(1, ai, aj);+            let n = cross(1, ai, aj - 1);+            for (x, dx, dy) in [(e, 1i64, 0i64), (wst, -1, 0), (so, 0, 1), (n, 0, -1)] {+                if x.is_finite() {+                    if let Some(t) = self.state(ai + dx, aj + dy, cl) {+                        self.relax(c.cell, t, ai + dx, aj + dy, g + unit + x);+                    }+                }+            }+            // A diagonal step needs one of its two L-shaped ways open: any 45-degree line passes+            // through one of them.+            for (dx, dy, a, b) in [(1i64, 1i64, e, so), (1, -1, e, n), (-1, 1, wst, so), (-1, -1, wst, n)] {+                let via_x = a + if dy > 0 { cross(1, ai + dx, aj) } else { cross(1, ai + dx, aj - 1) };+                let via_y = b + if dx > 0 { cross(0, ai, aj + dy) } else { cross(0, ai - 1, aj + dy) };+                let x = via_x.min(via_y);+                if x.is_finite() {+                    if let Some(t) = self.state(ai + dx, aj + dy, cl) {+                        self.relax(c.cell, t, ai + dx, aj + dy, g + unit * SQRT2 as f32 + x);+                    }+                }+            }+            if !self.no_vias && self.nl > 1 {+                let v = ci + cj * self.cw;+                if self.via[v] == 0 {+                    self.via[v] = if c.via_open(w, r, self.net, soft, ai as usize, aj as usize) { 1 } else { 2 };+                }+                if self.via[v] == 1 {+                    for o in 0..self.nl {+                        if o != cl {+                            let t = (o * self.ch + cj) * self.cw + ci;+                            self.relax(c.cell, t, ai, aj, g + r.cost_via as f32);+                        }+                    }+                }+            }+            if s == want {+                return g;+            }+        }+        f32::INFINITY+    }+}++/// What the search keeps between calls: the map and its recent backward searches.+#[derive(Default)]+pub struct Guide {+    pub coarse: Option<Coarse>,+    tables: Vec<Back>,+    pub back_pops: u64,+    pub closed_early: u64,+    pub pockets_closed: u64,+    pub searches: u64,+    pub nodes_ok: u64,+    pub nodes_failed: u64,+    /// The last query that failed, so a retry can afford a closer look.+    failed: Option<(NetId, u64, u64)>,+    pockets: Vec<((u64, NetId, bool, bool), u64, bool)>,+    /// When the first search of the run began, for the hard stop inside a long search (4.6).+    pub start: Option<crate::clock::Instant>,+    pub plan: Option<GlobalPlan>,+    /// What the connection being routed should look like, if it belongs to a bus.+    pub hint: Option<Hint>,+}++/// A bus member's preference: its neighbour's shape carried over to its own pins, and a layer. Only+/// ever a small cost: the search still finds its own way where the neighbour's shape doesn't fit.+#[derive(Clone, Default)]+pub struct Hint {+    pub net: NetId,+    /// Runs to follow, and the layer each is on.+    pub lanes: Vec<(V, V, usize)>,+    pub layer: Option<usize>,+}++/// How much dearer a step away from the lanes is. All octilinear routes between two points of one+/// length tie, so this only has to break ties, and more than the search's own 20% inflation would+/// flood. At 0, 0.1 and 0.25 the boards' results vary with no trend (benchmark C 269, 287, 259 of 300);+/// 0.1 is what benchmark B's picture was judged at.+const OFF_LANE: f64 = 0.1;++impl Hint {+    #[inline]+    pub fn extra(&self, a: V, b: V, layer: usize) -> f64 {+        let mut k = 0.0;+        if let Some(l) = self.layer {+            if l != layer {+                k += OFF_LANE;+            }+        }+        if !self.lanes.is_empty() && !self.lanes.iter().any(|(p, q, l)| *l == layer && pt_seg(a, *p, *q) <= 2000.0 && pt_seg(b, *p, *q) <= 2000.0) {+            k += OFF_LANE;+        }+        k+    }+}++/// The pocket check looks this far around a terminal, in squares of this size.+const POCKET_R: f64 = 2.0 * NM;+const POCKET_S: f64 = 0.05 * NM;++/// Is this terminal walled in? A flood at the fine scale from the pad, over squares that a single+/// obstacle doesn't provably cover, looking for the edge of the area, the other terminal, or a place+/// a via could stand. Measured on benchmark C: most failing searches come within two cells of a pin+/// they can't get into and then spend their whole node budget circling it. Same rule as the map:+/// walled in means proven, never rounded, and a lane that exactly fits stays open.+fn walled_in(c: &Coarse, w: &World, q: &Query, p: P, layers: &[usize], other: &[Terminal]) -> bool {+    let n = (2.0 * POCKET_R / POCKET_S) as i64;+    let (ox, oy) = (p.0 as f64 - POCKET_R, p.1 as f64 - POCKET_R);+    let hd = POCKET_S * 0.7072;+    let nl = c.route.len();+    let soft = q.soft.is_some();+    let un = n as usize;+    let mut closed = vec![false; un * un * nl];+    let centre = |i: i64, j: i64| V(ox + (i as f64 + 0.5) * POCKET_S, oy + (j as f64 + 0.5) * POCKET_S);+    let region = (ox, oy, ox + 2.0 * POCKET_R, oy + 2.0 * POCKET_R);+    let mut paint = |l: usize, shape: &Shape, bb: (f64, f64, f64, f64), need: f64| {+        let lo = |v: f64, o: f64| (((v - need - o) / POCKET_S).floor() as i64).clamp(0, n);+        let hi = |v: f64, o: f64| (((v + need - o) / POCKET_S).ceil() as i64).clamp(0, n);+        for j in lo(bb.1, oy)..hi(bb.3, oy) {+            for i in lo(bb.0, ox)..hi(bb.2, ox) {+                let at = (l * un + j as usize) * un + i as usize;+                if !closed[at] && shape.dist_pt(centre(i, j)) + hd < need {+                    closed[at] = true;+                }+            }+        }+    };+    for l in 0..nl {+        let need = c.need;+        let r = (region.0 - need, region.1 - need, region.2 + need, region.3 + need);+        w.layers[c.route[l]].visit(r, |o| {+            if (o.net == q.net && q.net != NO_NET) || (soft && matches!(o.owner, Owner::Conn(_))) || w.crosses_pour(o, q.net) {+                return true;+            }+            paint(l, &o.shape, o.bb, need);+            true+        });+        let e = c.need_edge;+        w.edge.visit((region.0 - e, region.1 - e, region.2 + e, region.3 + e), |o| {+            paint(l, &o.shape, o.bb, e);+            true+        });+    }+    let goal: Vec<(i64, i64, usize)> = other+        .iter()+        .filter_map(|t| if let Terminal::Point { p: g, layers } = t { Some((*g, layers)) } else { None })+        .flat_map(|(g, ls)| {+            let (i, j) = (((g.0 as f64 - ox) / POCKET_S).floor() as i64, ((g.1 as f64 - oy) / POCKET_S).floor() as i64);+            ls.iter().filter(|&&l| c.index[l] != usize::MAX).map(move |&l| (i, j, l)).collect::<Vec<_>>()+        })+        .map(|(i, j, l)| (i, j, c.index[l]))+        .collect();+    let mut seen = vec![false; un * un * nl];+    let mut via_tried = vec![false; un * un / 4 + un + 1];+    let mut stack: Vec<(i64, i64, usize)> = Vec::new();+    let (si, sj) = (n / 2, n / 2);+    for &l in layers {+        if c.index[l] != usize::MAX {+            let cl = c.index[l];+            seen[(cl * un + sj as usize) * un + si as usize] = true;+            stack.push((si, sj, cl));+        }+    }+    let via_need = q.rules.via as f64 / 2.0 + q.rules.clearance as f64;+    let via_edge = q.rules.via as f64 / 2.0 + q.rules.edge as f64;+    let via_hd = 2.0 * POCKET_S * 0.7072;+    let can_via = q.profile.max_vias > 0 && nl > 1;+    while let Some((i, j, l)) = stack.pop() {+        if i == 0 || j == 0 || i == n - 1 || j == n - 1 || goal.contains(&(i, j, l)) {+            return false;+        }+        if can_via {+            // Tested on squares twice the size, so each proof covers four flood squares.+            let (vi, vj) = (i / 2, j / 2);+            let tag = (vj * n / 2 + vi) as usize;+            if !via_tried[tag] {+                via_tried[tag] = true;+                let m = V(ox + (vi as f64 + 0.5) * 2.0 * POCKET_S, oy + (vj as f64 + 0.5) * 2.0 * POCKET_S);+                let bb = (m.0 - via_need, m.1 - via_need, m.0 + via_need, m.1 + via_need);+                let mut stands = true;+                for g in &w.layers {+                    g.visit(bb, |o| {+                        if (o.net == q.net && q.net != NO_NET) || (soft && matches!(o.owner, Owner::Conn(_))) {+                            return true;+                        }+                        if o.shape.dist_pt(m) + via_hd < via_need {+                            stands = false;+                            return false;+                        }+                        true+                    });+                    if !stands {+                        break;+                    }+                }+                if stands {+                    w.edge.visit((m.0 - via_edge, m.1 - via_edge, m.0 + via_edge, m.1 + via_edge), |o| {+                        if o.shape.dist_pt(m) + via_hd < via_edge {+                            stands = false;+                            return false;+                        }+                        true+                    });+                }+                if stands {+                    for o in 0..nl {+                        let at = (o * un + j as usize) * un + i as usize;+                        if !seen[at] && !closed[at] {+                            seen[at] = true;+                            stack.push((i, j, o));+                        }+                    }+                }+            }+        }+        for dj in -1..=1i64 {+            for di in -1..=1i64 {+                let (a, b) = (i + di, j + dj);+                let at = (l * un + b as usize) * un + a as usize;+                if !seen[at] && !closed[at] {+                    seen[at] = true;+                    stack.push((a, b, l));+                }+            }+        }+    }+    true+}++impl Guide {+    /// Prepare the backward search for a query, or say the query isn't guided. Pair centrelines+    /// and fan-ins skip checks the map can't know about, so they stay out of it.+    pub fn prepare(&mut self, w: &World, q: &Query, window: (f64, f64, f64, f64)) -> Option<usize> {+        if q.also.is_some() || !q.free.is_empty() || q.targets.is_empty() || q.profile.neck < q.rules.neck || q.profile.clearance < q.rules.clearance {+            return None;+        }+        if self.coarse.is_none() {+            self.coarse = Some(Coarse::build(w, q.rules));+        }+        let c = self.coarse.as_mut().unwrap();+        c.sync(w);+        let c = self.coarse.as_ref().unwrap();+        let soft = q.soft.is_some();+        let no_vias = q.profile.max_vias == 0;+        let (a, b) = (c.cell_of(V(window.0, window.1)), c.cell_of(V(window.2, window.3)));+        let (i0, j0) = (a.0.max(0), a.1.max(0));+        let (i1, j1) = (b.0.min(c.w as i64 - 1), b.1.min(c.h as i64 - 1));+        if i0 > i1 || j0 > j1 {+            return None;+        }+        let corridor = if soft || q.profile.margin >= 8.0 * NM { None } else { self.corridor_of(q) };+        let key = (q.net, terminal_hash(q.targets), soft, no_vias, (i0, j0, i1, j1), terminal_hash(q.sources) * corridor.is_some() as u64);+        let c = self.coarse.as_ref().unwrap();+        let rev = if soft { c.rev_s } else { c.rev_d };+        self.tables.retain(|t| t.rev == rev);+        if let Some(i) = self.tables.iter().position(|t| t.key == key) {+            return Some(i);+        }+        if self.tables.len() >= 8 {+            self.tables.remove(0);+        }+        let (cw, ch, nl) = ((i1 - i0 + 1) as usize, (j1 - j0 + 1) as usize, c.route.len());+        let n = cw * ch * nl;+        let mut src = (0, 0);+        for t in q.sources {+            if let Terminal::Point { p, .. } = t {+                src = c.cell_of((*p).into());+                break;+            }+        }+        let mut t = Back { key, corridor, rev, i0, j0, cw, ch, nl, g: vec![f32::INFINITY; n], closed: vec![false; n], via: vec![0; cw * ch], heap: BinaryHeap::new(), src, net: q.net, soft, no_vias, pops: 0 };+        for term in q.targets {+            match term {+                // A tap onto a rail: every cell along the track is a goal.+                Terminal::Track { a, b, layer, .. } => {+                    if c.index[*layer] == usize::MAX {+                        continue;+                    }+                    let l = c.index[*layer];+                    let (va, vb): (V, V) = ((*a).into(), (*b).into());+                    let steps = (hypot(sub(va, vb)) / (c.cell * 0.5)).ceil().max(1.0) as usize;+                    for k in 0..=steps {+                        let f = k as f64 / steps as f64;+                        let (i, j) = c.cell_of(V(va.0 + (vb.0 - va.0) * f, va.1 + (vb.1 - va.1) * f));+                        if let Some(s) = t.state(i, j, l) {+                            t.relax(c.cell, s, i, j, 0.0);+                        }+                    }+                }+                Terminal::Point { p, layers } => {+                    let (i, j) = c.cell_of((*p).into());+                    for &l in layers {+                        if c.index[l] != usize::MAX {+                            if let Some(s) = t.state(i, j, c.index[l]) {+                                t.relax(c.cell, s, i, j, 0.0);+                            }+                        }+                    }+                }+                Terminal::Zone { layer, poly } => {+                    if c.index[*layer] == usize::MAX {+                        continue;+                    }+                    let l = c.index[*layer];+                    let b = Shape::Poly { pts: poly.clone(), r: 0.0 }.bbox();+                    let (u, v) = (c.cell_of(V(b.0, b.1)), c.cell_of(V(b.2, b.3)));+                    let reach = c.cell * 0.7072;+                    let edge = Shape::Poly { pts: poly.clone(), r: 0.0 };+                    for j in u.1.max(j0)..=v.1.min(j1) {+                        for i in u.0.max(i0)..=v.0.min(i1) {+                            let m = V(c.x0 + (i as f64 + 0.5) * c.cell, c.y0 + (j as f64 + 0.5) * c.cell);+                            // dist_pt is zero inside the outline.+                            if edge.dist_pt(m) <= reach {+                                if let Some(s) = t.state(i, j, l) {+                                    t.relax(c.cell, s, i, j, 0.0);+                                }+                            }+                        }+                    }+                }+            }+        }+        self.tables.push(t);+        Some(self.tables.len() - 1)+    }++    /// One line for the run's report: what the search spent, and what the map saved it.+    pub fn summary(&self) -> String {+        format!("search: {} searches, {} nodes in those that succeeded, {} in those that failed; {} closed by the coarse map, {} by a walled-in terminal; {} coarse states", self.searches, self.nodes_ok, self.nodes_failed, self.closed_early, self.pockets_closed, self.back_pops)+    }++    /// Could a via stand in this point's cell? False is a proof, as everywhere on the map.+    pub fn via_possible(&mut self, table: usize, w: &World, r: &Rules, p: V) -> bool {+        let c = self.coarse.as_ref().unwrap();+        let (i, j) = c.cell_of(p);+        let t = &mut self.tables[table];+        let (a, b) = (i - t.i0, j - t.j0);+        if a < 0 || b < 0 || a >= t.cw as i64 || b >= t.ch as i64 {+            return true;+        }+        let v = b as usize * t.cw + a as usize;+        if t.via[v] == 0 {+            t.via[v] = if c.via_open(w, r, t.net, t.soft, i as usize, j as usize) { 1 } else { 2 };+        }+        t.via[v] == 1+    }++    pub fn corridor_of(&self, q: &Query) -> Option<Rc<Corridor>> {+        let plan = self.plan.as_ref()?;+        plan.corridors.get(&(q.net, ends_hash(q.sources), ends_hash(q.targets))).cloned()+    }++    pub fn note_failed(&mut self, q: &Query) {+        if let Some(c) = &self.coarse {+            self.failed = Some((q.net, terminal_hash(q.targets), if q.soft.is_some() { c.rev_s } else { c.rev_d }));+        }+    }++    /// Retrying after a failure: is either end walled in? Only then is the closer look worth it,+    /// and the answer carries over to every later attempt for the same pins.+    pub fn hopeless(&mut self, w: &World, q: &Query) -> bool {+        let Some(c) = self.coarse.as_ref() else { return false };+        let soft = q.soft.is_some();+        let rev = if soft { c.rev_s } else { c.rev_d };+        if self.failed != Some((q.net, terminal_hash(q.targets), rev)) {+            return false;+        }+        let no_vias = q.profile.max_vias == 0;+        self.pockets.retain(|x| x.1 == rev);+        let mut closed = false;+        for (ours, others) in [(q.sources, q.targets), (q.targets, q.sources)] {+            for t in ours {+                let Terminal::Point { p, layers } = t else { continue };+                if others.iter().any(|o| matches!(o, Terminal::Zone { .. })) {+                    continue;+                }+                let key = (terminal_hash(std::slice::from_ref(t)) ^ terminal_hash(others), q.net, soft, no_vias);+                let v = match self.pockets.iter().find(|x| x.0 == key) {+                    Some(x) => x.2,+                    None => {+                        let v = walled_in(c, w, q, *p, layers, others);+                        self.pockets.push((key, rev, v));+                        v+                    }+                };+                closed |= v;+            }+        }+        if closed {+            self.pockets_closed += 1;+        }+        closed+    }++    /// The coarse cost from a point on a layer to the target; infinity is a proof of no way there.+    #[inline]+    pub fn cost(&mut self, table: usize, w: &World, r: &Rules, p: V, layer: usize) -> f64 {+        let c = self.coarse.as_ref().unwrap();+        let (i, j) = c.cell_of(p);+        let t = &mut self.tables[table];+        let before = t.pops;+        let g = t.lookup(c, w, r, i, j, c.index[layer]);+        self.back_pops += t.pops - before;+        if g.is_finite() {+            // Each end of a real route can be up to a cell closer than the cell centres say.+            (g as f64 - 2.0 * c.cell).max(0.0)+        } else {+            f64::INFINITY+        }+    }+}++// ---------------------------------------------------------------------------------------------+// The global stage: before any copper is drawn, give every connection a corridor of coarse cells.+//+// Negotiation lives here and only here. PathFinder at lattice level scored poorly on ordinary boards+// (OrthoRoute's README cites 0.02 clean pass), while as an iterated assignment over a coarse network+// it converges (SUMO's duaIterate, VTR's rounds): route everything, price what is overused, repeat,+// with present and accumulated cost as in VTR's get_rr_cong_cost. A corridor can never make a route+// illegal: the detailed search still checks every step against real copper, and it only reads the+// corridor as a preference in its estimate, dropped when the search has to widen.+// ---------------------------------------------------------------------------------------------++use crate::board::Board;+use crate::classify::{Level, Task};+use std::collections::HashMap;+use std::rc::Rc;++const ROUNDS: usize = 16;+/// VTR's defaults, roughly: first present-cost factor, its growth per round, and the history step.+const PRES_INIT: f32 = 0.5;+const PRES_MULT: f32 = 1.5;+const ACC_FAC: f32 = 0.5;++/// A corridor: which global cells this connection plans to use, per layer.+pub struct Corridor {+    pub bbox: (f64, f64, f64, f64),+    on: Vec<bool>,+    i0: i64,+    j0: i64,+    gw: usize,+    gh: usize,+    f: i64,+    nl: usize,+}++impl Corridor {+    #[inline]+    fn contains(&self, ci: i64, cj: i64, l: usize) -> bool {+        let (i, j) = (ci.div_euclid(self.f) - self.i0, cj.div_euclid(self.f) - self.j0);+        i >= 0 && j >= 0 && (i as usize) < self.gw && (j as usize) < self.gh && l < self.nl && self.on[(l * self.gh + j as usize) * self.gw + i as usize]+    }+}++/// What the global stage hands back to the router: a preference per connection and an order hint.+#[derive(Default, Clone)]+pub struct GlobalPlan {+    corridors: HashMap<(NetId, u64, u64), Rc<Corridor>>,+    pub note: String,+}++struct Conn {+    a: (i64, i64, Vec<usize>),+    b: (i64, i64, Vec<usize>),+    demand: f32,+    path: Vec<(i64, i64, usize)>,+    key: (NetId, u64, u64),+}++fn env_on(name: &str) -> bool {+    std::env::var_os(name).is_some()+}++fn pad_term(board: &Board, w: &World, i: usize) -> Terminal {+    let p = &board.pads[i];+    Terminal::Point { p: p.center, layers: p.layers.iter().copied().filter(|l| w.route_layers.contains(l)).collect() }+}++/// Assign every connection a corridor by negotiated congestion. Called once per routing pass, with+/// the pairs already placed so their room is gone.+///+/// The plan doesn't change the routing order. Tried at 60 s: most contested first lost connections+/// against shortest first (benchmark C 265 against 268), least contested first won on benchmark C (271)+/// and lost on piprobe_v13 (86 against 87). That is within the run-to-run spread, so the order stays+/// as the router sets it.+pub fn plan(w: &World, r: &Rules, board: &Board, tasks: &[Task], held_to: &dyn Fn(&Task) -> Option<usize>) -> GlobalPlan {+    let t0 = std::time::Instant::now();+    let mut out = GlobalPlan::default();+    if env_on("ADOM_ROUTE_NO_GLOBAL") {+        w.guide.borrow_mut().plan = None;+        return out;+    }+    let mut guide = w.guide.borrow_mut();+    if guide.coarse.is_none() {+        guide.coarse = Some(Coarse::build(w, r));+    }+    let c = guide.coarse.as_mut().unwrap();+    c.sync(w);+    let c = guide.coarse.as_ref().unwrap();+    // Global cells of 1 mm on a molecule, 2 mm on a large board, so a round stays in milliseconds.+    let big = c.w as f64 * c.cell > 60.0 * NM || c.h as f64 * c.cell > 60.0 * NM;+    let f: usize = if big { 8 } else { 4 };+    let g = c.cell * f as f64;+    let (gw, gh, nl) = (c.w / f, c.h / f, c.route.len());+    if gw < 2 || gh < 2 {+        return out;+    }+    let pitch = (r.track + r.clearance) as f64;+    // Capacity of each global boundary: tracks that fit in each free run of real centreline room.+    // Layer l, direction d, (i, j): from global cell (i, j) to the next in x (d 0) or y (d 1).+    let ne = nl * 2 * gw * gh;+    let mut cap = vec![0f32; ne];+    let edge = |l: usize, d: usize, i: usize, j: usize| ((l * 2 + d) * gh + j) * gw + i;+    for l in 0..nl {+        for d in 0..2 {+            for j in 0..gh {+                for i in 0..gw {+                    let mut tracks = 0.0f32;+                    let mut run = 0usize;+                    let mut flush = |run: &mut usize| {+                        if *run > 0 {+                            tracks += (*run as f64 * c.s / pitch).floor() as f32 + 1.0;+                            *run = 0;+                        }+                    };+                    for t in 0..f {+                        let (bi, bj) = if d == 0 { ((i + 1) * f - 1, j * f + t) } else { (i * f + t, (j + 1) * f - 1) };+                        if bi >= c.w || bj >= c.h {+                            continue;+                        }+                        let b = c.boundary(l, d, bi, bj);+                        let m = c.mask_s[b] | c.mask_d[b];+                        for bit in 0..K {+                            if m & (1 << bit) == 0 {+                                run += 1;+                            } else {+                                flush(&mut run);+                            }+                        }+                    }+                    flush(&mut run);+                    cap[edge(l, d, i, j)] = tracks;+                }+            }+        }+    }+    let mut conns: Vec<Conn> = Vec::new();+    let gcell = |p: P| -> (i64, i64) {+        let (i, j) = c.cell_of(p.into());+        (i.div_euclid(f as i64), j.div_euclid(f as i64))+    };+    for t in tasks {+        if t.zone.is_some() || t.a == t.b {+            continue;+        }+        let (ta, tb) = (pad_term(board, w, t.a), pad_term(board, w, t.b));+        let (Terminal::Point { p: pa, layers: la }, Terminal::Point { p: pb, layers: lb }) = (&ta, &tb) else { continue };+        if la.is_empty() || lb.is_empty() {+            continue;+        }+        let (ca, cb) = (gcell(*pa), gcell(*pb));+        let demand = if t.level == Level::Power && t.main {+            let main = r.wide.get(board.net_name(t.net)).and_then(|v| v.first().copied()).unwrap_or(r.power_floor);+            (((main + r.clearance) as f64) / pitch).max(1.0) as f32+        } else {+            1.0+        };+        let key = (t.net, ends_hash(std::slice::from_ref(&ta)), ends_hash(std::slice::from_ref(&tb)));+        // A bus member with a layer chosen plans on that layer.+        let on = |ls: &Vec<usize>| -> Vec<usize> {+            match held_to(t) {+                Some(l) if ls.contains(&l) => vec![c.index[l]],+                _ => ls.iter().map(|&l| c.index[l]).collect(),+            }+        };+        conns.push(Conn { a: (ca.0, ca.1, on(la)), b: (cb.0, cb.1, on(lb)), demand, path: Vec::new(), key });+    }+    // Long ones first in the first round, so short ones see where the long ones want to be.+    let mut order: Vec<usize> = (0..conns.len()).collect();+    let span = |x: &Conn| (x.a.0 - x.b.0).abs() + (x.a.1 - x.b.1).abs();+    order.sort_by_key(|&i| -span(&conns[i]));++    let mut occ = vec![0f32; ne];+    let mut hist = vec![1f32; ne];+    let mut pres = PRES_INIT;+    let ng = gw * gh * nl;+    let mut best = vec![f32::INFINITY; ng];+    let mut prev = vec![u32::MAX; ng];+    let mut stamp = vec![0u32; ng];+    let mut tick = 0u32;+    let mut heap: BinaryHeap<Reverse<(u32, u32)>> = BinaryHeap::new();+    let base = (g * 0.75) as f32;+    let via_cost = r.cost_via as f32;+    let (mut first_over, mut last_over, mut rounds) = (0.0f32, 0.0f32, 0usize);+    for round in 0..ROUNDS {+        rounds = round + 1;+        let mut changed = 0;+        for &ci in &order {+            let conn = &mut conns[ci];+            // Only connections through something overused need a new corridor (incremental+            // PathFinder); the rest keep theirs, as SUMO keeps most drivers on their routes.+            let (mut over, mut has) = (false, false);+            for s in conn.path.windows(2) {+                has = true;+                if let Some(e) = charged(conn, s[0], s[1], &cap, gw, gh) {+                    if occ[e] > cap[e] {+                        over = true;+                        break;+                    }+                }+            }+            if has && !over {+                continue;+            }+            changed += 1;+            for s in conn.path.windows(2) {+                if let Some(e) = charged(conn, s[0], s[1], &cap, gw, gh) {+                    occ[e] -= conn.demand;+                }+            }+            // A* over global cells. Crossing a boundary costs its length, times history, times the+            // present cost of being over capacity.+            tick += 1;+            heap.clear();+            let idx = |i: i64, j: i64, l: usize| (l * gh + j as usize) * gw + i as usize;+            let inb = |i: i64, j: i64| i >= 0 && j >= 0 && (i as usize) < gw && (j as usize) < gh;+            let (ta, tb) = (conn.b.0, conn.b.1);+            let est = |i: i64, j: i64| ((i - ta).abs() + (j - tb).abs()) as f32 * base;+            for &l in &conn.a.2 {+                if inb(conn.a.0, conn.a.1) {+                    let s = idx(conn.a.0, conn.a.1, l);+                    best[s] = 0.0;+                    stamp[s] = tick;+                    prev[s] = u32::MAX;+                    heap.push(Reverse(((est(conn.a.0, conn.a.1) / 100.0) as u32, s as u32)));+                }+            }+            let mut goal = None;+            while let Some(Reverse((_, s))) = heap.pop() {+                let s = s as usize;+                let (i, j, l) = ((s % gw) as i64, ((s / gw) % gh) as i64, s / (gw * gh));+                if i == ta && j == tb && conn.b.2.contains(&l) {+                    goal = Some(s);+                    break;+                }+                let gs = best[s];+                let mult = if c.route[l] == 0 { 1.0 } else { r.cost_bottom as f32 };+                for (di, dj) in [(1i64, 0i64), (-1, 0), (0, 1), (0, -1)] {+                    let (a, b) = (i + di, j + dj);+                    if !inb(a, b) {+                        continue;+                    }+                    let e = step_edge((i, j, l), (a, b, l), gw, gh).unwrap();+                    let over_by = (occ[e] + conn.demand - cap[e]).max(0.0);+                    // A pin's own cell boundary reads closed to everyone (its pads block the map),+                    // so it costs no penalty for the connection that starts or ends there.+                    let at_end = (i == conn.a.0 && j == conn.a.1) || (i == ta && j == tb) || (a == conn.a.0 && b == conn.a.1) || (a == ta && b == tb);+                    let cong = if at_end && cap[e] < conn.demand { 1.0 } else { hist[e] * (1.0 + pres * over_by) };+                    let n = gs + base * mult * cong;+                    let t = idx(a, b, l);+                    if stamp[t] != tick || n < best[t] {+                        stamp[t] = tick;+                        best[t] = n;+                        prev[t] = s as u32;+                        heap.push(Reverse((((n + est(a, b)) / 100.0) as u32, t as u32)));+                    }+                }+                for o in 0..nl {+                    if o != l {+                        let t = idx(i, j, o);+                        let n = gs + via_cost;+                        if stamp[t] != tick || n < best[t] {+                            stamp[t] = tick;+                            best[t] = n;+                            prev[t] = s as u32;+                            heap.push(Reverse(((n + est(i, j)) as u32 / 100, t as u32)));+                        }+                    }+                }+            }+            conn.path.clear();+            if let Some(mut s) = goal {+                loop {+                    conn.path.push(((s % gw) as i64, ((s / gw) % gh) as i64, s / (gw * gh)));+                    if prev[s] == u32::MAX {+                        break;+                    }+                    s = prev[s] as usize;+                }+                conn.path.reverse();+            }+            for s in conn.path.windows(2) {+                if let Some(e) = charged(conn, s[0], s[1], &cap, gw, gh) {+                    occ[e] += conn.demand;+                }+            }+        }+        let mut over_total = 0.0;+        for e in 0..ne {+            let o = (occ[e] - cap[e]).max(0.0);+            over_total += o;+            hist[e] += ACC_FAC * o;+        }+        if round == 0 {+            first_over = over_total;+        }+        last_over = over_total;+        pres *= PRES_MULT;+        // No wall-clock cut-off (clock.rs): the rounds are bounded by ROUNDS, the same on every run.+        if changed == 0 {+            break;+        }+    }+    // Corridors: the planned cells, a cell wider each way, so the search has room to choose.+    for conn in &conns {+        if conn.path.is_empty() {+            continue;+        }+        let (mut i0, mut j0, mut i1, mut j1) = (i64::MAX, i64::MAX, i64::MIN, i64::MIN);+        for s in &conn.path {+            i0 = i0.min(s.0 - 1);+            j0 = j0.min(s.1 - 1);+            i1 = i1.max(s.0 + 1);+            j1 = j1.max(s.1 + 1);+        }+        let (cw, ch) = ((i1 - i0 + 1) as usize, (j1 - j0 + 1) as usize);+        let mut on = vec![false; cw * ch * nl];+        for s in &conn.path {+            for dj in -1..=1i64 {+                for di in -1..=1i64 {+                    on[(s.2 * ch + (s.1 + dj - j0) as usize) * cw + (s.0 + di - i0) as usize] = true;+                }+            }+        }+        let bbox = (c.x0 + i0 as f64 * g, c.y0 + j0 as f64 * g, c.x0 + (i1 + 1) as f64 * g, c.y0 + (j1 + 1) as f64 * g);+        out.corridors.insert(conn.key, Rc::new(Corridor { bbox, on, i0, j0, gw: cw, gh: ch, f: f as i64, nl }));+    }+    out.note = format!("global: {} connections, {} rounds, overuse {:.0} -> {:.0}, {:.0} ms", conns.len(), rounds, first_over, last_over, t0.elapsed().as_secs_f64() * 1000.0);+    guide.plan = Some(out.clone());+    out+}++/// The boundary a step uses up. A pin's own cell boundary reads closed to everyone, since its pads+/// block the map, so a step off a terminal over such a boundary uses nothing up.+#[inline]+fn charged(conn: &Conn, a: (i64, i64, usize), b: (i64, i64, usize), cap: &[f32], gw: usize, gh: usize) -> Option<usize> {+    let e = step_edge(a, b, gw, gh)?;+    let end = |p: (i64, i64, usize)| (p.0 == conn.a.0 && p.1 == conn.a.1) || (p.0 == conn.b.0 && p.1 == conn.b.1);+    if cap[e] < conn.demand && (end(a) || end(b)) {+        return None;+    }+    Some(e)+}++/// Would these two connections cross if each ran straight? The estimate buses use. Coarse on purpose:+/// which of two lines must give way depends on the ends, not on the detail of the route between.+pub fn chords_cross(a: V, b: V, c: V, d: V) -> bool {+    seg_cross(a, b, c, d)+}++/// The boundary between two neighbouring global cells on one layer; None for a via.+#[inline]+fn step_edge(a: (i64, i64, usize), b: (i64, i64, usize), gw: usize, gh: usize) -> Option<usize> {+    if a.2 != b.2 {+        return None;+    }+    let (d, i, j) = if a.1 == b.1 { (0, a.0.min(b.0), a.1) } else { (1, a.0, a.1.min(b.1)) };+    Some(((a.2 * 2 + d) * gh + j as usize) * gw + i as usize)+}++#[cfg(test)]+mod tests {+    use super::*;+    use crate::router::build_world;+    use crate::search::{search, Profile};++    fn board_text(extra: &str) -> String {+        format!(+            r#"(kicad_pcb (version 20240108) (generator test)+  (layers (0 "F.Cu" signal) (31 "B.Cu" signal) (44 "Edge.Cuts" user))+  (net 0 "") (net 1 "A") (net 2 "B")+  (gr_rect (start 0 0) (end 20 10) (layer "Edge.Cuts") (width 0.1))+  {extra}+)"#+        )+    }++    fn term(x: f64, y: f64) -> [Terminal; 1] {+        [Terminal::Point { p: (mm(x), mm(y)), layers: vec![0] }]+    }++    fn profile(r: &Rules, vias: u32) -> Profile {+        Profile { width: r.neck, neck: r.neck, clearance: r.clearance, target_gap: r.clearance, max_vias: vias, margin: 40.0 * NM, layer_bias: None }+    }++    fn query<'a>(r: &'a Rules, s: &'a [Terminal], t: &'a [Terminal], vias: u32) -> Query<'a> {+        Query { net: 99, also: None, sources: s, targets: t, profile: profile(r, vias), rules: r, soft: None, via_in: None, history: None, free: &[], arrive: None }+    }++    /// A wall of two tracks with a gap that a neck-width track fits exactly. Rounding of any kind+    /// would close this lane; the map must not. A tenth of a millimetre less must close it.+    #[test]+    fn a_lane_that_exactly_fits_stays_open() {+        let r = Rules::default();+        let gap = (r.neck + 2 * r.clearance) as f64 / NM;+        let half = r.track as f64 / NM / 2.0;+        let (a, b) = (5.0 - gap / 2.0 - half, 5.0 + gap / 2.0 + half);+        let extra = format!(+            r#"(segment (start 10 0.5) (end 10 {a}) (width 0.2) (layer "F.Cu") (net 2))+               (segment (start 10 {b}) (end 10 9.5) (width 0.2) (layer "F.Cu") (net 2))"#+        );+        let board = Board::parse(board_text(&extra)).unwrap();+        let w = build_world(&board, &r);+        let (s, t) = (term(5.0, 5.0), term(15.0, 5.0));+        let q = query(&r, &s, &t, 0);+        let mut guide = w.guide.borrow_mut();+        let tb = guide.prepare(&w, &q, (0.0, 0.0, 20.0 * NM, 10.0 * NM)).unwrap();+        assert!(guide.cost(tb, &w, &r, V(5.0 * NM, 5.0 * NM), 0).is_finite());+        drop(guide);+        assert!(search(&w, &q).is_some(), "the detailed search should use the lane too");++        let (a, b) = (a + 0.05, b - 0.05);+        let extra = format!(+            r#"(segment (start 10 0.5) (end 10 {a}) (width 0.2) (layer "F.Cu") (net 2))+               (segment (start 10 {b}) (end 10 9.5) (width 0.2) (layer "F.Cu") (net 2))"#+        );+        let board = Board::parse(board_text(&extra)).unwrap();+        let w = build_world(&board, &r);+        let q = query(&r, &s, &t, 0);+        assert!(search(&w, &q).is_none(), "the lane is 0.1 mm too narrow");+    }++    /// The same wall with no lane at all is a proof: no nodes spent.+    #[test]+    fn a_closed_wall_is_proved_without_searching() {+        let r = Rules::default();+        let extra = r#"(segment (start 10 0) (end 10 10) (width 0.2) (layer "F.Cu") (net 2))"#;+        let board = Board::parse(board_text(extra)).unwrap();+        let w = build_world(&board, &r);+        let (s, t) = (term(5.0, 5.0), term(15.0, 5.0));+        let q = query(&r, &s, &t, 0);+        assert!(search(&w, &q).is_none());+        let g = w.guide.borrow();+        assert_eq!(g.closed_early, 1);+        assert_eq!(g.nodes_failed, 0);+    }++    /// A committed route closes the map and taking it away opens it again.+    #[test]+    fn the_map_follows_commits_and_rips() {+        let r = Rules::default();+        let board = Board::parse(board_text("")).unwrap();+        let mut w = build_world(&board, &r);+        let (s, t) = (term(5.0, 5.0), term(15.0, 5.0));+        assert!(search(&w, &query(&r, &s, &t, 0)).is_some());+        let id = w.layers[0].add(Shape::Capsule { a: V(10.0 * NM, 0.0), b: V(10.0 * NM, 10.0 * NM), r: 0.1 * NM }, 2, Owner::Conn(7));+        assert!(search(&w, &query(&r, &s, &t, 0)).is_none());+        assert_eq!(w.guide.borrow().closed_early, 1);+        w.layers[0].remove(id);+        assert!(search(&w, &query(&r, &s, &t, 0)).is_some());+    }++    /// The hard case the map must not get wrong: every pin of the 0.4 mm QFN on PiProbe with its+    /// copper stripped. The designer routes all of these; "no path" here would be the map's mistake.+    #[test]+    fn piprobe_u1_escapes_are_open() {+        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/bench/boards/piprobe_v13.ref.kicad_pcb");+        if !std::path::Path::new(&path).exists() {+            eprintln!("skipped: {path} is not here (the reference boards do not ship with the source)");+            return;+        }+        let mut board = Board::read(path).unwrap();+        board.tracks.clear();+        board.vias.clear();+        let mut r = Rules::default();+        crate::project::apply(path, &mut r);+        let w = build_world(&board, &r);+        let u1 = board.footprints.iter().find(|f| f.pads.iter().any(|&p| board.pad_name(p).starts_with("U1.")));+        let u1 = u1.expect("U1 on the board");+        let mut guide = w.guide.borrow_mut();+        guide.coarse = Some(Coarse::build(&w, &r));+        let c = guide.coarse.as_ref().unwrap();+        let mut checked = 0;+        for &i in &u1.pads {+            let pad = &board.pads[i];+            if pad.net == NO_NET || pad.layers.is_empty() {+                continue;+            }+            let Some(&other) = (0..board.pads.len()).collect::<Vec<_>>().iter().find(|&&o| o != i && board.pads[o].net == pad.net && !u1.pads.contains(&o)) else { continue };+            let layers: Vec<usize> = pad.layers.iter().copied().filter(|l| w.route_layers.contains(l)).collect();+            let s = [Terminal::Point { p: pad.center, layers: layers.clone() }];+            let t = [Terminal::Point { p: board.pads[other].center, layers: board.pads[other].layers.iter().copied().filter(|l| w.route_layers.contains(l)).collect() }];+            let q = Query { net: pad.net, also: None, sources: &s, targets: &t, profile: profile(&r, 2), rules: &r, soft: None, via_in: None, history: None, free: &[], arrive: None };+            assert!(!walled_in(c, &w, &q, pad.center, &layers, &t), "{} called walled in", board.pad_name(i));+            checked += 1;+        }+        assert!(checked >= 20, "only {checked} U1 pins checked");+        drop(guide);+        for &i in &u1.pads {+            let pad = &board.pads[i];+            let Some(&other) = (0..board.pads.len()).collect::<Vec<_>>().iter().find(|&&o| o != i && pad.net != NO_NET && board.pads[o].net == pad.net && !u1.pads.contains(&o)) else { continue };+            let layers: Vec<usize> = pad.layers.iter().copied().filter(|l| w.route_layers.contains(l)).collect();+            if layers.is_empty() {+                continue;+            }+            let s = [Terminal::Point { p: pad.center, layers }];+            let t = [Terminal::Point { p: board.pads[other].center, layers: board.pads[other].layers.iter().copied().filter(|l| w.route_layers.contains(l)).collect() }];+            let q = Query { net: pad.net, also: None, sources: &s, targets: &t, profile: profile(&r, 2), rules: &r, soft: None, via_in: None, history: None, free: &[], arrive: None };+            let mut g = w.guide.borrow_mut();+            let tb = g.prepare(&w, &q, (-1e12, -1e12, 1e12, 1e12)).unwrap();+            assert!(g.cost(tb, &w, &r, pad.center.into(), pad.layers[0]).is_finite(), "{} closed on the coarse map", board.pad_name(i));+        }+    }+}

@@ -0,0 +1,154 @@+//! `grade`: runs the checker over the designer's boards and holds it to an expected-results file. His rule+//! (AI_Mistakes_Log R1): a check gates only after it passes the reference boards and fails the layouts he+//! rejected. Findings his own finished boards carry stay listed as known, with their coordinates,+//! for him to decide; a new one fails the grade, and so does a known one that has gone away.++use crate::board::Board;+use crate::check::{self, Finding, GEOMETRY_RULES};+use crate::classify;+use crate::project;+use crate::rules::Rules;+use serde_json::{json, Value};+use std::collections::BTreeMap;+use std::path::Path;++const NEAR_MM: f64 = 0.02;++pub struct Outcome {+    pub ok: bool,+    pub lines: Vec<String>,+    pub json: Value,+}++fn strs(v: Option<&Value>) -> Vec<String> {+    v.and_then(|x| x.as_array()).map(|a| a.iter().filter_map(|s| s.as_str().map(String::from)).collect()).unwrap_or_default()+}++pub fn run(file: &str) -> Result<Outcome, String> {+    let text = std::fs::read_to_string(file).map_err(|e| format!("{file}: {e}"))?;+    let v: Value = serde_json::from_str(&text).map_err(|e| format!("{file}: {e}"))?;+    let base = Path::new(file).parent().unwrap_or(Path::new("."));+    let boards = v.get("boards").and_then(|b| b.as_array()).ok_or("no boards in the grade file")?;+    let mut ok = true;+    let mut lines = Vec::new();+    let mut out = Vec::new();+    for e in boards {+        let name = e.get("name").and_then(|x| x.as_str()).unwrap_or("?");+        let rel = e.get("board").and_then(|x| x.as_str()).ok_or("board entry without a path")?;+        let path = base.join(rel);+        // A synthetic fixture is the reference board with copper added, in memory: `insert` is appended to the+        // file's text, so every check is proven to fire on a fault placed in a board it passes.+        let inserts = strs(e.get("insert"));+        let board = if inserts.is_empty() {+            Board::read(path.to_str().unwrap_or(rel))?+        } else {+            let t = std::fs::read_to_string(&path).map_err(|e| format!("{rel}: {e}"))?;+            let end = t.rfind(')').ok_or("board file has no closing bracket")?;+            Board::parse(format!("{}\n{}\n)\n", &t[..end], inserts.join("\n")))?+        };+        let mut rules = match e.get("spec").and_then(|x| x.as_str()) {+            Some(s) => Rules::load(base.join(s).to_str().unwrap_or(s))?,+            None => Rules::default(),+        };+        let pro = e.get("project").and_then(|x| x.as_str()).map(|p| base.join(p)).unwrap_or_else(|| path.with_extension("kicad_pro"));+        project::apply_files(&pro, &path.with_extension("kicad_dru"), &mut rules);+        for k in strs(e.get("kelvin")) {+            rules.kelvin.push(k);+        }+        rules.bind(&board);+        classify::find_pairs(&board, &mut rules);+        let (f, s) = check::check(&board, &rules);+        let errors: Vec<&Finding> = f.iter().filter(|x| x.severity == "error").collect();+        let count = |rule: &str| errors.iter().filter(|x| x.rule == rule).count();+        let mut fails: Vec<String> = Vec::new();++        let known_at = e.get("knownAt").and_then(|x| x.as_array()).cloned().unwrap_or_default();+        let listed: Vec<(String, f64, f64)> = known_at+            .iter()+            .filter_map(|k| Some((k.get("rule")?.as_str()?.to_string(), k.pointer("/at/0")?.as_f64()?, k.pointer("/at/1")?.as_f64()?)))+            .collect();+        let known_count: BTreeMap<String, usize> = e.get("knownCount").and_then(|x| x.as_object()).map(|o| o.iter().map(|(k, c)| (k.clone(), c.as_u64().unwrap_or(0) as usize)).collect()).unwrap_or_default();+        let is_known = |x: &Finding| known_count.contains_key(x.rule) || listed.iter().any(|(r, a, b)| r == x.rule && (a - x.at.0).abs() <= NEAR_MM && (b - x.at.1).abs() <= NEAR_MM);++        // A finished board: connected, and every geometry rule clean apart from what is listed.+        if e.get("finished").and_then(|x| x.as_bool()).unwrap_or(false) {+            if s.nets_open != 0 {+                fails.push(format!("{} nets open; KiCad and the reference board say 0", s.nets_open));+            }+            for x in errors.iter().filter(|x| GEOMETRY_RULES.contains(&x.rule) && !is_known(x)) {+                fails.push(format!("new finding {} at ({:.2}, {:.2}): {}", x.rule, x.at.0, x.at.1, x.text));+            }+            for (r, a, b) in &listed {+                if !f.iter().any(|x| x.rule == r && (a - x.at.0).abs() <= NEAR_MM && (b - x.at.1).abs() <= NEAR_MM) {+                    fails.push(format!("known {r} at ({a:.2}, {b:.2}) is no longer found: the list is stale or the check changed"));+                }+            }+            for (r, c) in &known_count {+                let got = f.iter().filter(|x| x.rule == r).count();+                if got != *c {+                    fails.push(format!("known {r}: expected {c}, found {got}"));+                }+            }+        }+        for r in strs(e.get("mustFail")) {+            if count(&r) == 0 {+                fails.push(format!("{r} must fail on this layout and did not"));+            }+        }+        for r in strs(e.get("mustPass")) {+            if count(&r) != 0 {+                fails.push(format!("{r} must pass on this layout and found {}", count(&r)));+            }+        }+        for r in strs(e.get("mustWarn")) {+            if !f.iter().any(|x| x.rule == r && x.severity != "error") {+                fails.push(format!("{r} must warn on this layout and did not"));+            }+        }+        // A fixture must add what it says and nothing else: the check fires on the fault it was+        // built for, and the board's other findings don't move.+        if let Some(add) = e.get("adds").and_then(|x| x.as_object()) {+            let plain = Board::read(path.to_str().unwrap_or(rel))?;+            let (f0, _) = check::check(&plain, &rules);+            let tally = |v: &[Finding]| {+                let mut m: BTreeMap<String, i64> = BTreeMap::new();+                for x in v.iter().filter(|x| x.severity == "error") {+                    *m.entry(x.rule.to_string()).or_insert(0) += 1;+                }+                m+            };+            let (t0, t1) = (tally(&f0), tally(&f));+            let mut rules_seen: Vec<&String> = t0.keys().chain(t1.keys()).collect();+            rules_seen.sort();+            rules_seen.dedup();+            for r in rules_seen {+                let d = t1.get(r).copied().unwrap_or(0) - t0.get(r).copied().unwrap_or(0);+                let want = add.get(r).and_then(|x| x.as_i64()).unwrap_or(0);+                if d != want {+                    fails.push(format!("the edit moved {r} by {d}, expected {want}"));+                }+            }+            for (r, w) in add {+                if !t1.contains_key(r.as_str()) && w.as_i64().unwrap_or(0) != 0 {+                    fails.push(format!("{r} never fired on the edit"));+                }+            }+        }+        let mut per: BTreeMap<&str, usize> = BTreeMap::new();+        for x in &f {+            *per.entry(x.rule).or_insert(0) += 1;+        }+        let known_n = errors.iter().filter(|x| is_known(x)).count();+        let pass = fails.is_empty();+        ok &= pass;+        lines.push(format!("{} {name}: {} errors ({} known), {} warnings, {} nets open. {:?}", if pass { "PASS" } else { "FAIL" }, errors.len(), known_n, f.len() - errors.len(), s.nets_open, per));+        for x in &fails {+            lines.push(format!("    {x}"));+        }+        if let Some(k) = e.get("kicad") {+            lines.push(format!("    KiCad DRC, last run by hand: {k}"));+        }+        out.push(json!({"name": name, "pass": pass, "errors": errors.len(), "known": known_n, "warnings": f.len() - errors.len(), "netsOpen": s.nets_open, "perRule": per, "fails": fails}));+    }+    Ok(Outcome { ok, lines, json: json!({"ok": ok, "boards": out}) })+}

@@ -0,0 +1,286 @@+//! Spatial index: one bucket grid per copper layer, plus one for holes and one for the edge.+//! Items can be added and removed as routes are ripped up.++use crate::board::NetId;+use crate::geom::*;+use std::cell::{Cell, RefCell};+use std::rc::Rc;++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Owner {+    Pad(u32),+    /// A committed route (connection id) on this run.+    Conn(u32),+    /// Copper that was on the board before this run; it never moves.+    Fixed,+    Zone(u32),+    Edge,+    Keepout,+    /// A fine-pitch pin's way out, held until its route is laid (4.7). Other nets keep clear.+    Lane(u32),+}++#[derive(Clone, Debug)]+pub struct Obs {+    pub shape: Shape,+    pub net: NetId,+    pub owner: Owner,+    pub bb: (f64, f64, f64, f64),+    /// A big pour's edges by place, so a query near it doesn't test them all.+    pub fast: Option<Rc<PolyIndex>>,+}++impl Obs {+    /// Edge distance from a segment to this item, exact up to `limit`; past that it may answer+    /// anything at or above `limit`. Pours of 700 to 1100 points took a search on benchmark B to+    /// 25 microseconds a node, against about 1 elsewhere.+    #[inline]+    pub fn dist_within(&self, a: V, b: V, limit: f64) -> f64 {+        match &self.fast {+            Some(f) => f.dist_within(a, b, limit),+            None => self.shape.dist_seg(a, b),+        }+    }+}++/// A polygon's edges in buckets: by cell for distance, by row for inside or out.+#[derive(Debug)]+pub struct PolyIndex {+    pts: Vec<V>,+    r: f64,+    x0: f64,+    y0: f64,+    cell: f64,+    w: usize,+    h: usize,+    cells: Vec<Vec<u32>>,+    rows: Vec<Vec<u32>>,+}++impl PolyIndex {+    /// Worth it only past this many points.+    const MIN_POINTS: usize = 32;++    fn new(pts: &[V], r: f64) -> PolyIndex {+        let mut bb = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+        for p in pts {+            bb = (bb.0.min(p.0), bb.1.min(p.1), bb.2.max(p.0), bb.3.max(p.1));+        }+        let cell = 1.0 * NM;+        let w = ((bb.2 - bb.0) / cell) as usize + 1;+        let h = ((bb.3 - bb.1) / cell) as usize + 1;+        let mut ix = PolyIndex { pts: pts.to_vec(), r, x0: bb.0, y0: bb.1, cell, w, h, cells: vec![Vec::new(); w * h], rows: vec![Vec::new(); h] };+        let n = pts.len();+        for e in 0..n {+            let (p, q) = (pts[e], pts[(e + 1) % n]);+            let (j0, j1) = (ix.row(p.1.min(q.1)), ix.row(p.1.max(q.1)));+            for j in j0..=j1 {+                ix.rows[j].push(e as u32);+                // Only the columns this edge reaches inside this row: long diagonals are common.+                let (ya, yb) = (ix.y0 + j as f64 * cell, ix.y0 + (j + 1) as f64 * cell);+                let at = |y: f64| if (q.1 - p.1).abs() < 1.0 { p.0 } else { p.0 + (q.0 - p.0) * ((y - p.1) / (q.1 - p.1)).clamp(0.0, 1.0) };+                let (xa, xb) = (at(ya), at(yb));+                let (i0, i1) = (ix.col(xa.min(xb).min(if j == j0 { p.0.min(q.0) } else { f64::MAX })), ix.col(xa.max(xb).max(if j == j0 { p.0.min(q.0) } else { f64::MIN })));+                let (i0, i1) = if (q.1 - p.1).abs() < 1.0 { (ix.col(p.0.min(q.0)), ix.col(p.0.max(q.0))) } else { (i0, i1) };+                for i in i0..=i1 {+                    ix.cells[j * w + i].push(e as u32);+                }+            }+        }+        ix+    }++    #[inline]+    fn col(&self, x: f64) -> usize {+        (((x - self.x0) / self.cell).max(0.0) as usize).min(self.w - 1)+    }+    #[inline]+    fn row(&self, y: f64) -> usize {+        (((y - self.y0) / self.cell).max(0.0) as usize).min(self.h - 1)+    }++    fn inside(&self, p: V) -> bool {+        if p.1 < self.y0 || p.1 > self.y0 + self.h as f64 * self.cell {+            return false;+        }+        let n = self.pts.len();+        let mut inside = false;+        for &e in &self.rows[self.row(p.1)] {+            let (a, b) = (self.pts[e as usize], self.pts[(e as usize + 1) % n]);+            if (a.1 > p.1) != (b.1 > p.1) && p.0 < (b.0 - a.0) * (p.1 - a.1) / (b.1 - a.1) + a.0 {+                inside = !inside;+            }+        }+        inside+    }++    fn dist_within(&self, a: V, b: V, limit: f64) -> f64 {+        if self.inside(a) || self.inside(b) {+            return 0.0;+        }+        let reach = limit + self.r;+        let (i0, i1) = (self.col(a.0.min(b.0) - reach), self.col(a.0.max(b.0) + reach));+        let (j0, j1) = (self.row(a.1.min(b.1) - reach), self.row(a.1.max(b.1) + reach));+        let n = self.pts.len();+        let mut d = limit + self.r;+        for j in j0..=j1 {+            for i in i0..=i1 {+                for &e in &self.cells[j * self.w + i] {+                    let (p, q) = (self.pts[e as usize], self.pts[(e as usize + 1) % n]);+                    d = d.min(seg_seg(a, b, p, q));+                    if d <= 0.0 {+                        return 0.0;+                    }+                }+            }+        }+        (d - self.r).max(0.0)+    }+}++pub struct Grid {+    x0: f64,+    y0: f64,+    cell: f64,+    w: usize,+    h: usize,+    cells: Vec<Vec<u32>>,+    items: Vec<Option<Obs>>,+    stamp: Vec<Cell<u32>>,+    tick: Cell<u32>,+    free: Vec<u32>,+    /// What changed since the coarse map last looked: (added, item).+    log: RefCell<Vec<(bool, Obs)>>,+}++impl Grid {+    pub fn new(bb: (f64, f64, f64, f64), cell: f64) -> Grid {+        let pad = 5.0 * NM;+        let x0 = bb.0 - pad;+        let y0 = bb.1 - pad;+        let w = (((bb.2 - bb.0 + 2.0 * pad) / cell).ceil() as usize + 1).max(1);+        let h = (((bb.3 - bb.1 + 2.0 * pad) / cell).ceil() as usize + 1).max(1);+        Grid { x0, y0, cell, w, h, cells: vec![Vec::new(); w * h], items: Vec::new(), stamp: Vec::new(), tick: Cell::new(0), free: Vec::new(), log: RefCell::new(Vec::new()) }+    }++    fn range(&self, bb: (f64, f64, f64, f64)) -> (usize, usize, usize, usize) {+        let cl = |v: f64, n: usize| -> usize { (v.max(0.0) as usize).min(n - 1) };+        (+            cl((bb.0 - self.x0) / self.cell, self.w),+            cl((bb.1 - self.y0) / self.cell, self.h),+            cl((bb.2 - self.x0) / self.cell, self.w),+            cl((bb.3 - self.y0) / self.cell, self.h),+        )+    }++    pub fn add(&mut self, shape: Shape, net: NetId, owner: Owner) -> u32 {+        let bb = shape.bbox();+        let fast = match &shape {+            Shape::Poly { pts, r } if pts.len() >= PolyIndex::MIN_POINTS => Some(Rc::new(PolyIndex::new(pts, *r))),+            _ => None,+        };+        self.log.borrow_mut().push((true, Obs { shape: shape.clone(), net, owner, bb, fast: fast.clone() }));+        let id = if let Some(i) = self.free.pop() {+            self.items[i as usize] = Some(Obs { shape, net, owner, bb, fast: fast.clone() });+            i+        } else {+            self.items.push(Some(Obs { shape, net, owner, bb, fast: fast.clone() }));+            self.stamp.push(Cell::new(0));+            (self.items.len() - 1) as u32+        };+        let (a, b, c, d) = self.range(bb);+        for j in b..=d {+            for i in a..=c {+                self.cells[j * self.w + i].push(id);+            }+        }+        id+    }++    pub fn remove(&mut self, id: u32) {+        let Some(o) = self.items[id as usize].take() else { return };+        self.log.borrow_mut().push((false, o.clone()));+        let (a, b, c, d) = self.range(o.bb);+        for j in b..=d {+            for i in a..=c {+                self.cells[j * self.w + i].retain(|&x| x != id);+            }+        }+        self.free.push(id);+    }++    /// Visit every item whose box meets `bb`. The visitor returns false to stop early.+    #[inline]+    pub fn visit(&self, bb: (f64, f64, f64, f64), mut f: impl FnMut(&Obs) -> bool) {+        let t = self.tick.get().wrapping_add(1);+        self.tick.set(t);+        let (a, b, c, d) = self.range(bb);+        for j in b..=d {+            for i in a..=c {+                for &id in &self.cells[j * self.w + i] {+                    let s = &self.stamp[id as usize];+                    if s.get() == t {+                        continue;+                    }+                    s.set(t);+                    let o = self.items[id as usize].as_ref().unwrap();+                    if o.bb.0 > bb.2 || o.bb.2 < bb.0 || o.bb.1 > bb.3 || o.bb.3 < bb.1 {+                        continue;+                    }+                    if !f(o) {+                        return;+                    }+                }+            }+        }+    }++    pub fn drain_log(&self) -> Vec<(bool, Obs)> {+        std::mem::take(&mut *self.log.borrow_mut())+    }++    pub fn iter(&self) -> impl Iterator<Item = &Obs> {+        self.items.iter().flatten()+    }+}++#[cfg(test)]+mod tests {+    use super::*;++    /// The index must agree with the exact distance wherever it matters, on a polygon with long+    /// edges of every slope and a notch, the shape a real pour has.+    #[test]+    fn indexed_distance_agrees_with_exact() {+        let mut pts = vec![V(0.0, 0.0), V(20.0, 3.0), V(23.0, 18.0), V(12.0, 9.0), V(9.0, 21.0), V(-2.0, 13.0)];+        // Enough points to be worth an index: subdivide every edge.+        let mut fine = Vec::new();+        for i in 0..pts.len() {+            let (a, b) = (pts[i], pts[(i + 1) % pts.len()]);+            for k in 0..8 {+                let t = k as f64 / 8.0;+                fine.push(V(a.0 + (b.0 - a.0) * t, a.1 + (b.1 - a.1) * t));+            }+        }+        pts = fine.iter().map(|p| V(p.0 * NM, p.1 * NM)).collect();+        let shape = Shape::Poly { pts: pts.clone(), r: 0.0 };+        let ix = PolyIndex::new(&pts, 0.0);+        let limit = 0.8 * NM;+        let mut x = 12345u64;+        let mut rnd = |m: f64| {+            x = x.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);+            (x >> 33) as f64 / (1u64 << 31) as f64 * m+        };+        for _ in 0..20000 {+            let a = V(rnd(28.0 * NM) - 3.0 * NM, rnd(28.0 * NM) - 3.0 * NM);+            let b = V(a.0 + rnd(6.0 * NM) - 3.0 * NM, a.1 + rnd(6.0 * NM) - 3.0 * NM);+            let exact = shape.dist_seg(a, b);+            let fast = ix.dist_within(a, b, limit);+            if exact < limit {+                assert!((exact - fast).abs() < 1.0, "{a:?} {b:?}: exact {exact}, indexed {fast}");+            } else {+                assert!(fast >= limit - 1.0, "{a:?} {b:?}: exact {exact}, indexed {fast}");+            }+        }+    }+}

@@ -0,0 +1,553 @@+//! adom-route: a whole-board PCB router built around the designer's routing standards.++mod board;+mod bus;+mod check;+mod classify;+mod clock;+mod compare;+mod conn;+mod current;+mod geom;+mod fixtures;+mod flow;+mod global;+mod grade;+mod index;+mod mask;+mod placement;+mod pour;+mod power;+mod post;+mod project;+mod quality;+mod render;+mod router;+mod rules;+mod spread;+mod search;+mod sx;+mod write;++use board::Board;+use clap::{Parser, Subcommand};+use rules::{Explicit, Rules};+use std::collections::BTreeMap;++/// The name this binary was built under (`adom-aiflow-routing`; `adom-route` is the same program).+const BIN: &str = env!("CARGO_BIN_NAME");++#[derive(Parser)]+#[command(name = BIN, version, about = "The routing stage of AI Flow: a whole-board PCB router and standards checker that tells the AI what to do next. A guide, never a gate.")]+struct Cli {+    /// The name of the AI conversation calling; it goes in the project's ledger+    #[arg(long, global = true)]+    ai_thread: Option<String>,+    /// Project folder (default: the nearest folder above the current one that has routing-flow/)+    #[arg(long, global = true)]+    project: Option<String>,+    #[command(subcommand)]+    cmd: Cmd,+}++#[derive(Subcommand)]+enum Cmd {+    /// Start the routing flow on a placed board: `init --board <B.kicad_pcb> [--spec <spec.json>]`+    Init {+        #[arg(long)]+        board: String,+        #[arg(long)]+        spec: Option<String>,+    },+    /// What to do now: the first step whose file is missing, and what the AI does in it (a suggestion)+    Next,+    /// Every step with its state+    Steps,+    /// The run ledger, one line per command+    Ledger,+    /// Route every open connection and write a new board file (the input is never changed)+    Route {+        /// The board to route (default in a project: the one `init` named)+        board: Option<String>,+        /// Where to write (default in a project: routing-flow/routed.kicad_pcb)+        #[arg(short, long)]+        out: Option<String>,+        /// Board spec JSON (clearance, track, wideNets, impedanceTargets, routePriority, ...)+        #[arg(long)]+        spec: Option<String>,+        #[arg(long)]+        json: bool,+        /// Clearance in mm. Overrides the project's Default class; the output project is updated to match+        #[arg(long)]+        clearance: Option<f64>,+        /// Track width in mm on open runs. Overrides the project; the output project is updated to match+        #[arg(long)]+        track: Option<f64>,+        /// Narrowest track in mm, for necks at fine-pitch parts. Overrides the project's minimum track+        #[arg(long)]+        neck: Option<f64>,+        /// Via diameter in mm. Overrides the project; the output project is updated to match+        #[arg(long)]+        via: Option<f64>,+        /// Via drill in mm. Overrides the project; the output project is updated to match+        #[arg(long)]+        drill: Option<f64>,+        /// Stop searching after this many seconds and write the best result so far. By default it+        /// scales with the board: at least 240 s, plus 2.6 s per connection on larger boards+        #[arg(long)]+        time_limit: Option<f64>,+    },+    /// Fast tests: route a few nets of each fixture's board alone and judge the result+    Fixtures {+        file: String,+        /// Run only the fixtures whose name contains this+        #[arg(long)]+        only: Option<String>,+        /// Keep the stripped and routed boards in this folder+        #[arg(long)]+        keep: Option<String>,+        /// Run exactly this one fixture in this process (what the command starts for each fixture)+        #[arg(long, hide = true)]+        one: Option<String>,+    },+    /// Grade a board against the routing standards+    Check {+        /// The board to grade (default in a project: the routed board, else the one `init` named)+        board: Option<String>,+        #[arg(long)]+        spec: Option<String>,+        #[arg(long)]+        json: bool,+        /// Print every finding, not only the summary+        #[arg(long)]+        all: bool,+    },+    /// Run the checker over the reference boards and compare with an expected-results file+    Grade {+        #[arg(default_value = "bench/grade.json")]+        file: String,+        #[arg(long)]+        json: bool,+    },+    /// Write a copy with all tracks and vias removed (to measure routing against a reference)+    Strip {+        board: String,+        #[arg(short, long)]+        out: String,+    },+    /// Draw the copper to an SVG, optionally a window x0,y0,x1,y1 in mm+    Draw {+        board: String,+        #[arg(short, long)]+        out: String,+        #[arg(long)]+        window: Option<String>,+        /// Draw zones' filled copper as saved, not their outlines+        #[arg(long)]+        fills: bool,+        /// Comma-separated net names to draw at full strength; the rest are dimmed+        #[arg(long)]+        highlight: Option<String>,+        /// Do not name the pads in a window+        #[arg(long)]+        no_labels: bool,+    },+    /// Net by net against a reference board: length, vias, layers, widths, bends, spacing+    Compare {+        board: String,+        reference: String,+        #[arg(long)]+        spec: Option<String>,+        #[arg(long)]+        json: bool,+    },+    /// Show how the board's nets sort into the routing hierarchy+    Plan {+        /// The board to read (default in a project: the one `init` named)+        board: Option<String>,+        #[arg(long)]+        spec: Option<String>,+    },+}++/// The one kind of error: the command could not run. Says what to try next. Everything else a+/// command finds (open connections, rule findings, a failed test) is reported under `OK:` with+/// hints, because the board, the AI and the human decide what to do with it, not this program.+fn fail(msg: impl std::fmt::Display, hint: &str) -> ! {+    println!("ERROR: {msg}");+    if !hint.is_empty() {+        println!("Hint: {hint}");+    }+    std::process::exit(1)+}++fn hint(text: impl std::fmt::Display) {+    println!("Hint: {text}");+}++/// The project the command runs in, if any: `--project`, else the nearest one above `near` or above+/// the current folder. Commands work the same without one; with one they keep their files and a+/// ledger line in `routing-flow/`.+fn find_project(cli_project: &Option<String>, near: Option<&str>) -> Option<flow::Project> {+    if let Some(p) = cli_project {+        return flow::Project::find(std::path::Path::new(p));+    }+    let from_board = near.and_then(|b| std::path::Path::new(b).parent().map(|d| if d.as_os_str().is_empty() { std::path::PathBuf::from(".") } else { d.to_path_buf() })).and_then(|d| flow::Project::find(&d));+    from_board.or_else(|| std::env::current_dir().ok().and_then(|d| flow::Project::find(&d)))+}++fn state_str(p: &Option<flow::Project>, key: &str) -> Option<String> {+    p.as_ref().and_then(|p| p.state[key].as_str().map(String::from)).filter(|s| !s.is_empty())+}++/// A positional board, or the project's; with neither the command cannot run.+fn board_or(given: Option<String>, p: &Option<flow::Project>, verb: &str) -> String {+    given.or_else(|| state_str(p, "board")).unwrap_or_else(|| fail(format!("no board to {verb}"), &format!("Pass one: `{BIN} {verb} <board.kicad_pcb>`, or start a project so every command knows it: `{BIN} init --board <board.kicad_pcb>`.")))+}++fn load(board: &str, spec: &Option<String>) -> (Board, Rules) {+    let (b, r, _) = load_notes(board, spec, Explicit::default());+    (b, r)+}++fn load_notes(board: &str, spec: &Option<String>, named: Explicit) -> (Board, Rules, Vec<String>) {+    let b = Board::read(board).unwrap_or_else(|e| fail(e, "Pass a .kicad_pcb file written by KiCad 9 or 10."));+    let mut r = match spec {+        Some(s) => Rules::load(s).unwrap_or_else(|e| fail(e, "Pass a JSON spec, or leave --spec off to use the standing rules.")),+        None => Rules::default(),+    };+    // What was named on the command line beats the spec, and both beat the project.+    if let Some(x) = named.clearance { r.clearance = x; r.floor = x; r.explicit.clearance = Some(x); }+    if let Some(x) = named.track { r.track = x; r.explicit.track = Some(x); }+    if let Some(x) = named.neck { r.neck = x; r.explicit.neck = Some(x); }+    if let Some(x) = named.via { r.via = x; r.explicit.via = Some(x); }+    if let Some(x) = named.drill { r.drill = x; r.explicit.drill = Some(x); }+    let mut notes = project::apply(board, &mut r);+    r.bind(&b);+    notes.extend(classify::find_pairs(&b, &mut r));+    (b, r, notes)+}++fn write_guard(input: &str, out: &str) {+    if let (Ok(a), Ok(b)) = (std::fs::canonicalize(input), std::fs::canonicalize(out)) {+        if a == b {+            fail("the output path is the input board, and the input is never changed", "Give -o a different file: a new revision beside the old one (4.6).");+        }+    }+    if input == out {+        fail("the output path is the input board, and the input is never changed", "Give -o a different file: a new revision beside the old one (4.6).");+    }+}++fn summary(json: &serde_json::Value) -> String {+    let s = &json["score"];+    format!(+        "{} errors, {} warnings. Open: {} nets ({} joins). Copper: {} mm ({} top, {} inner, {} bottom), {} vias, {} segments, {} 45-degree and {} 90-degree bends, tightest gap {} mm.",+        json["errors"], json["warnings"], s["netsOpen"], s["padsOpen"], s["lengthMm"], s["topMm"], s["innerMm"], s["bottomMm"], s["vias"], s["segments"], s["bends45"], s["bends90"], s["minGapMm"]+    )+}++fn main() {+    // Output cut short by the reader (`... | head`) is not a failure of the command: end quietly.+    let default_hook = std::panic::take_hook();+    std::panic::set_hook(Box::new(move |info| {+        if info.to_string().contains("Broken pipe") {+            std::process::exit(0);+        }+        default_hook(info);+    }));+    let cli = Cli::parse();+    let thread = cli.ai_thread.clone().unwrap_or_else(|| "unnamed".to_string());+    let cli_project = cli.project.clone();+    match cli.cmd {+        Cmd::Init { board, spec } => {+            let b = Board::read(&board).unwrap_or_else(|e| fail(e, "Pass a .kicad_pcb file written by KiCad 9 or 10."));+            let abs = |p: &str| std::fs::canonicalize(p).map(|x| x.display().to_string()).unwrap_or_else(|_| p.to_string());+            let dir = cli_project.clone().map(std::path::PathBuf::from).unwrap_or_else(|| std::path::Path::new(&abs(&board)).parent().map(|d| d.to_path_buf()).unwrap_or_else(|| std::path::PathBuf::from(".")));+            let pro = std::path::Path::new(&board).with_extension("kicad_pro");+            let state = serde_json::json!({+                "flow": "routing", "started": flow::now(), "board": abs(&board), "boardSha256": flow::sha256(std::path::Path::new(&board)),+                "spec": spec.as_deref().map(abs), "project": if pro.is_file() { serde_json::json!(abs(&pro.display().to_string())) } else { serde_json::Value::Null },+                "footprints": b.footprints.len(), "tracks": b.tracks.len(), "vias": b.vias.len()});+            let p = flow::Project::create(&dir, state).unwrap_or_else(|e| fail(format!("could not write {}: {e}", dir.join(flow::FLOW_DIR).display()), "Pass --project <a folder you can write to>."));+            p.log(&thread, "init", serde_json::json!({"board": abs(&board), "spec": spec}));+            println!("OK: routing flow started in {}: {} parts, {} tracks and {} vias already on the board.", p.flow_dir.display(), b.footprints.len(), b.tracks.len(), b.vias.len());+            if !pro.is_file() {+                hint(format!("No {} beside the board: rules come from KiCad's defaults (0.2 mm clearance and track, 0.5 mm to the edge). Put the project file there if the design has its own.", pro.display()));+            }+            if spec.is_none() {+                hint("No spec: supply rails have no currents, so they are drawn at the 0.40 mm floor. A spec with each rail's volts and amps lets the power stage size them; see the skill for its fields.");+            }+            if cli.ai_thread.is_none() {+                hint("Pass --ai-thread \"<your conversation's name>\" so the ledger says who ran what.");+            }+            hint(format!("Next: `{BIN} next`."));+        }+        Cmd::Next | Cmd::Steps | Cmd::Ledger => {+            let p = find_project(&cli_project, None).unwrap_or_else(|| fail("no routing-flow/ project here", &format!("Start one: `{BIN} init --board <board.kicad_pcb>`. Or use the verbs on their own: `{BIN} plan|route|check <board>` need no project.")));+            let steps = flow::steps();+            match cli.cmd {+                Cmd::Next => match p.current(&steps) {+                    Some((i, s)) => {+                        println!("OK: step {i} of {}: {}", steps.len(), s.name);+                        hint(&s.todo);+                        hint("This is the suggested order, not a gate: take another route when you have a better one, and say in the ledger or the review what you did and why.");+                    }+                    None => {+                        println!("OK: every step has its file. The routed board is {}.", p.path("routed.kicad_pcb").display());+                        hint("Show the human the board and the review before it goes on; what is still open is theirs to accept.");+                    }+                },+                Cmd::Steps => {+                    let cur = p.current(&steps).map(|(i, _)| i);+                    println!("OK: {} steps in {}", steps.len(), p.flow_dir.display());+                    for (i, s) in steps.iter().enumerate() {+                        println!("  {} {:<8} {}", if p.is_done(s) { "done" } else if cur == Some(i + 1) { "next" } else { "    " }, s.name, s.done.join(", "));+                    }+                }+                _ => {+                    let text = std::fs::read_to_string(p.path("run.jsonl")).unwrap_or_default();+                    println!("OK: {} ledger lines in {}", text.lines().count(), p.path("run.jsonl").display());+                    print!("{text}");+                }+            }+        }+        Cmd::Strip { board, out } => {+            write_guard(&board, &out);+            let b = Board::read(&board).unwrap_or_else(|e| fail(e, ""));+            std::fs::write(&out, write::strip(&b)).unwrap_or_else(|e| fail(e, ""));+            println!("OK: wrote {out} without its {} tracks and {} vias.", b.tracks.len(), b.vias.len());+        }+        Cmd::Draw { board, out, window, fills, highlight, no_labels } => {+            let b = Board::read(&board).unwrap_or_else(|e| fail(e, ""));+            let w = window.map(|w| {+                let v: Vec<f64> = w.split(',').filter_map(|x| x.parse().ok()).collect();+                if v.len() != 4 {+                    fail("window must be x0,y0,x1,y1 in mm", "");+                }+                (v[0], v[1], v[2], v[3])+            });+            let view = render::View { fills, highlight: highlight.map(|h| h.split(',').map(String::from).collect()).unwrap_or_default(), labels: w.is_some() && !no_labels };+            std::fs::write(&out, render::svg_view(&b, w, &view)).unwrap_or_else(|e| fail(e, ""));+            println!("OK: wrote {out}.");+        }+        Cmd::Grade { file, json } => {+            let o = grade::run(&file).unwrap_or_else(|e| fail(e, "Pass a grade file such as bench/grade.json."));+            if json {+                println!("{}", serde_json::to_string_pretty(&o.json).unwrap());+            } else {+                for l in &o.lines {+                    println!("{l}");+                }+                println!("OK: graded. {}", if o.ok { "Every board came out as the expected-results file says." } else { "The checker disagrees with the expected-results file on the lines marked FAIL above." });+                if !o.ok {+                    hint("Either the checker changed or the boards did: read the FAIL lines, then fix the rule or update the expected file, whichever is wrong.");+                }+            }+        }+        Cmd::Plan { board, spec } => {+            let proj = find_project(&cli_project, board.as_deref());+            let board = board_or(board, &proj, "plan");+            let spec = spec.or_else(|| state_str(&proj, "spec"));+            let (b, r) = load(&board, &spec);+            let infos = classify::classify(&b, &r);+            let mut by: BTreeMap<classify::Level, Vec<&str>> = BTreeMap::new();+            for i in &infos {+                by.entry(i.level).or_default().push(b.net_name(i.net));+            }+            let plan = router::make_plan(&b, &r);+            let mut out: Vec<String> = Vec::new();+            out.push(format!("OK: {} nets; {} connections to make, {} pairs.", infos.len(), plan.tasks.len(), plan.pairs.len()));+            for (l, v) in by {+                out.push(format!("  {:<18} {}", l.name(), v.join(" ")));+            }+            let fine: Vec<&str> = b.footprints.iter().enumerate().filter(|(i, _)| classify::is_fine_pitch(&b, &r, *i)).map(|(_, f)| f.reference.as_str()).collect();+            out.push(format!("  fine pitch: {}", fine.join(" ")));+            // Why, per net: 4.2 says never to judge current from a name or width alone, so the+            // designer can read what each class was judged from.+            for i in &infos {+                out.push(format!("  net {} = {}{}: {}", b.net_name(i.net), i.level.name(), if i.switching { " (switch node)" } else { "" }, i.why));+                for t in &i.taps {+                    out.push(format!("    Kelvin tap: {}", t.iter().map(|&p| b.pad_name(p)).collect::<Vec<_>>().join(" -> ")));+                }+            }+            let mut zs: BTreeMap<String, usize> = BTreeMap::new();+            for z in &b.zones {+                let names: Vec<&str> = z.layers.iter().map(|&l| b.layers[l].name.as_str()).collect();+                *zs.entry(format!("{} on {} keepout={} fills={}", b.net_name(z.net), names.join("+"), z.keepout_tracks, z.fills.len())).or_insert(0) += 1;+            }+            out.push(format!("  zones: {zs:?}"));+            for (p, n, w, g) in &plan.pairs {+                out.push(format!("  pair {} / {}: {:.4}/{:.3} mm", b.net_name(*p), b.net_name(*n), *w as f64 / geom::NM, *g as f64 / geom::NM));+            }+            println!("{}", out.join("\n"));+            // Supply nets with no current to size them by: said as a hint, since only the designer+            // (or a datasheet) knows the number.+            let unrated: Vec<&str> = infos.iter().filter(|i| i.level == classify::Level::Power && r.rail(b.net_name(i.net)).is_none()).map(|i| b.net_name(i.net)).collect();+            if !unrated.is_empty() {+                hint(format!("{} supply net(s) have no current in the spec and will be drawn at the 0.40 mm floor: {}. A rail entry with volts and amps lets the power stage size each one: a rail the board makes is rated by its regulator, a rail it only receives by the draw of the parts that take it (the prompt, their wiki pages and datasheets). When nothing says, ask the human for the expected draw.", unrated.len(), unrated.iter().take(12).cloned().collect::<Vec<_>>().join(", ")));+            }+            if let Some(p) = &proj {+                let _ = std::fs::write(p.path("plan.txt"), out.join("\n") + "\n");+                p.log(&thread, "plan", serde_json::json!({"board": board, "spec": spec, "nets": infos.len(), "connections": plan.tasks.len(), "pairs": plan.pairs.len(), "unratedRails": unrated.len()}));+                hint(format!("Saved as {}. Next: `{BIN} next`.", p.path("plan.txt").display()));+            }+        }+        Cmd::Compare { board, reference, spec, json } => {+            let (b, r) = load(&board, &spec);+            let (his, _) = load(&reference, &spec);+            let v = compare::report(&b, &his, &r, json);+            if json {+                println!("{}", serde_json::to_string_pretty(&v).unwrap());+            }+        }+        Cmd::Fixtures { file, only, keep, one } => {+            let one_given = one.is_some();+            let ok = match one {+                Some(name) => fixtures::run(&file, Some(&name), keep.as_deref()),+                None => fixtures::run_all(&file, only.as_deref(), keep.as_deref()),+            };+            // The hidden --one child tells its parent by exit code; the command itself only reports.+            if !ok && one_given {+                std::process::exit(1);+            }+            if !ok {+                hint("A FAIL line is a behaviour that changed: read its board in the --keep folder before deciding whether the router or the fixture is wrong.");+            }+        }+        Cmd::Check { board, spec, json, all } => {+            let proj = find_project(&cli_project, board.as_deref());+            let routed = proj.as_ref().map(|p| p.path("routed.kicad_pcb")).filter(|p| p.is_file()).map(|p| p.display().to_string());+            let board = board.or(routed).unwrap_or_else(|| board_or(None, &proj, "check"));+            let spec = spec.or_else(|| state_str(&proj, "spec"));+            let (b, r) = load(&board, &spec);+            let (f, s) = check::check(&b, &r);+            let j = check::to_json(&f, &s);+            let errors = j["errors"].as_u64().unwrap_or(0);+            if json {+                println!("{}", serde_json::to_string_pretty(&j).unwrap());+            } else {+                // The check ran, so it answers OK; what it found follows. A finding is a report with a+                // suggestion, never a verdict: the designer may have drawn that copper on purpose.+                println!("OK: checked {board}: {}", summary(&j));+                println!("  per rule: {}", j["perRule"]);+                println!("  widths: {}", j["score"]["widths"]);+                let show = if all { f.len() } else { 25 };+                for x in f.iter().take(show) {+                    println!("  {:<5} {:<14} ({:.2}, {:.2}) {}", x.severity, x.rule, x.at.0, x.at.1, x.text);+                }+                if f.len() > show {+                    println!("  ... {} more (--all shows them)", f.len() - show);+                }+                if errors != 0 {+                    hint("Each finding names its rule and place; --all lists every one. Fix what is real and check again. A finding on copper the designer drew on purpose is theirs to keep: say so in the review.");+                }+                hint("KiCad's own DRC with zones refilled, against the board's project, is the judge of clearance and of what is really joined; run it on the same file.");+            }+            if let Some(p) = &proj {+                let _ = std::fs::write(p.path("check.json"), serde_json::to_string_pretty(&j).unwrap_or_default() + "\n");+                p.log(&thread, "check", serde_json::json!({"board": board, "errors": errors, "warnings": j["warnings"], "perRule": j["perRule"]}));+                if !json {+                    hint(format!("Saved as {}. Next: `{BIN} next`.", p.path("check.json").display()));+                }+            }+        }+        Cmd::Route { board, out, spec, json, clearance, track, neck, via, drill, time_limit } => {+            let proj = find_project(&cli_project, board.as_deref());+            let board = board_or(board, &proj, "route");+            let spec = spec.or_else(|| state_str(&proj, "spec"));+            let out = out.or_else(|| proj.as_ref().map(|p| p.path("routed.kicad_pcb").display().to_string())).unwrap_or_else(|| fail("nowhere to write the routed board", &format!("Pass -o <routed.kicad_pcb>, or start a project (`{BIN} init --board {board}`) and it goes to routing-flow/routed.kicad_pcb.")));+            write_guard(&board, &out);+            let named = Explicit { clearance: clearance.map(geom::mm), track: track.map(geom::mm), neck: neck.map(geom::mm), via: via.map(geom::mm), drill: drill.map(geom::mm) };+            let (b, mut r, rule_notes) = load_notes(&board, &spec, named);+            // Copper already on the board narrower than the settings allow: the settings may be wrong+            // for this design, or those tracks are. That is the designer's to say. The router leaves+            // them as they are, lays new copper to the settings, and says so at the end.+            let floor = r.min.track.max(0);+            let narrow: Vec<&board::Track> = b.tracks.iter().filter(|t| t.width + 1000 < floor).collect();+            let narrow_hint = narrow.iter().min_by_key(|t| t.width).map(|n| {+                format!(+                    "{} tracks already on the board are narrower than the {:.3} mm minimum (the narrowest {:.3} mm on {} at ({:.2}, {:.2})). They were left as they are and new copper follows the minimum. If the thin ones are right for this design, pass --neck {:.3} and route again; if not, they are for the designer to fix.",+                    narrow.len(), geom::to_mm(floor), geom::to_mm(n.width), b.net_name(n.net), geom::to_mm(n.a.0), geom::to_mm(n.a.1), geom::to_mm(n.width)+                )+            });+            for n in &rule_notes {+                eprintln!("note: {n}");+            }+            let plan = router::make_plan(&b, &r);+            // Large boards need the time: benchmark C reached 278 of 302 at 240 s and 298 at 800 s.+            let joins = plan.tasks.len() + plan.pairs.len() * 2;+            // In work-clock seconds (clock.rs), which are calibrated to the densest benchmark board: a+            // small board does about twice the search work per wall second, so the old 2.6 s a join and+            // 240 s floor, kept as they were, halved every small board's budget (carrier-fc-rp2350a-mini+            // stopped at 62 of 74 with "ran out of budget", 2026-11-10). 5.5 and 505 give back the work+            // those wall-clock limits meant.+            r.time_limit = time_limit.unwrap_or((5.5 * joins as f64).max(505.0));+            let mut rt = router::Router::new(&b, r.clone());+            let o = rt.run(&plan);+            let routes: Vec<&router::Route> = {+                let mut v: Vec<&router::Route> = rt.routes.values().collect();+                v.sort_by_key(|x| x.id);+                v+            };+            let text = write::render(&b, &routes, &r);+            std::fs::write(&out, &text).unwrap_or_else(|e| fail(e, ""));+            let updated = project::write_for_output(&board, &out, &r.explicit).unwrap_or_else(|e| fail(e, ""));+            r.pad_rules = rt.rules.pad_rules.clone();+            if let Some(path) = project::write_dru(&board, &out, &r.pad_rules).unwrap_or_else(|e| fail(e, "")) {+                if !r.pad_rules.is_empty() {+                    println!("  REVIEW: {} local pad rule(s) proposed in {path}", r.pad_rules.len());+                }+            }+            for u in &updated {+                println!("  project updated: {u}");+            }+            // Grade the written file from scratch; the checker shares no state with the router.+            let written = Board::parse(text).unwrap_or_else(|e| fail(e, "The written board did not parse back; this is a bug in the writer."));+            let (f, s) = check::check(&written, &r);+            let j = check::to_json(&f, &s);+            let failed: Vec<String> = o.failed.iter().map(|t| format!("{} ({}): {} to {}", b.net_name(t.net), t.level.name(), b.pad_name(t.a), b.pad_name(t.b))).collect();+            if json {+                let out_json = serde_json::json!({"out": out, "seconds": o.seconds, "failed": failed, "rips": rt.rips, "searches": rt.searches, "nodes": rt.nodes, "notes": rt.notes, "check": j});+                println!("{}", serde_json::to_string_pretty(&out_json).unwrap());+            } else {+                let tasks = plan.tasks.len() + plan.pairs.len() * 2;+                // Route's own outcome: did every connection get made? The written board's grade is+                // reported on the next line, and `check` is what passes or fails a board.+                println!("OK: wrote {out}: {} of {} connections routed in {:.1} s ({} rip-ups).", tasks.saturating_sub(o.failed.len()), tasks, o.seconds, rt.rips);+                println!("  check: {}", summary(&j));+                println!("  per rule: {}", j["perRule"]);+                println!("  widths: {}", j["score"]["widths"]);+                for x in &failed {+                    println!("  unrouted: {x}");+                }+                for n in &rt.notes {+                    println!("  note: {n}");+                }+                for l in &rt.log {+                    println!("  {l}");+                }+                println!("  {}", rt.world.guide.borrow().summary());+                for x in f.iter().filter(|x| x.severity == "error").take(12) {+                    println!("  {:<5} {:<14} ({:.2}, {:.2}) {}", x.severity, x.rule, x.at.0, x.at.1, x.text);+                }+                if !o.failed.is_empty() {+                    hint(format!("{} connection(s) are open; each has its reason in the notes above. Ideas, yours to weigh: move the part whose pad is walled in, give a supply rail its current in the spec so it is planned first, allow more work with --time-limit, or route those few by hand.", o.failed.len()));+                }+                if !r.pad_rules.is_empty() {+                    hint("The local pad rules marked REVIEW let a track pass a pad closer than its class asks, where no track fits otherwise. They are proposals for the human: keep the .kicad_dru beside the board only if they agree.");+                }+                if let Some(h) = &narrow_hint {+                    hint(h);+                }+            }+            if let Some(p) = &proj {+                let tasks = plan.tasks.len() + plan.pairs.len() * 2;+                p.log(&thread, "route", serde_json::json!({"board": board, "out": out, "connections": tasks, "open": o.failed.len(), "workSeconds": o.seconds, "checkErrors": j["errors"], "localRules": r.pad_rules.len()}));+                if !json {+                    hint(format!("Look at it before trusting the numbers: `{BIN} draw {out} -o routed.svg`. Next: `{BIN} next`."));+                }+            }+        }+    }+}