CIRCUIT — design document

Replaces: the circuit entry in oracle-games-pack.js (today: tags: ['maze','chase','collect','pursuit','levels'], icon 👾, "Drain every node. Four sentries would rather you did not." — a Pac-Man clone wearing an electronics name).

Keeps: the id circuit and the name Circuit. The owner's complaint was never that the name was wrong — it was that the game did not match the name. Renaming would dodge the note instead of answering it.

New one-line pitch: *Lay copper. Current takes every path you give it — you only choose the proportions.*

> Status of this document. Nothing here is argued from taste alone. Every number below was measured from a working prototype, and every claim that turned out to be false when measured is recorded as such. Prototype: …\scratchpad\bld\ (circuit.js 1,303 lines, playable at index.html; probe.js / scenes.js / shorttest.js are the headless measurement harnesses; FINAL-PROBE.txt is the raw run). No product file was touched by this run.

---

Verdict — which of the three, and why

Three complete designs were built and measured. All three are continuous simulations, all three

correctly refuse the logic-gate trap, and all three are honest about their own faults. They are

not equally right for this brief.

A wins, on the owner's criteria in his order.

1. Genuinely about current flow. All three simulate it; only A makes the player *make* the

circuit. In B the player never manipulates anything electrical — they hold one of seven

buttons and the board is scenery. That matters against the actual complaint, which was that

the game did not look or behave like the thing it is named after. "You drew that copper and

the current you gave it went everywhere at once" is an answer; "you held a button and seven

needles moved" is a weaker one. C is the same family as A with less board identity — its

render reads as *perfboard*, a dotted lattice, not a fabricated PCB.

2. Fun at 30 seconds and at level 50. This is where B fails hardest, and its own bench says

so: the naive move — touch whatever is worst — measures **three times worse than doing

nothing** (dies at 5.5 s vs 17 s). A game whose intuitive first action is actively punished

has a comprehension cliff in front of the fun, on a phone, in an arcade. A's first thirty

seconds are a drag and a light coming on, and it teaches current division wordlessly by

letting the player watch a lit module dim when they add a second path.

3. Phone. B wins this one outright — press-and-hold needs no precision at all. A is

acceptable (a 38 px routing pitch is a lane you draw *along*, not a target you must hit) but

carries the real risk in the set: dwell-for-width, untested by a thumb. It is de-risked by a

graft below rather than waved at. C is worst here: stroke-*speed* as a gauge means the game

demands slowness at exactly the moment it has made the player panic.

4. 60 fps with this art. A is the only one with a measured answer that is comfortably inside

budget, and it is the only one that found a real performance bug by measuring

(91.1 ms → 1.10 ms, §11).

5. Different from the 34 shipped. All three clear this. None of them is reachable by

reskinning anything in the pack.

Two decisive facts, verified against the real files rather than taken from any design's prose:

• **A does *not* need a framework change.** Its own weakness list claimed it did, and the research

brief agreed. Both are wrong. oracle-games.js lines 1841–1949: `WANT_PTR = !!spec.pointer ||

TKIND === 'dragX'; pointerdown calls cv.setPointerCapture(pid) and sets g.pdown` and

g.tapN; pointermove writes g.ptrX/g.ptrY in canvas space *before* the pid === null

guard, so a captured drag keeps reporting after the thumb leaves the canvas; pointerup is

also bound on window so a release off-element still ends the gesture. That is continuous

free-form drag with capture, available today via spec.pointer: true. This deletes A's

weakness #8 and, with it, the need to touch a shared file another workflow is editing.

• A's prototype is the most complete and the most self-critical. 1,303 lines, playable, ten

measured scenes, and a probe that *contradicts its own designer three times* — copper does not

run away (positive temperature coefficient is a ballast: two parallel routes converge and go

flat, FINAL-PROBE.txt §G); a uniformly thin trace *cannot* burn (it chokes its own current

and settles at heat 0.50, §E control); and modelling only diagonal crossings meant 0 of 7 vias

were ever spent. A design that publishes the measurements that killed its own ideas is the one

to trust.

What B and C were right about, and what is now grafted in: §13.

---

0. The strategic argument, in one paragraph

Not one of the 34 shipped games *simulates* anything. Every one is discrete-state — turns, tiles, toggles, collisions. snake, blockescape, slide15, 2048, lightsout, minesweeper, nonogram, sudoku, ricochet, pulse, simon, reaction, floppykai, wallrun, flipside: all of them resolve to integers on a grid. A continuous real-valued network where one local edit changes every value on the board is a mechanic the pack does not have in any form, and it is not reachable by reskinning any of them. That is the reason to build this rather than the eleven other "circuit game" ideas, all of which collapse into something already shipped (logic gates → lightsout XOR parity; deduce-from-edge-clues → nonogram; tap-in-phase → pulse; aim-and-bank → ricochet).

---

1. Core loop

A board arrives unrouted: a 5 V input terminal with a fuse, a hatched ground pour along the foot, a scatter of ground stitching vias, and two to five power modules that each need a minimum current before their PGOOD indicator lights.

1. Route. Drag copper from a rail pad toward a module. Current begins flowing the instant the loop closes.

2. Watch it divide. Every new path re-divides the current *everywhere*, in proportion to conductance. Feeding one module well starves its neighbour. There is no "correct path"; there is a budget.

3. Hold. When every module is at or above demand simultaneously, a BRING-UP bar starts filling. Hold for ~3 s and the board passes.

4. Except the copper is warming. Resistance rises as it heats, the delivered current droops, and a board that worked at t=0 can drop a module out at t=20 s. The hold bar resets.

5. Fix it and re-hold. Widen, re-route, cut, add a parallel feed. One more.

The whole loop is 25–70 seconds. A run is a ladder of boards inside GC.arcade, with the harness's free lives / continue / level banner.

Why it is tense: three constraints that are *mutually coupled by physics*, so satisfying one worsens another.

Measured, on a real board: two modules both fed at w=6 draw 10.86 A against an 11.6 A fuse and both light. The same two at w=12 draw 14.54 A and blow it. Full width everywhere is not a strategy, it is the loss condition.

---

2. The player verb, and its gesture

One verb: DRAW COPPER. Linger to make it thicker.

• Drag from any live node (rail pad, ground stitch, ground pour, load pin, or your own existing copper). Octilinear only — eight neighbours, so every trace is orthogonal or 45°.
• Width is dwell time in a grid cell. Enter a cell and leave immediately → minimum copper (3 px). Rest your thumb there for 0.8 s → maximum (12 px). Nothing else changes width: no pinch, no toggle, no mode, no menu.
• Hold on existing copper (0.40 s) to cut it. A drill circle closes on the segment; release inside the ring and that segment is gone.

That is the entire input vocabulary: press, linger, drag, release. One finger, one-handed, and identical on a desktop mouse.

Why dwell-for-width is the right gesture, not a gimmick:

• It carries two variables (topology and cross-section) in one gesture with no mode switch — the phone-native problem the d-pad deletion was about.
• It has an honest cost curve: width costs time, thinness costs risk. Rushing gives you fragile copper *right now*; patience gives you robust copper while the clock runs and the fuse budget shrinks. That asymmetry is the whole difficulty knob.
• It is physically evocative — a plating head that moves slower deposits more — and it produces the correct engineering result by accident: copper naturally comes out fat near the source and thin at the tips, which is exactly how real power distribution is routed, because that is where the current is.
• It is self-teaching. You will dwell by accident within the first ten seconds and watch the copper swell under your thumb.

Second stroke plates the copper (grafted, and it is the safety net under dwell). Re-drawing

along a segment you already own adds one width step to it. Same gesture, same finger, no mode.

It is physically the right story — a second pass of the plating head deposits more copper — and it

is what makes width *deliberate* rather than *emergent*: minimum copper is always what you get by

default, and every step above it is paid for in a stroke you chose to make. It also gives the

player a repair verb that is not "cut it and start again", which is the only other thing they can

currently do to a route that is too thin.

The hook already exists in the prototype and is one line: addSeg() returns 'dup' when the drag

re-enters a segment that is already there (circuit.js:410), and Game.prototype.widen(s, w)

(:437) already does the conductance and copper-budget bookkeeping. 'dup' → widen(s, s.w + step).

Segments already carry a plated: 0 field for the render.

This is what makes the dwell risk survivable. Ship both. If dwell tests well, the two

compound — you can lay fat copper in one pass or build it up in two. If dwell tests badly, delete

it and retrace alone is a complete, unambiguous width system that never fires by accident. That is

a much better fallback than the corner toggle this document previously conceded to, because it is

still one continuous gesture and still costs *time*, which is the difficulty knob the whole design

is built on.

Framework note — corrected. An earlier draft of this document claimed the verb needed a new

GC.arcade touch kind. It does not, and that was checked against the file, not remembered.

oracle-games.js:1845 sets WANT_PTR from !!spec.pointer; :1879 calls setPointerCapture on

pointerdown; :1888 maintains g.tapN; :1890/:1897 write g.ptrX/g.ptrY in canvas space on

both down and move, with the move write placed *above* the if (pid === null) return guard; and

:1949 binds pointerup on window so a release outside the canvas still ends the drag. So

spec.pointer: true plus the game's own handling in step() is the whole input layer, and **no

shared file needs to change.** Snap distance must still be converted from glass px to canvas units

the same way SWIPE_MIN is (24 px measured on the glass, :1846), or it changes meaning with board

size. Hit-testing for cut and for node snap is nearest-target-within-N, never rectangle

containment — B's prototype settled on 42 design units ≈ 39 CSS px at 375 wide, and that number is

worth starting from.

---

3. What a level looks like

Portrait, 540×1080 canvas (fit scales it), a 13×22 routing grid on a 38 px pitch — 27.8 real px on a 375-wide phone, which is a routing lane you draw *along*, not a button you have to hit.

 ┌──────────────────────────────────────────┐
 │ J1  +5V IN                    F1  11.6A  │  terminal block + glass fuse
 │ ●━━━━━━━━━━━━●━━━━━━━━━━━━●   ▭▭▭▭▭▭▭▭▭  │  three rail pads
 │                                          │
 │      ⊕G                    ⊕G            │  ground stitching vias
 │            ┌────┐                        │
 │            │ U1 │  ← module, 62×46,      │
 │            └────┘    demand bar in silk  │
 │   ⊕G                          ⊕G         │
 │            ┌────┐                        │
 │            │ U2 │                        │
 │            └────┘                        │
 │▨▨▨▨▨▨▨▨ GROUND POUR ▨▨▨▨▨▨▨▨▨▨▨▨▨▨▨▨▨▨▨▨│  hatched, dull, the return
 │ TP1   TP2   TP3   TP4   J3 ●●●●●●●●      │
 └──────────────────────────────────────────┘
   BRING-UP ▮▮▮▮▮▮▮▯▯▯▯     FUSE F1 ▮▮▮▮▮▮▯▯▯
   LV 4      VIAS 5/7       CU 73      T 89

The HUD is silkscreen, rendered by a drawHud function on the dark bezel *outside* the board rectangle — so the rule "nothing on the board is bright unless it is current or heat" survives contact with the UI. No amps are ever printed. The fuse is a gauge; demand is a row of ticks; the hold is a row of ticks. There is not one number on screen that the player is expected to compute.

The five-second read

A green fibreglass board with brown copper traces, cyan sparks streaming along them from a fused input terminal into little black modules, moving faster where the copper is narrow. Nobody will ask what it is about.

---

4. How it teaches itself, with no words at all

No tutorial. No Ohm's law. Four boards, each of which can only teach one thing:

• Level 1 — geometry teaches the verb. One module, placed *directly beneath the centre rail pad*. The only thing a thumb can do is pull a straight line down. The module lights. That is the tutorial.
• Level 2 — the same board, but demand is raised so a rushed route fails. Measured: at w=3 the module gets 4.33 A cold, droops to 3.34 A as the copper warms, and never reaches its 4.10 A demand. At w=7 it gets 6.94 A cold, settles at 5.96 A, and holds. The player rushes, watches it die, redraws it slower, and has learned dwell-for-width without reading anything.
• Level 3 — two modules teaches current division. Feed one fat and one thin and *watch the thin one go dark*. Measured: w=[12,3] splits 74.3 % / 25.7 % and starves the second; w=[6,6] splits 57.5 % / 42.5 % and lights both. The lesson — *helping one starves the other* — is delivered by the board, not by a sentence.
• Level 5 — the fuse teaches the budget. The board is winnable, and the naive answer (maximum copper everywhere) blows the fuse in front of you. The glass fogs and the element parts.

The one concession to words is GCHOW, which sits behind a button and is never in the way (§9).

---

5. The physics — laws exact, constants calibrated, and stated

All of this is implemented and measured in the prototype.

The one honest fudge, named. Real copper is too good a conductor for routing to matter at signal currents. The prototype's copper is roughly 100× more resistive than 1 oz copper at this scale. This is not a physics error, it is a choice of regime: the game is set in power distribution, the one domain where trace resistance and ampacity genuinely dominate design, and the constant is tuned so a board-sized route has a board-sized effect. Every *law* is exact; one *constant* is a game knob, and it is written down rather than hidden.

*Measured, before and after that calibration was corrected:* at the first value (K=0.0030, 0.62 Ω loads) the width sweep spanned 5.06 A → 6.57 A and every width satisfied the load. The trace was decoration. At the shipped value (K=0.0075, 0.34 Ω loads) the same sweep spans 4.33 A → 8.55 A and w=3 starves. That correction only happened because the sweep was run, not reasoned about.

Three findings that contradicted the plan

1. Parallel copper self-balances. There is no thermal runaway, and the design must not claim one.

The intuitive escalation — a hot trace gets more resistive, pushes current onto its neighbour, which heats, cascade — is wrong for copper in parallel. A positive temperature coefficient is a *ballast*: the hotter branch sheds current. Measured over 25 s on two parallel routes (w=6 and w=4): currents 5.01/2.84 A → 4.50/2.74 A and then flat, heats settled at 0.28/0.18. The real escalation is the IR-drop droop — warming copper raises total resistance, delivered current falls, and modules drop out of spec — plus demand that ramps. That is what makes a board fail at t=20 s, and it is the honest version.

**2. A uniformly thin trace cannot burn. The *weakest link* burns.**

Same reason: a thin trace chokes its own current and settles. Measured control — a whole route at w=3 settles at 3.34 A / heat 0.50 and never fails. But one rushed node inside a w=9 route carries the full 7.03 A of the fat copper either side of it, and its own resistance is too small a share of the loop to save it: heat 0.02 → 1.00 and it lets go at t=1.48 s. This is a far better mechanic than the one originally planned. *Your route is only as strong as its narrowest segment*, so the punishment for rushing is specific, spatial, and teaches you to look back over your own copper.

3. Two thin traces beat one fat one, for free, and it costs board space.

Because the ampacity exponent is 0.725 < 1: one w=12 trace carries 10.93 A; two w=6 traces at *identical total conductance* carry 13.22 A — 21 % more, at twice the area. This is why real power boards run parallel copper, and it is a genuine strategy the player can discover with no tutorial and no unlock. It emerges from the exponent.

The short circuit

The pour is 18 rows from the rail, so a stray trace to the pour is not a short — it is a resistor (measured 9.1 A into a 10.5 A fuse; nothing happens). Ground stitching vias fix this and two other things at once. Measured, on a working two-module board:

Every branch dims at once, which is the single most legible proof that the rule is proportional. The player has ~0.55 s to cut it. The fuse peaks at 0.87 of 1.0 — a near miss — and then the shorting copper, being the weakest thing in the loop, destroys itself and saves the fuse. You lose that route permanently. That window is a skill expression, not a death.

---

6. Board space, crossings, and vias

Two segments that share a grid node share copper. So a route cannot pass through a node another net already owns without merging with it — which is sometimes what you want (a second parallel feed) and sometimes a short. This is the "limited board space" pressure, and it is stronger than a crossing rule: the board fills up as nets claim nodes.

When a step would collide with foreign copper, the drag automatically dives to the back layer — via barrel, dark green trace under the mask, via barrel — for 2 from the via budget. No new gesture; the decision is *whether to route through there*, which is the interesting one. Going under costs three ways: the budget, +60 % resistance, and half the ampacity (IPC's internal constant). With the budget spent, the step is simply refused.

*This was measured wrong first.* Modelling only diagonal-vs-diagonal crossings meant 0 of 7 vias were used on a level-16 board — a whole mechanic that never fired. With node occupancy included, the same board spends 6 of 7 and renders three back-layer runs. See scene-8-late-board.png.

---

7. Difficulty, level 1 → 50 → forever

Each band adds one pressure, not one mechanic. The mechanic count stays at five: route, dwell, cut, dive, hold.

Per-board par on copper used and vias spent gives a 3-star rating and a reason to replay a board you already beat.

---

8. Failure, scoring, save

Three failure states, all legible, none arbitrary:

1. FUSE BLOWN — total draw exceeded budget. The element parts inside the glass and the glass fogs. Costs a life.

2. TIMED OUT — the bring-up window closed with a module below spec. The board de-energises. Costs a life.

3. BURNED — a segment exceeded ampacity. *Not* a loss: it destroys that segment and scars the board permanently. It only kills you if you cannot re-route in the time left.

Lives, the continue panel, the level banner and the result card all come free from GC.arcade (lives: 3, levelBase: 1e9 + explicit g.levelUp() per board cleared, exactly as the current circuit does).

Score. Laddered mode = 1000 base + time bonus + fuse headroom − copper used − 40/via, reported via GC.report; copper and vias are also the par the three-star chase is measured against. Burn-in mode is scored in coulombs delivered *(grafted, §13.8)* — charge that actually reached a module while it was inside its window. It is the honest unit, it climbs smoothly, and it is the only number in the game the player is ever shown that is a real physical quantity.

Save/resume in GC.stat: level, per-board star ratings, and the burn-in high score. A board in progress is a small object (segments = {a,b,w,layer,heat}) so mid-board resume is genuinely cheap — unlike most of the pack.

---

9. Ship-complete checklist

• GCHOW guide — five panels, all diagrams, almost no prose: *drag to lay*, *linger or draw over it again to thicken*, *hold to cut*, *both bars full = pass*, *a gate you hold starves its branch and feeds the rest*. Plus one diagram that has to exist: the same current entering a junction and leaving in two unequal streams, because that is the one thing a player may never quite believe. The cut panel says it the way C's design argued it: the iron adds where it moves and lifts where it lingers.
• GCFX sound palette. The whole board is a power supply, so the palette is *electrical*, not chiptune:
• music — a low 33 Hz-rooted drone bed with a slow filter sweep, tuned so its pitch tracks total current: the board hums harder as you load it. The music is a meter.
• coin — a short plating tick per grid cell laid; pitch rises with the dwell width, so you *hear* the copper thicken.
• merge — the PGOOD chirp when a module comes up.
• spawn — the bring-up hold completing: a rising three-step.
• explode — the burn: a filtered noise crack with a fast decay, not a boom.
• bad — the fuse: a hard DC thump followed by silence in the drone for 400 ms. Losing the hum is the loudest thing in the game.
• Achievements (GCPROG): *First Light* (board 1) · *Derating* (pass a board with every segment under 70 % of ampacity) · *Ballast* (feed one module with two parallel traces) · *Scar Tissue* (pass a board after a burn) · *Under the Board* (pass a board using every via) · *Sixty Seconds* (60 s of burn-in) · *No Slack* (pass with the fuse over 95 %).
• Reduced motion: carriers drop to a slow dashed march; no glow pulses. The state is still fully readable because rate and speed are encoded in geometry, not brightness.
• Colour-blindness: the three signal hues are cyan / amber / green, which is the worst possible triple for deuteranopia. Mitigation is already structural — charge is *moving dots*, heat is a *bright wide trace with a tan halo*, PGOOD is a *dot inside a module outline*. They differ in form, position and motion, not only hue. A high-contrast option swaps green PGOOD for white. This has been reasoned, not simulated — run the frames through a deuteranope simulation before shipping, because the design has been measuring luminance and the risk here is hue.
• The policy bench (§13.1) is a ship gate, not a nice-to-have. No level past 8 gets tuned until none is proven to fail it and lookahead is proven to clear it. Physics measurements do not tell you whether a level is a game.
• Build order, so the riskiest thing is answered first: (1) the width verb — dwell *and* retrace, in front of the owner's thumb, before anything else is polished; (2) the policy bench; (3) levels 1–12 tuned against it; (4) gates and hold-up caps; (5) the back half.

---

10. Art direction

10.1 The palette, and why each colour

Real boards have a material identity. These are fabrication finishes, not accent colours.

10.2 One light, stated and obeyed

Key at upper-left, azimuth 135°, elevation ~35°, L = normalize(−0.577, −0.577, 0.577). Everything derives from it:

• contact shadows offset (+1.1, +1.1) at rgba(0,0,0,0.50), one width wider than the object;
• specular offset (−0.45, −0.45);
• component bodies get a rgba(255,240,215,0.18) bevel on the top edge only;
• via barrels are lit on the side away from the key and black on the near side — that asymmetry is what makes a hole read as a hole rather than a dark circle;
• the mask gloss is one radial gradient centred at 16 %, 8 %, falling to rgba(0,0,0,0.30) at the far corner.

10.3 Material, in passes, not fills

A copper trace is four passes plus grain, and removing pass 1 or 3 is exactly what turns it back into an orange rectangle:

1. Contact shadow, width+1.4, offset along the light. Copper stands 35 µm proud of the board and it *occludes*.

2. Oxide flank, width+1.3, #2E1B0B.

3. Face — a gradient ACROSS the trace, not along it. Every segment is a straight line, so the correct anisotropy is a perpendicular linear gradient: lit flank → face → dark flank. *This is the second version.* The first build put the specular as a centred stripe at α 0.42; it measured **L\* 62.7 — a grey blade — and made hot copper vs cold copper 1.04:1, invisible**. Rolled foil grains along its length; the highlight is a flank, never a blob.

4. Grain, the baked noise tile at α 0.26. At 0.5 it lifted the whole trace out of budget.

Occlusion is doing real work here: unenergised copper sits at only 1.37:1 against the mask and is still perfectly findable, because it casts a shadow. Occlusion substitutes for luminance contrast — that is what lets dead traces stay quiet without becoming invisible.

10.4 Motion that means something

• Carriers are discrete and countable. They are spawned at the rail at a rate proportional to total current, and at every junction routed into a branch with probability proportional to that branch's share. A 74/26 split is *literally countable* at the junction.
• Speed is current density, not current. v ∝ J = I/w, so the *same* current in *narrower* copper visibly moves faster. Two independent channels encoding two different quantities.
• Magnitude is spacing, never brightness. Above roughly one carrier per 6 px the dots merge into a continuous glowing line — which is precisely the "glowing line that pulses" failure mode this design exists to reject, arrived at from the other direction. Rate is tuned to ~1 per 9 px and hard-capped at 420 live carriers. *The first build was measured at 92 carriers on two traces and read as a bead chain; it is now 2.6/A.*
• The plating meniscus. While you drag, a molten bead sits at the tip and swells as you dwell. The width gauge *is* the material — there is no slider. See scene-2-mid-drag.png: the trace visibly thickens toward the tip.
• Heat climbs monotonically in luminance. The intuitive metal ramp (copper → dull red → orange → white) is non-monotonic: dull red is *darker* than copper, so a heating trace would go dark first and read as switched off. The ramp here never passes through red. Measured hot-vs-cold: **3.70:1, ΔL\* 38.0.**
• A burn is readable by its BRIGHT halo. Overheated mask blisters and delaminates, revealing tan FR-4. A dark char core on a dark mask is invisible (the prior research measured 1.02:1); the blister here reads 1.45:1 and carries real chroma, tan against green, which is a hue contrast as well as a luminance one.

10.5 Restraint — what is deliberately dull

Everything that is *board* lives between **L\* 19 and 37**: component bodies 19.2, ground pour 25.9, mask field 27.0, FR-4 rim 27.8, inner-layer ghosting ~28, unenergised copper 36.0. Nothing on that list ever changes.

The rule, measured rather than asserted: the pixels above L\* 70 on the board are carrier, copper_hot, led_good and silk_text, and together they cover 0.44 % of the board area. Bright is a *signal*, not a surface. Silkscreen is the one static exception — it is the brightest non-emissive thing on a real board — and it was pulled from α 0.92 to 0.78 when it measured L\* 85.7 / 7.2:1, thirty characters of static ink shouting louder than a lit rail.

Charge and heat are separated by HUE, not brightness, because they are both bright and they mean opposite things. Measured separation: 173° (cyan 213° vs amber 40°). PGOOD sits at 144°, a third meaning with a third hue. And carrier cores are drawn source-over while only their halo is lighter, because lighter over a warm base saturates toward white and arrives as an orange-white blob with no hue left.

10.6 Detail that rewards a second look

Tented vias (soft green domes, no hole — deliberately *quiet*) mixed 2:1 with open plated barrels, both on half-pitch, because scattered detail reads as dirt. Unpopulated 0805 land patterns, most of them with no silk outline — a box round every one read as confetti. Ground stitching vias with four-spoke thermal reliefs and a silk G. Thermal relief where a module leg meets the pour. Thieving copper in the pour. Fiducials. Test points TP1–TP4 with silk labels. A J3 through-hole connector footprint with a square pin-1 pad. Inner-layer copper ghosting with 45° doglegs, α 0.38 — the single largest "this is a real two-layer board" upgrade for the least work. Board legend KAI-7 PWR DIST REV C and the fuse rating F1 11.6A, so the board tells you its own budget before you route anything.

45° mitring is the strongest "this is a PCB" tell and it is nearly free — one pass over the point list, radius 7 px, miterLimit 4. Orthogonal-only reads as a wiring *diagram*; mitred reads as a routed *board*.

No marking below ~5 px. Illegible text reads as dirt and actively cheapens a render. Modules get their designator in silkscreen *outside* the outline, the way a fab places it, and a bare thermal slug instead of a fake part number.

Silk outlines are corner ticks, not boxes — four brackets say the same thing at a quarter of the ink.

10.7 Readability outranks beauty

Design targets, all met in the shipped prototype:

---

11. Feasibility — measured, not assumed

Desktop headless Chrome, 540×1080 buffer at 375 CSS px / dpr 2, level 10, four modules, 36 segments, 41 nodes:

• Solve: 5 CG iterations, 0.006 ms warm-started. Cold solve happens once per topology change.
• Frame (step + full draw): median 0.50 ms, p95 0.80 ms, p99 1.10 ms, max 1.10 ms.
• × 6 phone penalty → 3.0 ms against a 16.7 ms budget.

One real performance bug was found by measuring, not by reading. The static bake flag was being set by the network rebuild, so *every single segment the player laid* re-rendered the whole board — weave, ghosting, hatch, two blurred silkscreen passes. Max frame was 91.1 ms. Separating "the board changed" from "the copper changed" took it to 1.10 ms. Bake procedural texture once at load; never inside the frame loop; and ctx.filter='blur()' belongs only on static content.

---

12. Weaknesses — honestly

1. Dwell-for-width is still the single biggest risk in the design, and no thumb has touched it. It could easily feel *laggy* ("why won't my trace get fat") or *accidental* ("I stopped to think and got copper I didn't want"). Retrace-to-plate (§2) is now the answer to that, and it downgrades this from "the design may not work" to "one of two width verbs may not survive" — but it does not remove the risk, it insures it. This is still the first thing that goes in front of the owner, and the question to ask him is narrow: *did the trace ever get fatter than you meant it to?*

2. A partially-routed net silently does nothing. Measured on a level-16 board: routes that ran out of vias mid-drag left dead copper that *looks* finished and carries 0 A. Unconnected copper must be drawn differently — unplated, no carriers, and the module's demand bar flat at zero — or players will stare at a route that looks right and is not. This is specified but not yet built.

3. The physics is calibrated, not real. Copper is ~100× too resistive. It is stated openly and it is the right call, but an electrical engineer will notice within a minute, and the game will be quietly wrong about a real quantity in a genre that attracts people who care.

4. The mid-board period may be dead time. Between "I have routed everything" and "the hold bar fills" there can be several seconds where the correct play is *to do nothing and watch*. That is thematically perfect (it is a bench burn-in test) and it may be boring. Rising demand and switched loads exist partly to paper over this, and they arrive at level 25.

5. Levels 29–44 are asserted, not prototyped. Diodes, capacitor banks, ground bounce and inductive kick are described here from first principles. Only routing, division, heating, burning, fusing, vias and the hold have actually been built and measured. The back half of the curve is a plan, and plans of this kind are usually 30 % wrong.

6. The scar reads as a component. A pale tan capsule on a green board is legible as *damage* in motion, but in a still frame it can be mistaken for a part. It wants to be more irregular and less symmetric than a stroked line.

7. Deuteranopia gets the worst possible hue triple. Structural mitigations are real (motion, form, position), but a colour-blind player will have a meaningfully harder time than a sighted one, and no amount of shape language fully fixes cyan-vs-green.

8. ~~It needs a framework change.~~ Withdrawn — this was false, and it is worth recording why. Both this document and the research brief asserted that no GC.arcade touch kind gives continuous free-form drag with capture, and therefore that shared code had to change. Reading oracle-games.js:1841–1949 shows spec.pointer: true already provides exactly that, including capture and an off-canvas release. Two of the three competing designs checked the file and got it right; this one reasoned from the research summary and got it wrong. The lesson generalises past this game: a claim about the framework that was never read out of the framework is a guess.

9. It is the slowest game in the pack. A board takes 25–70 seconds. Every other game in the arcade is a 30-second reflex loop. This may simply be a different appetite than the one the Game Center currently serves, and the burn-in mode is the only part of it that behaves like an arcade game.

10. Procedural boards may produce dull ones. The generator here is a placeholder — column table plus a stitch list. A board grammar that reliably forces interesting collisions (rather than five parallel straight lines) is real design work that has not been done, and without it level 20 looks like level 5 with more modules.

11. **The difficulty curve has never been *played*, only reasoned about — and this is the largest methodological hole in the design.** Every number in FINAL-PROBE.txt is a physics measurement. Not one of them answers *is level 16 winnable*, *does doing nothing win*, or *is the correct move ever the obvious one*. The competing design measured exactly that and it changed its curve; this one has not. §13.1 is the fix and it should be built before any level past 8 is tuned.

12. The grafted suppression verb collides with cut. Both are press-and-hold. They must be disambiguated by what is under the finger (copper → cut; a gate body → suppress), never by duration — two different hold-lengths on one surface is precisely the mode-switch this design has otherwise refused. If that disambiguation feels ambiguous in the hand, suppression is the thing that goes, not cut.

13. The bottom third of the board is empty and empty mask reads as unfinished, not as restraint. Visible in every scene frame: below the last module there is silkscreen, four test points and a connector, and then nothing. Restraint means *dull*, not *absent*. That region needs inner-layer ghosting, thieving copper, a second footprint and legend — all of it below L\* 30 so it fills the frame without competing for attention.

---

13. Grafted from the two runners-up

Neither losing design was wrong; they were right about different things. Everything below is

adopted with attribution, and the two items that contradict this document's earlier claims are

marked as corrections rather than quietly patched.

13.1 The policy bench — the single most valuable thing either runner-up built *(from B)*

B's circuit-bench.js does not measure physics. It measures whether the game is a game, by

running scripted players against every level and asking four questions:

1. Is doing nothing fatal? (If not, the level is dead time wearing a difficulty label.)

2. Can a skilled policy clear it? (If not, it is not tuned, it is broken.)

3. Is the correct action ever non-local — on a branch other than the one visibly in trouble?

4. What does the sim cost per frame under real play, not on an idle board?

Crucially it runs every policy with human latency baked in: re-decide every 200 ms, and the

decision lands 150 ms late. The numbers are therefore not a superhuman bot's.

This is the missing half of this design's evidence. Build the equivalent for routing, with three

policies — none (never touches the board), greedy (always widens the starved module), and

lookahead (widens whichever edit most raises the *minimum* margin across all modules). Then:

• none must fail every level from 3 onward. If it survives, that board has dead time in it,

and weakness #4 is real and measurable rather than a worry.

• lookahead must clear to ~50 and start failing beyond it. If it clears 80, the curve is flat.
• greedy must be measurably worse than lookahead from about level 8, because that is the

level where "help the one that is starving" stops being the right answer and "stop feeding the

one that is fat" starts being it. B measured its equivalent crossover at level 12 and found the

correct target was on a *different* branch than the one in trouble 100 % of the time past it.

If routing has no such crossover, the game is a search for one best path — i.e. a maze — and the

whole strategic argument in §0 collapses.

B also recorded that its first scoring function was wrong and produced a fake curve: a policy

protecting the *average* margin played no better than doing nothing, and only protecting the

*minimum* produced a real skill gradient. Take that as given rather than rediscovering it.

13.2 The gate — hold to starve, and it fixes the dead time *(from B)*

B's entire game is one verb this design does not have: **press and hold a MOSFET to choke its

branch, and every other branch gets stronger.** As a whole game it has a comprehension cliff; as a

level-25 unlock inside this one it is close to perfect, because:

• It is the same finger and the same physics. Closing a channel raises that branch's resistance;

division does the rest. No solver change — it is one conductance being driven by input.

• It gives the player something to *do* during the hold — which is weakness #4, answered with a

verb instead of with a rising number. This is a better fix than "switched loads", because a load

that switches itself is content happening *to* the player; a gate is content the player operates.

• It is legible from the art already specified: a real gate necks shut. B's timings —

close τ = 90 ms, open τ = 260 ms — are worth taking verbatim, because the asymmetry means you

*commit* to a hold, and it makes a 180 ms tap already an 86 % pinch without needing a

tap/hold distinction at all.

• Sliding the thumb hands over to the next gate, so one continuous drag chokes the bus in turn.

Its leash is the hold-up capacitor, also from B: a starved module runs on stored charge for a

few seconds before its PGOOD drops (B measured ~4.9 s at total outage). That is what stops the

player parking on one gate forever, and it is a far better introduction to capacitance than this

document's level-33 "charge a bank and dump it" — accumulation and depletion become something the

player *causes with their own thumb* rather than a thing they wait for.

Replaces the current level 25–28 band. The capacitor-bank band at 33–36 stays, and now lands on a

player who already understands stored charge.

13.3 Prove the game dies without the physics *(from B)*

B's strongest single argument is a one-line bench: sweep the source stiffness. At 99.5 % ideal, a

gate closing gives its siblings +0.17 % — no game exists. At 66 %, +9.88 %. Set the source

impedance to zero and there is literally nothing to play.

Run the routing equivalent and put the number in this document: **hold the fuse and the loads

constant, drive rail impedance to zero, and confirm that widening one branch stops affecting the

others.** If it still affects them, the coupling is coming from something other than the physics

and needs finding. This is the cheapest possible answer to "could this be reskinned?", and it is an

answer with a number in it.

13.4 No decision may depend on a string *(from B)*

B measured its silkscreen at 2.20:1 against the mask and, rather than brightening it, ruled that

no decision may depend on reading one. This document's silk measures better (5.91:1, dL\* 51.8,

FINAL-PROBE.txt §J) but the rule is adopted anyway: reference designators, the revision string

and the fuse rating are second-look detail. If the player ever has to *read* U3 to know which

module is starving, the state is being carried by text and the render has failed. Modules are told

apart by position, by the colour of their PGOOD dot, and by the copper going into them.

13.5 The burn-in clock is a ramping supply, not a rising demand *(from C)*

This document's endless mode says "demand ramps forever". C's formulation is better and should

replace it: **the supply itself ramps, I(t) = I₀ · (1 + t/T), T falling from 50 s to 20 s across

the run.** One number, physically honest, and every other pressure falls out of it rather than

being added to it — more current means more I²R in every trace, which means ampacity crossings and

burns, which means the fuse budget tightens, all without a single new rule. It also means the

endless mode needs no new content at all, which is what makes it shippable in the first version.

13.6 The thermal knife-edge is a readability contract *(from C)*

C measured the burn timing as a table rather than a threshold: **1.2× ampacity runs hot forever and

never fails; 1.5× burns at 6.6 s; 2× at 1.9 s; 3× at 0.7 s.** That shape is what makes "hot" a

*warning the player learns to read* instead of a countdown they cannot see. Re-measure it against

this design's constants (HEAT_A = 0.396, HEAT_B = 0.55, AMP_EXP = 0.725) and **treat the

1.2×-is-survivable rung as a requirement, not an outcome** — if every overheating trace eventually

burns, the amber state means "you have already lost" and the player has no reason to look at it.

13.7 A dump made of wire is a short *(from C)*

The most valuable playtest datum either runner-up produced, and it was a *failure*: C's scripted

policy built a ballast path to dump surplus current and killed its own run in 3.0 s, because a

19-segment thin path to ground is ~0.20 Ω against 0.35 Ω load branches — so the dump took 46 % of

the budget and starved everything it was meant to protect.

This applies verbatim to the ballast and keep-out content at levels 13–20. **If a bot with perfect

information gets it exactly backwards, a first-time player certainly will.** So ballast is not

introduced as an affordance and explained; it is introduced as a **board that is already wrong in

that exact way**, where the player's first move is to *narrow* the dump and watch the modules come

back. Teach it as a repair, not as a tool.

13.8 Motion decides meaning *(from C)*

C's justification for its cut gesture is better than this document's and costs nothing to adopt:

the iron adds where it moves and lifts where it lingers. That is why hold-to-cut is intuitive

rather than arbitrary — park a soldering iron on a trace and it comes up. State it that way in the

how-to guide. Take also C's live ring on the stroke head: whatever the width verb is doing, it

is shown at the fingertip, in the material, never in a corner of the HUD.

C's score unit is also the right one: coulombs delivered — charge that actually reached a

module inside its window. It is the honest quantity, it is the same thing B scores in

(amp-seconds), and it is what the burn-in mode should count. The laddered mode keeps board-pass

plus a copper/via par for the three-star chase.

13.9 What was deliberately *not* taken

• B's instrument strip. Seven aligned window meters in a bar across the board. B's own author

called it "UI wearing a solder-mask coat" and it is — but it is *load-bearing* UI there, because

comparison of seven branches needs a common baseline. This design has two to five modules, each

with its own demand bar drawn *at the part*, and that is the more beautiful answer. It is only

available because there are fewer things to compare. If module count ever passes five, this

decision has to be revisited rather than defended.

• C's stroke-speed gauge. Speed as a semantic channel means the game demands slowness at

exactly the moment it has manufactured panic. Dwell has the same failure mode in a milder form,

which is why §2 now ships retrace alongside it.

• B's fixed board. Seven identical columns is a readable diagram and a repetitive one. Board

authorship is the reason this design has a par chase and a level-50 that does not look like

level 5.

---

Prototype index

The runner-up prototypes, kept because their benches are being grafted (§13):

---

14. Rendering a real PCB on Canvas2D — the technique layer

> Scope. §10 states *what the board should look like* and measures the result. This section

> states *how each material is made* and measures the cost. It is a second, independent

> prototype (…\scratchpad\pcb\) written to answer one question: can a board that reads as a

> photographed PCB — layer stack, plating, weave, vias, slivers — hold 60 fps on a phone with

> no image files? Yes, with 3.3 ms of a 16.7 ms budget at 375×812 dpr2. Four claims in the

> first draft of this section were falsified by measurement and are recorded as such.

>

> Environment: Electron, software raster (disableHardwareAcceleration), offscreen,

> muted, headless. Software raster is the pessimistic case and was chosen deliberately — a

> phone with a working GPU-composited canvas does better, not worse.

14.1 The layer stack is the whole trick

A PCB photograph reads as a PCB because of four stacked physical layers, not because of its

colour. Render them in order and the look arrives on its own; author the final colours directly

and it never does.

The single most important technique in this document: the mask is a multiply, not a fill

Solder mask is a translucent film. Light goes down through it, reflects off whatever is

underneath, and comes back up through it. That is multiplication, and Canvas2D has the

operator:

// mk = mask coverage, opaque tint, with pad apertures punched by destination-out
ctx.globalCompositeOperation = 'multiply';  ctx.drawImage(mk, 0, 0);
ctx.globalCompositeOperation = 'source-over';
ctx.globalAlpha = 0.34; ctx.drawImage(mkScatter, 0, 0);   // the film's own body

Because it is multiplicative, buried copper stays brighter than buried substrate for free.

You do not author "mask over copper" and "mask over substrate" as two greens — you author one

film, and the copper underneath decides. Three things fall out that authored flats cannot do:

• a *hot* trace glows through the mask correctly, because its own luminance is the input;
• the ground pour, inner-layer ghosting and thieving all differentiate themselves with no

extra colours;

• apertures are free — where the coverage canvas is transparent, multiply is a no-op and

bare plating shows through.

Falsified claim, recorded. The first draft asserted the film would also *win on contrast*.

It does not. Measured on the same region: film pipeline 1.14:1 buried-trace-vs-field, flat

authored greens 1.25:1. The flat version is marginally more legible and looks like a

diagram; the film version looks like a board and responds to state. The film is chosen for

material and for dynamic range, not for contrast, and §14.4 buys the contrast back a

different way.

14.2 Per-material recipes

FR-4 weave — a real plain weave, never a noise field. Tile 64 px, pitch 8 px, bundle 6.4 px.

Three passes: all warp strips laid down, all weft over them, then warp redrawn **clipped to the

cells where (i+j) is even** so it genuinely interlaces. Each bundle is a cylinder — a

perpendicular linear gradient weft → warp → warp → weft with stops at 0/0.30/0.52/1.0 — plus

three wrapping hairline striations at α 0.13 for glass anisotropy. Then an epoxy flood

(rgba(156,138,87,0.34)) and one crossover-occlusion multiply. Seamless because the tile is an

exact multiple of the pitch.

Copper trace — four passes, per segment. Passes 1 and 3 are what stop it being an orange

rectangle:

1. contact shadow, width+1.6, offset against the light — copper occludes;

2. oxide flank, width+1.3, #5A3115 (an etched edge is darker *and redder* than the face);

3. face — a linear gradient across the trace, not along it (rolled foil grains along its

length, so the highlight is a *flank*, never a blob);

4. grain — the baked streak tile at α 0.26, overlay.

Round caps and joins hide the per-segment seams; 45° mitring (mitre(), radius 7 px) is one

pass over the point list and is the strongest single "this is a routed board" tell.

Plating — the finishes differ by VARIANCE, not by hue. This is the finding I would carry to

any other project:

They are 4 L\* apart in mean and measure 1.07:1 against each other — they are *not*

distinguished by brightness or colour. ENIG is a shallow gradient over a flat fill plus one

thin nickel rim; HASL is a radial dome plus a small sharp hot spot offset toward the key and

jittered per pad. Two finishes on one board is what stops everything metallic reading as "the

same shiny thing".

Falsified claim, recorded. My first ENIG measured **sd 18.8 — higher than the HASL beside

it**, i.e. exactly backwards, and rendered as a gold ball. Two separate errors: a wide-range

gradient, and a measurement bug (a *square* sample window around a *round* pad is dominated by

the pad/background edge and reports ≈17 for every finish). Sampling inside r×0.78 and

flattening the ramp gave the table above. **A material claim measured through a bad window is

not measured.**

Via — annular ring, then a black bore, then a radial gradient offset away from the key

(light falls into the tube and lands on the *far* wall), then a dark arc on the near rim. The

asymmetry is the entire effect: a symmetric dark circle reads as a dot, not a hole.

Tented via — a soft dome with a centre sag dimple, measured at 1.17:1 against the mask

field. Deliberately almost invisible: it is texture, not information.

Teardrops — the fab fillet where a trace enters a pad. Two quadratics from the trace edges

to tangent points at 0.72 r on the pad. Absent from most procedural boards, present on every

real one, and it costs one filled path.

Silkscreen bleed — screen-printed ink spreads; it is never a crisp vector. Draw to an

offscreen, then compose a blurred copy at α 0.62 under a crisp copy at α 0.40. ctx.filter

is expensive (2.8 ms full-screen) and therefore belongs only on baked content.

Mask slivers — the fragile 1–1.5 px mask webs between fine-pitch pads, with a lit edge on

the key side and a dark edge opposite. One of the most recognisable close-up PCB details and

almost free.

Edge fingers — hard gold with a per-finger diagonal gradient, a dark trailing edge, a bright

leading edge, and a routed chamfer along the board edge (transparent → light → black over

4 px). The chamfer is the tell.

14.3 Cost, measured at both target resolutions

What is cacheable: essentially everything. The entire static board — substrate, copper,

film, plating, silkscreen, components — bakes to one offscreen and the frame loop draws it with

a single drawImage.

Caching the board is worth 17× at phone dpr2 (2.1 ms vs 36.4 ms) and is the difference

between shipping and not. Tile bakes are one-time: weave 90.9 ms, grain 2.0 ms.

Isolated costs at 750×1624, for budgeting: one full-screen multiply 3.7 ms; 36 four-pass

trace segments 5.9 ms; a full-screen blur(0.85px) silk bake 2.8 ms; 60 ENIG pads

1.5 ms; 60 open vias 2.2 ms; 60 tented vias 0.6 ms; a full-screen weave pattern fill 0.3 ms.

Carrier sprites beat live gradients by 30–50 %. Bake the halo once to a small canvas and

blit it: 420 carriers cost 3.3 ms as sprites vs 4.2 ms as per-carrier createRadialGradient

(1920×1080: 5.9 vs 8.9 ms). createRadialGradient inside a per-object loop is the most common

avoidable cost in this kind of renderer.

A composite op inside a hot loop is catastrophic — measured. The weave tile's crossover

occlusion was 64 per-cell multiply fills on a 64 px canvas and cost 601 ms. Building the

occlusion map with plain source-over and applying it with one multiply gave identical

pixels at 90.9 ms — 6.6× (I predicted 70× and was wrong; the remaining cost is the 64

radial gradients themselves, not the compositing). **Every globalCompositeOperation change

forces a surface read/modify/write. Count them; do not count draw calls.**

14.4 Two failures found by measuring, and their generalisable fixes

Buried copper measured 1.055:1 against the mask field — invisible. My hypothesis was the

scatter pass. I swept its alpha 0.00 → 0.80 and the contrast moved from 1.03 to 1.06. **The

hypothesis was wrong and the sweep is what said so.** Two real causes:

1. Flank treatments must be a constant width in PIXELS, not a fraction of the stroke. The

face gradient used proportional stops (0.34 / 0.66), so an 8 px trace was *all flank and no

face* — its centre sat 75 % of the way into the oxide colour. Deriving the flank fraction

from an absolute 1.6 px (fl = clamp(1.6/w, 0.06, 0.34)) with a plateau between took it to

1.27:1 on its own. This generalises to every bevel, rim and edge highlight in the game.

2. The substrate was too bright to leave copper anywhere to go. Real FR-4 seen from the

mask side is resin-rich and dull. Darkening the weave tile by 0.64 finished the job.

Darken with a TINT, not with grey. A neutral multiply drops chroma with luminance and the

tan cloth turns to concrete (visible in the first study sheet). Multiplying by

rgb(255,238,198)×k is the same darkening with the chroma intact.

Final contrast table, all three resolutions:

The luminance budget holds: under 1 % of the board is bright on a phone. Bright is a

signal, not a surface. Silkscreen at 375×812 (3.48) sits just under its band and wants α 0.82

rather than 0.78 at dpr1 — the one open tuning item.

14.5 Animating current so it reads as current

Direction, magnitude and rate are three separate channels and each gets its own encoding.

Nothing here is brightness, because brightness is already spent on *heat* and on *importance*.

• Direction — carriers advance along the path and the comet tail trails behind, so a

still frame still shows which way. Asymmetry, not an arrow.

• Magnitude — carrier spacing. Countable. A 74/26 split at a junction is literally

countable, because carriers are routed into a branch with probability equal to its share.

• Rate — speed = current density J = I/w, so the *same* current in *narrower* copper

visibly runs faster. Two quantities, two channels, no collision.

• Surge vs trickle — a surge is dense and fast and the carrier stretches into a

capsule whose length ∝ speed (motion blur as a drawn primitive, not a filter), and the

trace itself warms. Four cues agreeing. A trickle is four well-separated dots crawling on

cold copper.

• Voltage ≠ current. On switch-on the *field* arrives in one frame — a wavefront sweeps the

whole net and the mask relief brightens — and only then do carriers begin to crawl. That

distinction is physically true, visually rich, and free.

• Accumulation must be a state, not an animation. A capacitor shows a fill level that

persists when input stops; carriers arriving at the plate are *absorbed* and stop. A pulsing

glow cannot represent a state variable. A column that stays where you left it can.

The hard limit, measured: carriers fuse into exactly the bar we are avoiding

"Magnitude = spacing" is only a readout while the dots are separable. Past a density they fuse

into a lit bar — the "glowing line that pulses" failure, arrived at from the other direction.

Measured as peak L\* minus mean trough L\* along the trace centreline (the honest metric;

global max/min is pinned by the brightest core and the darkest gap and stays flat at 0.525

regardless of density, which is why the first attempt at this measurement said nothing):

It is the halo that fuses, not the core. With an 11.7 px halo the troughs have risen to

L\* 50 *at 16 px spacing* — already a bar with bumps. Taking "trough stays below L\* 40" as the

criterion, the minimum workable spacing is 6 px at halo 0, 9 px at halo 5.2, 14 px at halo 8.3

and ~19 px at halo 11.7 — a constant ratio:

> halo radius ≤ 0.58 × carrier spacing, with an absolute floor of spacing ≥ 6 px set by

> the core diameter. The density ladder (flowtest-ladder.png) confirms it by eye: 6/12/24/48

> carriers over 800 px are countable, 96 is a fusing chain, 140 is a solid bar.

This is a design constraint, not a rendering note. It puts a hard cap on carriers per unit

length, and therefore a surge can never be drawn by adding more dots. Above the cap the

magnitude channel is saturated and the game must switch to speed, capsule length, heat and

trace state — which is precisely the behaviour that makes a surge read as a surge instead of as

a brighter line. The 200-carrier frame in measure-phone_750x1624_dpr2.png is the failure

preserved: at 2.8 px spacing it is a neon bar.

14.6 What the render still gets wrong

Honest, from looking at the frames rather than the tables:

1. **The ground pour and bare substrate are 0.4 L\* apart** (26.1 vs 25.7) — the pour boundary

reads as a *texture* change, not a copper boundary, and the pour is the largest copper

feature on the board. It needs its own separation (target ≥ 1.3:1); §14.4's substrate

darkening gets it to 1.31 and that is the floor, not the goal.

2. Pour keep-outs are axis-aligned rectangles and read as floating boxes. A real pour is

poured *around* the routing with a constant clearance. The keep-out must be generated by

offsetting the trace paths, not by punching rectangles.

3. Tented vias read as water droplets — too glossy and too round. Flatten the dome and cut

the specular.

4. HASL is still too spherical. The variance is now right; the silhouette is not. It wants

an irregular rim, not a circle.

5. The bottom third of the board is empty, exactly as §12.13 says. Confirmed visually.

6. The weave is convincing at 4× and near-invisible at 1×. That is arguably correct, but it

means 90.9 ms of bake is buying detail most players will never resolve on a phone; a cheaper

2-pass weave should be measured against it before shipping.

7. Everything here is measured under software raster on a desktop. No phone has run it. The

×6 rule of thumb applied to 3.3 ms says 19.8 ms — *over* budget — and the reason I am not

worried is that the phone case is GPU-composited while this measurement is not. **That is an

argument, not a measurement, and it is the first thing to check on real hardware.**

14.7 Prototype index for this section