copperhead 0.10.0 → 0.11.0

package/dist/kicad/draft/engine.js

@@ -1,4 +1,4 @@
-import { knum } from '../emit.js';
+import { knum, CAPTION_SIZE } from '../emit.js';
 import { powerSymbolSource, pwrFlagSource } from './symsource.js';
 /**
  * The rule-based deterministic drafting engine (design D1/D2). All geometry is
@@ -10,20 +10,137 @@ import { powerSymbolSource, pwrFlagSource } from './symsource.js';
 const U = 1.27;
 /** Stub length from a pin to its label/power symbol, in grid units. */
 const STUB = 2;
-/** Cell margin around a symbol body (room for stubs, labels, text), in units. */
-const MARGIN = 6;
+/** Cell margin around a symbol body (room for stubs, labels, text), in units,
+ * for the first draft; a measured round shrinks it to `MEASURED_MARGIN`. */
+const BASE_MARGIN = 4;
+/** Cell margin once the cell is sized from what it actually drew. */
+const MEASURED_MARGIN = 2;
+/** Vertical cell margin, units: rows are tighter than columns because a
+ * part's texts sit beside it, not above and below; a pin that faces up or
+ * down with a rail or ground on it reserves `POWER_REACH` instead. */
+const VMARGIN = 2;
+const POWER_REACH = 6;
+/** Clear grid units kept beyond a cell's measured drawn extent. */
+const MEASURE_PAD = 1;
+/** Padding, grid units, a group box keeps around the label and field text it
+ * encloses, and the clearance kept between two such boxes. */
+const BOX_PAD = 1;
+/** Grid units between two drawn group boxes, after the boxes have grown to
+ * their text: the one distance a reader sees between blocks. Equal to
+ * GROUP_GAP, the gap the wrap fits between rects, so a fit on measured
+ * boxes is exact. */
+const BOX_LINE_GAP = 4;
+const BOX_GAP = 4;
 /** Vertical gap between rows and horizontal channel between columns, units. */
-const ROW_GAP = 4;
-const CHANNEL = 8;
+const ROW_GAP = 3;
+const CHANNEL = 4;
 /** Gap between group boxes, units. */
-const GROUP_GAP = 8;
-/** Local nets up to this many endpoints may be wired (design D2). */
+const GROUP_GAP = 4;
+/** Local nets up to this many endpoints may be wired (design D2); a larger
+ * cluster is narrowed to the endpoints bound to one anchor before routing. */
 const MAX_WIRED_ENDPOINTS = 4;
+/** Subsets of one cluster the wire pass tries to route before it gives up. */
+const ROUTE_ATTEMPTS = 64;
+/** Nodes the masonry wrap's deal search visits before it keeps the best deal found so far. */
+const MASONRY_NODE_BUDGET = 200_000;
 /** Wire-span budget in mm beyond which a net becomes labels. */
 const MAX_WIRE_SPAN = 50.8;
 /** Label text metrics, matching the legibility checker's conservative box. */
 const LABEL_HEIGHT = 1.27;
-const LABEL_ADVANCE = 0.6;
+/**
+ * Advance the ENGINE gives text when it spaces groups, clears labels and
+ * fields of one another, and draws the box around a group. The checker's 0.6
+ * is tuned below KiCad's stroke font on purpose (design C3: never a false
+ * collision); measured on a plotted sheet the font advances about 0.72 of
+ * its height, so an engine that cleared text at 0.6 drew sheets where a rail
+ * name ran into the label on the next pin row while the checker called them
+ * clean. The engine is the side that must be conservative: it reserves 0.8.
+ */
+const LABEL_ADVANCE = 0.8;
+const TEXT_RESERVE = LABEL_ADVANCE;
+/** Advance of KiCad's stroke font for the upper-case pin names inside a
+ * body, per height: wider than the mixed-case reserve above. */
+const NAME_ADVANCE = 1.0;
+/** Air between any two texts, mm. Boxes that merely do not overlap still
+ * read as one smudge on paper (esp32-amp's "100k" sat 0.6 mm above
+ * "USB_OV"); every clearance check pads the candidate by this. */
+const TEXT_PAD = 0.8;
+const padBox = (b, p = TEXT_PAD) => ({ minX: b.minX - p, minY: b.minY - p, maxX: b.maxX + p, maxY: b.maxY + p });
+/** `COPPERHEAD_DRAFT_TRACE=1` prints every placement decision the engine
+ * makes silently: what it claimed, what it skipped and why, what it refused. */
+const trace = (msg) => {
+    if (process.env['COPPERHEAD_DRAFT_TRACE'] === '1')
+        console.error(`[draft] ${msg}`);
+};
+/** `labelTextBox` at the reserve advance: what the text takes on paper. */
+const labelReserveBox = (name, x, y, rot, kind = 'local') => labelBoxAt(name, x, y, rot, kind, TEXT_RESERVE);
+/**
+ * Along-axis length a global label's flag adds beyond its text: the margin
+ * either side of the text plus the pointed tip. Measured from eeschema's own
+ * outline at 1.27 mm (a 12-character name draws 17.0 mm long against about
+ * 14.5 of text), and kept a little generous because the advance estimate
+ * under-reads wide glyphs.
+ */
+const FLAG_PAD = 2.5 * LABEL_HEIGHT;
+/** Grid units of the caption band at the top of a group box: the bold
+ * caption at `CAPTION_SIZE` plus clearance over the tallest thing a cell can
+ * carry above its body (a rail symbol on an upward stub with its value text). */
+const CAPTION_BAND = 7;
+/**
+ * The box a label occupies at `advance` per character. A local label is bare
+ * text standing on its anchor (see `labelTextBox`); a global label is a flag
+ * two text heights tall, centred on the anchor line, whose length runs away
+ * from the anchor in the rotation's direction — 0 right, 90 up, 180 left,
+ * 270 down in schematic Y-down coordinates, exactly as eeschema draws it.
+ */
+const labelBoxAt = (name, x, y, rot, kind, advance) => {
+    const textW = Math.max(1, name.length) * advance * LABEL_HEIGHT;
+    if (kind === 'global') {
+        const w = textW + FLAG_PAD;
+        const h = LABEL_HEIGHT;
+        const r = ((rot % 360) + 360) % 360;
+        if (r === 90)
+            return { minX: x - h, minY: y - w, maxX: x + h, maxY: y };
+        if (r === 270)
+            return { minX: x - h, minY: y, maxX: x + h, maxY: y + w };
+        if (r === 180)
+            return { minX: x - w, minY: y - h, maxX: x, maxY: y + h };
+        return { minX: x, minY: y - h, maxX: x + w, maxY: y + h };
+    }
+    // A plain label STANDS on its anchor line: the checker measures it that way
+    // (`labelBounds`), and so does the engine. The union box that also reached
+    // half a height below the line dated from the checker's centred days; kept,
+    // it made every name on a row collide with that row's own continuing wire
+    // (esp32-amp's UART_TXD could stand nowhere on its 9 mm run).
+    return rot === 180
+        ? { minX: x - textW, minY: y - LABEL_HEIGHT, maxX: x, maxY: y }
+        : { minX: x, minY: y - LABEL_HEIGHT, maxX: x + textW, maxY: y };
+};
+/** KiCad's label rotation for text running outward along a stub direction. */
+const rotOutward = (o) => (o.dx === -1 ? 180 : o.dy === -1 ? 90 : o.dy === 1 ? 270 : 0);
+/**
+ * Flag shape for a global label at a pin, from the pin's electrical type:
+ * an output pin's net leaves through an output flag, an input's arrives
+ * through an input flag, a bidirectional or tri-state pin's points both
+ * ways, and everything else (passive parts, power, unspecified) gets the
+ * plain box. Cosmetic to KiCad's ERC, informative to a reader.
+ */
+export function flagShape(etype) {
+    switch (etype) {
+        case 'output':
+        case 'open_collector':
+        case 'open_emitter':
+        case 'power_out':
+            return 'output';
+        case 'input':
+            return 'input';
+        case 'bidirectional':
+        case 'tri_state':
+            return 'bidirectional';
+        default:
+            return 'passive';
+    }
+}
 /** How far a colliding label may ride its stub outward, in grid units.
  * Deep enough to carry a bottom-pin label past the routing channel that runs
  * under its connector (#220 phase 2); rungs stay ordered nearest-first, so a
@@ -71,6 +188,8 @@ const PAPERS = [
 ];
 const FRAME = 10;
 const TITLE_STRIP = 30;
+/** The title block's width along the bottom edge, as the checker measures it. */
+const TITLE_BLOCK_W = 110;
 /** Max pin-to-pin gap, grid units, for chaining a passive bank on one trunk
  * (#233): wide enough for two-pin parts sitting in adjacent COLUMNS (cell
  * width plus the channel, ~23 units), tight enough that a trunk never spans
@@ -248,6 +367,37 @@ export function splitBankRuns(line, canStub, canJoin) {
     flush();
     return runs;
 }
+/** `sym` mirrored left-for-right (KiCad's `(mirror y)`), then turned by `rot`. */
+const transformSym = (sym, rot, mirror) => {
+    if (!mirror)
+        return rotatedSym(sym, rot);
+    const pins = sym.pins.map((p) => ({ ...p, x: -p.x, angle: (((180 - p.angle) % 360) + 360) % 360 }));
+    const b = sym.body ? bodyBoundsOf(sym) : null;
+    const body = b ? { minX: -b.maxX, maxX: -b.minX, minY: b.minY, maxY: b.maxY } : null;
+    return rotatedSym({ ...sym, pins, body }, rot);
+};
+/**
+ * The symbol as KiCad draws it at rotation `rot` (0, 90, 180, 270): pins,
+ * their direction angles and the body box all turned in symbol space, so
+ * every downstream helper (pinAt, outward, bodyBoundsOf) reads the drawn
+ * geometry without knowing the part was turned. Matches `pinAbsolute`:
+ * rx = x cos − y sin, ry = x sin + y cos.
+ */
+const rotatedSym = (sym, rot) => {
+    const r = ((rot % 360) + 360) % 360;
+    if (r === 0)
+        return sym;
+    const turn = (x, y) => r === 90 ? { x: -y, y: x } : r === 180 ? { x: -x, y: -y } : { x: y, y: -x };
+    const pins = sym.pins.map((p) => ({ ...p, ...turn(p.x, p.y), angle: (p.angle + r) % 360 }));
+    const b = sym.body ? bodyBoundsOf(sym) : null;
+    let body = null;
+    if (b) {
+        const c1 = turn(b.minX, b.minY);
+        const c2 = turn(b.maxX, b.maxY);
+        body = { minX: Math.min(c1.x, c2.x), maxX: Math.max(c1.x, c2.x), minY: Math.min(c1.y, c2.y), maxY: Math.max(c1.y, c2.y) };
+    }
+    return { ...sym, pins, body };
+};
 const bodyBoundsOf = (sym) => {
     if (sym.body)
         return sym.body;
@@ -257,6 +407,49 @@ const bodyBoundsOf = (sym) => {
         return { minX: -U, minY: -U, maxX: U, maxY: U };
     return { minX: Math.min(...xs), minY: Math.min(...ys), maxX: Math.max(...xs), maxY: Math.max(...ys) };
 };
+/**
+ * Wire and label colours by function: rails one colour, grounds another,
+ * and every FAMILY of signal nets — the nets sharing a prefix before the
+ * first underscore, when there are at least two of them (I2S_BCLK, I2S_DIN,
+ * I2S_LRCLK; SPI_…; BTN_…) — a colour of its own from a fixed palette, in
+ * family-name order so the same design colours the same way every time. A
+ * lone signal keeps the theme's default: colouring everything in a block
+ * one colour would say nothing.
+ */
+const FAMILY_PALETTE = [
+    [30, 90, 200],
+    [130, 50, 170],
+    [0, 130, 120],
+    [210, 120, 0],
+    [180, 30, 140],
+    [110, 130, 0],
+    [140, 80, 40],
+    [40, 60, 140],
+];
+const RAIL_COLOR = [170, 30, 30];
+const GROUND_COLOR = [70, 70, 70];
+function netColorsOf(nets, classes) {
+    const out = {};
+    const families = new Map();
+    for (const n of nets) {
+        const cls = classes.get(n.name)?.cls ?? 'signal';
+        if (cls === 'rail')
+            out[n.name] = RAIL_COLOR;
+        else if (cls === 'ground')
+            out[n.name] = GROUND_COLOR;
+        else {
+            const m = /^([A-Za-z0-9]+)_/.exec(n.name);
+            if (m)
+                families.set(m[1], [...(families.get(m[1]) ?? []), n.name]);
+        }
+    }
+    const named = [...families.entries()].filter(([, members]) => members.length >= 2).sort((a, b) => a[0].localeCompare(b[0]));
+    named.forEach(([, members], i) => {
+        for (const name of members)
+            out[name] = FAMILY_PALETTE[i % FAMILY_PALETTE.length];
+    });
+    return out;
+}
 /** Pin connection point in schematic space for a part placed at (x, y), rot 0. */
 const pinAt = (p, pin) => ({ x: p.x + pin.x, y: p.y - pin.y });
 /** Outward direction of a pin (away from the body), schematic space. */
@@ -315,13 +508,64 @@ const boundsOverlap = (a, b) => a.minX < b.maxX - 0.01 && a.maxX > b.minX + 0.01
  * conservative metrics. Shared by the de-collision pass and the overlap report
  * so "clear" means one thing in the engine.
  */
-const labelTextBox = (name, x, y, rot) => {
-    const w = Math.max(1, name.length) * LABEL_ADVANCE * LABEL_HEIGHT;
-    const h = LABEL_HEIGHT / 2;
-    return rot === 180
-        ? { minX: x - w, minY: y - h, maxX: x, maxY: y + h }
-        : { minX: x, minY: y - h, maxX: x + w, maxY: y + h };
-};
+const labelTextBox = (name, x, y, rot, kind = 'local') => 
+// A local label is bottom-justified on its anchor: on paper the text stands
+// on the wire line and rises one full height above it, and the checker's
+// `labelBounds` measures exactly that. A global label's flag is measured as
+// eeschema draws it (`labelBoxAt`).
+labelBoxAt(name, x, y, rot, kind, LABEL_ADVANCE);
+/**
+ * Where a wired run's name may sit when it must be a global flag, in
+ * preference order: standing up from the top of a vertical trunk (the flag on
+ * a pole a reviewer expects), then every other wire end continuing its
+ * segment outward, then the interior grid points of each segment with the
+ * flag perpendicular to the wire, upward before downward. Every candidate
+ * lies on a wire of the run, so the name always attaches.
+ */
+export function wiredFlagCandidates(segs) {
+    const out = [];
+    const seen = new Set();
+    const push = (x, y, rot) => {
+        const k = `${pointKey(x, y)}/${rot}`;
+        if (seen.has(k))
+            return;
+        seen.add(k);
+        out.push({ x, y, rot });
+    };
+    const vertical = segs.filter((s) => sameCoord(s.x1, s.x2));
+    const horizontal = segs.filter((s) => !sameCoord(s.x1, s.x2));
+    // Horizontal first: a name reads along the row it names (the drafting
+    // standard keeps text horizontal), so the ends of horizontal segments
+    // continuing outward come before a flag standing up from a trunk top, and
+    // both before a flag perpendicular to a wire's interior.
+    const ends = segs.flatMap((s) => [{ x: s.x1, y: s.y1 }, { x: s.x2, y: s.y2 }]).sort((a, b) => a.y - b.y || a.x - b.x);
+    for (const p of ends) {
+        for (const s of horizontal) {
+            if (!sameCoord(s.y1, p.y))
+                continue;
+            if (sameCoord(p.x, Math.max(s.x1, s.x2)))
+                push(p.x, p.y, 0);
+            if (sameCoord(p.x, Math.min(s.x1, s.x2)))
+                push(p.x, p.y, 180);
+        }
+    }
+    const tops = vertical.map((s) => ({ x: s.x1, y: Math.min(s.y1, s.y2) })).sort((a, b) => a.y - b.y || a.x - b.x);
+    for (const t of tops)
+        push(t.x, t.y, 90);
+    for (const p of ends) {
+        for (const s of vertical) {
+            if (sameCoord(s.x1, p.x) && sameCoord(p.y, Math.max(s.y1, s.y2)))
+                push(p.x, p.y, 270);
+        }
+    }
+    for (const s of segs) {
+        for (const rot of sameCoord(s.x1, s.x2) ? [0, 180] : [90, 270]) {
+            for (const p of interiorGridPoints([s], U))
+                push(p.x, p.y, rot);
+        }
+    }
+    return out;
+}
 /**
  * Pairs of labels naming DIFFERENT nets whose text boxes overlap.
  *
@@ -332,7 +576,7 @@ const labelTextBox = (name, x, y, rot) => {
  */
 export function findLabelOverlaps(labels) {
     const out = new Map();
-    const boxes = labels.map((l) => labelTextBox(l.name, l.x, l.y, l.rot));
+    const boxes = labels.map((l) => labelTextBox(l.name, l.x, l.y, l.rot, l.kind));
     for (let i = 0; i < labels.length; i++) {
         for (let j = i + 1; j < labels.length; j++) {
             const a = labels[i];
@@ -366,7 +610,174 @@ const segCrossesBody = (x1, y1, x2, y2, b) => {
         return y1 > b.minY + 0.01 && y1 < b.maxY - 0.01 && inX;
     return inX && inY; // conservative for diagonals (the engine never draws them)
 };
+/**
+ * Draft, then check the drawn group boxes against one another: a box grows
+ * past its tiling estimate when the text it must hold (a flag on a hung
+ * part, a rail name at the edge) reaches further than the pin labels the
+ * estimate counted, and two boxes then intersect (usb-atmega-node's Status
+ * over IO Headers). Each overlap widens the right-hand group's left reserve
+ * by the overlap and the sheet is drafted again; placement is a pure
+ * function of the intent and these reserves, so the result stays
+ * deterministic. Three rounds bound the cost.
+ */
 export function draftSchematicPlacement(validated, projectName, today) {
+    const reserves = new Map();
+    let frameSlack = 0;
+    let wrapGap = 0;
+    // The squeeze. The first draft sizes every cell by rule (a margin a side, a
+    // power symbol's worth under every hung part, a label beside every pin) and
+    // draws into that room; most of the room stays empty. Each further round
+    // sizes the cells from what the previous round actually drew — body,
+    // wires, labels, power symbols, field text of the cell and of everything
+    // hung on it — plus a pad, and draws again. Rounds continue while the
+    // group boxes shrink and the engine's own gates hold (no merged nets, the
+    // label-overlap budget kept); the smallest passing sheet is the result.
+    // This is the step a drafter does by eye after placing: look, then pull
+    // things together.
+    let measured;
+    let best = null;
+    let squeezeRounds = 0;
+    let areaBefore = 0;
+    const boxArea = (rects) => rects.reduce((a, r) => a + (r.x2 - r.x1) * (r.y2 - r.y1), 0);
+    let retries = 0;
+    // The look. Before any wrap is fitted the engine can only estimate how far
+    // a group's labels reach past its cells, and it estimates generously: a
+    // label's width beside every pin that might carry one. Those reserves
+    // decide how many groups share a row or column, so a wrapped sheet is
+    // drafted once more with the reach every box was actually measured to
+    // take, and that draft is kept when it fits the same or a smaller sheet
+    // with the gates still holding.
+    let reachMeasured;
+    let look = 'not-yet';
+    let lookVerdict;
+    for (let round = 0; round < 16; round++) {
+        const { model, report, rects, measured: nextMeasured, reach, wrapped } = draftOnce(validated, projectName, today, reserves, frameSlack, measured, wrapGap, reachMeasured);
+        let widened = false;
+        const stillWrong = [];
+        // A row or column wrapped to the full usable width leaves no room for the
+        // text its boxes grow to hold afterwards, and a box then crosses the
+        // frame (usb-atmega-node's IO Headers on A3). Any box past the frame
+        // shrinks the usable frame by the overflow and the sheet is drafted again.
+        const paper = PAPERS.find((p) => p.name === report.sheetFit.paper);
+        if (paper) {
+            const over = Math.max(0, ...rects.flatMap((r) => [FRAME - r.x1, r.x2 - (paper.w - FRAME), FRAME - r.y1, r.y2 - (paper.h - FRAME)]));
+            if (over > 0.01) {
+                frameSlack += over + U;
+                widened = true;
+                stillWrong.push(`a box crosses the frame by ${over.toFixed(1)} mm`);
+                trace(`a group box crosses the frame by ${over.toFixed(2)} mm; the usable frame shrinks by ${frameSlack.toFixed(2)} mm and the sheet is drafted again`);
+            }
+            // A sheet fitted into the title strip was judged on its group rects
+            // before the boxes grew to their text; a box that grew into the title
+            // block's own corner (as the checker reserves it, narrowed on small
+            // pages) overflows the usable height by how far it reaches in.
+            const cornerX = paper.w - FRAME - Math.min(TITLE_BLOCK_W, (paper.w - 2 * FRAME) / 2);
+            const cornerY = paper.h - FRAME - Math.min(TITLE_STRIP, (paper.h - 2 * FRAME) / 4);
+            const into = Math.max(0, ...rects.map((r) => (r.x2 > cornerX + 0.01 && r.y2 > cornerY + 0.01 ? r.y2 - cornerY : 0)));
+            if (over <= 0.01 && into > 0.01) {
+                frameSlack += into + U;
+                widened = true;
+                stillWrong.push(`a box enters the title block's corner by ${into.toFixed(1)} mm`);
+                trace(`a group box enters the title block's corner by ${into.toFixed(2)} mm; the usable frame shrinks by ${frameSlack.toFixed(2)} mm and the sheet is drafted again`);
+            }
+        }
+        for (let i = 0; i < rects.length; i++) {
+            for (let j = i + 1; j < rects.length; j++) {
+                const a = rects[i];
+                const b = rects[j];
+                const ox = Math.min(a.x2, b.x2) - Math.max(a.x1, b.x1);
+                const oy = Math.min(a.y2, b.y2) - Math.max(a.y1, b.y1);
+                if (ox <= 0.01 || oy <= 0.01)
+                    continue;
+                widened = true;
+                stillWrong.push(`"${a.name}" and "${b.name}" intersect`);
+                if (oy < ox) {
+                    // boxes in different rows (or columns) touching along the wrap
+                    // gap: widen the gap between wrapped rows and columns
+                    wrapGap += oy + U;
+                    trace(`group boxes "${a.name}" and "${b.name}" overlap by ${oy.toFixed(2)} mm across the wrap; the wrap gap grows to ${wrapGap.toFixed(2)} mm and the sheet is drafted again`);
+                    continue;
+                }
+                const right = a.x1 < b.x1 ? b : a;
+                const r = reserves.get(right.name) ?? { left: 0, right: 0 };
+                r.left += ox + U;
+                reserves.set(right.name, r);
+                trace(`group boxes "${a.name}" and "${b.name}" overlap by ${ox.toFixed(2)} mm; "${right.name}" reserves ${r.left.toFixed(2)} mm more on its left and the sheet is drafted again`);
+            }
+        }
+        if (widened && retries < 3) {
+            retries++;
+            continue; // the same cells, re-tiled: not a squeeze round
+        }
+        const area = boxArea(rects);
+        const refusals = report.notes.filter((n) => /refused/.test(n)).length;
+        const paperIdx = PAPERS.findIndex((p) => p.name === report.paper);
+        // a round whose boxes still overlap or cross the frame after three
+        // re-tilings is not a sheet to keep; nor one that lost a hung part, or
+        // needs a larger sheet, or shrank by less than three percent
+        const passes = !widened && report.mergedNets.length === 0 && !report.labelOverlapBudgetExceeded;
+        if (widened)
+            report.notes.push(`group boxes still wrong after ${retries} re-tilings (${stillWrong.join('; ')}); the sheet is drawn as it stands`);
+        retries = 0;
+        reserves.clear();
+        frameSlack = 0;
+        wrapGap = 0;
+        if (!best) {
+            areaBefore = area;
+            best = { model, report, area, refusals, paperIdx };
+            if (look === 'not-yet' && wrapped && passes) {
+                look = 'drafting';
+                reachMeasured = reach;
+                trace(`box reach measured: ${[...reach].map(([g, r]) => `${g.slice(0, 2).trim()} ${r.left.toFixed(1)}/${r.right.toFixed(1)} ${r.top.toFixed(1)}/${r.bottom.toFixed(1)}`).join(', ')}; the wrap is fitted again on it`);
+                continue;
+            }
+        }
+        else if (look === 'drafting') {
+            look = 'done';
+            if (passes && refusals <= best.refusals && (paperIdx < best.paperIdx || (paperIdx === best.paperIdx && area <= best.area))) {
+                trace(`measured-reach draft kept: ${report.paper}, boxes ${area.toFixed(0)} mm² (was ${best.report.paper}, ${best.area.toFixed(0)} mm²)`);
+                lookVerdict = { kept: true, paperBefore: best.report.paper, paperAfter: report.paper };
+                if (paperIdx < best.paperIdx)
+                    report.notes.push(`label reach measured: the wrap fitted again takes ${report.paper}, not ${best.report.paper}`);
+                areaBefore = area;
+                best = { model, report, area, refusals, paperIdx };
+            }
+            else {
+                trace(`measured-reach draft not kept: ${passes ? `${report.paper}, boxes ${area.toFixed(0)} mm²` : 'gates failed'} against ${best.report.paper}, ${best.area.toFixed(0)} mm²`);
+                lookVerdict = { kept: false, paperBefore: best.report.paper, paperAfter: best.report.paper };
+                reachMeasured = undefined;
+            }
+        }
+        else if (passes && refusals <= best.refusals && paperIdx <= best.paperIdx && area < best.area * 0.97) {
+            best = { model, report, area, refusals, paperIdx };
+        }
+        else {
+            trace(`squeeze round ${squeezeRounds}: ${passes ? `boxes ${area.toFixed(0)} mm² did not shrink` : 'gates failed'}; keeping the previous round`);
+            break;
+        }
+        // Rounds beyond the first run only when asked for: on the boards drafted
+        // so far the rules were within a few percent of the drawing, and the
+        // extra drafts cost time and re-pin every fixture. The measurement and
+        // the report are always made.
+        if (squeezeRounds >= 3 || process.env['COPPERHEAD_DRAFT_SQUEEZE'] !== '1')
+            break;
+        measured = nextMeasured;
+        squeezeRounds++;
+        trace(`squeeze round ${squeezeRounds}: cells measured, group boxes ${area.toFixed(0)} mm²; drafting again`);
+    }
+    const out = best;
+    out.report.sheetFit.squeeze = { rounds: squeezeRounds, boxAreaBefore: Math.round(areaBefore), boxAreaAfter: Math.round(out.area) };
+    if (lookVerdict)
+        out.report.sheetFit.look = lookVerdict;
+    if (squeezeRounds > 0) {
+        out.report.notes.push(`cells measured: group boxes ${Math.round(areaBefore / 1000)} k mm² to ${Math.round(out.area / 1000)} k mm² over ${squeezeRounds} round(s) on ${out.report.paper}`);
+    }
+    return { model: out.model, report: out.report };
+}
+function draftOnce(validated, projectName, today, reserves, frameSlack = 0, measured, wrapGap = 0, reachMeasured) {
+    // a measured round keeps only a small margin: the measured overhang says
+    // where the drawing actually reaches
+    const MARGIN = measured ? MEASURED_MARGIN : BASE_MARGIN;
     const { intent, symbols, docGroups } = validated;
     const notes = [];
     // ---------- net classification (deterministic, visible in the report) ----------
@@ -410,6 +821,19 @@ export function draftSchematicPlacement(validated, projectName, today) {
         }));
     });
     const instByKey = new Map(instances.map((i) => [i.key, i]));
+    /** The pin that controls a transistor (base or gate), or null for anything else. */
+    const controlPinOf = (key) => {
+        const inst = instByKey.get(key);
+        if (!inst || inst.sym.pins.length !== 3)
+            return null;
+        if (!/^Transistor|^Device:Q_|^Q\d/.test(inst.part.libId) && !/^Q\d/.test(inst.ref))
+            return null;
+        return inst.sym.pins.find((p) => /^(B|G|Base|Gate)$/i.test(p.name)) ?? null;
+    };
+    const isTransistor = (key) => controlPinOf(key) !== null;
+    /** Switches are the anchors of a button block: the pull-up, the debounce
+     * cap and the ESD diode all hang on the switch's signal pin. */
+    const isSwitch = (key) => /^Switch[:_]|^Device:SW_|^Button/i.test(instByKey.get(key)?.part.libId ?? '');
     /** Placed instances per refdes, for expanding a common pin's endpoint. */
     const instancesOfRef = new Map();
     for (const inst of instances)
@@ -509,14 +933,45 @@ export function draftSchematicPlacement(validated, projectName, today) {
         let right = 0;
         for (const key of keys) {
             const inst = instByKey.get(key);
+            if (!inst)
+                continue;
+            // a part with pins only on its top and bottom (a vertical R or C)
+            // carries its reference and value beside it on the right
+            if (inst.sym.pins.every((pin) => outward(pin).dx === 0)) {
+                const fieldW = Math.max(inst.ref.length + 1, inst.part.value.length) * TEXT_RESERVE * LABEL_HEIGHT;
+                right = Math.max(right, 1.27 + fieldW + 1.27);
+            }
             for (const pin of inst?.sym.pins ?? []) {
-                const net = signalNetOfPin.get(`${inst.ref}.${pin.number}`);
-                if (!net)
-                    continue;
                 const o = outward(pin);
                 if (o.dx === 0)
                     continue;
-                const extent = STUB * U + Math.max(1, net.length) * LABEL_ADVANCE * LABEL_HEIGHT;
+                const ep = `${inst.ref}.${pin.number}`;
+                const signal = signalNetOfPin.get(ep);
+                const power = signal ? undefined : netByEndpoint.get(ep);
+                if (!signal && !power)
+                    continue;
+                // a small signal net whose every endpoint is in this group is wired,
+                // not labelled: no flag reaches out from it (counting one for every
+                // pin put 27 mm between groups whose facing sides carry no label). A
+                // larger in-group net may still end in stub labels, so it keeps its
+                // reserve.
+                if (signal) {
+                    const net = netByEndpoint.get(ep);
+                    const others = (net?.pins ?? []).filter((other) => other !== ep).map((other) => /^([^.]+)\./.exec(other)?.[1] ?? '');
+                    const leaves = !net || net.pins.length > MAX_WIRED_ENDPOINTS || others.some((ref) => partByRef.get(ref)?.group !== inst.part.group);
+                    // only when every other endpoint is a two-lead part (or a test
+                    // point): those hang on the pin and are wired by construction; two
+                    // ICs of one group may still sit past wire span and take labels
+                    const hangs = others.every((ref) => (symbols.get(ref)?.pins.length ?? 3) <= 2);
+                    if (!leaves && hangs)
+                        continue;
+                }
+                // a signal: stub plus the label's flag (text, margins and tip); a
+                // rail or ground on a sideways pin: the longer power stub, the bar,
+                // and the name drawn outward in line
+                const extent = signal
+                    ? STUB * U + Math.max(1, signal.length) * TEXT_RESERVE * LABEL_HEIGHT + FLAG_PAD
+                    : (STUB + 2) * U + 1.905 + Math.max(1, power.name.length) * TEXT_RESERVE * LABEL_HEIGHT;
                 if (o.dx === -1)
                     left = Math.max(left, extent);
                 else
@@ -526,8 +981,9 @@ export function draftSchematicPlacement(validated, projectName, today) {
         return { left, right };
     };
     /** Extra gap units so facing label text fits a boundary whose body-to-body
-     * clearance is `baseUnits` (one unit of slack between the two texts). */
-    const widenBy = (rightOfPrev, leftOfNext, baseUnits) => Math.max(0, ceilU(rightOfPrev + leftOfNext) + 1 - baseUnits);
+     * clearance is `baseUnits`: the two texts, the box padding each group draws
+     * around its own text (`BOX_PAD` a side), and the gap between the boxes. */
+    const widenBy = (rightOfPrev, leftOfNext, baseUnits) => Math.max(0, ceilU(rightOfPrev + leftOfNext) + 2 * BOX_PAD + BOX_GAP - baseUnits);
     // ---------- group ordering: hints, then SUBSYSTEMS.md order, then name ----------
     const groupNames = [...new Set(intent.parts.filter((p) => !symbols.get(p.ref).isPower).map((p) => p.group))];
     const orderIndex = (g) => {
@@ -544,9 +1000,20 @@ export function draftSchematicPlacement(validated, projectName, today) {
     const placed = new Map();
     const groupRects = [];
     const groupOf = new Map();
+    /** Part key -> the anchor it was hung on or laid beside. A bound part is
+     * wired to its anchor whatever the distance: the shelf placed it there
+     * deliberately, and a lane past the wire span still belongs to its pin. */
+    const boundTo = new Map();
     const groupExtents = new Map();
     for (const gname of groupNames) {
-        groupExtents.set(gname, labelExtents(instances.filter((i) => i.part.group === gname && !i.sym.isPower).map((i) => i.key)));
+        // The estimate reserves a label's width beside every pin that might take
+        // one; the drawing seldom uses a tenth of it. A round that has seen the
+        // drawing reserves what its box actually grew past its cells, plus a
+        // unit.
+        const m = reachMeasured?.get(gname);
+        const e = m ? { left: m.left + U, right: m.right + U } : labelExtents(instances.filter((i) => i.part.group === gname && !i.sym.isPower).map((i) => i.key));
+        const r = reserves.get(gname);
+        groupExtents.set(gname, { left: e.left + (r?.left ?? 0), right: e.right + (r?.right ?? 0) });
     }
     /**
      * Place every group's cells. `bandBudgetW` caps a single group's width, in
@@ -594,23 +1061,83 @@ export function draftSchematicPlacement(validated, projectName, today) {
                     }
                 }
             }
-            for (let iter = 0; iter < members.length; iter++) {
-                let changed = false;
+            // The IC leads its group. Edges above are stored refdes-ordered, and
+            // C, D, J, L, Q and R all sort before U, so plain propagation pushed
+            // every IC to the deepest column on the right with its passives strung
+            // out to its left — a reader looked for the part the group is about and
+            // found it last. When a group has ICs (three or more pins, not a
+            // connector), they anchor the first column after the connectors and
+            // every other member sits at its signal-net hop distance from the
+            // nearest IC; a member no signal path reaches stays beside the ICs.
+            // A group with no IC keeps the edge propagation, where the connector
+            // column is the only anchor there is.
+            // A transistor is a three-pin part, but it is not what a group is
+            // about: it belongs at the end of the run that drives its base, the way
+            // a hand-drawn sheet puts a level shifter or a switch right on the pin.
+            const groupIC = (key) => instByKey.get(key).sym.pins.length >= 3 && !isConnector(instByKey.get(key).part) && !isTransistor(key);
+            const anchors = members.filter((m) => groupIC(m.key)).map((m) => m.key);
+            if (anchors.length) {
+                // IC to IC, the signal flow still propagates (a chain of forty
+                // stages is forty columns, not one), refdes-ordered as before
+                const icSet = new Set(anchors);
+                for (let iter = 0; iter < anchors.length; iter++) {
+                    let changed = false;
+                    for (const e of edges) {
+                        if (!icSet.has(e.from) || !icSet.has(e.to))
+                            continue;
+                        const want = depth.get(e.from) + 1;
+                        if (depth.get(e.to) < want) {
+                            depth.set(e.to, want);
+                            changed = true;
+                        }
+                    }
+                    if (!changed)
+                        break;
+                }
+                // then every other member at its hop distance past the nearest IC,
+                // never routing through a connector or another IC
+                const adj = new Map();
                 for (const e of edges) {
-                    const want = (depth.get(e.from) ?? 0) + 1;
-                    if ((depth.get(e.to) ?? 0) < want && want <= members.length) {
-                        depth.set(e.to, want);
-                        changed = true;
+                    adj.set(e.from, [...(adj.get(e.from) ?? []), e.to]);
+                    adj.set(e.to, [...(adj.get(e.to) ?? []), e.from]);
+                }
+                const dist = new Map(anchors.map((k) => [k, depth.get(k)]));
+                const queue = [...anchors].sort((a, b) => dist.get(a) - dist.get(b));
+                while (queue.length) {
+                    const k = queue.shift();
+                    for (const o of adj.get(k) ?? []) {
+                        if (dist.has(o) || isConnector(instByKey.get(o).part))
+                            continue;
+                        dist.set(o, dist.get(k) + 1);
+                        queue.push(o);
                     }
                 }
-                if (!changed)
-                    break;
+                for (const [k, d] of dist)
+                    if (!icSet.has(k))
+                        depth.set(k, d);
+            }
+            else {
+                for (let iter = 0; iter < members.length; iter++) {
+                    let changed = false;
+                    for (const e of edges) {
+                        const want = (depth.get(e.from) ?? 0) + 1;
+                        if ((depth.get(e.to) ?? 0) < want && want <= members.length) {
+                            depth.set(e.to, want);
+                            changed = true;
+                        }
+                    }
+                    if (!changed)
+                        break;
+                }
             }
             const depths = [...new Set([...depth.values()])].sort((a, b) => a - b);
             const columns = depths.map((d) => members.filter((m) => depth.get(m.key) === d).map((m) => m.key));
-            // barycenter row ordering (two sweeps), refdes as the deterministic tie
+            // barycenter row ordering (two sweeps), refdes as the deterministic
+            // tie; an IC stays at the top of its column so the group reads from
+            // its top-left corner
             const rowOf = new Map();
-            columns.forEach((col) => col.sort((a, b) => a.localeCompare(b, undefined, { numeric: true })).forEach((r, i) => rowOf.set(r, i)));
+            const lead = (ref) => (groupIC(ref) ? 0 : 1);
+            columns.forEach((col) => col.sort((a, b) => lead(a) - lead(b) || a.localeCompare(b, undefined, { numeric: true })).forEach((r, i) => rowOf.set(r, i)));
             for (let sweep = 0; sweep < 2; sweep++) {
                 for (let ci = 1; ci < columns.length; ci++) {
                     const col = columns[ci];
@@ -623,33 +1150,760 @@ export function draftSchematicPlacement(validated, projectName, today) {
                             return rowOf.get(ref);
                         return neigh.reduce((s, o) => s + rowOf.get(o), 0) / neigh.length;
                     };
-                    col.sort((a, b) => bary(a) - bary(b) || a.localeCompare(b, undefined, { numeric: true })).forEach((r, i) => rowOf.set(r, i));
+                    col.sort((a, b) => lead(a) - lead(b) || bary(a) - bary(b) || a.localeCompare(b, undefined, { numeric: true })).forEach((r, i) => rowOf.set(r, i));
                 }
             }
             // cells: sized from body plus margins, positions snapped to the grid
             const cellDims = new Map();
             for (const m of members) {
                 const b = bodyBoundsOf(m.sym);
+                const mo = measured?.get(m.key);
+                if (mo) {
+                    // the cell is what the previous round drew around this body, a pad
+                    // past it on every side: the body sits at shelfL + MARGIN from the
+                    // cell's left edge and topPad + MARGIN from its top
+                    const shelfL = Math.max(0, ceilU(mo.left) + MEASURE_PAD - MARGIN);
+                    const shelfR = Math.max(0, ceilU(mo.right) + MEASURE_PAD - MARGIN);
+                    const topPad = Math.max(0, ceilU(mo.top) + MEASURE_PAD - VMARGIN);
+                    const below = Math.max(VMARGIN, ceilU(mo.bottom) + MEASURE_PAD);
+                    cellDims.set(m.key, {
+                        w: shelfL + MARGIN + ceilU(b.maxX - b.minX) + MARGIN + shelfR,
+                        h: topPad + VMARGIN + ceilU(b.maxY - b.minY) + below,
+                        body: b,
+                        shelfL,
+                        shelfR,
+                        topPad,
+                    });
+                    continue;
+                }
+                // a rail or ground on a pin facing up or down draws a stub, a bar and
+                // a name past the body: that pin's side reserves the symbol's reach
+                const powered = (dy) => m.sym.pins.some((p) => outward(p).dy === dy && netByEndpoint.has(`${m.ref}.${p.number}`) && (netClasses.get(netByEndpoint.get(`${m.ref}.${p.number}`).name)?.cls ?? 'signal') !== 'signal');
+                const topReach = powered(-1) ? POWER_REACH : 0;
+                const botReach = powered(1) ? POWER_REACH : 0;
                 cellDims.set(m.key, {
                     w: ceilU(b.maxX - b.minX) + 2 * MARGIN,
-                    h: ceilU(b.maxY - b.minY) + 2 * MARGIN,
+                    h: Math.max(0, topReach - VMARGIN) + VMARGIN + ceilU(b.maxY - b.minY) + VMARGIN + Math.max(0, botReach - VMARGIN),
                     body: b,
+                    shelfL: 0,
+                    shelfR: 0,
+                    topPad: Math.max(0, topReach - VMARGIN),
                 });
             }
+            const hangs = [];
+            const inlines = [];
+            const hungKeys = new Set();
+            for (const [k, v] of boundTo)
+                if (groupOf.get(k) === gname)
+                    boundTo.delete(k), void v;
+            /**
+             * The rotation (0, 90, 180, 270) that turns two-lead part `key` so that
+             * pin `nearPin` faces direction `want` (schematic dx/dy) and its other
+             * lead faces the opposite way; null when the part is not a two-lead
+             * part with opposed leads. This is what lets a diode, LED, fuse or
+             * switch (horizontal leads in the library) hang like a resistor, and a
+             * resistor lie along a row like a diode.
+             */
+            /** A test point: one pin, probing the net it sits on. It hangs beside that net's pin. */
+            const isTestPoint = (key) => {
+                const inst = instByKey.get(key);
+                return !!inst && inst.sym.pins.length === 1 && (/TestPoint/i.test(inst.part.libId) || /^TP\d/.test(inst.ref));
+            };
+            const orientFor = (key, nearPin, want) => {
+                const pins = instByKey.get(key)?.sym.pins ?? [];
+                if (pins.length !== 2 && !isTestPoint(key))
+                    return null;
+                for (const rot of [0, 90, 180, 270]) {
+                    const rs = rotatedSym(instByKey.get(key).sym, rot);
+                    const near = rs.pins.find((p) => p.number === nearPin);
+                    if (!near)
+                        return null;
+                    const on = outward(near);
+                    if (on.dx !== want.dx || on.dy !== want.dy)
+                        continue;
+                    if (pins.length === 1)
+                        return rot;
+                    const other = rs.pins.find((p) => p.number !== nearPin);
+                    const oo = outward(other);
+                    if (oo.dx === -want.dx && oo.dy === -want.dy)
+                        return rot;
+                }
+                return null;
+            };
+            /** Both leads of a two-lead part, un-rotated; a test point's one pin twice. */
+            const leadsOf = (key) => {
+                const pins = instByKey.get(key)?.sym.pins ?? [];
+                if (isTestPoint(key))
+                    return { a: pins[0], b: pins[0] };
+                if (pins.length !== 2)
+                    return null;
+                const oa = outward(pins[0]);
+                const ob = outward(pins[1]);
+                if (oa.dx !== -ob.dx || oa.dy !== -ob.dy)
+                    return null; // leads must oppose
+                return { a: pins[0], b: pins[1] };
+            };
+            const hangable = (key) => memberKeySet.has(key) &&
+                !decapOwner.has(key) &&
+                !hungKeys.has(key) &&
+                !isConnector(instByKey.get(key).part) &&
+                !/crystal|reson/i.test(instByKey.get(key)?.part.libId ?? '') &&
+                leadsOf(key) !== null;
+            /** Lead span along the hang or run, mm: connection point to connection
+             * point, or for a test point the body's reach past its one pin. */
+            const spanOf = (key, rot = 0) => {
+                const ctl = controlPinOf(key);
+                if (ctl) {
+                    const b = bodyBoundsOf(instByKey.get(key).sym);
+                    return Math.max(b.maxX - ctl.x, ctl.x - b.minX);
+                }
+                const l = leadsOf(key);
+                if (isTestPoint(key)) {
+                    const rs = rotatedSym(instByKey.get(key).sym, rot);
+                    const pin = rs.pins[0];
+                    const b = bodyBoundsOf(rs);
+                    const o = outward(pin);
+                    // the body lies opposite the pin's outward direction
+                    return o.dy !== 0 ? Math.max(0, o.dy === 1 ? b.maxY - pin.y : pin.y - b.minY) : Math.max(0, o.dx === 1 ? pin.x - b.minX : b.maxX - pin.x);
+                }
+                return Math.hypot(l.a.x - l.b.x, l.a.y - l.b.y);
+            };
+            const INLINE_GAP = 4 * U;
+            /**
+             * Claim a hang from IC pin `pin` starting at `first` (an endpoint of the
+             * pin's net). `dir` 1 hangs down from the row, -1 rises above it; the
+             * chain continues through two-endpoint links to a rail, a ground or a
+             * tapped node. The part is turned so its near lead faces the row.
+             */
+            const claimHang = (icKey, pin, dx, first, dir) => {
+                const chain = [first.key];
+                const nearPins = [first.pin];
+                hungKeys.add(first.key);
+                boundTo.set(first.key, icKey);
+                let ends = 'open';
+                for (;;) {
+                    const cur = chain[chain.length - 1];
+                    if (isTestPoint(cur))
+                        break;
+                    const l = leadsOf(cur);
+                    const near = nearPins[nearPins.length - 1];
+                    const far = l.a.number === near ? l.b : l.a;
+                    const beyond = netByEndpoint.get(`${instByKey.get(cur).ref}.${far.number}`);
+                    if (!beyond)
+                        break;
+                    if ((netClasses.get(beyond.name)?.cls ?? 'signal') !== 'signal') {
+                        ends = 'power';
+                        break;
+                    }
+                    if (beyond.pins.length !== 2)
+                        break;
+                    const next = beyond.pins.map(epKey).find((e) => e !== null && e.key !== cur);
+                    if (!next || !hangable(next.key) || chain.includes(next.key))
+                        break;
+                    chain.push(next.key);
+                    nearPins.push(next.pin);
+                    hungKeys.add(next.key);
+                    boundTo.set(next.key, icKey);
+                }
+                let h = 0;
+                let w = 0;
+                for (const key of chain) {
+                    const inst = instByKey.get(key);
+                    // turned to hang: the body's extent across the axis and its span along it
+                    const rotH = orientFor(key, nearPins[chain.indexOf(key)], { dx: 0, dy: -dir }) ?? 0;
+                    const rs = rotatedSym(inst.sym, rotH);
+                    const b = bodyBoundsOf(rs);
+                    h += spanOf(key, rotH) + HANG_GAP;
+                    // a hung part is narrow: its body, the reference and value
+                    // beside it, and a unit of air — not the column cell's margins
+                    const fieldW = Math.max(inst.ref.length + 1, inst.part.value.length) * TEXT_RESERVE * LABEL_HEIGHT + 1.27;
+                    w = Math.max(w, b.maxX - b.minX + fieldW + U);
+                }
+                if (ends === 'power')
+                    h += HANG_POWER_END;
+                hangs.push({ ic: icKey, pin, dx, dir, chain, slot: 0, straight: false, w, h, ends });
+                hangNearPins.set(chain.join('+'), nearPins);
+            };
+            const hangNearPins = new Map();
+            const placedOffset = new Set();
+            /**
+             * Claim a series run along the row from IC pin `pin`: `first` lies on
+             * the row with its near lead toward the IC, and the run continues
+             * through two-endpoint links while the next part is a two-lead part.
+             * The far end gets whatever the wire pass gives it: a wire to a
+             * connector on the row, or a label.
+             */
+            /** Gap before a part on a row: room for the wired net's name above the wire, at least one plain gap. */
+            const gapFor = (netName) => Math.max(INLINE_GAP, grid(ceilU(Math.max(1, netName.length) * TEXT_RESERVE * LABEL_HEIGHT + 2 * U)));
+            const claimInline = (icKey, pin, dx, first) => {
+                const pinNet = netByEndpoint.get(`${instByKey.get(icKey).ref}.${pin.number}`)?.name ?? '';
+                const chain = [{ key: first.key, nearPin: first.pin, gap: gapFor(pinNet) }];
+                hungKeys.add(first.key);
+                boundTo.set(first.key, icKey);
+                let farNet = null;
+                for (let n = 0; n < 3; n++) {
+                    const cur = chain[chain.length - 1];
+                    if (isTransistor(cur.key)) {
+                        farNet = null; // the run ends in the transistor; its other pins take what the wire pass gives
+                        break;
+                    }
+                    const l = leadsOf(cur.key);
+                    const far = l.a.number === cur.nearPin ? l.b : l.a;
+                    const beyond = netByEndpoint.get(`${instByKey.get(cur.key).ref}.${far.number}`);
+                    farNet = beyond?.name ?? null;
+                    if (!beyond || beyond.pins.length !== 2)
+                        break;
+                    const next = beyond.pins.map(epKey).find((e) => e !== null && e.key !== cur.key);
+                    if (!next || chain.some((c) => c.key === next.key))
+                        break;
+                    // a series resistor into a base or gate: the transistor ends the run,
+                    // turned so that pin faces the part that drives it
+                    if (isTransistor(next.key)) {
+                        if (!memberKeySet.has(next.key) || hungKeys.has(next.key) || controlPinOf(next.key).number !== next.pin)
+                            break;
+                        chain.push({ key: next.key, nearPin: next.pin, gap: gapFor(beyond.name) });
+                        hungKeys.add(next.key);
+                        boundTo.set(next.key, icKey);
+                        farNet = null;
+                        break;
+                    }
+                    if (!hangable(next.key))
+                        break;
+                    chain.push({ key: next.key, nearPin: next.pin, gap: gapFor(beyond.name) });
+                    hungKeys.add(next.key);
+                    boundTo.set(next.key, icKey);
+                }
+                let len = 0;
+                for (const c of chain)
+                    len += c.gap + spanOf(c.key);
+                // room for the label the far end may carry
+                if (farNet)
+                    len += STUB * U + Math.max(1, farNet.length) * TEXT_RESERVE * LABEL_HEIGHT;
+                inlines.push({ ic: icKey, pin, dx, chain, len, farNet, offset: 0 });
+            };
+            const epKey = (ep) => {
+                const m = /^([^.]+)\.(.+)$/.exec(ep);
+                return m ? { key: instKeyOf(m[1], m[2]), pin: m[2] } : null;
+            };
+            // Three units, not four: a hung part's near stub ends one unit past
+            // the gap, and pins sit two units apart, so an even gap parks that
+            // stub end exactly on the neighbouring pin's row, where any run along
+            // that row would join it (every single pull-up beside a pull-down on
+            // the next pin was refused for this). An odd gap keeps it between rows.
+            const HANG_GAP = 3 * U;
+            /**
+             * How far the labels on one side of an anchor actually reach, given
+             * what has been claimed on it: a pin whose parts hang carries no stub
+             * label any more, only its run's name (and only when the net has
+             * endpoints elsewhere), so the lanes may start that much closer to the
+             * IC. `labelExtents` assumes a stub label on every pin and put the
+             * lanes 15 mm further out than the drawing needed.
+             */
+            const sideReach = (icKey, dx) => {
+                const ic = instByKey.get(icKey);
+                let reach = 0;
+                for (const pin of ic.sym.pins) {
+                    if (outward(pin).dx !== dx)
+                        continue;
+                    const net = netByEndpoint.get(`${ic.ref}.${pin.number}`);
+                    if (!net)
+                        continue;
+                    const nameW = Math.max(1, net.name.length) * TEXT_RESERVE * LABEL_HEIGHT;
+                    if ((netClasses.get(net.name)?.cls ?? 'signal') !== 'signal') {
+                        reach = Math.max(reach, (STUB + 2) * U + 1.905 + nameW);
+                        continue;
+                    }
+                    const eps = net.pins.map(epKey);
+                    const claimed = eps.some((e) => e !== null && boundTo.get(e.key) === icKey);
+                    const elsewhere = eps.some((e) => e === null || (e.key !== icKey && !memberKeySet.has(e.key) && !decapOwner.has(e.key)));
+                    if (claimed)
+                        reach = Math.max(reach, elsewhere ? nameW + FLAG_PAD + U : STUB * U);
+                    else
+                        reach = Math.max(reach, STUB * U + nameW + FLAG_PAD);
+                }
+                return reach;
+            };
+            const HANG_POWER_END = 5 * U;
+            /** Rows a power symbol and its name need past a pin: stub, bar, text. */
+            const POWER_CLEAR_ROWS = 6;
+            // Parts hang on ICs first, then on connectors and switches: a fuse
+            // rises from the jack's pin, a button's pull-up, debounce cap and ESD
+            // diode hang on the switch's signal pin. A switch already hung on an
+            // IC pin (a reset button dropping from EN) anchors nothing itself.
+            const claimAnchors = [
+                ...anchors,
+                ...members.filter((m) => !anchors.includes(m.key) && (isConnector(m.part) || isSwitch(m.key))).map((m) => m.key),
+            ];
+            for (const icKey of claimAnchors) {
+                if (hungKeys.has(icKey))
+                    continue;
+                const ic = instByKey.get(icKey);
+                const sidePins = ic.sym.pins
+                    .filter((p) => outward(p).dx !== 0)
+                    .sort((a, b) => b.y - a.y || a.x - b.x); // top row first (symbol y is up)
+                for (const pin of sidePins) {
+                    const dx = outward(pin).dx;
+                    const net = netByEndpoint.get(`${ic.ref}.${pin.number}`);
+                    if (!net || (netClasses.get(net.name)?.cls ?? 'signal') !== 'signal')
+                        continue;
+                    // the wire pass draws this net only if it stays in the group with
+                    // few endpoints; a net that will be labelled anyway gives no hang
+                    const eps = net.pins.map(epKey).filter((e) => e !== null);
+                    // A net that leaves the group or carries more endpoints than the
+                    // wire pass joins still hangs its local parts: the pull-up on a
+                    // fault line that also goes to the MCU, the RC on a button the
+                    // MCU reads. The wire pass joins the pin and its hung parts as
+                    // one local run and labels it once for the rest of the net
+                    // (esp32-amp shipped fourteen such parts as labelled islands).
+                    if (eps.length > MAX_WIRED_ENDPOINTS)
+                        trace(`${ic.ref}.${pin.number} ${net.name}: ${eps.length} endpoints, local parts still hang`);
+                    // a crystal's load caps belong to the flanking idiom below
+                    if (eps.some((e) => /crystal|reson/i.test(instByKey.get(e.key)?.part.libId ?? '')))
+                        continue;
+                    // the chain enters the first part through whichever lead is on the
+                    // pin's net: through the top lead it hangs DOWN from the row,
+                    // through the bottom lead it rises above it (the pull-up shape)
+                    // every hangable endpoint of the pin's net hangs, each as its own
+                    // chain: a compensation network is a series RC AND a shunt C on
+                    // one pin, and leaving the shunt in a far column keeps the whole
+                    // net past wire span, labelled
+                    /** The net on the lead of `key` that is NOT `nearPin`. */
+                    const farNetOf = (key, nearPin) => {
+                        const l = leadsOf(key);
+                        const far = l.a.number === nearPin ? l.b : l.a;
+                        return netByEndpoint.get(`${instByKey.get(key).ref}.${far.number}`);
+                    };
+                    /** Bridges from this pin to another pin of the IC, resolved after the pin's other parts. */
+                    const pinBridges = [];
+                    for (const first of eps) {
+                        if (first.key === icKey)
+                            continue;
+                        // a transistor driven straight from the pin lies on the row, base to the pin
+                        if (isTransistor(first.key) && memberKeySet.has(first.key) && !hungKeys.has(first.key) && controlPinOf(first.key).number === first.pin) {
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(first.key).ref} lies on the row (transistor)`);
+                            claimInline(icKey, pin, dx, first);
+                            continue;
+                        }
+                        if (!hangable(first.key)) {
+                            const why = !memberKeySet.has(first.key) ? 'not a group member' : decapOwner.has(first.key) ? 'a decoupling cap' : hungKeys.has(first.key) ? 'already claimed' : isConnector(instByKey.get(first.key).part) ? 'a connector' : leadsOf(first.key) === null ? 'not a two-lead part' : 'a crystal';
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(first.key).ref} not hangable (${why})`);
+                            continue;
+                        }
+                        // a test point rises above the row of the pin it probes
+                        if (isTestPoint(first.key)) {
+                            claimHang(icKey, pin, dx, first, -1);
+                            continue;
+                        }
+                        // Look to the END of the run this part starts, through two-endpoint
+                        // links: a run that ends on a rail or ground is a SHUNT and hangs
+                        // from the row — rising to a rail (a pull-up), dropping to ground
+                        // (a pull-down, a filter cap, a series RC to ground). A run whose
+                        // far net returns to a pin of this IC BRIDGES the two pins and
+                        // hangs toward the other pin's row so that net stays within wire
+                        // span (a bootstrap cap between BST and OUT). Everything else is
+                        // a SERIES element — a 100 Ω in an I2S line, an output inductor —
+                        // and lies along the row, away from the IC, the way the reference
+                        // sheet draws it.
+                        let cur = first;
+                        let farNet = farNetOf(cur.key, cur.pin);
+                        const seen = new Set([first.key]);
+                        for (let n = 0; n < 4 && farNet && (netClasses.get(farNet.name)?.cls ?? 'signal') === 'signal' && farNet.pins.length === 2; n++) {
+                            const next = farNet.pins.map(epKey).find((e) => e !== null && e.key !== cur.key);
+                            if (!next || !hangable(next.key) || seen.has(next.key))
+                                break;
+                            seen.add(next.key);
+                            cur = next;
+                            farNet = farNetOf(cur.key, cur.pin);
+                        }
+                        const farCls = farNet ? (netClasses.get(farNet.name)?.cls ?? 'signal') : null;
+                        // A bridge (the far net returns to another pin of this IC) lies
+                        // on the row of the pin that has NOTHING ELSE on it: claimed
+                        // from the busier pin it blocked that pin's row, and the series
+                        // part behind it could not be wired (esp32-amp's C28 on OUT_LN
+                        // left L3 a labelled island while C27 on BST_AP let L2 wire).
+                        const bridgeEp = cur.key === first.key && farNet && farCls === 'signal' && farNet.pins.length === 2
+                            ? farNet.pins.find((ep) => ep.startsWith(`${ic.ref}.`) && ep !== `${ic.ref}.${pin.number}`)
+                            : undefined;
+                        const otherPin = bridgeEp ? ic.sym.pins.find((p) => `${ic.ref}.${p.number}` === bridgeEp) : undefined;
+                        if (otherPin) {
+                            const others = eps.filter((e) => e.key !== icKey && e.key !== first.key && (hangable(e.key) || boundTo.get(e.key) === icKey));
+                            pinBridges.push({ first, otherPin, othersOnPin: others.length > 0 });
+                            continue;
+                        }
+                        // A part between two pins of this IC (a bootstrap cap between
+                        // BST and OUT) lies along its row too: hung, its far lead
+                        // landed rows away from the other pin and that pin's branch ran
+                        // along a third row under a label. On the row, the far net
+                        // reaches the other pin's row through the router's trunk.
+                        // A bridge to another pin of this IC (a bootstrap cap between BST
+                        // and SW) hangs in a lane toward that pin's row, its far lead
+                        // joined to that row by one short jog: laid along the row it sat
+                        // past every lane and every series part, and the bank under the
+                        // group followed the row out (rails 112 mm wide, 91 by hand).
+                        if (farCls === 'ground') {
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(first.key).ref} hangs down (to ${farNet.name})`);
+                            claimHang(icKey, pin, dx, first, 1);
+                        }
+                        else if (farCls === 'rail') {
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(first.key).ref} rises (to ${farNet.name})`);
+                            claimHang(icKey, pin, dx, first, -1);
+                        }
+                        else {
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(first.key).ref} lies on the row (far net ${farNet?.name ?? 'none'})`);
+                            claimInline(icKey, pin, dx, first);
+                        }
+                    }
+                    // A bridge cap (BST to SW) hangs in the lane this pin already has,
+                    // toward the other pin's row, when the pin has a hang to share the
+                    // lane with (the buck's L1 rising from SW): one axis, one T, and the
+                    // other row reaches the cap's far lead with a single jog. With no
+                    // lane of its own to join it stays on the row (hung alone it cost
+                    // four attachments on the amplifier's four bootstrap pairs); and it
+                    // is left to the other pin when this pin carries series parts and
+                    // that pin carries nothing else.
+                    const pinHasHang = hangs.some((hg) => hg.ic === icKey && hg.pin.number === pin.number);
+                    for (const b of pinBridges) {
+                        if (hungKeys.has(b.first.key))
+                            continue;
+                        if (pinHasHang) {
+                            const dir = b.otherPin.y < pin.y ? 1 : -1; // symbol y is up: a lower pin means dropping
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(b.first.key).ref} bridges to ${ic.ref}.${b.otherPin.number}; shares the pin's lane, ${dir === 1 ? 'down' : 'up'}`);
+                            claimHang(icKey, pin, dx, b.first, dir);
+                        }
+                        else if (b.othersOnPin) {
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(b.first.key).ref} bridges to ${ic.ref}.${b.otherPin.number}; left for that pin`);
+                        }
+                        else {
+                            trace(`${ic.ref}.${pin.number} ${net.name}: ${instByKey.get(b.first.key).ref} bridges to ${ic.ref}.${b.otherPin.number}; lies on the row`);
+                            claimInline(icKey, pin, dx, b.first);
+                        }
+                    }
+                }
+                // Slots per side. A hang whose rows are free of every other pin on
+                // that side stays dead straight on its stub axis (AC-16.31: the wire
+                // from the pin continues into the chain with no bend); the rest take
+                // the first shelf slot whose rows are free. Rows are relative to the
+                // IC origin, y down; symbol pin y is up.
+                for (const dx of [-1, 1]) {
+                    const side = hangs.filter((hg) => hg.ic === icKey && hg.dx === dx);
+                    const inlineSide = inlines.filter((il) => il.ic === icKey && il.dx === dx);
+                    // Two horizontal parts on rows one pitch apart cannot share an x
+                    // range: a run on a row next to an earlier run starts past that
+                    // run's end (the reference sheet's output filter alternates the
+                    // inductor and the cap across its rows for the same reason).
+                    // a part lying on a row carries its reference above and its value
+                    // below, so its texts reach the neighbouring rows: runs within
+                    // three rows of each other stagger (two left C27's value under L3's
+                    // reference)
+                    const ROWS_NEAR = 3 * 2.54 + 0.01;
+                    for (const il of [...inlineSide].sort((a, b) => b.pin.y - a.pin.y)) {
+                        let offset = 0;
+                        for (;;) {
+                            const clash = inlineSide.find((o) => o !== il && o.offset !== undefined && placedOffset.has(o) && Math.abs(o.pin.y - il.pin.y) <= ROWS_NEAR && offset < o.offset + o.len && offset + il.len > o.offset);
+                            if (!clash)
+                                break;
+                            offset = clash.offset + clash.len + INLINE_GAP;
+                        }
+                        il.offset = offset;
+                        placedOffset.add(il);
+                    }
+                    if (!side.length && !inlineSide.length)
+                        continue;
+                    // any connected neighbour blocks the straight axis: a signal pin's
+                    // stub end sits on it, and a rail or ground pin's longer stub
+                    // crosses it — legal, but a wire through the IC's supply stubs is
+                    // exactly the crossing a drafter moves a part to avoid (the Tier C
+                    // divider drew two of them). A no-connect neighbour blocks nothing.
+                    const sidePinYs = ic.sym.pins
+                        .filter((p) => outward(p).dx === dx && netByEndpoint.has(`${ic.ref}.${p.number}`))
+                        .map((p) => -p.y);
+                    const pitch = Math.max(0, ...side.map((hg) => hg.w)) + U;
+                    const slots = [];
+                    let anyShelved = false;
+                    // Slot order matters: a lower pin's branch runs along its row from
+                    // the stub to its chain's axis, and a chain hanging down from a
+                    // higher pin must not cross that row inside the branch's span. So
+                    // down-hangs take slots from the lowest pin upward and up-hangs from
+                    // the highest pin downward: the chain that passes other pins' rows
+                    // is always the outer one, and every branch stays clear of every
+                    // sibling's stub end (esp32-amp's RT branch ran into the COMP
+                    // hang's stub end the first time).
+                    // Slots go to PINS, not hangs: a part rising and a part dropping
+                    // from one pin share one axis — the divider on its pin — and meet
+                    // the row in a single T. A slot's occupied range runs from the pin
+                    // ROW to the chain end, because the branch along the row belongs
+                    // to it: measured from the first part instead, a chain rising from
+                    // a lower pin shared its slot with the higher pin's drop and the
+                    // two axes met on that pin's row (esp32-amp's USB_OV divider was
+                    // refused for exactly that, four hangs on two adjacent pins).
+                    // One axis carries at most one chain up and one chain down; a
+                    // third chain on the same pin (the NTC divider's cap beside its
+                    // thermistor) takes the next lane out, and each lane is slotted as
+                    // its own group.
+                    const byPin = new Map();
+                    for (const hg of side)
+                        byPin.set(hg.pin.number, [...(byPin.get(hg.pin.number) ?? []), hg]);
+                    const pinRow = (g) => -g[0].pin.y;
+                    const pinGroups = [];
+                    for (const hgs of byPin.values()) {
+                        const ups = hgs.filter((hg) => hg.dir === -1);
+                        const downs = hgs.filter((hg) => hg.dir === 1);
+                        for (let i = 0; i < Math.max(ups.length, downs.length); i++) {
+                            const lane = [ups[i], downs[i]].filter((hg) => hg !== undefined);
+                            pinGroups.push(lane);
+                        }
+                    }
+                    const ordered = [
+                        ...pinGroups.filter((g) => g.some((hg) => hg.dir === 1)).sort((a, b) => pinRow(b) - pinRow(a)),
+                        ...pinGroups.filter((g) => g.every((hg) => hg.dir === -1)).sort((a, b) => pinRow(a) - pinRow(b)),
+                    ];
+                    const lowRowAll = Math.max(...side.map((hg) => -hg.pin.y));
+                    const highRowAll = Math.min(...side.map((hg) => -hg.pin.y));
+                    for (const g of ordered) {
+                        const rowY = pinRow(g);
+                        const top = Math.min(rowY, ...g.map((hg) => (hg.dir === -1 ? highRowAll - HANG_GAP - hg.h : rowY)));
+                        const bot = Math.max(rowY, ...g.map((hg) => (hg.dir === 1 ? lowRowAll + HANG_GAP + hg.h : rowY)));
+                        // the clearance check pads the axis range by four units past the
+                        // pin row and the chain end, so a neighbour that close blocks it
+                        // the same five units (four of pad plus one) the clearance check
+                        // itself applies, else a neighbour exactly at the edge passes here
+                        // and refuses there (J1's fuse against the CC1 pin two rows down)
+                        const straight = !sidePinYs.some((y) => y !== rowY && y > top - 5 * U && y < bot + 5 * U);
+                        for (const hg of g)
+                            hg.straight = straight;
+                        if (straight)
+                            continue;
+                        anyShelved = true;
+                        let k = 0;
+                        while ((slots[k] ?? []).some((iv) => top < iv.bot + 2 * U && bot > iv.top - 2 * U))
+                            k++;
+                        (slots[k] ??= []).push({ top, bot });
+                        for (const hg of g)
+                            hg.slot = k;
+                    }
+                    const dims = cellDims.get(icKey);
+                    const ext = labelExtents([icKey]);
+                    // Lanes come first, past the side's labels; the inline runs start
+                    // beyond the lanes. A part lying on the row between the stub and
+                    // the lanes blocked the row for the pin's own hung parts (Q1 on
+                    // VBUS_FET_EN left R17 unreachable), and a run on another row
+                    // starting inside the lanes crossed their bodies.
+                    const laneReach = sideReach(icKey, dx);
+                    void ext;
+                    const lanesW = anyShelved ? slots.length * pitch : 0;
+                    for (const il of inlineSide)
+                        il.offset += anyShelved ? ceilU(laneReach + 2 * U) * U + lanesW : 0;
+                    const inlineW = Math.max(0, ...inlineSide.map((il) => il.offset + il.len));
+                    // shelf: the IC's own labels, the stub, the lanes, then the runs. A
+                    // straight hang sits within the stub and the cell's own margin and
+                    // channel, so a side whose hangs are all straight and carries no
+                    // inline run reserves nothing (a five-part board went from A5 to A4
+                    // when it did).
+                    const shelf = anyShelved ? ceilU(laneReach + STUB * U) + 2 + Math.ceil(lanesW / U) + (inlineSide.length ? ceilU(inlineW - lanesW - laneReach) : 0) : inlineSide.length ? ceilU(inlineW + STUB * U) + 2 : 0;
+                    if (!measured?.has(icKey)) {
+                        if (dx === 1)
+                            dims.shelfR = shelf;
+                        else
+                            dims.shelfL = shelf;
+                        dims.w += shelf;
+                    }
+                    // y-down relative to the IC origin: the body spans -maxY..-minY
+                    const lowRow = Math.max(...side.map((hg) => -hg.pin.y));
+                    const highRow = Math.min(...side.map((hg) => -hg.pin.y));
+                    const deepest = Math.max(-dims.body.minY, ...side.map((hg) => (hg.dir === 1 ? (hg.straight ? -hg.pin.y : lowRow) + HANG_GAP + hg.h : -hg.pin.y)), ...inlineSide.map((il) => -il.pin.y + 3 * U));
+                    // what this side uses below the body's top, and how far its labels
+                    // reach: the shelf below that is free for the infill pass
+                    const laneDepth = Math.max(-dims.body.maxY, ...side.map((hg) => (hg.dir === 1 ? (hg.straight ? -hg.pin.y : lowRow) + HANG_GAP + hg.h : -hg.pin.y)), ...inlineSide.map((il) => -il.pin.y + 3 * U));
+                    const usedBelow = ceilU(laneDepth - -dims.body.maxY) + 2;
+                    if (dx === 1) {
+                        dims.usedR = usedBelow;
+                        dims.reachR = ceilU(laneReach + 2 * U);
+                    }
+                    else {
+                        dims.usedL = usedBelow;
+                        dims.reachL = ceilU(laneReach + 2 * U);
+                    }
+                    const highest = Math.min(-dims.body.maxY, ...side.map((hg) => (hg.dir === -1 ? (hg.straight ? -hg.pin.y : highRow) - HANG_GAP - hg.h : -hg.pin.y)));
+                    // an inline run lies on its row; a transistor at its end reaches two
+                    // rows above and below it (collector and emitter stubs)
+                    for (const il of inlineSide) {
+                        for (const c of il.chain) {
+                            if (!controlPinOf(c.key))
+                                continue;
+                            const b = bodyBoundsOf(instByKey.get(c.key).sym);
+                            const reach = Math.max(b.maxY, -b.minY) + STUB * U + POWER_CLEAR_ROWS * U;
+                            if (measured?.has(icKey))
+                                continue;
+                            dims.topPad = Math.max(dims.topPad, ceilU(-dims.body.maxY - (-il.pin.y - reach)));
+                            dims.h = Math.max(dims.h, ceilU(Math.max(deepest, -il.pin.y + reach) - Math.min(highest, -il.pin.y - reach)) + VMARGIN + 2);
+                        }
+                    }
+                    if (!measured?.has(icKey)) {
+                        dims.topPad = Math.max(dims.topPad, ceilU(-dims.body.maxY - highest));
+                        // the chain's end already carries the symbol's own room; two
+                        // units of air below it, not a full margin (a button block's cell
+                        // was 39 mm tall where a drafter draws it on a 25 mm pitch)
+                        dims.h = Math.max(dims.h, ceilU(deepest - highest) + VMARGIN + 2);
+                    }
+                }
+            }
+            // Node hangs: the far end of a series run is a node too. An RC filter's
+            // cap, a button's debounce cap and ESD diode sit on the net PAST the
+            // series resistor, so they hang from the run's last part, dropping or
+            // rising from the row just beyond its far lead, the first straight down
+            // from the row's end and the rest on lanes past it.
+            const nodeAnchors = new Set();
+            for (const il of [...inlines]) {
+                const last = il.chain[il.chain.length - 1];
+                if (isTransistor(last.key))
+                    continue;
+                const l = leadsOf(last.key);
+                const farPin = l.a.number === last.nearPin ? l.b : l.a;
+                const farNet = netByEndpoint.get(`${instByKey.get(last.key).ref}.${farPin.number}`);
+                if (!farNet || (netClasses.get(farNet.name)?.cls ?? 'signal') !== 'signal')
+                    continue;
+                const eps = farNet.pins.map(epKey).filter((e) => e !== null);
+                let lanes = 0;
+                for (const first of eps) {
+                    if (first.key === last.key || !hangable(first.key))
+                        continue;
+                    const fl = leadsOf(first.key);
+                    const far = fl.a.number === first.pin ? fl.b : fl.a;
+                    const beyond = netByEndpoint.get(`${instByKey.get(first.key).ref}.${far.number}`);
+                    const cls = beyond ? (netClasses.get(beyond.name)?.cls ?? 'signal') : null;
+                    if (cls !== 'ground' && cls !== 'rail')
+                        continue; // only shunts; a second series part is a network
+                    trace(`${instByKey.get(last.key).ref}.${farPin.number} ${farNet.name} (node): ${instByKey.get(first.key).ref} ${cls === 'ground' ? 'hangs down' : 'rises'}`);
+                    claimHang(last.key, farPin, il.dx, first, cls === 'ground' ? 1 : -1);
+                    const hg = hangs[hangs.length - 1];
+                    hg.slot = lanes;
+                    hg.straight = lanes === 0;
+                    lanes++;
+                    nodeAnchors.add(last.key);
+                }
+                if (!lanes)
+                    continue;
+                // the run's owner reserves the lanes and the drop below them
+                const nodeHangs = hangs.filter((hg) => hg.ic === last.key);
+                const pitch = Math.max(0, ...nodeHangs.map((hg) => hg.w)) + U;
+                const add = (lanes - 1) * pitch + 2 * U + Math.max(0, ...nodeHangs.map((hg) => hg.w)) / 2;
+                il.len += add;
+                const dims = cellDims.get(il.ic);
+                if (measured?.has(il.ic))
+                    continue;
+                if (il.dx === 1)
+                    dims.shelfR += ceilU(add);
+                else
+                    dims.shelfL += ceilU(add);
+                dims.w += ceilU(add);
+                const rowRel = -il.pin.y;
+                const hDown = Math.max(0, ...nodeHangs.filter((hg) => hg.dir === 1).map((hg) => hg.h));
+                const hUp = Math.max(0, ...nodeHangs.filter((hg) => hg.dir === -1).map((hg) => hg.h));
+                const bottom = Math.max(-dims.body.minY, rowRel + HANG_GAP + hDown);
+                const top = Math.min(-dims.body.maxY, rowRel - HANG_GAP - hUp);
+                dims.topPad = Math.max(dims.topPad, ceilU(-dims.body.maxY - top));
+                dims.h = Math.max(dims.h, ceilU(bottom - top) + VMARGIN + 2);
+            }
+            void nodeAnchors;
+            for (const col of columns) {
+                for (let i = col.length - 1; i >= 0; i--)
+                    if (hungKeys.has(col[i]))
+                        col.splice(i, 1);
+            }
+            for (let i = columns.length - 1; i >= 0; i--)
+                if (!columns[i].length)
+                    columns.splice(i, 1);
+            // The budget must leave room for the label TEXT facing the sheet edges:
+            // a band filled to the full usable width puts the leftmost column's
+            // left-facing labels outside the frame (#220 phase 1), and no later
+            // shift can fix both edges at once.
+            const ext = groupExtents.get(gname);
+            const bandW = Math.max(1, bandBudgetW - ceilU(ext.left) - ceilU(ext.right));
+            // Height the decoupling bank adds UNDER the columns once they span
+            // `blockW` units: the same row-wrap the bank placement below performs.
+            const bankHeight = (blockW) => {
+                if (!caps.length)
+                    return 0;
+                const capBudget = Math.min(bandW, Math.max(64, blockW));
+                let rows = 1;
+                let x = 0;
+                for (const c of caps) {
+                    const b = bodyBoundsOf(c.sym);
+                    const w = ceilU(b.maxX - b.minX) + 2 * MARGIN;
+                    if (x > 0 && x + w > capBudget) {
+                        rows++;
+                        x = 0;
+                    }
+                    x += w;
+                }
+                return MARGIN + 4 + rows * (2 * MARGIN + 6);
+            };
             // Column height budget (#220 phase 4): a depth whose parts stack taller
             // than the budget splits into several side-by-side columns, in row
             // order, so a 24-part board stops drafting as one full-height strip on
             // a sheet two sizes too large. Cells never shrink; only the arrangement
             // changes, so readability is untouched.
-            const columnsToPlace = colBudgetH === Infinity
-                ? columns
-                : columns.flatMap((col) => {
+            //
+            // The bank sits under the columns and counts against the SAME budget:
+            // a group whose columns already fit the budget got no shorter under the
+            // compaction retries while its bulk-cap rows pushed the group past the
+            // sheet (a 30-part power-input group missed A1 by 8 mm that way). The
+            // bank's rows are estimated at the columns' pre-split width — a lower
+            // bound on the width they end up with, so an upper bound on rows.
+            const colsW = columns.reduce((s, col) => s + Math.max(...col.map((r) => cellDims.get(r).w)), 0) +
+                CHANNEL * Math.max(0, columns.length - 1);
+            const sheetBudget = colBudgetH === Infinity ? Infinity : Math.max(1, colBudgetH - bankHeight(colsW));
+            // ---------- in-group column balance ----------
+            // A depth whose parts stack into one strip draws the group as a tall
+            // thin column beside a short IC with the rest of the box empty: an
+            // amplifier group put 20 filter caps in one 500 mm column next to a
+            // 120 mm IC, and the box was two-thirds air. A drafter runs such parts
+            // in several columns no taller than the IC they serve. So every column
+            // is budgeted at the taller of the group's tallest IC cell and the side
+            // of the square the group's cells would fill, and one taller than that
+            // splits into equal-height side-by-side columns. The IC's CELL, not its
+            // column: a transistor or an eFuse sharing a column with eight
+            // resistors must not make that strip the reference height. Row order
+            // is preserved chunk by chunk, exactly as the sheet budget splits, so
+            // barycenter ordering and the trunk idioms are untouched.
+            const colH = (col) => col.reduce((s, r, i) => s + cellDims.get(r).h + (i ? ROW_GAP : 0), 0);
+            const isIC = (key) => instByKey.get(key).sym.pins.length >= 3;
+            const anchorH = Math.max(0, ...members.filter((m) => isIC(m.key)).map((m) => cellDims.get(m.key).h));
+            const cellArea = columns.reduce((s, c) => s + colH(c) * Math.max(...c.map((r) => cellDims.get(r).w)), 0);
+            const squareSide = Math.ceil(Math.sqrt(cellArea));
+            // Under a band budget the group is shaped to FILL the band's width, not
+            // to be square: a column of eight test points re-rows into two of four
+            // and the button blocks stack three deep, the grid a person draws when
+            // the group must sit in a 250 mm column (esp32-amp's UI group went
+            // from 364 × 150 to the width of its neighbours).
+            // A group with no IC to lead it (buttons, test points, LEDs) has no
+            // natural shape, and its columns line up as a strip five blocks wide;
+            // shape it no wider than two and a half times its square side, the grid
+            // a person draws. Groups led by an IC keep the IC's own proportions.
+            const shapeToAspect = anchors.length === 0;
+            const aspectBand = Math.ceil(2.5 * squareSide);
+            const searchBand = shapeToAspect ? Math.min(aspectBand, bandW) : bandW;
+            const targetH = shapeToAspect
+                ? Math.max(Math.ceil(cellArea / searchBand), Math.ceil(squareSide / 2))
+                : bandBudgetW === Infinity
+                    ? squareSide
+                    : Math.max(Math.ceil(cellArea / bandBudgetW), Math.ceil(squareSide / 2));
+            const balanceH = Math.max(anchorH, targetH);
+            /** Split `col` into the fewest equal-height chunks that each fit
+             * `budget`; a single cell never splits, and a column shorter than
+             * `minCells` is left alone (a drafter does not re-row three parts). */
+            const splitColumn = (col, budget, minCells = 1) => {
+                const total = colH(col);
+                if (total <= budget || col.length < minCells)
+                    return [col];
+                const k = Math.ceil(total / budget);
+                const fill = (cap) => {
                     const chunks = [];
                     let cur = [];
                     let h = 0;
                     for (const ref of col) {
                         const add = cellDims.get(ref).h + (cur.length ? ROW_GAP : 0);
-                        if (cur.length && h + add > colBudgetH) {
+                        if (cur.length && h + add > cap) {
                             chunks.push(cur);
                             cur = [ref];
                             h = cellDims.get(ref).h;
@@ -662,20 +1916,134 @@ export function draftSchematicPlacement(validated, projectName, today) {
                     if (cur.length)
                         chunks.push(cur);
                     return chunks;
-                });
+                };
+                // Balanced chunks first, for the look of level columns: the split of
+                // the column into k consecutive chunks that minimises the tallest
+                // chunk (a greedy fill to an equal target fell 7-1 on eight test
+                // points of two heights, and 2-2-1 on five equal cells). If even
+                // that tallest chunk is over the budget, fill to the budget instead.
+                const hs = col.map((ref) => cellDims.get(ref).h);
+                const n = hs.length;
+                const runH = (i, j) => hs.slice(i, j + 1).reduce((a, b) => a + b, 0) + ROW_GAP * (j - i);
+                const bestMax = Array.from({ length: k + 1 }, () => new Array(n + 1).fill(Infinity));
+                const cutAt = Array.from({ length: k + 1 }, () => new Array(n + 1).fill(0));
+                bestMax[0][0] = 0;
+                for (let parts = 1; parts <= k; parts++) {
+                    for (let j = 1; j <= n; j++) {
+                        for (let i = parts - 1; i < j; i++) {
+                            const v = Math.max(bestMax[parts - 1][i], runH(i, j - 1));
+                            if (v < bestMax[parts][j]) {
+                                bestMax[parts][j] = v;
+                                cutAt[parts][j] = i;
+                            }
+                        }
+                    }
+                }
+                if (bestMax[k][n] > budget)
+                    return fill(budget);
+                const chunks = [];
+                for (let parts = k, j = n; parts >= 1; parts--) {
+                    const i = cutAt[parts][j];
+                    chunks.unshift(col.slice(i, j));
+                    j = i;
+                }
+                return chunks;
+            };
+            const BALANCE_MIN_CELLS = 4;
+            // Under a band budget, the lowest column height at which the group's
+            // columns fit the band side by side in ONE band wins: shorter columns
+            // mean more of them and a group that wraps onto bands anyway, taller
+            // ones a group that fills the band's width in one pass (five button
+            // blocks as two columns of three beside two columns of test points).
+            let chosenH = balanceH;
+            if (bandBudgetW !== Infinity || shapeToAspect) {
+                const widthAt = (h) => {
+                    const cols = columns.flatMap((col) => splitColumn(col, h, BALANCE_MIN_CELLS));
+                    // the same channel and facing-label widening the placement below applies
+                    return cols.reduce((sum, c, i) => {
+                        const next = cols[i + 1];
+                        return sum + Math.max(...c.map((r) => cellDims.get(r).w)) + (next ? CHANNEL + widenBy(labelExtents(c).right, labelExtents(next).left, 2 * MARGIN + CHANNEL) : 0);
+                    }, 0);
+                };
+                // against the band the columns actually get (the budget less the
+                // group's own label reserves), not the raw budget
+                const ceiling = Math.max(balanceH, ...columns.map(colH));
+                for (let h = balanceH; h <= ceiling; h += 2) {
+                    if (widthAt(h) <= searchBand) {
+                        chosenH = h;
+                        break;
+                    }
+                }
+                if (widthAt(chosenH) > searchBand)
+                    chosenH = shapeToAspect ? balanceH : ceiling;
+            }
+            let columnsToPlace = columns.flatMap((col) => splitColumn(col, chosenH, BALANCE_MIN_CELLS).flatMap((c) => (sheetBudget === Infinity ? [c] : splitColumn(c, sheetBudget))));
+            // Shelf infill. An IC's side shelf is as deep as its tallest lane, but
+            // the lanes hang from the top pins and the shelf below them is empty;
+            // small cells from later columns move into that room (the USB ESD
+            // array under the UART bridge's transistor runs, where the hand-laid
+            // sheet keeps it), and the column they leave narrows or disappears.
+            const infill = new Map();
+            for (let ci = 0; ci < columnsToPlace.length; ci++) {
+                for (const host of columnsToPlace[ci]) {
+                    const d = cellDims.get(host);
+                    for (const side of [1, -1]) {
+                        const shelf = side === 1 ? d.shelfR : d.shelfL;
+                        const used = side === 1 ? d.usedR : d.usedL;
+                        const reach = side === 1 ? d.reachR ?? 0 : d.reachL ?? 0;
+                        if (!shelf || used === undefined)
+                            continue;
+                        const freeW = shelf - reach - 1;
+                        let top = d.topPad + VMARGIN + used;
+                        let freeH = d.h - top - 1;
+                        trace(`infill room: ${instByKey.get(host).ref} ${side === 1 ? 'right' : 'left'} shelf ${shelf}u reach ${reach}u used ${used}u -> free ${freeW}x${freeH}u`);
+                        if (freeW < 8 || freeH < 8)
+                            continue;
+                        // candidates from every other column, later ones first; a cell
+                        // leaving the host's own column shortens it
+                        const order = [...columnsToPlace.keys()].sort((a, b) => (a > ci ? 0 : a === ci ? 1 : 2) - (b > ci ? 0 : b === ci ? 1 : 2) || a - b);
+                        for (const cj of order) {
+                            if (freeH < 8)
+                                break;
+                            const col = columnsToPlace[cj];
+                            for (let k = col.length - 1; k >= 0 && freeH >= 8; k--) {
+                                const cand = col[k];
+                                if (cand === host)
+                                    continue;
+                                // connectors keep the left column (the reader looks for them
+                                // there); anchors and anything with lanes of its own stay put
+                                // only a substantial part (four pins or more: an ESD array, a
+                                // level shifter) is worth tucking away; scattering test points
+                                // and LEDs into shelves reads as clutter, not economy
+                                const cinst = instByKey.get(cand);
+                                if (isConnector(cinst.part) || cinst.sym.pins.length < 4)
+                                    continue;
+                                const cd = cellDims.get(cand);
+                                if (cd.shelfL || cd.shelfR || cd.w > freeW || cd.h > freeH)
+                                    continue;
+                                infill.set(host, [...(infill.get(host) ?? []), { key: cand, side, relY: top }]);
+                                col.splice(k, 1);
+                                trace(`infill: ${instByKey.get(cand).ref} moves under the ${side === 1 ? 'right' : 'left'} shelf of ${instByKey.get(host).ref}`);
+                                top += cd.h + ROW_GAP;
+                                freeH -= cd.h + ROW_GAP;
+                            }
+                        }
+                    }
+                }
+            }
+            columnsToPlace = columnsToPlace.filter((c) => c.length);
+            const hostGeom = new Map();
+            trace(`group "${gname}" columns (band ${bandBudgetW === Infinity ? 'inf' : bandBudgetW}u, col budget ${colBudgetH === Infinity ? 'inf' : colBudgetH}u, balance ${balanceH}u chosen ${chosenH}u): ${columnsToPlace.map((c) => `[${c.map((k) => `${instByKey.get(k).ref}:${cellDims.get(k).w}x${cellDims.get(k).h}`).join(' ')}]`).join(' ')}`);
             let colX = groupX;
             let groupMaxY = 0;
             let bandTop = 0; // y origin (units) of the current band of columns
             let bandCount = 1;
-            // The budget must leave room for the label TEXT facing the sheet edges:
-            // a band filled to the full usable width puts the leftmost column's
-            // left-facing labels outside the frame (#220 phase 1), and no later
-            // shift can fix both edges at once.
-            const ext = groupExtents.get(gname);
-            const bandW = Math.max(1, bandBudgetW - ceilU(ext.left) - ceilU(ext.right));
             for (let ci = 0; ci < columnsToPlace.length; ci++) {
                 const col = columnsToPlace[ci];
                 const colW = Math.max(...col.map((r) => cellDims.get(r).w));
+                const colShelfL = Math.max(...col.map((r) => cellDims.get(r).shelfL));
+                const colShelfR = Math.max(...col.map((r) => cellDims.get(r).shelfR));
+                const colCoreW = Math.max(...col.map((r) => cellDims.get(r).w - cellDims.get(r).shelfL - cellDims.get(r).shelfR));
                 // Banding (#219): a column that would tile past the width budget starts
                 // a new band of columns below everything placed so far, the way the
                 // shelf-wrap below re-rows whole groups. Never before the first column
@@ -689,9 +2057,14 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 let rowY = bandTop;
                 for (const ref of col) {
                     const dims = cellDims.get(ref);
-                    const cx = colX + Math.floor(colW / 2); // shared column axis (units)
-                    const cy = rowY + Math.floor(dims.h / 2);
+                    // shared column axis (units): the core span between the shelves a
+                    // hung IC reserves beside itself
+                    const cx = colX + colShelfL + Math.floor((colW - colShelfL - colShelfR - Math.max(0, colW - colShelfL - colShelfR - colCoreW)) / 2);
                     const b = dims.body;
+                    // the body sits at the top of its cell, under the room any up-hang
+                    // needs; a cell with nothing hung is body plus margins, so this is
+                    // its centre as before
+                    const cy = rowY + dims.topPad + VMARGIN + Math.floor(ceilU(b.maxY - b.minY) / 2);
                     // origin so the body centers on the cell center, snapped to grid
                     const ox = grid(cx - Math.round((b.minX + b.maxX) / 2 / U));
                     const oy = grid(cy + Math.round((b.minY + b.maxY) / 2 / U));
@@ -706,7 +2079,10 @@ export function draftSchematicPlacement(validated, projectName, today) {
                         body: { minX: ox + b.minX, minY: oy - b.maxY, maxX: ox + b.maxX, maxY: oy - b.minY },
                         cellW: dims.w,
                         cellH: dims.h,
+                        rot: 0,
                     });
+                    if (infill.has(ref))
+                        hostGeom.set(ref, { colX, colW, colShelfR, rowY });
                     rowY += dims.h + ROW_GAP;
                 }
                 groupMaxY = Math.max(groupMaxY, rowY - ROW_GAP);
@@ -714,7 +2090,20 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 colX += colW + CHANNEL + (next ? widenBy(labelExtents(col).right, labelExtents(next).left, 2 * MARGIN + CHANNEL) : 0);
             }
             // decoupling rows: caps in a uniform row under their owner (or the group)
-            const capRefs = caps.map((c) => c.key).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+            // by rail first, then by reference: caps of one rail sit side by side
+            // and share one trunk and one pair of symbols (sorted by reference
+            // alone, a +5V cap numbered after the +3V3 caps stood apart with its
+            // own two symbols)
+            const railOf = (key) => {
+                const inst = instByKey.get(key);
+                for (const p of inst.sym.pins) {
+                    const n = netByEndpoint.get(`${inst.ref}.${p.number}`);
+                    if (n && (netClasses.get(n.name)?.cls ?? 'signal') === 'rail')
+                        return n.name;
+                }
+                return '';
+            };
+            const capRefs = caps.map((c) => c.key).sort((a, b) => railOf(a).localeCompare(railOf(b)) || a.localeCompare(b, undefined, { numeric: true }));
             if (capRefs.length) {
                 // The bank stacks under the circuit at the circuit's own width, the
                 // way a hand-drawn sheet does — a 45-cap ribbon run out to the band
@@ -722,34 +2111,98 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 // it deserved (#233). The floor keeps a short bank (four typical cap
                 // cells) on one row even when the circuit above it is narrower.
                 const blockW = Math.max(64, colX - groupX);
-                const capBudget = Math.min(bandW, blockW);
+                let capBudget = Math.min(bandW, blockW);
+                // Under a height budget the bank is part of the group's height too:
+                // when its rows at the circuit's width would run past the budget,
+                // widen the bank — only as far as the rows need, never past the
+                // band — instead of letting it decide the sheet on its own.
+                if (colBudgetH !== Infinity) {
+                    const capWidths = capRefs.map((ref) => {
+                        const b = bodyBoundsOf(instByKey.get(ref).sym);
+                        return ceilU(b.maxX - b.minX) + 2 * MARGIN;
+                    });
+                    const rowsAt = (budget) => {
+                        let rows = 1;
+                        let x = 0;
+                        for (const w of capWidths) {
+                            if (x > 0 && x + w > budget) {
+                                rows++;
+                                x = 0;
+                            }
+                            x += w;
+                        }
+                        return rows;
+                    };
+                    const rowsAllowed = Math.max(1, Math.floor((colBudgetH - groupMaxY - (MARGIN + 4)) / (2 * MARGIN + 6)));
+                    if (rowsAt(capBudget) > rowsAllowed) {
+                        const total = capWidths.reduce((a, b) => a + b, 0);
+                        capBudget = Math.min(bandW, Math.max(capBudget, Math.ceil(total / rowsAllowed) + Math.max(...capWidths)));
+                    }
+                }
                 let capX = groupX;
                 let capY = groupMaxY + MARGIN + 4;
+                let bankRowH = 2 * MARGIN + 6;
+                // A bank member with horizontal leads (a TVS diode drawn lying down)
+                // stands up like the caps beside it, its rail lead on top; lying in
+                // the row it carried its ground symbol sideways under the next cap's
+                // name. Each member is turned, and measured, by its own leads.
+                const bankRotOf = (ref) => {
+                    const inst = instByKey.get(ref);
+                    if (inst.sym.pins.length !== 2 || !inst.sym.pins.every((p) => outward(p).dx !== 0))
+                        return 0;
+                    const railPin = inst.sym.pins.find((p) => (netClasses.get(netByEndpoint.get(`${inst.ref}.${p.number}`)?.name ?? '')?.cls ?? 'signal') === 'rail') ?? inst.sym.pins[0];
+                    return orientFor(ref, railPin.number, { dx: 0, dy: -1 }) ?? 90;
+                };
                 for (const ref of capRefs) {
                     const inst = instByKey.get(ref);
-                    const b = bodyBoundsOf(inst.sym);
+                    const rot = bankRotOf(ref);
+                    const sym = rotatedSym(inst.sym, rot);
+                    const b = bodyBoundsOf(sym);
+                    // a measured cap takes the room its drawing needed (its own fields,
+                    // the rail bar and name above, the ground below), plus the pad
+                    const mo = measured?.get(ref);
+                    const capW = mo ? ceilU(mo.left) + ceilU(b.maxX - b.minX) + ceilU(mo.right) + 2 * MEASURE_PAD : ceilU(b.maxX - b.minX) + 2 * MARGIN;
+                    const capLeft = mo ? ceilU(mo.left) + MEASURE_PAD : MARGIN;
+                    const capTop = mo ? ceilU(mo.top) + MEASURE_PAD : MARGIN;
+                    const capRowH = mo ? capTop + ceilU(b.maxY - b.minY) + ceilU(mo.bottom) + MEASURE_PAD : 2 * MARGIN + 6;
+                    bankRowH = Math.max(bankRowH, capRowH);
                     // Banding (#219): a decoupling bank wider than the budget wraps onto
-                    // another uniform row rather than running past the frame.
-                    if (capX > groupX && capX + ceilU(b.maxX - b.minX) + 2 * MARGIN - groupX > capBudget) {
+                    // another uniform row rather than running past the frame; and it
+                    // wraps BEFORE a rail whose caps would not all fit the row, so one
+                    // rail's caps stay on one trunk (PVDD's pair split across two rows
+                    // left the second cap with its own two symbols).
+                    const railStart = capRefs.indexOf(ref) === 0 || railOf(capRefs[capRefs.indexOf(ref) - 1]) !== railOf(ref);
+                    let railRunW = 0;
+                    if (railStart) {
+                        for (let k = capRefs.indexOf(ref); k < capRefs.length && railOf(capRefs[k]) === railOf(ref); k++) {
+                            const kb = bodyBoundsOf(rotatedSym(instByKey.get(capRefs[k]).sym, bankRotOf(capRefs[k])));
+                            const km = measured?.get(capRefs[k]);
+                            railRunW += km ? ceilU(km.left) + ceilU(kb.maxX - kb.minX) + ceilU(km.right) + 2 * MEASURE_PAD : ceilU(kb.maxX - kb.minX) + 2 * MARGIN;
+                        }
+                    }
+                    const needW = railStart && railRunW <= capBudget ? railRunW : capW;
+                    if (capX > groupX && capX + needW - groupX > capBudget) {
                         capX = groupX;
-                        capY += 2 * MARGIN + 6;
+                        capY += bankRowH;
+                        bankRowH = capRowH;
                     }
-                    const ox = grid(capX + MARGIN);
-                    const oy = grid(capY + MARGIN);
+                    const ox = mo ? grid(capX + capLeft - Math.floor(b.minX / U)) : grid(capX + MARGIN);
+                    const oy = mo ? grid(capY + capTop + Math.ceil(b.maxY / U)) : grid(capY + MARGIN);
                     placed.set(ref, {
                         part: inst.part,
                         refDes: inst.ref,
                         unit: inst.unit,
-                        sym: inst.sym,
+                        sym,
                         x: ox,
                         y: oy,
                         body: { minX: ox + b.minX, minY: oy - b.maxY, maxX: ox + b.maxX, maxY: oy - b.minY },
-                        cellW: ceilU(b.maxX - b.minX) + 2 * MARGIN,
-                        cellH: ceilU(b.maxY - b.minY) + 2 * MARGIN,
+                        cellW: capW,
+                        cellH: capRowH,
+                        rot,
                     });
-                    capX += ceilU(b.maxX - b.minX) + 2 * MARGIN;
+                    capX += capW;
                 }
-                groupMaxY = capY + 2 * MARGIN + 6;
+                groupMaxY = capY + bankRowH;
             }
             // ---------- idiom micro-templates and the alignment pass (7.5/7.5a) ----------
             // Column placement is correct but reads machine-made for the small
@@ -800,6 +2253,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
                     body: { minX: ox + b.minX, minY: oy - b.maxY, maxX: ox + b.maxX, maxY: oy - b.minY },
                     cellW: prev.cellW,
                     cellH: prev.cellH,
+                    rot: prev.rot,
                 };
             };
             /** Apply candidate moves unless any moved body lands within a grid unit of
@@ -852,8 +2306,10 @@ export function draftSchematicPlacement(validated, projectName, today) {
                         const end = { x: p.x + o.dx * len * U, y: p.y + o.dy * len * U };
                         if (!ownEps.has(ep)) {
                             for (const q of [p, end]) {
-                                if (sameCoord(q.x, axisX) && q.y > yMin - U && q.y < yMax + U)
+                                if (sameCoord(q.x, axisX) && q.y > yMin - U && q.y < yMax + U) {
+                                    trace(`axis x=${axisX} blocked by ${ep} (${net.name}) at y=${q.y}`);
                                     return false;
+                                }
                             }
                         }
                         // A horizontal stub SEGMENT crossing the axis exactly at a chain
@@ -871,8 +2327,10 @@ export function draftSchematicPlacement(validated, projectName, today) {
                             if (row && row.net !== net.name) {
                                 const lo = Math.min(p.x, end.x) - 0.001;
                                 const hi = Math.max(p.x, end.x) + 0.001;
-                                if (axisX >= lo && axisX <= hi)
+                                if (axisX >= lo && axisX <= hi) {
+                                    trace(`axis x=${axisX} crossed by the stub of ${ep} (${net.name}) on a ${row.net} row`);
                                     return false;
+                                }
                             }
                         }
                     }
@@ -880,7 +2338,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 return true;
             };
             /** The room a rail/ground end grows past its pin: stub, bar, value text. */
-            const POWER_CLEAR = 8 * U;
+            const POWER_CLEAR = 5 * U;
             const powerEndBox = (axisX, pinY, dir) => ({
                 minX: axisX - 3 * U,
                 maxX: axisX + 3 * U,
@@ -890,8 +2348,8 @@ export function draftSchematicPlacement(validated, projectName, today) {
             /** Clearance-check a chain (or flank) move set against its axis and its
              * power-end growth, then apply; marks the parts idiom-placed only when
              * everything held. */
-            const finalizeMoves = (segments, moves, clearBoxes = []) => {
-                const own = ownEndpoints(moves.keys());
+            const finalizeMoves = (segments, moves, clearBoxes = [], ownOverride) => {
+                const own = ownOverride ?? ownEndpoints(moves.keys());
                 const movedRefs = new Set(moves.keys());
                 for (const seg of segments) {
                     // the pad covers the power stub and symbol a rail/ground end grows
@@ -905,8 +2363,10 @@ export function draftSchematicPlacement(validated, projectName, today) {
                     for (const [oref, op] of placed) {
                         if (moves.has(oref))
                             continue;
-                        if (padOverlap(box, op.body, 0))
+                        if (padOverlap(box, op.body, 0)) {
+                            trace(`power end at x=${(box.minX + box.maxX) / 2} would sit on ${oref}`);
                             return false;
+                        }
                     }
                 }
                 if (!applyMoves(moves))
@@ -956,10 +2416,224 @@ export function draftSchematicPlacement(validated, projectName, today) {
                     segments.push({ axisX, ys: [at.y, cand.y - v.bot.y] });
                     clearBoxes.push(powerEndBox(axisX, cand.y - v.bot.y, 1)); // the ground symbol below the cap
                 }
-                // all-or-nothing per crystal: one dropped cap and one column cap would
-                // read worse than the plain columns the pass is improving on
-                if (moves.size)
-                    finalizeMoves(segments, moves, clearBoxes);
+                // all-or-nothing per crystal: one dropped cap and one column cap would
+                // read worse than the plain columns the pass is improving on
+                if (moves.size)
+                    finalizeMoves(segments, moves, clearBoxes);
+            }
+            // Pin-anchored hangs claimed above: each chain drops from its pin's row
+            // into its shelf slot. Slot 0 sits past the IC's labels on that side,
+            // so the wire pass draws pin, stub, a short branch and the chain's
+            // stub as one local route; deeper slots stagger outward. A hang the
+            // clearance check refuses goes to the leftover column at the group's
+            // right edge, never on top of something.
+            const leftovers = [];
+            const placeInfill = () => {
+                for (const [host, cells] of infill) {
+                    const g = hostGeom.get(host);
+                    const d = cellDims.get(host);
+                    if (!g)
+                        continue;
+                    for (const f of cells) {
+                        const cd = cellDims.get(f.key);
+                        const fb = cd.body;
+                        const x0 = f.side === 1 ? g.colX + g.colW - g.colShelfR + (d.reachR ?? 0) : g.colX + 1;
+                        const fcx = x0 + Math.floor(cd.w / 2);
+                        const fcy = g.rowY + f.relY + Math.floor(cd.h / 2);
+                        const fox = grid(fcx - Math.round((fb.minX + fb.maxX) / 2 / U));
+                        const foy = grid(fcy + Math.round((fb.minY + fb.maxY) / 2 / U));
+                        placed.set(f.key, placeCell(f.key, fox, foy));
+                    }
+                }
+            };
+            const placeCell = (key, ox, oy, rot = 0, mirror) => {
+                const inst = instByKey.get(key);
+                const dims = cellDims.get(key);
+                const sym = transformSym(inst.sym, rot, mirror);
+                const b = bodyBoundsOf(sym);
+                return {
+                    part: inst.part,
+                    refDes: inst.ref,
+                    unit: inst.unit,
+                    sym,
+                    x: ox,
+                    y: oy,
+                    body: { minX: ox + b.minX, minY: oy - b.maxY, maxX: ox + b.maxX, maxY: oy - b.minY },
+                    cellW: dims.w,
+                    cellH: dims.h,
+                    rot,
+                    ...(mirror ? { mirror } : {}),
+                };
+            };
+            placeInfill();
+            // Inline runs: each part lies on its pin's row with its near lead
+            // toward the IC, one gap past the stub, the next part one gap on. The
+            // wire pass then draws pin, stub, gap and lead as one straight line.
+            for (const il of inlines) {
+                const icPl = placed.get(il.ic);
+                if (!icPl) {
+                    leftovers.push(...il.chain.map((c) => c.key));
+                    continue;
+                }
+                const at = pinAt(icPl, il.pin);
+                const s = { x: at.x + il.dx * STUB * U, y: at.y };
+                const moves = new Map();
+                let cursor = s.x + il.dx * il.offset; // x of the last connection point on the row
+                let ok = true;
+                for (const c of il.chain) {
+                    const ctl = controlPinOf(c.key);
+                    // a transistor keeps collector up and emitter down; it is mirrored,
+                    // never turned, so its base faces the part that drives it
+                    const mirror = ctl ? (outward(ctl).dx === -il.dx ? undefined : 'y') : undefined;
+                    const rot = ctl ? 0 : orientFor(c.key, c.nearPin, { dx: -il.dx, dy: 0 });
+                    if (rot === null) {
+                        ok = false;
+                        break;
+                    }
+                    cursor = cursor + il.dx * c.gap; // the next near lead
+                    const rs = transformSym(instByKey.get(c.key).sym, rot, mirror);
+                    const near = rs.pins.find((pn) => pn.number === c.nearPin);
+                    const ox = grid(Math.round((cursor - near.x) / U));
+                    const oy = grid(Math.round((s.y + near.y) / U));
+                    moves.set(c.key, placeCell(c.key, ox, oy, rot, mirror));
+                    cursor = cursor + il.dx * spanOf(c.key);
+                }
+                if (ok) {
+                    for (const [key, cand] of moves)
+                        placed.set(key, cand);
+                    // no axis to clear: the run's wires are the row itself, which the
+                    // wire pass checks segment by segment; bodies must still fit
+                    if (!finalizeMoves([], moves, [], new Set())) {
+                        for (const key of moves.keys())
+                            placed.delete(key);
+                        ok = false;
+                    }
+                }
+                if (!ok) {
+                    leftovers.push(...il.chain.map((c) => c.key));
+                    for (const c of il.chain)
+                        boundTo.delete(c.key);
+                    const refs = il.chain.map((c) => instByKey.get(c.key).ref).join(', ');
+                    const note = `inline refused: ${refs} could not lie on ${instByKey.get(il.ic).ref}.${il.pin.number}'s row in "${gname}"; drawn in a column instead`;
+                    trace(note);
+                    if (!notes.includes(note))
+                        notes.push(note);
+                }
+            }
+            for (const hg of hangs) {
+                const icPl = placed.get(hg.ic);
+                if (!icPl) {
+                    leftovers.push(...hg.chain);
+                    continue;
+                }
+                // a node anchor is a hung part, placed turned: read its pin as drawn
+                const pinNow = icPl.sym.pins.find((p) => p.number === hg.pin.number) ?? hg.pin;
+                const at = pinAt(icPl, pinNow);
+                const s = { x: at.x + hg.dx * STUB * U, y: at.y };
+                const side = hangs.filter((o) => o.ic === hg.ic && o.dx === hg.dx);
+                const pitch = Math.max(0, ...side.map((o) => o.w)) + U;
+                const ext = labelExtents([hg.ic]);
+                const reach = sideReach(hg.ic, hg.dx);
+                void ext;
+                const firstSlot = grid(Math.round((s.x + hg.dx * (reach + 2 * U + pitch / 2)) / U));
+                const slotX = grid(Math.round((firstSlot + hg.dx * hg.slot * pitch) / U));
+                trace(`hang ${hg.chain.map((k) => instByKey.get(k).ref).join('+')} on ${instByKey.get(hg.ic).ref}.${hg.pin.number}: stub (${s.x}, ${s.y}) reach ${reach.toFixed(2)} pitch ${pitch.toFixed(2)} slot ${hg.slot} -> x ${hg.straight ? s.x : slotX}${hg.straight ? ' (straight)' : ''}`);
+                const netOfHang = (key, pinN) => netByEndpoint.get(`${instByKey.get(key).ref}.${pinN}`)?.name ?? '';
+                let placedOk = false;
+                // dead straight on the stub axis when the pin-neighbour test found
+                // the rows free (AC-16.31), else the reserved shelf slot. Trying the
+                // axis regardless passed the clearance check — a wire may legally
+                // cross a neighbouring rail stub — and drew exactly that crossing
+                // on the Tier C divider, twice.
+                const axes = hg.straight ? [s.x] : [slotX];
+                // Chains on one side start level: drops below the side's lowest hung
+                // pin row, rises above its highest. Started at its own row, a chain
+                // from one pin put its body across the next pin's row, and that
+                // pin's run out to its lane hit the body (U1's FLT pull-up against
+                // the OVLO divider). Level bases turn that into a wire crossing at
+                // worst, and the resistors of a comb line up the way a drafter
+                // lines them up. A straight hang keeps its own row.
+                const sidePinYsAbs = side.map((o) => pinAt(icPl, icPl.sym.pins.find((p) => p.number === o.pin.number) ?? o.pin).y);
+                const baseY = hg.straight ? s.y : hg.dir === 1 ? Math.max(...sidePinYsAbs) : Math.min(...sidePinYsAbs);
+                for (const axisX of axes) {
+                    for (let lift = 0; lift < 3 && !placedOk; lift++) {
+                        // the near lead of the first part sits one gap from the base row,
+                        // and each further part one gap on, away from the IC
+                        let cursor = grid(Math.round((baseY + hg.dir * HANG_GAP) / U)) + hg.dir * lift * 2 * U;
+                        const moves = new Map();
+                        const conn = [{ y: s.y, net: netOfHang(hg.ic, hg.pin.number) }];
+                        const startY = cursor;
+                        const nearPins = hangNearPins.get(hg.chain.join('+'));
+                        for (const [i, key] of hg.chain.entries()) {
+                            // turned so the near lead faces the row (up for a hang that
+                            // drops, down for one that rises) and the far lead points away
+                            const rot = orientFor(key, nearPins[i], { dx: 0, dy: -hg.dir }) ?? 0;
+                            const rs = rotatedSym(instByKey.get(key).sym, rot);
+                            const near = rs.pins.find((pn) => pn.number === nearPins[i]);
+                            const farLead = rs.pins.find((pn) => pn.number !== nearPins[i]) ?? near;
+                            const span = spanOf(key, rot);
+                            moves.set(key, placeCell(key, axisX - near.x, cursor + near.y, rot));
+                            conn.push({ y: cursor, net: netOfHang(key, near.number) }, { y: cursor + hg.dir * span, net: netOfHang(key, farLead.number) });
+                            cursor = cursor + hg.dir * (span + HANG_GAP);
+                        }
+                        const endY = cursor - hg.dir * HANG_GAP;
+                        const clearBoxes = hg.ends === 'power' ? [powerEndBox(axisX, endY, hg.dir)] : [];
+                        const ys = [Math.min(startY, endY, s.y), Math.max(startY, endY, s.y)];
+                        // Only the nets that run ALONG the axis are the chain's own: the
+                        // anchor net and each link between chain parts. The rail or ground
+                        // at the far end is not — a pull-up's rail is also the IC's supply
+                        // pin, and counting it as own let an axis run straight through
+                        // that pin (esp32-amp's BUCK_EN divider on U4's PVDD pin; the
+                        // router refused the wire, so the net shipped labelled).
+                        const axisNets = new Set(conn.map((c) => c.net));
+                        const own = new Set();
+                        for (const net of intent.nets)
+                            if (axisNets.has(net.name))
+                                for (const ep of net.pins)
+                                    own.add(ep);
+                        // the clearance check reads a chain's OWN connection points from the
+                        // placed map; hung parts have no column position, so they go in as
+                        // their candidates first and come out again if the check refuses
+                        for (const [key, cand] of moves)
+                            placed.set(key, cand);
+                        if (finalizeMoves([{ axisX, ys, conn }], moves, clearBoxes, own))
+                            placedOk = true;
+                        else
+                            for (const key of moves.keys())
+                                placed.delete(key);
+                    }
+                    if (placedOk)
+                        break;
+                }
+                if (!placedOk) {
+                    leftovers.push(...hg.chain);
+                    for (const k of hg.chain)
+                        boundTo.delete(k);
+                    const refs = hg.chain.map((k) => instByKey.get(k).ref).join(', ');
+                    const note = `hang refused: ${refs} could not be placed cleanly on ${instByKey.get(hg.ic).ref}.${hg.pin.number} in "${gname}"; drawn in a column instead`;
+                    trace(note);
+                    if (!notes.includes(note))
+                        notes.push(note);
+                }
+            }
+            if (leftovers.length) {
+                // a column of their own past everything the group placed so far
+                let x = Math.max(groupX, ...[...placed.values()].filter((p) => groupOf.get([...placed.entries()].find(([, q]) => q === p)?.[0] ?? '') === gname).map((p) => Math.ceil(p.body.maxX / U) + MARGIN)) + CHANNEL;
+                const colW = Math.max(...leftovers.map((k) => cellDims.get(k).w));
+                let rowY = bandTop;
+                for (const key of leftovers) {
+                    const dims = cellDims.get(key);
+                    const b = dims.body;
+                    const cx = x + Math.floor(colW / 2);
+                    const cy = rowY + Math.floor(dims.h / 2);
+                    const ox = grid(cx - Math.round((b.minX + b.maxX) / 2 / U));
+                    const oy = grid(cy + Math.round((b.minY + b.maxY) / 2 / U));
+                    placed.set(key, placeCell(key, ox, oy));
+                    rowY += dims.h + ROW_GAP;
+                }
+                groupMaxY = Math.max(groupMaxY, rowY - ROW_GAP);
+                colX = x + colW + CHANNEL;
+                void colX;
             }
             const walk = (start, dir, chain) => {
                 let current = start;
@@ -971,14 +2645,22 @@ export function draftSchematicPlacement(validated, projectName, today) {
                         return { kind: 'open' }; // declared no-connect or unused
                     if (classOf(net.name) !== 'signal')
                         return { kind: 'power' };
+                    // a tapped node is not a series link, but it is a fine END: the chain
+                    // stops there and the label that names the node sits on it (R18 over
+                    // Q1's drain, its other end on the four-way USB_EN)
                     if (net.pins.length !== 2)
-                        return { kind: 'invalid' }; // a tapped node is not a series chain
+                        return { kind: 'open' };
                     const otherEp = net.pins.map(parseEp).find((e) => e !== null && e.key !== current);
                     if (!otherEp)
                         return { kind: 'invalid' };
                     const opl = placed.get(otherEp.key);
-                    if (!opl || groupOf.get(otherEp.key) !== gname)
+                    if (!opl)
                         return { kind: 'invalid' };
+                    // the other end lives in another group: this end is open, and the
+                    // label that names the net across the sheet sits on it (an LED's
+                    // resistor driven from the MCU group stacks over its LED here)
+                    if (groupOf.get(otherEp.key) !== gname)
+                        return { kind: 'open' };
                     if (chainable(otherEp.key) && !chain.includes(otherEp.key)) {
                         const ov = vertPins(otherEp.key);
                         // the link must enter through the lead facing the chain, or the
@@ -1003,12 +2685,33 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 if (!chainable(m.key) || chained.has(m.key))
                     continue;
                 const chain = [m.key];
-                const topEnd = walk(m.key, 'up', chain);
-                const bottomEnd = walk(chain[chain.length - 1], 'down', chain);
+                let topEnd = walk(m.key, 'up', chain);
+                let bottomEnd = walk(chain[chain.length - 1], 'down', chain);
                 for (const ref of chain)
                     chained.add(ref);
+                trace(`chain ${chain.map((k) => instByKey.get(k).ref).join('+')}: top ${topEnd.kind} bottom ${bottomEnd.kind}`);
                 if (topEnd.kind === 'invalid' || bottomEnd.kind === 'invalid')
                     continue;
+                // The anchor sits BELOW the chain but meets its top lead (R18's pin 1
+                // on Q1's drain, which faces up): turn every part half a turn so the
+                // lead that meets the anchor is the bottom one, and stack upward.
+                // The reverse case (an anchor above, met by a bottom lead) mirrors it.
+                // A turned chain that is then abandoned below gets its column's
+                // orientation back: `abandon` restores every part the turn replaced.
+                const unturned = new Map();
+                const flip = () => {
+                    for (const key of chain) {
+                        const pl = placed.get(key);
+                        unturned.set(key, pl);
+                        placed.set(key, placeCell(key, pl.x, pl.y, (pl.rot + 180) % 360, pl.mirror));
+                    }
+                    [topEnd, bottomEnd] = [bottomEnd, topEnd];
+                    chain.reverse();
+                };
+                const abandon = () => {
+                    for (const [key, pl] of unturned)
+                        placed.set(key, pl);
+                };
                 if (chain.length > 4)
                     continue; // beyond four parts this is a network, not an idiom
                 const anchors = [topEnd, bottomEnd].filter((e) => e.kind === 'anchor');
@@ -1016,6 +2719,10 @@ export function draftSchematicPlacement(validated, projectName, today) {
                     continue; // a lone floating part has nothing to align to
                 if (topEnd.kind === 'open' && bottomEnd.kind === 'open')
                     continue;
+                if (topEnd.kind === 'anchor' && outward(topEnd.pin).dy === -1 && bottomEnd.kind !== 'anchor')
+                    flip();
+                else if (bottomEnd.kind === 'anchor' && outward(bottomEnd.pin).dy === 1 && topEnd.kind !== 'anchor')
+                    flip();
                 const stubEndOf = (a) => {
                     const at = pinAt(placed.get(a.ref), a.pin);
                     const o = outward(a.pin);
@@ -1026,14 +2733,18 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 let order = chain;
                 if (topEnd.kind === 'anchor') {
                     const s = stubEndOf(topEnd);
-                    if (s.o.dy === -1)
-                        continue; // an up-facing pin cannot feed a downward run
+                    if (s.o.dy === -1) {
+                        abandon(); // an up-facing pin cannot feed a downward run
+                        continue;
+                    }
                     if (bottomEnd.kind === 'anchor') {
                         const b = stubEndOf(bottomEnd);
                         // both ends must sit on one axis with the second anchor below and
                         // able to receive from above, else leave the columns alone
-                        if (!sameCoord(s.x, b.x) || b.y <= s.y || b.o.dy === 1)
+                        if (!sameCoord(s.x, b.x) || b.y <= s.y || b.o.dy === 1) {
+                            abandon();
                             continue;
+                        }
                     }
                     axisX = s.x;
                     cursor = s.y + CHAIN_GAP;
@@ -1041,14 +2752,17 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 else if (bottomEnd.kind === 'anchor') {
                     // rail above, anchor below (a pull-up): stack upward from the anchor
                     const s = stubEndOf(bottomEnd);
-                    if (s.o.dy === 1)
-                        continue; // a down-facing pin cannot feed an upward run
+                    if (s.o.dy === 1) {
+                        abandon(); // a down-facing pin cannot feed an upward run
+                        continue;
+                    }
                     axisX = s.x;
                     order = [...chain].reverse();
                     // Bounded lift: when a connection row would sit on a foreign stub's
                     // crossing (axisClear's segment check), raise the whole stack a grid
                     // row at a time rather than shipping the contact or losing the idiom.
                     const netOf = (key, pinN) => netByEndpoint.get(epOf(key, pinN))?.name ?? '';
+                    let lifted = false;
                     for (let lift = 0; lift < 3; lift++) {
                         let up = s.y - CHAIN_GAP - lift * 2 * U;
                         const moves = new Map();
@@ -1064,9 +2778,13 @@ export function draftSchematicPlacement(validated, projectName, today) {
                         const topY = up + CHAIN_GAP;
                         const topRef = order[order.length - 1];
                         const done = finalizeMoves([{ axisX, ys: [s.y, topY], conn: [...conn, { y: topY, net: netOf(topRef, vertPins(topRef).top.number) }] }], moves, topEnd.kind === 'power' ? [powerEndBox(axisX, topY, -1)] : []);
-                        if (done)
+                        if (done) {
+                            lifted = true;
                             break;
+                        }
                     }
+                    if (!lifted)
+                        abandon();
                     continue;
                 }
                 else {
@@ -1079,6 +2797,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 }
                 const cursor0 = cursor;
                 const netOf2 = (key, pinN) => netByEndpoint.get(epOf(key, pinN))?.name ?? '';
+                let stacked = false;
                 for (let lift = 0; lift < 3; lift++) {
                     cursor = cursor0 + lift * 2 * U;
                     const moves = new Map();
@@ -1109,20 +2828,39 @@ export function draftSchematicPlacement(validated, projectName, today) {
                     const endNet = conn.length ? conn[0].net : '';
                     const startConn = { y: cursor0 - CHAIN_GAP, net: topEnd.kind === 'anchor' ? netOf2(topEnd.ref, topEnd.pin.number) : endNet };
                     const lastConn = { y: axisEndY, net: bottomEnd.kind === 'anchor' ? netOf2(bottomEnd.ref, bottomEnd.pin.number) : (conn.length ? conn[conn.length - 1].net : '') };
-                    if (fits && finalizeMoves([{ axisX, ys: [cursor0 - CHAIN_GAP, axisEndY], conn: [startConn, ...conn, lastConn] }], moves, clearBoxes))
+                    if (fits && finalizeMoves([{ axisX, ys: [cursor0 - CHAIN_GAP, axisEndY], conn: [startConn, ...conn, lastConn] }], moves, clearBoxes)) {
+                        stacked = true;
                         break;
+                    }
                     if (!fits)
                         break; // lifting only shrinks the room below; no retry can help
                 }
+                if (!stacked)
+                    abandon();
             }
             const memberRefs = [...members.map((m) => m.key), ...capRefs];
             const cells = memberRefs.map((r) => placed.get(r));
             if (cells.length) {
                 const minX = Math.min(...cells.map((c) => c.body.minX)) - MARGIN * U;
-                const maxX = Math.max(...cells.map((c) => c.body.maxX)) + MARGIN * U;
-                const minY = Math.min(...cells.map((c) => c.body.minY)) - (MARGIN + 4) * U;
+                // a two-lead part carries its reference and value beside its body;
+                // at the group's right edge that text is what the next group must
+                // clear (the rails bank's "47uF/10V" ran under the amplifier's box)
+                const fieldReach = (c) => c.sym.pins.length <= 2 ? Math.max(c.refDes.length, c.part.value.length) * TEXT_RESERVE * LABEL_HEIGHT + 1.27 : 0;
+                const maxX = Math.max(...cells.map((c) => c.body.maxX + fieldReach(c))) + MARGIN * U;
+                // the top inset holds the caption band (a bold caption at
+                // CAPTION_SIZE, inset 2 mm) above the tallest thing a cell can carry
+                // over its body: a rail symbol on an upward stub with its value text
+                // over it, which with an IC at the top-left corner sat 4.3 mm under
+                // the box edge at six units; CAPTION_BAND keeps the caption's
+                // bottom edge clear of it
+                const minY = Math.min(...cells.map((c) => c.body.minY)) - (MARGIN + CAPTION_BAND) * U;
                 const maxY = Math.max(...cells.map((c) => c.body.maxY)) + (MARGIN + 2) * U;
-                groupRects.push({ name: gname, x1: minX, y1: minY, x2: maxX, y2: maxY });
+                // a measured round already knows how far the box will grow above
+                // and below its cells (caption band, text, power symbols): the rect
+                // carries it so every fit stacks boxes, not cells
+                const reach = reachMeasured?.get(gname);
+                groupRects.push({ name: gname, x1: minX, y1: minY - (reach?.top ?? 0), x2: maxX, y2: maxY + (reach?.bottom ?? 0) });
+                trace(`group "${gname}": rect x ${minX.toFixed(1)}..${maxX.toFixed(1)} y ${minY.toFixed(1)}..${maxY.toFixed(1)} (${cells.length} cells)`);
                 groupX = Math.round(maxX / U) + GROUP_GAP;
                 prevGroup = gname;
                 bandsOf.set(gname, bandCount);
@@ -1147,9 +2885,9 @@ export function draftSchematicPlacement(validated, projectName, today) {
     const hinted = paperHint ? PAPERS.find((p) => p.name === paperHint) : undefined;
     // A hint pins the width budget; otherwise try every sheet, smallest first.
     const candidates = hinted ? [hinted] : PAPERS;
-    const gap = GROUP_GAP * U;
-    const usableW = (p) => p.w - 2 * FRAME;
-    const usableH = (p) => p.h - 2 * FRAME - TITLE_STRIP;
+    const gap = GROUP_GAP * U + wrapGap;
+    const usableW = (p) => p.w - 2 * FRAME - frameSlack;
+    const usableH = (p) => p.h - 2 * FRAME - TITLE_STRIP - frameSlack;
     /**
      * Shelf-wrap the group rects to a width budget; returns per-group offsets.
      *
@@ -1172,22 +2910,286 @@ export function draftSchematicPlacement(validated, projectName, today) {
         let rowLeftExt = leftExtOf(groupRects[0].name);
         let dyUnits = 0;
         let rowH = 0;
-        for (const r of groupRects) {
-            // A group wider than the whole budget still starts its own row; it will
-            // overflow, and the caller rejects this paper for it.
-            if (r.x1 > rowOriginX && r.x2 - rowOriginX + rowLeftExt + rightExtOf(r.name) > budgetW) {
+        // Every box in a row shares the row's top. The single-row pass gives the
+        // boxes different tops when one reserved room above its IC for a
+        // pull-up (esp32-amp's rails box started 16 mm below its neighbours),
+        // and a row height measured box by box then misses that offset, so the
+        // next row landed on the tall box's bottom. Each box moves to the common
+        // top; its height is then its own.
+        const topY = Math.min(...groupRects.map((r) => r.y1));
+        // Rows are consecutive runs of groups (reading order is kept), but WHICH
+        // consecutive runs is chosen to minimise the stack's height, not by
+        // filling each row until the next group no longer fits: first-fit paired
+        // esp32-amp's two tallest groups with two short ones and stacked five
+        // rows where four would do. A group wider than the whole budget still
+        // starts its own row; it will overflow, and the caller rejects this paper
+        // for it.
+        const n = groupRects.length;
+        const heightOf = (r) => r.y2 - r.y1;
+        const runFits = (i, j) => i === j || groupRects[j].x2 - groupRects[i].x1 + leftExtOf(groupRects[i].name) + rightExtOf(groupRects[j].name) <= budgetW;
+        const best = new Array(n + 1).fill(Infinity);
+        const cut = new Array(n + 1).fill(0);
+        best[0] = 0;
+        for (let j = 1; j <= n; j++) {
+            let rowMax = 0;
+            for (let i = j; i >= 1; i--) {
+                rowMax = Math.max(rowMax, heightOf(groupRects[i - 1]));
+                if (!runFits(i - 1, j - 1))
+                    break;
+                const h = best[i - 1] + rowMax + (i > 1 ? gap : 0);
+                if (h < best[j]) {
+                    best[j] = h;
+                    cut[j] = i - 1;
+                }
+            }
+            if (best[j] === Infinity) {
+                // no run ending here fits: the group is its own (overflowing) row
+                best[j] = best[j - 1] + heightOf(groupRects[j - 1]) + (j > 1 ? gap : 0);
+                cut[j] = j - 1;
+            }
+        }
+        const starts = [];
+        for (let j = n; j > 0; j = cut[j])
+            starts.unshift(cut[j]);
+        const rowStart = new Set(starts);
+        if (process.env['COPPERHEAD_DRAFT_TRACE'] === '1') {
+            const rows = [];
+            for (let k = 0; k < starts.length; k++) {
+                const a = starts[k];
+                const b = k + 1 < starts.length ? starts[k + 1] : n;
+                const members = groupRects.slice(a, b);
+                rows.push(`[${members.map((r) => r.name.slice(0, 2).trim()).join('+')} h${Math.max(...members.map(heightOf)).toFixed(0)}]`);
+            }
+            trace(`wrap at ${budgetW.toFixed(0)}: rows ${rows.join(' ')} -> ${best[n].toFixed(0)} tall`);
+        }
+        for (const [idx, r] of groupRects.entries()) {
+            if (idx > 0 && rowStart.has(idx)) {
                 dyUnits += Math.ceil((rowH + gap) / U);
                 rowOriginX = r.x1;
                 rowLeftExt = leftExtOf(r.name);
                 rowH = 0;
             }
-            deltas.push({ dx: grid(Math.round((originX - rowOriginX) / U)), dy: dyUnits * U });
-            rowH = Math.max(rowH, r.y2 - r.y1);
+            const lift = grid(Math.round((topY - r.y1) / U));
+            deltas.push({ dx: grid(Math.round((originX - rowOriginX) / U)), dy: dyUnits * U + lift });
+            rowH = Math.max(rowH, r.y2 + lift - topY);
         }
+        void rowLeftExt;
         const xs = groupRects.flatMap((r, i) => [r.x1 + deltas[i].dx, r.x2 + deltas[i].dx]);
         const ys = groupRects.flatMap((r, i) => [r.y1 + deltas[i].dy, r.y2 + deltas[i].dy]);
         return { deltas, w: Math.max(...xs) - Math.min(...xs), h: Math.max(...ys) - Math.min(...ys) };
     };
+    /**
+     * The column-major counterpart of `wrapTo`: groups keep their declared
+     * order but fill top-to-bottom, then left-to-right, the way a person lays
+     * a newspaper page. Consecutive runs form columns no taller than `budgetH`;
+     * a column is as wide as its widest group (label extents included) and the
+     * breaks are chosen to minimise the total width. Groups of like width stack
+     * well this way (the engagement sheet's three 250 mm groups in one column,
+     * its three 205 mm groups in the next), which rows of mismatched heights
+     * never achieve.
+     */
+    const wrapColumns = (budgetH) => {
+        const originX = groupRects[0].x1;
+        const topY = Math.min(...groupRects.map((r) => r.y1));
+        const leftExtOf = (name) => groupExtents.get(name)?.left ?? 0;
+        const rightExtOf = (name) => groupExtents.get(name)?.right ?? 0;
+        const gap = GROUP_GAP * U + wrapGap;
+        const n = groupRects.length;
+        const hOf = (r) => r.y2 - r.y1;
+        const wOf = (r) => r.x2 - r.x1 + leftExtOf(r.name) + rightExtOf(r.name);
+        const runH = (i, j) => {
+            let h = 0;
+            for (let k = i; k <= j; k++)
+                h += hOf(groupRects[k]) + (k > i ? gap : 0);
+            return h;
+        };
+        const best = new Array(n + 1).fill(Infinity);
+        const cut = new Array(n + 1).fill(0);
+        best[0] = 0;
+        for (let j = 1; j <= n; j++) {
+            let colW = 0;
+            for (let i = j; i >= 1; i--) {
+                colW = Math.max(colW, wOf(groupRects[i - 1]));
+                if (i < j && runH(i - 1, j - 1) > budgetH)
+                    break;
+                const w = best[i - 1] + colW + (i > 1 ? gap : 0);
+                if (w < best[j]) {
+                    best[j] = w;
+                    cut[j] = i - 1;
+                }
+            }
+        }
+        const starts = [];
+        for (let j = n; j > 0; j = cut[j])
+            starts.unshift(cut[j]);
+        const deltas = [];
+        let colOriginUnits = Math.round(originX / U);
+        let maxH = 0;
+        for (let k = 0; k < starts.length; k++) {
+            const a = starts[k];
+            const b = k + 1 < starts.length ? starts[k + 1] : n;
+            const members = groupRects.slice(a, b);
+            const colLeft = Math.max(...members.map((r) => leftExtOf(r.name)));
+            let yUnits = Math.round(topY / U);
+            for (const r of members) {
+                deltas.push({ dx: (colOriginUnits + Math.ceil(colLeft / U)) * U - grid(Math.round(r.x1 / U)), dy: yUnits * U - grid(Math.round(r.y1 / U)) });
+                yUnits += Math.ceil(hOf(r) / U) + GROUP_GAP + Math.ceil(wrapGap / U);
+            }
+            maxH = Math.max(maxH, (yUnits - GROUP_GAP) * U - topY);
+            colOriginUnits += Math.ceil(Math.max(...members.map(wOf)) / U) + GROUP_GAP + Math.ceil(wrapGap / U);
+        }
+        if (process.env['COPPERHEAD_DRAFT_TRACE'] === '1') {
+            trace(`column wrap at ${budgetH.toFixed(0)}: ${starts.map((a, k) => `[${groupRects.slice(a, k + 1 < starts.length ? starts[k + 1] : n).map((r) => r.name.slice(0, 2).trim()).join('+')}]`).join(' ')} -> ${best[n].toFixed(0)} wide`);
+        }
+        return { deltas, w: best[n], h: maxH, kind: 'columns' };
+    };
+    /**
+     * The grid a person lays when neither rows nor columns fit: k columns,
+     * groups dealt to them in declared order (group i in column i mod k), each
+     * column stacking its own groups from the top. Reading order runs along
+     * the rows as before, but a short group no longer holds a whole row's
+     * height open beside a tall one (the hand-laid A2 sheet: power, amplifier
+     * and UI in one column, PD, MCU and UART in the next, rails in the third).
+     */
+    /** Masonry deals already searched in this draft, by budget and group sizes. */
+    const masonryDeals = new Map();
+    const wrapMasonry = (k, budgetH) => {
+        const originX = groupRects[0].x1;
+        const topY = Math.min(...groupRects.map((r) => r.y1));
+        const leftExtOf = (name) => groupExtents.get(name)?.left ?? 0;
+        const rightExtOf = (name) => groupExtents.get(name)?.right ?? 0;
+        const n = groupRects.length;
+        const wOf = (i) => groupRects[i].x2 - groupRects[i].x1 + leftExtOf(groupRects[i].name) + rightExtOf(groupRects[i].name);
+        const hOf = (i) => groupRects[i].y2 - groupRects[i].y1;
+        const gap = GROUP_GAP * U + wrapGap;
+        // Every way of dealing n groups to k columns (order kept within a
+        // column, columns in the order their first groups are declared) is
+        // judged and the narrowest that fits the height wins; ties go to the
+        // shorter. Seven groups in three columns is 301 deals, but twelve in four
+        // is 611 501, and the fit asks for this at every budget of every sheet:
+        // enumerating them all made a twelve-group board draft in tens of
+        // seconds. So the deals are walked as a tree, a group at a time, and a
+        // branch is cut as soon as a column is already too tall, or the columns
+        // opened so far are already wider than the best deal found (or as wide
+        // and as tall): no deal below it could replace the best. The walk visits
+        // deals in the enumeration's order and cuts only branches that could not
+        // win, so the deal it keeps is the one the full enumeration keeps. Past
+        // a node budget the walk stops with the best deal so far, and deals
+        // round-robin when it has found none. Shapes recur across the budgets
+        // the fit tries, so a search is remembered by the groups' sizes.
+        const sizesKey = `${k}|${budgetH}|${gap}|${groupRects.map((_, i) => `${wOf(i)}x${hOf(i)}`).join(',')}`;
+        let cols = masonryDeals.get(sizesKey);
+        if (cols === undefined) {
+            let found = null;
+            let bestW = Infinity;
+            let bestH = Infinity;
+            const judge = (assign) => {
+                const cs = Array.from({ length: k }, () => []);
+                assign.forEach((c, i) => cs[c].push(i));
+                if (cs.some((c) => !c.length))
+                    return;
+                const hs = cs.map((c) => c.reduce((h, i, m) => h + hOf(i) + (m ? gap : 0), 0));
+                const maxH = Math.max(...hs);
+                if (maxH > budgetH)
+                    return;
+                const w = cs.reduce((acc, c) => acc + Math.max(...c.map(wOf)), 0) + (k - 1) * gap;
+                if (w < bestW - 1e-6 || (Math.abs(w - bestW) <= 1e-6 && maxH < bestH)) {
+                    bestW = w;
+                    bestH = maxH;
+                    found = cs;
+                }
+            };
+            // columns are opened in reading order: the first group starts the
+            // first column, and a group may start a new column only when every
+            // earlier one is open (a restricted-growth string), so the same deal
+            // is never judged under k! column orders
+            const assign = new Array(n).fill(0);
+            const colH = new Array(k).fill(0);
+            const colW = new Array(k).fill(0);
+            const colN = new Array(k).fill(0);
+            let nodes = 0;
+            const grow = (i, open, widthSoFar, tallest) => {
+                if (nodes > MASONRY_NODE_BUDGET)
+                    return;
+                nodes++;
+                if (n - i < k - open)
+                    return; // too few groups left to open every column
+                if (i === n) {
+                    judge(assign);
+                    return;
+                }
+                for (let c = 0; c < Math.min(open + 1, k); c++) {
+                    const h = colH[c] + hOf(i) + (colN[c] ? gap : 0);
+                    if (h > budgetH)
+                        continue;
+                    const w = Math.max(colW[c], wOf(i));
+                    const lowerW = widthSoFar - colW[c] + w + (k - 1) * gap;
+                    const tall = Math.max(tallest, h);
+                    if (lowerW > bestW + 1e-6 || (lowerW >= bestW - 1e-6 && tall >= bestH))
+                        continue;
+                    const [h0, w0] = [colH[c], colW[c]];
+                    assign[i] = c;
+                    colH[c] = h;
+                    colW[c] = w;
+                    colN[c]++;
+                    grow(i + 1, Math.max(open, c + 1), lowerW - (k - 1) * gap, tall);
+                    colN[c]--;
+                    colH[c] = h0;
+                    colW[c] = w0;
+                }
+            };
+            grow(0, 0, 0, 0);
+            if (nodes > MASONRY_NODE_BUDGET) {
+                trace(`masonry k=${k} at ${budgetH.toFixed(0)}: search stopped at ${MASONRY_NODE_BUDGET} nodes, ${found ? 'keeping the best deal so far' : 'dealing round-robin'}`);
+                if (!found)
+                    judge(groupRects.map((_, i) => i % k));
+            }
+            cols = found;
+            masonryDeals.set(sizesKey, cols);
+        }
+        if (!cols)
+            return null;
+        const colW = cols.map((c) => Math.max(0, ...c.map(wOf)));
+        const colH = cols.map((c) => c.reduce((h, i, m) => h + hOf(i) + (m ? gap : 0), 0));
+        const deltas = new Array(groupRects.length);
+        let colOriginUnits = Math.round(originX / U);
+        for (const [ci, c] of cols.entries()) {
+            const colLeft = Math.max(0, ...c.map((i) => leftExtOf(groupRects[i].name)));
+            let yUnits = Math.round(topY / U);
+            for (const i of c) {
+                const r = groupRects[i];
+                deltas[i] = { dx: (colOriginUnits + Math.ceil(colLeft / U)) * U - grid(Math.round(r.x1 / U)), dy: yUnits * U - grid(Math.round(r.y1 / U)) };
+                yUnits += Math.ceil((r.y2 - r.y1) / U) + GROUP_GAP + Math.ceil(wrapGap / U);
+            }
+            colOriginUnits += Math.ceil(colW[ci] / U) + (ci + 1 < k ? GROUP_GAP + Math.ceil(wrapGap / U) : 0);
+        }
+        const w = (colOriginUnits - Math.round(originX / U)) * U;
+        trace(`masonry wrap k=${k} at ${budgetH.toFixed(0)}: ${cols.map((c) => `[${c.map((i) => groupRects[i].name.slice(0, 2).trim()).join('+')}]`).join(' ')} -> ${w.toFixed(0)} wide, ${Math.max(...colH).toFixed(0)} tall`);
+        return { deltas, w, h: Math.max(...colH), kind: 'masonry' };
+    };
+    /**
+     * Does wrapped content of `w` × `h` fit sheet `p`? The title strip is
+     * reserved across the whole width by default; content taller than that
+     * may still fit when the group boxes that reach into the strip stay clear
+     * of the title block's own corner (a person lays the left-hand column down
+     * to the frame and keeps the bottom-right for the block).
+     */
+    const fitsFrame = (p, w, h, rects) => {
+        if (w > usableW(p))
+            return { ok: false, intoStrip: false };
+        if (h <= usableH(p))
+            return { ok: true, intoStrip: false };
+        if (h > usableH(p) + TITLE_STRIP - 4 * U)
+            return { ok: false, intoStrip: false };
+        // final placement: centred in width, top-aligned (the frame plus four units) in height
+        const minX = Math.min(...rects.map((r) => r.x1));
+        const minY = Math.min(...rects.map((r) => r.y1));
+        const x0 = FRAME + Math.max(0, (usableW(p) - w) / 2) - minX;
+        const y0 = FRAME + 4 * U - minY;
+        const corner = { minX: p.w - FRAME - TITLE_BLOCK_W, minY: p.h - FRAME - TITLE_STRIP, maxX: p.w - FRAME, maxY: p.h - FRAME };
+        const clear = rects.every((r) => !(r.x1 + x0 < corner.maxX && r.x2 + x0 > corner.minX && r.y1 + y0 < corner.maxY && r.y2 + y0 > corner.minY));
+        return { ok: clear, intoStrip: clear };
+    };
     /**
      * Whether the current placement fits sheet `p`, with the group shelf-wrap
      * deltas that make it fit. `wrap` is null when there is nothing to reflow:
@@ -1196,8 +3198,29 @@ export function draftSchematicPlacement(validated, projectName, today) {
      */
     const fitsOn = (p) => {
         if (groupRects.length > 1) {
+            const wrappedRects = (d) => groupRects.map((r, i) => ({ x1: r.x1 + d[i].dx, y1: r.y1 + d[i].dy, x2: r.x2 + d[i].dx, y2: r.y2 + d[i].dy }));
             const w = wrapTo(usableW(p));
-            return w.w <= usableW(p) && w.h <= usableH(p) ? { paper: p, wrap: w } : null;
+            const fw = fitsFrame(p, w.w, w.h, wrappedRects(w.deltas));
+            if (fw.ok)
+                return { paper: p, wrap: { ...w, kind: 'rows' }, intoStrip: fw.intoStrip };
+            // rows of mismatched heights may miss where columns of like widths fit
+            for (const budgetH of [usableH(p), usableH(p) + TITLE_STRIP - 4 * U]) {
+                const c = wrapColumns(budgetH);
+                const fc = fitsFrame(p, c.w, c.h, wrappedRects(c.deltas));
+                if (fc.ok)
+                    return { paper: p, wrap: c, intoStrip: fc.intoStrip };
+            }
+            for (const budgetH of [usableH(p), usableH(p) + TITLE_STRIP - 4 * U]) {
+                for (let k = 2; k <= Math.min(4, groupRects.length - 1); k++) {
+                    const m = wrapMasonry(k, budgetH);
+                    if (!m)
+                        continue;
+                    const fm = fitsFrame(p, m.w, m.h, wrappedRects(m.deltas));
+                    if (fm.ok)
+                        return { paper: p, wrap: m, intoStrip: fm.intoStrip };
+                }
+            }
+            return null;
         }
         const r = groupRects[0];
         return !r || (r.x2 - r.x1 <= usableW(p) && r.y2 - r.y1 <= usableH(p)) ? { paper: p, wrap: null } : null;
@@ -1219,15 +3242,36 @@ export function draftSchematicPlacement(validated, projectName, today) {
      * spread the same cells into more side-by-side columns, so walk the height
      * fractions until the content matches the sheet's aspect or nothing fits.
      */
+    /** Closest miss per sheet a budgeted attempt could not fit, for the notes. */
+    const budgetMisses = [];
     const tryPaperBudgeted = (p) => {
-        for (const frac of [1, 0.7, 0.5]) {
-            const b = placeAllGroups(Math.floor(usableW(p) / U), Math.floor((usableH(p) * frac) / U));
+        let best = null;
+        // finer fractions re-row a tall group's columns until the groups are
+        // short enough for two or three rows of them to stack on the sheet
+        for (const [frac, div] of [1, 0.7, 0.5, 0.4, 0.35, 0.3, 0.25].flatMap((fr) => [1, 2, 2.5, 3].map((d) => [fr, d]))) {
+            // band budgets of a half and a third of the sheet fold a wide flat
+            // group (five button blocks in a row) toward the width of a column
+            const b = placeAllGroups(Math.floor(usableW(p) / div / U), Math.floor((usableH(p) * frac) / U));
             const f = fitsOn(p);
+            if (groupRects.length > 1) {
+                const w = wrapTo(usableW(p));
+                trace(`try ${p.name} frac ${frac} div ${div}: wrapped ${w.w.toFixed(0)}x${w.h.toFixed(0)} vs ${usableW(p)}x${usableH(p)}; ${groupRects.map((r) => `${r.name.slice(0, 12)}=${(r.x2 - r.x1).toFixed(0)}x${(r.y2 - r.y1).toFixed(0)}`).join(' ')}`);
+            }
             if (f)
                 return { fit: f, bands: b };
+            // remember the closest miss so a failed pass can say how far off it was
+            if (groupRects.length) {
+                const w = groupRects.length > 1 ? wrapTo(usableW(p)) : { w: groupRects[0].x2 - groupRects[0].x1, h: groupRects[0].y2 - groupRects[0].y1 };
+                const over = Math.max(w.w - usableW(p), w.h - usableH(p));
+                if (!best || over < Math.max(best.w - usableW(p), best.h - usableH(p)))
+                    best = { w: w.w, h: w.h };
+            }
         }
+        if (best)
+            budgetMisses.push(`${p.name} ${Math.round(best.w)}×${Math.round(best.h)} mm vs ${usableW(p)}×${usableH(p)} usable`);
         return null;
     };
+    let compaction = hinted ? 'pinned' : 'not-needed';
     let bands = placeAllGroups(Infinity);
     let fit = bestFit();
     if (!fit) {
@@ -1244,10 +3288,12 @@ export function draftSchematicPlacement(validated, projectName, today) {
             if (t) {
                 bands = t.bands;
                 fit = t.fit;
+                compaction = 'banded';
                 break;
             }
         }
         if (!fit) {
+            compaction = 'overflow';
             const largest = candidates[candidates.length - 1];
             bands = placeAllGroups(Math.floor(usableW(largest) / U), Math.floor(usableH(largest) / U));
             fit = { paper: largest, wrap: groupRects.length > 1 ? wrapTo(usableW(largest)) : null };
@@ -1288,6 +3334,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 }
             }
             if (compacted) {
+                compaction = 'compacted';
                 bands = compactedBands;
                 fit = compacted;
                 notes.push(`sheet compacted: the natural layout fit ${naturalPaper.name} at ${Math.round(naturalUtil * 100)}% utilization; reflowed onto ${fit.paper.name}`);
@@ -1297,8 +3344,10 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 }
             }
             else {
-                // nothing smaller holds the reflowed content: restore the natural
-                // placement byte for byte
+                // nothing smaller holds the reflowed content: say so, with how far
+                // each sheet missed, then restore the natural placement byte for byte
+                compaction = 'failed';
+                notes.push(`sheet not compacted: the natural layout fits ${naturalPaper.name} at ${Math.round(naturalUtil * 100)}% utilization, but no smaller sheet holds the reflowed content (${budgetMisses.join('; ')})`);
                 bands = placeAllGroups(Infinity);
                 fit = bestFit();
             }
@@ -1306,9 +3355,21 @@ export function draftSchematicPlacement(validated, projectName, today) {
     }
     if (fit.wrap) {
         const wrap = fit.wrap;
-        const rows = new Set(wrap.deltas.map((d) => d.dy)).size;
-        if (rows > 1)
-            notes.push(`groups wrapped onto ${rows} rows to fit the sheet`);
+        if (wrap.kind === 'columns') {
+            const cols = new Set(wrap.deltas.map((d, i) => Math.round((groupRects[i].x1 + d.dx) / U))).size;
+            notes.push(`groups wrapped onto ${cols} columns to fit the sheet (declared order runs down each column)`);
+        }
+        else if (wrap.kind === 'masonry') {
+            const cols = new Set(wrap.deltas.map((d, i) => Math.round((groupRects[i].x1 + d.dx) / U))).size;
+            notes.push(`groups laid in ${cols} columns to fit the sheet (declared order runs along the rows; each column stacks its own groups)`);
+        }
+        else {
+            // rows, like columns above, are counted by where their boxes land, not
+            // by the shift each took to get there (every group starts elsewhere)
+            const rows = new Set(wrap.deltas.map((d, i) => Math.round((groupRects[i].y1 + d.dy) / U))).size;
+            if (rows > 1)
+                notes.push(`groups wrapped onto ${rows} rows to fit the sheet`);
+        }
         groupRects.forEach((r, i) => {
             const d = wrap.deltas[i];
             if (!d.dx && !d.dy)
@@ -1555,7 +3616,8 @@ export function draftSchematicPlacement(validated, projectName, today) {
             const joinClear = (prev, c) => {
                 const y = c.ep.at.y + c.o.dy * STUB * U;
                 const seg = { x1: prev.ep.at.x, y1: y, x2: c.ep.at.x, y2: y };
-                return (c.ep.at.x - prev.ep.at.x <= BANK_PITCH_MAX * U &&
+                return (groupOf.get(prev.ep.ref) === groupOf.get(c.ep.ref) &&
+                    c.ep.at.x - prev.ep.at.x <= BANK_PITCH_MAX * U &&
                     !powerBodies.some((b) => segCrossesBody(seg.x1, seg.y1, seg.x2, seg.y2, b)) &&
                     !touchesForeign([seg], net.name, ownEps, { predictStubs: true }) &&
                     !crossesForeignStubLine(seg));
@@ -1595,10 +3657,15 @@ export function draftSchematicPlacement(validated, projectName, today) {
             if (len > maxLen)
                 len = maxLen;
             const at = (l) => ({ x: ep.at.x + o.dx * l * U, y: ep.at.y + o.dy * l * U });
-            const valueAtOf = (end) => ({
-                x: end.x,
-                y: end.y + (o.dy !== 0 ? o.dy * 3.556 : cls === 'ground' ? 3.556 : -3.556),
-            });
+            // A vertical stub carries its name beyond the bar, in line. A HORIZONTAL
+            // stub used to put the name 3.556 mm above (rails) or below (grounds)
+            // the bar: 1.4 pin rows off, so on any IC with pins one row apart the
+            // rail name of pin 5 sat on the label of pin 4 (esp32-amp's eFuse,
+            // VBUS_FUSED over EFUSE_USB_FLT). The name now continues outward along
+            // the row, past the bar, where the row is its own.
+            const valueAtOf = (end) => o.dy !== 0
+                ? { x: end.x, y: end.y + o.dy * 3.556 }
+                : { x: end.x + o.dx * (Math.max(1, net.name.length) * LABEL_ADVANCE * LABEL_HEIGHT / 2 + 1.905), y: end.y };
             // Adjacent power pins collide their value texts two ways, resolved two
             // ways. The SAME net repeated (a TQFP's VCC pins one row apart) hides
             // the duplicates: one visible name per cluster carries the same
@@ -1762,27 +3829,25 @@ export function draftSchematicPlacement(validated, projectName, today) {
             const o = outward(ep.pin);
             return { ep, end: { x: ep.at.x + o.dx * STUB * U, y: ep.at.y + o.dy * STUB * U }, o };
         });
-        const groupsTouched = new Set(eps.map((e) => groupOf.get(e.ref)));
-        const spanX = Math.max(...stubs.map((s) => s.end.x)) - Math.min(...stubs.map((s) => s.end.x));
-        const spanY = Math.max(...stubs.map((s) => s.end.y)) - Math.min(...stubs.map((s) => s.end.y));
-        let asWire = groupsTouched.size === 1 && eps.length <= MAX_WIRED_ENDPOINTS && Math.max(spanX, spanY) <= MAX_WIRE_SPAN;
-        if (asWire) {
-            // trunk-and-branch: a vertical trunk with horizontal branches. Several
-            // deterministic trunk positions are tried in order (median stub x, right
-            // of everything, left of everything); the first collision-free routing
-            // wins, and if none exists the net falls back to labels — the engine may
-            // never trip its own wire-through-symbol gate.
-            const xs = stubs.map((s) => s.end.x).sort((a, b) => a - b);
-            const ys = stubs.map((s) => s.end.y);
+        const routeStubs = (subset) => {
+            const xs = subset.map((s) => s.end.x).sort((a, b) => a - b);
+            const ys = subset.map((s) => s.end.y);
+            const admit = (candidate) => {
+                if (candidate.some((c) => bodies.some((b) => segCrossesBody(c.x1, c.y1, c.x2, c.y2, b))))
+                    return false;
+                return !touchesForeign(candidate, net.name, new Set(net.pins));
+            };
+            const found = [];
+            // A vertical trunk with horizontal branches, at the median stub x,
+            // right of everything, left of everything.
             const trunkCandidates = [
                 grid(Math.round(xs[Math.floor(xs.length / 2)] / U)),
                 grid(Math.round(xs[xs.length - 1] / U) + STUB),
                 grid(Math.round(xs[0] / U) - STUB),
             ];
-            let routed = false;
             for (const trunkX of trunkCandidates) {
                 const candidate = [];
-                for (const s of stubs) {
+                for (const s of subset) {
                     candidate.push({ x1: s.ep.at.x, y1: s.ep.at.y, x2: s.end.x, y2: s.end.y });
                     if (!sameCoord(s.end.x, trunkX))
                         candidate.push({ x1: s.end.x, y1: s.end.y, x2: trunkX, y2: s.end.y });
@@ -1793,74 +3858,269 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 for (let i = 1; i < meetYs.length; i++) {
                     candidate.push({ x1: trunkX, y1: meetYs[i - 1], x2: trunkX, y2: meetYs[i] });
                 }
-                if (candidate.some((c) => bodies.some((b) => segCrossesBody(c.x1, c.y1, c.x2, c.y2, b))))
-                    continue;
-                // No candidate segment may touch a foreign connection point (I22,
-                // #204): a trunk routed down a column of neighbouring stub ends
-                // silently merges nets. Mirrors the chain pass's axisClear,
-                // generalized to every candidate segment.
-                if (touchesForeign(candidate, net.name, new Set(net.pins)))
-                    continue;
-                for (const c of candidate)
-                    addWire(net.name, c.x1, c.y1, c.x2, c.y2);
-                // one label names the wired net (topmost-leftmost wire point): the net
-                // stays identifiable to PINOUT/drift and to a reviewer without a
-                // label-per-pin, matching hand-drafting practice
-                const pts = candidate.flatMap((c) => [
-                    { x: c.x1, y: c.y1 },
-                    { x: c.x2, y: c.y2 },
-                ]);
-                pts.sort((a, b) => a.y - b.y || a.x - b.x);
-                labels.push({ name: net.name, x: pts[0].x, y: pts[0].y, rot: 0 });
-                wiredLabels.push({ label: labels.length - 1, pts, segs: candidate.map((c) => ({ ...c })) });
-                wired++;
-                if (eps.length > 2) {
-                    for (const s of stubs) {
-                        const meet = sameCoord(s.end.x, trunkX) ? s.end : { x: trunkX, y: s.end.y };
+                if (admit(candidate))
+                    found.push({ segs: candidate, trunkX });
+            }
+            // A comb: the trunk lies ALONG one endpoint's row — the IC pin's row
+            // when the net has one — and every other stub rises or drops to it.
+            // This is how a pin with parts hung on it is drawn: the row runs out to
+            // the axis, the chain above and the chain below meet it in one T. The
+            // vertical trunk alone could not route a pull-up and a pull-down on one
+            // pin (its branch to the second part ran along a foreign row), so one
+            // of them shipped labelled.
+            const rows = [...new Map(subset.map((s) => [knum(s.end.y), s])).values()].sort((a, b) => {
+                const ica = (placed.get(a.ep.ref)?.sym.pins.length ?? 0) >= 3 ? 0 : 1;
+                const icb = (placed.get(b.ep.ref)?.sym.pins.length ?? 0) >= 3 ? 0 : 1;
+                return ica - icb || a.end.y - b.end.y;
+            });
+            for (const rowStub of rows) {
+                const trunkY = rowStub.end.y;
+                const candidate = [];
+                for (const s of subset) {
+                    candidate.push({ x1: s.ep.at.x, y1: s.ep.at.y, x2: s.end.x, y2: s.end.y });
+                    if (!sameCoord(s.end.y, trunkY))
+                        candidate.push({ x1: s.end.x, y1: s.end.y, x2: s.end.x, y2: trunkY });
+                }
+                const meetXs = [...new Map(xs.map((x) => [knum(x), x])).values()].sort((a, b) => a - b);
+                for (let i = 1; i < meetXs.length; i++) {
+                    candidate.push({ x1: meetXs[i - 1], y1: trunkY, x2: meetXs[i], y2: trunkY });
+                }
+                if (admit(candidate))
+                    found.push({ segs: candidate, trunkX: meetXs[0], trunkY });
+            }
+            // A hook, for two stubs where one lies on a row and the other is a
+            // lead below or above it on an axis the row would have to cross: run
+            // the row past the lead by two units, turn to the lead's level, and
+            // come back to its stub end. This is how a bootstrap cap's far lead is
+            // reached from the row it bridges to (the other lead sits on the same
+            // axis, in the way of a straight drop).
+            if (!found.length && subset.length === 2) {
+                for (const [a, b] of [[subset[0], subset[1]], [subset[1], subset[0]]]) {
+                    if (a.o.dx === 0 || b.o.dy === 0)
+                        continue; // a: a sideways pin (the row); b: a vertical lead
+                    for (const past of [2 * U, -2 * U]) {
+                        const turnX = grid(Math.round((b.end.x + past) / U));
+                        const candidate = [
+                            { x1: a.ep.at.x, y1: a.ep.at.y, x2: a.end.x, y2: a.end.y },
+                            { x1: a.end.x, y1: a.end.y, x2: turnX, y2: a.end.y },
+                            { x1: turnX, y1: a.end.y, x2: turnX, y2: b.end.y },
+                            { x1: turnX, y1: b.end.y, x2: b.end.x, y2: b.end.y },
+                            { x1: b.ep.at.x, y1: b.ep.at.y, x2: b.end.x, y2: b.end.y },
+                        ].filter((c) => !(sameCoord(c.x1, c.x2) && sameCoord(c.y1, c.y2)));
+                        if (admit(candidate)) {
+                            found.push({ segs: candidate, trunkX: turnX });
+                            break;
+                        }
+                    }
+                    if (found.length)
+                        break;
+                }
+            }
+            if (!found.length) {
+                trace(`route ${net.name}: no clean route for ${subset.map((s) => `${s.ep.ref}.${s.ep.pin.number}`).join(', ')}`);
+                return null;
+            }
+            // the fewest segments is the fewest bends; ties keep the classic order
+            return found.reduce((best, r) => (r.segs.length < best.segs.length ? r : best), found[0]);
+        };
+        /** Labels naming this net's wired runs, promoted to flags below if the net also leaves through a stub. */
+        const netWired = [];
+        /** Draw a routed subset: its wires, one label naming the net, and junction dots. */
+        const commitRoute = (subset, r) => {
+            for (const c of r.segs)
+                addWire(net.name, c.x1, c.y1, c.x2, c.y2);
+            // one label names the wired run (topmost-leftmost wire point): the net
+            // stays identifiable to PINOUT/drift and to a reviewer without a
+            // label-per-pin, matching hand-drafting practice
+            const pts = r.segs.flatMap((c) => [
+                { x: c.x1, y: c.y1 },
+                { x: c.x2, y: c.y2 },
+            ]);
+            pts.sort((a, b) => a.y - b.y || a.x - b.x);
+            // The name stands above the wire from its anchor rightward. A trunk's
+            // top is the classic place; a run that is one horizontal row (a part
+            // on its pin's row) has no trunk, and its left end is the pin, so the
+            // name sits over the stub and the gap the row left for it. Whichever
+            // candidate clears every body wins; the run's top-left point is the
+            // last resort.
+            const vertTops = r.segs.filter((c) => sameCoord(c.x1, c.x2)).map((c) => ({ x: c.x1, y: Math.min(c.y1, c.y2) }));
+            const candidates = [...vertTops.sort((a, b) => a.y - b.y || a.x - b.x), pts[0]];
+            const clearOfBodies = (pt) => {
+                const b = labelTextBox(net.name, pt.x, pt.y, 0);
+                if ([...placed.values()].some((pl) => boundsOverlap(b, pl.body)))
+                    return false;
+                return !labels.some((o) => o.name !== net.name && boundsOverlap(padBox(b), labelTextBox(o.name, o.x, o.y, o.rot)));
+            };
+            const at = candidates.find(clearOfBodies) ?? pts[0];
+            labels.push({ name: net.name, x: at.x, y: at.y, rot: 0, kind: 'local' });
+            netWired.push(labels.length - 1);
+            wiredLabels.push({ label: labels.length - 1, pts, segs: r.segs.map((c) => ({ ...c })) });
+            wired++;
+            if (subset.length > 2) {
+                if (r.trunkY !== undefined) {
+                    // comb: a branch meeting the row trunk strictly inside its span is a T
+                    const xs = subset.map((s) => s.end.x);
+                    for (const s of subset) {
+                        const meet = sameCoord(s.end.y, r.trunkY) ? s.end : { x: s.end.x, y: r.trunkY };
+                        if (meet.x > Math.min(...xs) + 0.01 && meet.x < Math.max(...xs) - 0.01)
+                            junctions.push(meet);
+                    }
+                }
+                else {
+                    const ys = subset.map((s) => s.end.y);
+                    for (const s of subset) {
+                        const meet = sameCoord(s.end.x, r.trunkX) ? s.end : { x: r.trunkX, y: s.end.y };
                         if (meet.y > Math.min(...ys) && meet.y < Math.max(...ys))
                             junctions.push(meet);
                     }
                 }
-                routed = true;
-                break;
             }
-            if (!routed)
-                asWire = false;
-        }
-        if (!asWire) {
-            for (const s of stubs) {
-                // A stub is a wire too: its endpoint resting on a foreign net's wire
-                // or connection point merges nets exactly like a trunk would (the
-                // cap-to-ground drop's 2-unit stub ended on the neighbouring power
-                // pin's stub interior — I22's third face). Grow the stub a grid unit
-                // at a time until the endpoint is clear; the interior then CROSSES
-                // the foreign wire mid-segment, which does not connect. If no length
-                // clears, emit the plain stub and let the merged-net gate refuse
-                // loudly rather than ship the contact.
-                let end = s.end;
-                const own = new Set(net.pins);
-                // Rungs in preference order: the classic 0..2 extensions first so
-                // clear cases stay byte-identical, then deeper extensions, then a
-                // one-unit retreat. A stub that ships with NO clear rung still ends
-                // touching a foreign wire and the merge gate refuses the draft, so
-                // every extra rung here is a board that drafts instead of refusing
-                // (jetson's twelve wire-contact refusals were exactly this fallback).
-                for (const len of [STUB, STUB + 1, STUB + 2, STUB + 3, STUB + 4, STUB + 5, STUB + 6, 1]) {
-                    const cand = {
-                        x: s.ep.at.x + s.o.dx * len * U,
-                        y: s.ep.at.y + s.o.dy * len * U,
-                    };
-                    if (!touchesForeign([{ x1: s.ep.at.x, y1: s.ep.at.y, x2: cand.x, y2: cand.y }], net.name, own)) {
-                        end = cand;
-                        break;
-                    }
+        };
+        // Clusters: endpoints in one group whose stub ends sit within wire span of
+        // one another, in x order. A net that stays in one group and fits the
+        // span is one cluster — the classic case, drawn as before. A net that
+        // also leaves the group, or runs longer, still gets each local run wired
+        // and labelled once: adjacency before labelling (#220 phase 3), so a part
+        // hung on a pin or lying on its row is wired to it whatever the rest of
+        // the net does. Lone endpoints keep a stub and a label.
+        const sorted = [...stubs].sort((a, b) => a.end.x - b.end.x || a.end.y - b.end.y);
+        const clusters = [];
+        const anchorKey = (ref) => {
+            let k = ref;
+            for (let i = 0; i < 4 && boundTo.has(k); i++)
+                k = boundTo.get(k);
+            return k;
+        };
+        const near = (a, b) => (Math.abs(a.end.x - b.end.x) <= MAX_WIRE_SPAN && Math.abs(a.end.y - b.end.y) <= MAX_WIRE_SPAN) ||
+            // a part hung on a pin or lying on its row joins that pin's cluster
+            // however far its lane sits: the fourth lane of a comb is past the
+            // wire span, and it is still that pin's part
+            anchorKey(a.ep.ref) === anchorKey(b.ep.ref);
+        for (const s of sorted) {
+            const home = clusters.find((cl) => groupOf.get(cl[0].ep.ref) === groupOf.get(s.ep.ref) && cl.every((o) => near(o, s)));
+            if (home)
+                home.push(s);
+            else
+                clusters.push([s]);
+        }
+        const wiredStubs = new Set();
+        for (const found of clusters) {
+            // A cluster past the wired-net size is a pin with its hung parts plus
+            // whatever else sits within span: it is narrowed to the largest set of
+            // endpoints bound to one anchor, so the parts hung on a pin are wired
+            // to it however many there are, and the rest keep stubs and labels.
+            let cl = found;
+            if (cl.length > MAX_WIRED_ENDPOINTS) {
+                const byAnchor = new Map();
+                for (const s of cl)
+                    byAnchor.set(anchorKey(s.ep.ref), [...(byAnchor.get(anchorKey(s.ep.ref)) ?? []), s]);
+                cl = [...byAnchor.values()].reduce((a, b) => (b.length > a.length ? b : a));
+                trace(`route ${net.name}: cluster of ${found.length} narrowed to ${cl.length} bound to ${anchorKey(cl[0].ep.ref)}`);
+            }
+            if (cl.length < 2)
+                continue;
+            // the whole cluster, else the largest subset that routes: a run on the
+            // IC pin's row still draws as a wire when a third endpoint's branch
+            // cannot be cleared, and only that endpoint keeps a stub label. Subsets
+            // are tried largest first in index order, at most ROUTE_ATTEMPTS.
+            let attempts = 0;
+            let done = false;
+            const cur = [];
+            const pick = (start, size) => {
+                if (done || attempts >= ROUTE_ATTEMPTS)
+                    return;
+                if (cur.length === size) {
+                    attempts++;
+                    const r = routeStubs(cur);
+                    if (!r)
+                        return;
+                    const sub = [...cur];
+                    commitRoute(sub, r);
+                    for (const s of sub)
+                        wiredStubs.add(s);
+                    done = true;
+                    return;
+                }
+                for (let i = start; i <= cl.length - (size - cur.length) && !done; i++) {
+                    cur.push(cl[i]);
+                    pick(i + 1, size);
+                    cur.pop();
+                }
+            };
+            for (let size = cl.length; size >= 2 && !done && attempts < ROUTE_ATTEMPTS; size--)
+                pick(0, size);
+            if (!done && attempts >= ROUTE_ATTEMPTS)
+                trace(`route ${net.name}: ${ROUTE_ATTEMPTS} subsets of ${cl.length} tried, none routed`);
+        }
+        for (const s of stubs) {
+            if (wiredStubs.has(s))
+                continue;
+            // A stub is a wire too: its endpoint resting on a foreign net's wire
+            // or connection point merges nets exactly like a trunk would (the
+            // cap-to-ground drop's 2-unit stub ended on the neighbouring power
+            // pin's stub interior — I22's third face). Grow the stub a grid unit
+            // at a time until the endpoint is clear; the interior then CROSSES
+            // the foreign wire mid-segment, which does not connect. If no length
+            // clears, emit the plain stub and let the merged-net gate refuse
+            // loudly rather than ship the contact.
+            let end = s.end;
+            const own = new Set(net.pins);
+            // Rungs in preference order: the classic 0..2 extensions first so
+            // clear cases stay byte-identical, then deeper extensions, then a
+            // one-unit retreat. A stub that ships with NO clear rung still ends
+            // touching a foreign wire and the merge gate refuses the draft, so
+            // every extra rung here is a board that drafts instead of refusing
+            // (jetson's twelve wire-contact refusals were exactly this fallback).
+            for (const len of [STUB, STUB + 1, STUB + 2, STUB + 3, STUB + 4, STUB + 5, STUB + 6, 1]) {
+                const cand = {
+                    x: s.ep.at.x + s.o.dx * len * U,
+                    y: s.ep.at.y + s.o.dy * len * U,
+                };
+                if (!touchesForeign([{ x1: s.ep.at.x, y1: s.ep.at.y, x2: cand.x, y2: cand.y }], net.name, own)) {
+                    end = cand;
+                    break;
                 }
-                addWire(net.name, s.ep.at.x, s.ep.at.y, end.x, end.y);
-                // labels are always horizontal (drafting standard): leftward pins read
-                // outward to the left, everything else extends to the right
-                labels.push({ name: net.name, x: end.x, y: end.y, rot: s.o.dx === -1 ? 180 : 0 });
-                stubbedLabels.push({ label: labels.length - 1, wire: wires.length - 1, o: s.o, pins: net.pins });
-                labelled++;
+            }
+            addWire(net.name, s.ep.at.x, s.ep.at.y, end.x, end.y);
+            // a stub ends in a global flag that continues the stub's direction,
+            // the way a person hangs a flag on a wire end: a leftward stub reads
+            // leftward, an upward one reads upward; the shape says what the pin is
+            labels.push({ name: net.name, x: end.x, y: end.y, rot: rotOutward(s.o), kind: 'global', shape: flagShape(s.ep.pin.etype) });
+            stubbedLabels.push({ label: labels.length - 1, wire: wires.length - 1, o: s.o, pins: net.pins });
+            labelled++;
+        }
+        // A net that also leaves its run through a stub is named by global flags
+        // there, and a local label of the same name would not connect to them in
+        // KiCad: the run's own name becomes a flag too, re-anchored where a flag
+        // fits (a local name stands over its wire; a flag has a body of its own).
+        // A net wired whole keeps its plain local name on the run.
+        if (netWired.length && stubs.some((s) => !wiredStubs.has(s))) {
+            for (const idx of netWired) {
+                const lb = labels[idx];
+                const rec = wiredLabels.find((w) => w.label === idx);
+                lb.kind = 'global';
+                lb.shape = 'passive';
+                const clear = (c) => ![...placed.values()].some((pl) => boundsOverlap(labelTextBox(lb.name, c.x, c.y, c.rot, 'global'), pl.body));
+                const at = wiredFlagCandidates(rec.segs).find(clear) ?? { x: lb.x, y: lb.y, rot: 90 };
+                trace(`label ${lb.name}: run name becomes a flag at (${at.x}, ${at.y}, ${at.rot})`);
+                lb.x = at.x;
+                lb.y = at.y;
+                lb.rot = at.rot;
+            }
+        }
+    }
+    if (process.env['COPPERHEAD_DRAFT_TRACE'] === '1') {
+        // every crossing of two nets' wires, for the trace: a comb whose lanes
+        // cross another pin's row is legal, but a drafter wants to know where
+        const H = wires.filter((w) => sameCoord(w.y1, w.y2));
+        const V = wires.filter((w) => sameCoord(w.x1, w.x2));
+        for (const h of H) {
+            for (const v of V) {
+                if (h.net === v.net)
+                    continue;
+                const hx1 = Math.min(h.x1, h.x2), hx2 = Math.max(h.x1, h.x2), vy1 = Math.min(v.y1, v.y2), vy2 = Math.max(v.y1, v.y2);
+                if (v.x1 > hx1 + 0.01 && v.x1 < hx2 - 0.01 && h.y1 > vy1 + 0.01 && h.y1 < vy2 - 0.01)
+                    trace(`crossing ${h.net} (row y=${h.y1}) x ${v.net} (x=${v.x1})`);
             }
         }
     }
@@ -1876,11 +4136,39 @@ export function draftSchematicPlacement(validated, projectName, today) {
     /** What KiCad renders for the reference: a multi-unit instance shows its
      * unit letter (U1A, U1B), so width metrics must measure the rendered text. */
     const displayRefOf = (pl) => pl.unit !== null ? `${pl.refDes}${String.fromCharCode(64 + Math.min(pl.unit, 26))}` : pl.refDes;
+    /**
+     * Width of the body interior left free by the pin NAMES drawn inside it on
+     * the rows a ref/value pair at `cy` would occupy. A large module's names
+     * (ESP32-WROVER's "MTMS/GPIO14/ADC2_CH6") run most of the way across, and a
+     * value dropped on the centre line read as one word with them.
+     */
+    const interiorSpan = (pl, cy) => {
+        let leftW = 0;
+        let rightW = 0;
+        for (const pin of pl.sym.pins) {
+            const o = outward(pin);
+            if (o.dx === 0)
+                continue;
+            const py = pinAt(pl, pin).y;
+            if (Math.abs(py - cy) > 2.54 + 0.7)
+                continue;
+            const w = Math.max(0, pin.name.length) * NAME_ADVANCE * LABEL_HEIGHT;
+            if (o.dx === -1)
+                leftW = Math.max(leftW, w);
+            else
+                rightW = Math.max(rightW, w);
+        }
+        return { left: pl.body.minX + leftW, right: pl.body.maxX - rightW };
+    };
+    /** A library symbol that draws text of its own inside the body (ESP32-WROVER
+     * prints its family name across the middle) has no free interior. */
+    const hasGraphicText = (pl) => /\(text\s/.test(pl.sym.sourceText ?? '');
+    const pinSidesOf = (pl) => new Set(pl.sym.pins.map((p) => {
+        const o = outward(p);
+        return o.dx === -1 ? 'left' : o.dx === 1 ? 'right' : o.dy === -1 ? 'top' : 'bottom';
+    }));
     for (const [, pl] of [...placed.entries()].sort((a, b) => a[0].localeCompare(b[0], undefined, { numeric: true }))) {
-        const pinSides = new Set(pl.sym.pins.map((p) => {
-            const o = outward(p);
-            return o.dx === -1 ? 'left' : o.dx === 1 ? 'right' : o.dy === -1 ? 'top' : 'bottom';
-        }));
+        const pinSides = pinSidesOf(pl);
         const cy = (pl.body.minY + pl.body.maxY) / 2;
         const cx = (pl.body.minX + pl.body.maxX) / 2;
         const textW = Math.max(displayRefOf(pl).length, pl.part.value.length) * 0.8 * 1.27;
@@ -1892,14 +4180,21 @@ export function draftSchematicPlacement(validated, projectName, today) {
             // below the body otherwise
             valueAt = pinSides.has('bottom') ? { x: cx, y: pl.body.minY - 5.08 } : { x: cx, y: pl.body.maxY + 2.54 };
         }
-        else if (pl.body.maxX - pl.body.minX >= textW + 2.54 &&
-            pl.body.maxY - pl.body.minY >= 7.62) {
+        else if (pl.body.maxY - pl.body.minY >= 7.62 &&
+            !hasGraphicText(pl) &&
+            // the name at its real advance, centred in the interval the pin names
+            // leave free, with two text heights of air each side: measured from
+            // the body centre instead, ESP32-WROVER's value printed across the
+            // ends of its long left-hand pin names
+            interiorSpan(pl, cy).right - interiorSpan(pl, cy).left >= (textW * NAME_ADVANCE) / LABEL_ADVANCE + 4 * 2.54) {
             // pins on top AND a body big enough to hold its own name: a TQFP-class
             // part carries pins on all four sides, so every outside slot lands on
             // some pin's stub or label; the body interior is the one guaranteed-free
             // area, and it is where KiCad's own large symbols put their text
-            refAt = { x: cx, y: cy - 1.27 };
-            valueAt = { x: cx, y: cy + 1.27 };
+            const span = interiorSpan(pl, cy);
+            const mid = grid(Math.round((span.left + span.right) / 2 / U));
+            refAt = { x: mid, y: cy - 1.27 };
+            valueAt = { x: mid, y: cy + 1.27 };
         }
         else {
             refAt = { x: pl.body.maxX + textW / 2 + 1.27, y: cy - 1.27 };
@@ -1910,7 +4205,8 @@ export function draftSchematicPlacement(validated, projectName, today) {
             libId: pl.sym.libId,
             value: pl.part.value,
             footprint: pl.part.footprint ?? '',
-            at: { x: pl.x, y: pl.y, rot: 0 },
+            at: { x: pl.x, y: pl.y, rot: pl.rot },
+            ...(pl.mirror ? { mirror: pl.mirror } : {}),
             refAt,
             valueAt,
             pinNumbers: pl.sym.pins.map((p) => p.number),
@@ -1944,6 +4240,8 @@ export function draftSchematicPlacement(validated, projectName, today) {
         const fieldBoxes = extraSymbols
             .filter((s) => !s.hideValue)
             .map((s) => centeredTextBox(s.value, s.valueAt.x, s.valueAt.y));
+        const powerBodies = extraSymbols.map((s) => ({ minX: s.at.x - 2 * U, minY: s.at.y - 2 * U, maxX: s.at.x + 2 * U, maxY: s.at.y + 2 * U }));
+        const labelBoxes = labels.map((l) => labelTextBox(l.name, l.x, l.y, l.rot, l.kind));
         for (const { sym, pl } of emitPairs) {
             const dref = displayRefOf(pl);
             const cx = (pl.body.minX + pl.body.maxX) / 2;
@@ -1957,15 +4255,54 @@ export function draftSchematicPlacement(validated, projectName, today) {
                         if (op !== pl && boundsOverlap(b, op.body))
                             return false;
                     }
-                    if (fieldBoxes.some((t) => boundsOverlap(t, b)))
+                    // a rail bar or ground symbol is a drawn body too, not just its
+                    // value text (R23's reference printed through PVDD's bar)
+                    if (powerBodies.some((pb) => boundsOverlap(b, pb)))
+                        return false;
+                    // the part's own pins: the pin line and its number, from the pin
+                    // end to the body edge (U8's name printed over its no-connect pins,
+                    // which draw no wire for the wire check to see)
+                    for (const pin of pl.sym.pins) {
+                        const p = pinAt(pl, pin);
+                        const o = outward(pin);
+                        const band = o.dx !== 0
+                            ? { minX: Math.min(p.x, o.dx === 1 ? pl.body.maxX : pl.body.minX), maxX: Math.max(p.x, o.dx === 1 ? pl.body.maxX : pl.body.minX), minY: p.y - 1.5, maxY: p.y + 1.5 }
+                            : { minX: p.x - 1.5, maxX: p.x + 1.5, minY: Math.min(p.y, o.dy === 1 ? pl.body.maxY : pl.body.minY), maxY: Math.max(p.y, o.dy === 1 ? pl.body.maxY : pl.body.minY) };
+                        if (boundsOverlap(b, band))
+                            return false;
+                    }
+                    if (fieldBoxes.some((t) => boundsOverlap(t, padBox(b))))
+                        return false;
+                    // net labels are on the sheet by now; a slot on top of one is no slot
+                    if (labelBoxes.some((t) => boundsOverlap(t, padBox(b))))
                         return false;
                 }
                 return true;
             };
             if (!pairClear(sym.refAt, sym.valueAt)) {
                 const ladder = [];
-                for (const extra of [0, 2.54]) {
-                    ladder.push([{ x: cx, y: pl.body.maxY + 2.54 + extra }, { x: cx, y: pl.body.maxY + 5.08 + extra }], [{ x: cx, y: pl.body.minY - 5.08 - extra }, { x: cx, y: pl.body.minY - 2.54 - extra }], [
+                // corner slots: a part with a stub on its top or bottom centre (a
+                // module's rail pin) still has its top-left and top-right free
+                const xl = pl.body.minX + textW / 2 + 1.27;
+                const xr = pl.body.maxX - textW / 2 - 1.27;
+                // A part lying on a row (leads left and right) has rows one pitch
+                // above and below it; its texts fit BETWEEN the rows, half a pitch
+                // out from the body, wherever the neighbouring row carries no wire
+                // there. Reference above and value below first, then both on one
+                // side, then side by side on one line.
+                if (pinSidesOf(pl).has('left') && pinSidesOf(pl).has('right') && !pinSidesOf(pl).has('top')) {
+                    const hh = 1.27;
+                    // Both texts on ONE side first, and side by side on one line before
+                    // stacked: two parts on rows two pitches apart then keep their texts
+                    // in their own half of the gap (C27's value and L3's reference met
+                    // in the middle of the five millimetres between their rows).
+                    ladder.push([{ x: cx, y: pl.body.minY - hh - 2.54 }, { x: cx, y: pl.body.minY - hh }], [{ x: cx - textW / 2 - 0.635, y: pl.body.minY - hh }, { x: cx + textW / 2 + 0.635, y: pl.body.minY - hh }], [{ x: cx, y: pl.body.maxY + hh }, { x: cx, y: pl.body.maxY + hh + 2.54 }], [{ x: cx - textW / 2 - 0.635, y: pl.body.maxY + hh }, { x: cx + textW / 2 + 0.635, y: pl.body.maxY + hh }], [{ x: cx, y: pl.body.minY - hh }, { x: cx, y: pl.body.maxY + hh }]);
+                }
+                // rungs reach past a rail symbol and its name on a top or bottom
+                // stub (about 6 mm out), so a module pinned on all four sides still
+                // finds a slot above or below itself instead of on its own labels
+                for (const extra of [0, 2.54, 5.08, 7.62, 10.16]) {
+                    ladder.push([{ x: cx, y: pl.body.maxY + 2.54 + extra }, { x: cx, y: pl.body.maxY + 5.08 + extra }], [{ x: cx, y: pl.body.minY - 5.08 - extra }, { x: cx, y: pl.body.minY - 2.54 - extra }], [{ x: xl, y: pl.body.minY - 5.08 - extra }, { x: xl, y: pl.body.minY - 2.54 - extra }], [{ x: xr, y: pl.body.minY - 5.08 - extra }, { x: xr, y: pl.body.minY - 2.54 - extra }], [{ x: xl, y: pl.body.maxY + 2.54 + extra }, { x: xl, y: pl.body.maxY + 5.08 + extra }], [{ x: xr, y: pl.body.maxY + 2.54 + extra }, { x: xr, y: pl.body.maxY + 5.08 + extra }], [
                         { x: pl.body.maxX + textW / 2 + 1.27 + extra, y: cy - 1.27 },
                         { x: pl.body.maxX + textW / 2 + 1.27 + extra, y: cy + 1.27 },
                     ], [
@@ -1973,13 +4310,17 @@ export function draftSchematicPlacement(validated, projectName, today) {
                         { x: pl.body.minX - textW / 2 - 1.27 - extra, y: cy + 1.27 },
                     ]);
                 }
+                let slotted = false;
                 for (const [r, v] of ladder) {
                     if (pairClear(r, v)) {
                         sym.refAt = r;
                         sym.valueAt = v;
+                        slotted = true;
                         break;
                     }
                 }
+                if (!slotted)
+                    trace(`fields of ${dref}: no clear slot in ${ladder.length} rungs; heuristic kept`);
             }
             fieldBoxes.push(centeredTextBox(dref, sym.refAt.x, sym.refAt.y), centeredTextBox(sym.value, sym.valueAt.x, sym.valueAt.y));
         }
@@ -2015,24 +4356,95 @@ export function draftSchematicPlacement(validated, projectName, today) {
     // are the label's own attachment and never count as collisions.
     for (const rec of wiredLabels) {
         const lb = labels[rec.label];
-        const clearWired = (x, y) => {
-            const box = labelTextBox(lb.name, x, y, 0);
-            if (bodies.some((b) => boundsOverlap(box, b)))
-                return false;
-            if (textObstacles.some((b) => boundsOverlap(box, b)))
+        const clearWired = (x, y, rot, pad = TEXT_PAD) => {
+            const box = labelTextBox(lb.name, x, y, rot, lb.kind);
+            const padBox = (b) => ({ minX: b.minX - pad, minY: b.minY - pad, maxX: b.maxX + pad, maxY: b.maxY + pad });
+            const blocked = (why) => {
+                trace(`label ${lb.name} at (${x}, ${y}, ${rot}) blocked by ${why}`);
                 return false;
-            if (wires.some((w) => !segContains(w, x, y) && segHitsBox(w, box)))
-                return false;
-            return !labels.some((o, i) => i !== rec.label && o.name !== lb.name && boundsOverlap(box, labelTextBox(o.name, o.x, o.y, o.rot)));
+            };
+            // A wire through the anchor is the label's own attachment — for a
+            // plain label, whose text stands above the line. A flag is drawn
+            // CENTRED on its anchor line, so a wire continuing under its text
+            // runs straight through the flag; only the wire on the pole side
+            // (behind the flag's tip) is its attachment.
+            const attached = (w) => {
+                if (!segContains(w, x, y))
+                    return false;
+                if (lb.kind !== 'global')
+                    return true;
+                const r = ((rot % 360) + 360) % 360;
+                if (r === 0)
+                    return Math.max(w.x1, w.x2) <= x + 0.01;
+                if (r === 180)
+                    return Math.min(w.x1, w.x2) >= x - 0.01;
+                if (r === 90)
+                    return Math.min(w.y1, w.y2) >= y - 0.01;
+                return Math.max(w.y1, w.y2) <= y + 0.01;
+            };
+            const hitBody = [...placed.entries()].find(([, pl]) => boundsOverlap(box, pl.body));
+            if (hitBody)
+                return blocked(`the body of ${hitBody[0]} (${JSON.stringify(hitBody[1].body)})`);
+            if (textObstacles.some((b) => boundsOverlap(padBox(box), b)))
+                return blocked('field text');
+            if (wires.some((w) => !attached(w) && segHitsBox(w, box)))
+                return blocked('a wire');
+            return !labels.some((o, i) => i !== rec.label && o.name !== lb.name && boundsOverlap(padBox(box), labelTextBox(o.name, o.x, o.y, o.rot, o.kind)));
         };
-        if (clearWired(lb.x, lb.y))
+        if (clearWired(lb.x, lb.y, lb.rot))
             continue;
-        const alt = rec.pts.find((p) => clearWired(p.x, p.y));
+        trace(`label ${lb.name}: (${lb.x}, ${lb.y}, ${lb.rot}) not clear, searching`);
+        // A flag may turn as well as move — its candidates each carry a rotation
+        // — and prefers a trunk top; a local name stays horizontal and walks the
+        // run's points in anchor-preference order.
+        if (lb.kind === 'global') {
+            // a run's name reads along the row (the drafting standard keeps text
+            // horizontal); a flag that could only stand up leaves the net to
+            // local labels below
+            const alt = wiredFlagCandidates(rec.segs)
+                .filter((c) => c.rot === 0 || c.rot === 180)
+                .find((c) => clearWired(c.x, c.y, c.rot));
+            if (alt) {
+                lb.x = alt.x;
+                lb.y = alt.y;
+                lb.rot = alt.rot;
+                continue;
+            }
+            // A flag that fits nowhere on its run (a part on a pin row of a
+            // 2.54 mm-pitch IC has no free end and no room for a flag standing up
+            // between the rows) leaves the net named by plain labels instead:
+            // every flag of this net becomes a local label, which KiCad connects
+            // across the sheet just the same, and the run's name goes back to
+            // standing on its wire.
+            for (const o of labels) {
+                if (o.name !== lb.name)
+                    continue;
+                o.kind = 'local';
+                delete o.shape;
+                if (o.rot === 90 || o.rot === 270)
+                    o.rot = 0; // plain text reads along the row
+            }
+            lb.rot = 0;
+            trace(`label ${lb.name}: no flag position clears; the net keeps local labels`);
+        }
+        const alt = rec.pts.find((p) => clearWired(p.x, p.y, 0));
         if (alt) {
+            trace(`label ${lb.name} moved along its run (${lb.x}, ${lb.y}) -> (${alt.x}, ${alt.y})`);
             lb.x = alt.x;
             lb.y = alt.y;
             continue;
         }
+        // reading leftward from a point on the run is the same text on the same
+        // wire; a run whose right-hand end is a part's body (a resistor on the
+        // row) often clears only that way
+        const altLeft = [...rec.pts, ...interiorGridPoints(rec.segs, U)].find((p) => clearWired(p.x, p.y, 180));
+        if (altLeft) {
+            trace(`label ${lb.name} reads leftward from (${altLeft.x}, ${altLeft.y})`);
+            lb.x = altLeft.x;
+            lb.y = altLeft.y;
+            lb.rot = 180;
+            continue;
+        }
         // No segment endpoint clears, but the label may sit at ANY point of its
         // own net's wires: walk the interior grid points of each segment too
         // (#220 phase 2). Endpoints stay the first choice so a run that used to
@@ -2045,20 +4457,39 @@ export function draftSchematicPlacement(validated, projectName, today) {
         // one the IR gave it. Three corpus nets shipped exactly that way —
         // Net-(F201-Pad1), Net-(U8-BIN) and Net-(U8-RIN), each anchored on no
         // wire of its own run.
-        const inner = interiorGridPoints(rec.segs, U).find((p) => clearWired(p.x, p.y));
+        const inner = interiorGridPoints(rec.segs, U).find((p) => clearWired(p.x, p.y, 0));
         if (inner) {
+            trace(`label ${lb.name} moved to an interior point (${inner.x}, ${inner.y})`);
             lb.x = inner.x;
             lb.y = inner.y;
+            continue;
+        }
+        // Last resort before leaving the name on a body: the full pad cannot be
+        // had on a 2.54 mm pin row under a flag (a flag's half height plus a
+        // standing label's height already fill the pitch), so accept a quarter
+        // pad at the first point that clears everything else.
+        // (A flag on the row above already reaches a full height below its line,
+        // so against it even a quarter pad is too much; touching boxes are not a
+        // collision to the checker, and are the last rung.)
+        const tightCandidates = [...rec.pts.map((p) => ({ ...p, rot: 0 })), ...interiorGridPoints(rec.segs, U).map((p) => ({ ...p, rot: 0 })), ...rec.pts.map((p) => ({ ...p, rot: 180 }))];
+        const tight = tightCandidates.find((c) => clearWired(c.x, c.y, c.rot, TEXT_PAD / 4)) ?? tightCandidates.find((c) => clearWired(c.x, c.y, c.rot, 0));
+        if (tight) {
+            trace(`label ${lb.name} placed at (${tight.x}, ${tight.y}, ${tight.rot}) with a reduced pad`);
+            lb.x = tight.x;
+            lb.y = tight.y;
+            lb.rot = tight.rot;
+            continue;
         }
+        trace(`label ${lb.name}: no clear point on its run; left at (${lb.x}, ${lb.y})`);
     }
     for (const rec of stubbedLabels) {
         const lb = labels[rec.label];
         const stub = wires[rec.wire];
         const clearAt = (x, y, rot = lb.rot) => {
-            const box = labelTextBox(lb.name, x, y, rot);
+            const box = labelTextBox(lb.name, x, y, rot, lb.kind);
             if (bodies.some((b) => boundsOverlap(box, b)))
                 return false;
-            if (textObstacles.some((b) => boundsOverlap(box, b)))
+            if (textObstacles.some((b) => boundsOverlap(padBox(box), b)))
                 return false;
             if (wires.some((w, i) => i !== rec.wire && segHitsBox(w, box)))
                 return false;
@@ -2070,9 +4501,10 @@ export function draftSchematicPlacement(validated, projectName, today) {
             // coordinates. Read live from `labels`, so already-nudged neighbours are
             // seen at their final positions and immovable wired-net labels (which
             // carry no stub to ride) are seen at all.
-            return !labels.some((o, i) => i !== rec.label &&
-                o.name !== lb.name &&
-                boundsOverlap(box, labelTextBox(o.name, o.x, o.y, o.rot)));
+            // A label of the SAME net is still text: two BUCK_EN labels one over
+            // the other read as one smudge and the checker flags them (a hung
+            // part's stub label rode down onto the IC pin's).
+            return !labels.some((o, i) => i !== rec.label && boundsOverlap(padBox(box), labelTextBox(o.name, o.x, o.y, o.rot, o.kind)));
         };
         /**
          * Does another net's label sit on exactly this point? That is the fatal
@@ -2096,11 +4528,24 @@ export function draftSchematicPlacement(validated, projectName, today) {
             predictStubs: false,
         });
         const rideTo = (x, y) => {
+            if (!sameCoord(x, lb.x) || !sameCoord(y, lb.y))
+                trace(`label ${lb.name}: rides its stub from (${lb.x}, ${lb.y}) to (${x}, ${y})`);
             stub.x2 = x;
             stub.y2 = y;
             lb.x = x;
             lb.y = y;
         };
+        // A flag on a vertical stub reads along the row when nothing stands
+        // there (the drafting standard keeps text horizontal; the checker names
+        // every rotated label a horizontal one would have fitted).
+        if (lb.kind === 'global' && rec.o.dy !== 0 && (lb.rot === 90 || lb.rot === 270)) {
+            const flat = [0, 180].find((r) => clearAt(lb.x, lb.y, r) && !mergesAt(lb.x, lb.y));
+            if (flat !== undefined) {
+                lb.rot = flat;
+                continue;
+            }
+            trace(`flag ${lb.name} at (${lb.x}, ${lb.y}) stays vertical: no horizontal draw clears`);
+        }
         if (clearAt(lb.x, lb.y))
             continue;
         /** Candidate points along the stub, nearest first. */
@@ -2139,6 +4584,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
                 !mergesAt(c.x, c.y) &&
                 (sameCoord(c.x, lb.x) && sameCoord(c.y, lb.y) ? true : wireClearAt(c.x, c.y)));
             if (flip) {
+                trace(`label ${lb.name}: turns to rotation ${flipRot} to clear`);
                 lb.rot = flipRot;
                 rideTo(flip.x, flip.y);
                 continue;
@@ -2171,7 +4617,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
     // measure as clean. Nothing clear keeps the placed slot so the report stays
     // honest, and a value that is already clean does not move at all.
     {
-        const labelBoxesFinal = labels.map((l) => labelTextBox(l.name, l.x, l.y, l.rot));
+        const labelBoxesFinal = labels.map((l) => labelTextBox(l.name, l.x, l.y, l.rot, l.kind));
         const memberText = emitPairs.flatMap(({ sym: s, pl }) => [
             centeredTextBox(displayRefOf(pl), s.refAt.x, s.refAt.y),
             centeredTextBox(s.value, s.valueAt.x, s.valueAt.y),
@@ -2180,9 +4626,9 @@ export function draftSchematicPlacement(validated, projectName, today) {
         const liveBoxes = new Map(valueEntries.map((s) => [s, powerValueBox(s.value, s.valueAt.x, s.valueAt.y)]));
         const clearFor = (self, b) => !bodies.some((bd) => boundsOverlap(b, bd)) &&
             !wires.some((w) => segHitsBoxEarly(w, b)) &&
-            !labelBoxesFinal.some((lb) => boundsOverlap(lb, b)) &&
-            !memberText.some((t) => boundsOverlap(t, b)) &&
-            ![...liveBoxes].some(([o, ob]) => o !== self && boundsOverlap(ob, b));
+            !labelBoxesFinal.some((lb) => boundsOverlap(lb, padBox(b))) &&
+            !memberText.some((t) => boundsOverlap(t, padBox(b))) &&
+            ![...liveBoxes].some(([o, ob]) => o !== self && boundsOverlap(ob, padBox(b)));
         for (const s of valueEntries) {
             if (clearFor(s, liveBoxes.get(s)))
                 continue;
@@ -2232,6 +4678,470 @@ export function draftSchematicPlacement(validated, projectName, today) {
         }
     }
     // ---------- sheet: content-derived paper, balanced placement ----------
+    // ---------- group boxes enclose their text ----------
+    // what the wrap was fitted on, to measure how far the text grew each box
+    const rectsBeforeText = groupRects.map((r) => ({ name: r.name, x1: r.x1, x2: r.x2, y1: r.y1, y2: r.y2 }));
+    const reachOut = new Map();
+    // A box drawn from bodies plus a fixed margin cuts through the text its
+    // parts carry: with the IC in the leftmost column, its left-facing pin
+    // labels ran out through the box edge (EN, BTN_PLAY, SPK_L+ on esp32-amp),
+    // and a rail name on a connector stub crossed the line on every reference
+    // board. Grow each box to hold its members' stub labels, their reference
+    // and value fields, and the power symbols on their pins, plus BOX_PAD; the
+    // group gaps above were widened for exactly this text, so boxes stay clear
+    // of one another.
+    {
+        const pinGroup = new Map();
+        for (const [key, pl] of placed) {
+            const g = groupOf.get(key);
+            if (!g)
+                continue;
+            for (const pin of pl.sym.pins) {
+                const p = pinAt(pl, pin);
+                pinGroup.set(pointKey(p.x, p.y), g);
+            }
+        }
+        const boxesOf = new Map();
+        const addBox = (g, b) => {
+            if (!g)
+                return;
+            boxesOf.set(g, [...(boxesOf.get(g) ?? []), b]);
+        };
+        // a label at the end of a stub that starts on a member pin
+        for (const lb of labels) {
+            const stub = wires.find((w) => sameCoord(w.x2, lb.x) && sameCoord(w.y2, lb.y) && pinGroup.has(pointKey(w.x1, w.y1)));
+            const g = stub ? pinGroup.get(pointKey(stub.x1, stub.y1)) : undefined;
+            addBox(g, labelReserveBox(lb.name, lb.x, lb.y, lb.rot, lb.kind));
+        }
+        // reference and value fields of every member, at the reserve advance
+        const fieldBox = (text, x, y) => {
+            const w = Math.max(1, text.length) * TEXT_RESERVE * LABEL_HEIGHT;
+            return { minX: x - w / 2, minY: y - LABEL_HEIGHT / 2, maxX: x + w / 2, maxY: y + LABEL_HEIGHT / 2 };
+        };
+        const keyOfPlaced = new Map([...placed.entries()].map(([k, p]) => [p, k]));
+        for (const { sym, pl } of emitPairs) {
+            const g = groupOf.get(keyOfPlaced.get(pl) ?? '');
+            addBox(g, fieldBox(displayRefOf(pl), sym.refAt.x, sym.refAt.y));
+            addBox(g, fieldBox(sym.value, sym.valueAt.x, sym.valueAt.y));
+        }
+        // power symbols on member stubs, with their value text
+        for (const ps of extraSymbols) {
+            const stub = wires.find((w) => sameCoord(w.x2, ps.at.x) && sameCoord(w.y2, ps.at.y) && pinGroup.has(pointKey(w.x1, w.y1)));
+            const g = stub ? pinGroup.get(pointKey(stub.x1, stub.y1)) : undefined;
+            if (!g)
+                continue;
+            addBox(g, { minX: ps.at.x - 2 * U, minY: ps.at.y - 2 * U, maxX: ps.at.x + 2 * U, maxY: ps.at.y + 2 * U });
+            if (!ps.hideValue)
+                addBox(g, powerValueBox(ps.value, ps.valueAt.x, ps.valueAt.y));
+        }
+        // every member body too: a hung part on a shared lane or an infilled
+        // cell may sit past the cells the rect was first drawn from
+        for (const [key, pl] of placed) {
+            const g = groupOf.get(key);
+            if (g)
+                addBox(g, pl.body);
+        }
+        for (const r of groupRects) {
+            for (const b of boxesOf.get(r.name) ?? []) {
+                r.x1 = Math.min(r.x1, b.minX - BOX_PAD * U);
+                r.x2 = Math.max(r.x2, b.maxX + BOX_PAD * U);
+                r.y1 = Math.min(r.y1, b.minY - BOX_PAD * U);
+                r.y2 = Math.max(r.y2, b.maxY + BOX_PAD * U);
+            }
+            // The caption is a band across the top of the box, not a corner the
+            // parts may rise into: nothing drawn starts above the caption's
+            // bottom plus a unit of air, whatever its column (a rail name beside
+            // the caption read as part of it).
+            const contentTop = Math.min(...(boxesOf.get(r.name) ?? []).map((b) => b.minY));
+            if (Number.isFinite(contentTop))
+                r.y1 = Math.min(r.y1, contentTop - (2 + CAPTION_SIZE + U));
+            r.y1 = grid(Math.floor(r.y1 / U));
+        }
+        // measured before the boxes are aligned: alignment is a choice, not text
+        for (const [i, r] of groupRects.entries()) {
+            const before = rectsBeforeText[i];
+            const applied = reachMeasured?.get(r.name);
+            reachOut.set(r.name, {
+                left: Math.max(0, before.x1 - r.x1),
+                right: Math.max(0, r.x2 - before.x2),
+                top: (applied?.top ?? 0) + Math.max(0, before.y1 - r.y1),
+                bottom: (applied?.bottom ?? 0) + Math.max(0, r.y2 - before.y2),
+            });
+        }
+        // Boxes in one row of the wrap share a bottom edge, boxes in one column
+        // a right edge, when the neighbour's space is free anyway: a row of
+        // boxes ending at three different heights reads as three afterthoughts.
+        // A line of the wrap (a row, or a column) is the set of boxes whose
+        // fitted rects landed at one top (one left): the shifts that took them
+        // there differ box by box, since the single-row pass gave them
+        // different tops.
+        const columnar = fit.wrap?.kind === 'columns' || fit.wrap?.kind === 'masonry';
+        // Two boxes share a line when their fitted rects overlap across it (in
+        // height for a row, in width for a column): a row's boxes may start at
+        // different tops (the single-row pass gives a box room above its IC for
+        // a pull-up) and two rows never overlap, the wrap having left a gap.
+        const lineIndex = new Array(groupRects.length).fill(-1);
+        {
+            const lo = (i) => (columnar ? rectsBeforeText[i].x1 : rectsBeforeText[i].y1);
+            const hi = (i) => (columnar ? rectsBeforeText[i].x2 : rectsBeforeText[i].y2);
+            const order = groupRects.map((_, i) => i).sort((a, b) => lo(a) - lo(b));
+            let line = -1;
+            let reach = -Infinity;
+            for (const i of order) {
+                if (lo(i) >= reach - 1e-6)
+                    line++;
+                lineIndex[i] = line;
+                reach = Math.max(reach, hi(i));
+            }
+        }
+        const lineOf = (i) => lineIndex[i];
+        if (fit.wrap) {
+            const byLine = new Map();
+            for (const [i, r] of groupRects.entries()) {
+                byLine.set(lineOf(i), [...(byLine.get(lineOf(i)) ?? []), r]);
+            }
+            for (const line of byLine.values()) {
+                if (line.length < 2)
+                    continue;
+                if (fit.wrap.kind === 'columns' || fit.wrap.kind === 'masonry') {
+                    const right = Math.max(...line.map((r) => r.x2));
+                    for (const r of line)
+                        r.x2 = right;
+                }
+                else {
+                    const bottom = Math.max(...line.map((r) => r.y2));
+                    for (const r of line)
+                        r.y2 = bottom;
+                }
+            }
+        }
+        // The boxes grew into the gaps the wrap left between cells, each by its
+        // own text, so two boxes might nearly touch where two others stood 10 mm
+        // apart, and a row's boxes started at three different heights. Every box
+        // now moves, with everything drawn in it, so that BOX_LINE_GAP separates
+        // neighbours along and across the lines of the wrap, and a row shares
+        // its top (a column its left). Content moves by whole units to keep the
+        // grid; the box takes the exact position, so its padding varies by less
+        // than a unit while the gaps do not.
+        {
+            const lineGap = BOX_LINE_GAP * U;
+            const byLine = new Map();
+            for (const [i, r] of groupRects.entries()) {
+                byLine.set(lineOf(i), [...(byLine.get(lineOf(i)) ?? []), { r, i }]);
+            }
+            // Every drawn item belongs to one group, decided once before anything
+            // moves: a wire, label, junction, no-connect or power symbol to the
+            // group of the pins on its run (wires joined end to end form the run),
+            // anything unwired to the box it lies in. Deciding by box while boxes
+            // move would hand a moved group's items to the next box they land in.
+            const parent = new Map();
+            const find = (k) => {
+                let x = k;
+                while (parent.has(x) && parent.get(x) !== x)
+                    x = parent.get(x);
+                return x;
+            };
+            const union = (a, b) => {
+                if (!parent.has(a))
+                    parent.set(a, a);
+                if (!parent.has(b))
+                    parent.set(b, b);
+                const ra = find(a);
+                const rb = find(b);
+                if (ra !== rb)
+                    parent.set(ra, rb);
+            };
+            for (const w of wires)
+                union(pointKey(w.x1, w.y1), pointKey(w.x2, w.y2));
+            const runGroup = new Map();
+            for (const [pt, g] of pinGroup) {
+                const root = find(pt);
+                if (!runGroup.has(root))
+                    runGroup.set(root, g);
+            }
+            const inside = (x, y, r) => x >= r.x1 - 1e-6 && x <= r.x2 + 1e-6 && y >= r.y1 - 1e-6 && y <= r.y2 + 1e-6;
+            const groupAt = (x, y) => runGroup.get(find(pointKey(x, y))) ?? groupRects.find((r) => inside(x, y, r))?.name;
+            const wireGroup = new Map(wires.map((w) => [w, groupAt(w.x1, w.y1) ?? groupAt(w.x2, w.y2)]));
+            const pointGroup = new Map();
+            for (const it of [...labels, ...uniqJunctions, ...noConnects])
+                pointGroup.set(it, groupAt(it.x, it.y));
+            const powerGroup = new Map(extraSymbols.map((ps) => [ps, groupAt(ps.at.x, ps.at.y)]));
+            const moveGroup = (r, dx, dy) => {
+                if (!dx && !dy)
+                    return;
+                for (const [key, pl] of placed) {
+                    if (groupOf.get(key) !== r.name)
+                        continue;
+                    pl.x += dx;
+                    pl.y += dy;
+                    pl.body.minX += dx;
+                    pl.body.maxX += dx;
+                    pl.body.minY += dy;
+                    pl.body.maxY += dy;
+                }
+                for (const { sym, pl } of emitPairs) {
+                    if (groupOf.get(keyOfPlaced.get(pl) ?? '') !== r.name)
+                        continue;
+                    sym.at.x += dx;
+                    sym.at.y += dy;
+                    sym.refAt.x += dx;
+                    sym.refAt.y += dy;
+                    sym.valueAt.x += dx;
+                    sym.valueAt.y += dy;
+                }
+                for (const ps of extraSymbols) {
+                    if (powerGroup.get(ps) !== r.name)
+                        continue;
+                    ps.at.x += dx;
+                    ps.at.y += dy;
+                    ps.valueAt.x += dx;
+                    ps.valueAt.y += dy;
+                }
+                for (const w of wires) {
+                    if (wireGroup.get(w) !== r.name)
+                        continue;
+                    w.x1 += dx;
+                    w.x2 += dx;
+                    w.y1 += dy;
+                    w.y2 += dy;
+                }
+                for (const it of [...labels, ...uniqJunctions, ...noConnects]) {
+                    if (pointGroup.get(it) !== r.name)
+                        continue;
+                    it.x += dx;
+                    it.y += dy;
+                }
+                r.x1 += dx;
+                r.x2 += dx;
+                r.y1 += dy;
+                r.y2 += dy;
+            };
+            const snap = (d) => grid(Math.round(d / U));
+            const lines = [...byLine.entries()].sort((a, b) => a[0] - b[0]).map(([, members]) => members);
+            const left0 = Math.min(...groupRects.map((r) => r.x1));
+            const top0 = Math.min(...groupRects.map((r) => r.y1));
+            // what each box was before the alignment above shared its edges
+            const ownSize = new Map(groupRects.map((r, i) => [r.name, { w: Math.max(...(boxesOf.get(r.name) ?? []).map((b) => b.maxX + BOX_PAD * U), rectsBeforeText[i].x2) - r.x1, h: Math.max(...(boxesOf.get(r.name) ?? []).map((b) => b.maxY + BOX_PAD * U), rectsBeforeText[i].y2) - r.y1 }]));
+            if (columnar) {
+                let colLeft = left0;
+                for (const members of lines) {
+                    members.sort((a, b) => a.r.y1 - b.r.y1);
+                    const colW = Math.max(...members.map((m) => m.r.x2 - m.r.x1));
+                    let y = top0;
+                    for (const { r } of members) {
+                        const h = r.y2 - r.y1;
+                        moveGroup(r, snap(colLeft - r.x1), snap(y - r.y1));
+                        r.x1 = colLeft;
+                        r.x2 = colLeft + colW;
+                        r.y1 = y;
+                        r.y2 = y + h;
+                        y += h + lineGap;
+                    }
+                    colLeft += colW + lineGap;
+                }
+            }
+            else {
+                let rowTop = top0;
+                for (const members of lines) {
+                    members.sort((a, b) => a.r.x1 - b.r.x1);
+                    const rowH = Math.max(...members.map((m) => m.r.y2 - m.r.y1));
+                    let x = left0;
+                    for (const { r } of members) {
+                        const w = r.x2 - r.x1;
+                        moveGroup(r, snap(x - r.x1), snap(rowTop - r.y1));
+                        r.x1 = x;
+                        r.x2 = x + w;
+                        r.y1 = rowTop;
+                        r.y2 = rowTop + rowH;
+                        x += w + lineGap;
+                    }
+                    rowTop += rowH + lineGap;
+                }
+            }
+            // A shared edge may reach where the box's own text did not: the
+            // title-block corner. The sheet pass below centres the content in the
+            // frame; predicted here the same way, any box whose aligned edge would
+            // enter the corner falls back to its own width or height there.
+            {
+                const paper = fit.paper;
+                const xs = groupRects.flatMap((r) => [r.x1, r.x2]);
+                const ys = groupRects.flatMap((r) => [r.y1, r.y2]);
+                const contentW = Math.max(...xs) - Math.min(...xs);
+                const contentH = Math.max(...ys) - Math.min(...ys);
+                const dx = grid(Math.round((FRAME + Math.max(0, (paper.w - 2 * FRAME - contentW) / 2) - Math.min(...xs)) / U));
+                const dy = grid(Math.round((FRAME + 4 * U + Math.max(0, (paper.h - 2 * FRAME - TITLE_STRIP - contentH) / 2) - Math.min(...ys)) / U));
+                const cornerX = paper.w - FRAME - TITLE_BLOCK_W - dx;
+                const cornerY = paper.h - FRAME - TITLE_STRIP - dy;
+                for (const r of groupRects) {
+                    if (r.x2 <= cornerX || r.y2 <= cornerY)
+                        continue;
+                    const o = ownSize.get(r.name);
+                    const ownX2 = r.x1 + o.w;
+                    const ownY2 = r.y1 + o.h;
+                    // give back the aligned width first (a wide short row), then the height
+                    if (ownX2 <= cornerX && r.x2 > ownX2)
+                        r.x2 = ownX2;
+                    if (r.x2 > cornerX && ownY2 <= cornerY && r.y2 > ownY2)
+                        r.y2 = ownY2;
+                }
+            }
+        }
+    }
+    // ---------- measure what every cell drew (for the squeeze), before the sheet shift ----------
+    // Every drawn item is attributed to the cells it belongs to: a body and its
+    // fields to their instance; a wire, with the labels and power symbols on
+    // it, to every instance with a pin on its run (a comb belongs to the IC and
+    // the parts hung on it, which roll up to the IC below). A cell's overhang is
+    // then how far that union reaches past its body on each side.
+    const measuredOut = new Map();
+    {
+        const parent = new Map();
+        const find = (k) => {
+            let r = k;
+            while (parent.has(r) && parent.get(r) !== r)
+                r = parent.get(r);
+            return r;
+        };
+        const union = (a, b) => {
+            if (!parent.has(a))
+                parent.set(a, a);
+            if (!parent.has(b))
+                parent.set(b, b);
+            const ra = find(a);
+            const rb = find(b);
+            if (ra !== rb)
+                parent.set(ra, rb);
+        };
+        for (const w of wires)
+            union(pointKey(w.x1, w.y1), pointKey(w.x2, w.y2));
+        const boxes = new Map();
+        const dbgSrc = new Map();
+        const extend = (key, b, why = 'body') => {
+            if (process.env['COPPERHEAD_DRAFT_TRACE'] === '1')
+                dbgSrc.set(key, [...(dbgSrc.get(key) ?? []), `${why}[${b.minX.toFixed(0)},${b.minY.toFixed(0)}..${b.maxX.toFixed(0)},${b.maxY.toFixed(0)}]`]);
+            const cur = boxes.get(key);
+            boxes.set(key, cur ? { minX: Math.min(cur.minX, b.minX), minY: Math.min(cur.minY, b.minY), maxX: Math.max(cur.maxX, b.maxX), maxY: Math.max(cur.maxY, b.maxY) } : { ...b });
+        };
+        const compOwners = new Map();
+        for (const [key, pl] of placed) {
+            extend(key, pl.body);
+            for (const pin of pl.sym.pins) {
+                const p = pinAt(pl, pin);
+                const pk = pointKey(p.x, p.y);
+                if (!parent.has(pk))
+                    continue;
+                const c = find(pk);
+                compOwners.set(c, (compOwners.get(c) ?? new Set()).add(key));
+            }
+        }
+        const keyOf = new Map([...placed.entries()].map(([k, p]) => [p, k]));
+        for (const { sym, pl } of emitPairs) {
+            const key = keyOf.get(pl);
+            if (!key)
+                continue;
+            extend(key, centeredTextBox(displayRefOf(pl), sym.refAt.x, sym.refAt.y), 'ref');
+            extend(key, centeredTextBox(sym.value, sym.valueAt.x, sym.valueAt.y), 'value');
+        }
+        const compBox = new Map();
+        const extendComp = (c, b) => {
+            const cur = compBox.get(c);
+            compBox.set(c, cur ? { minX: Math.min(cur.minX, b.minX), minY: Math.min(cur.minY, b.minY), maxX: Math.max(cur.maxX, b.maxX), maxY: Math.max(cur.maxY, b.maxY) } : { ...b });
+        };
+        for (const w of wires)
+            extendComp(find(pointKey(w.x1, w.y1)), { minX: Math.min(w.x1, w.x2), minY: Math.min(w.y1, w.y2), maxX: Math.max(w.x1, w.x2), maxY: Math.max(w.y1, w.y2) });
+        const compAt = (x, y) => {
+            const pk = pointKey(x, y);
+            if (parent.has(pk))
+                return find(pk);
+            const w = wires.find((s) => segContains(s, x, y));
+            return w ? find(pointKey(w.x1, w.y1)) : null;
+        };
+        for (const l of labels) {
+            const c = compAt(l.x, l.y);
+            if (c)
+                extendComp(c, labelTextBox(l.name, l.x, l.y, l.rot, l.kind));
+        }
+        for (const ps of extraSymbols) {
+            const c = compAt(ps.at.x, ps.at.y);
+            if (!c)
+                continue;
+            extendComp(c, { minX: ps.at.x - 2 * U, minY: ps.at.y - 2 * U, maxX: ps.at.x + 2 * U, maxY: ps.at.y + 2 * U });
+            if (!ps.hideValue)
+                extendComp(c, powerValueBox(ps.value, ps.valueAt.x, ps.valueAt.y));
+        }
+        const rootOf = (k) => {
+            let r = k;
+            for (let i = 0; i < 6 && boundTo.has(r); i++)
+                r = boundTo.get(r);
+            return r;
+        };
+        // A run with one owner cell (an IC and the parts hung on it) is that
+        // cell's; a run shared by several independent cells (a bank's rail and
+        // ground trunks, a cluster wire between two column parts) gives each
+        // owner only the wires that touch its own pins, with the labels and
+        // symbols at their far ends — attributed whole, a bank's trunk made every
+        // capacitor's cell as wide as the bank.
+        const pinComp = new Map(); // pin point -> owner key
+        for (const [key, pl] of placed)
+            for (const pin of pl.sym.pins) {
+                const p = pinAt(pl, pin);
+                pinComp.set(pointKey(p.x, p.y), key);
+            }
+        const itemsAt = new Map(); // point -> boxes of labels/symbols anchored there
+        const addItem = (x, y, b) => {
+            itemsAt.set(pointKey(x, y), [...(itemsAt.get(pointKey(x, y)) ?? []), b]);
+        };
+        for (const l of labels)
+            addItem(l.x, l.y, labelTextBox(l.name, l.x, l.y, l.rot, l.kind));
+        for (const ps of extraSymbols) {
+            addItem(ps.at.x, ps.at.y, { minX: ps.at.x - 2 * U, minY: ps.at.y - 2 * U, maxX: ps.at.x + 2 * U, maxY: ps.at.y + 2 * U });
+            if (!ps.hideValue)
+                addItem(ps.at.x, ps.at.y, powerValueBox(ps.value, ps.valueAt.x, ps.valueAt.y));
+        }
+        for (const [c, owners] of compOwners) {
+            const roots = new Set([...owners].map(rootOf));
+            const b = compBox.get(c);
+            if (!b)
+                continue;
+            if (roots.size === 1) {
+                extend([...roots][0], b, `run(${[...owners].join('+')})`);
+                continue;
+            }
+            for (const w of wires) {
+                if (find(pointKey(w.x1, w.y1)) !== c)
+                    continue;
+                const ends = [pointKey(w.x1, w.y1), pointKey(w.x2, w.y2)];
+                const touching = new Set(ends.map((e) => pinComp.get(e)).filter((k) => k !== undefined).map(rootOf));
+                for (const r of touching) {
+                    extend(r, { minX: Math.min(w.x1, w.x2), minY: Math.min(w.y1, w.y2), maxX: Math.max(w.x1, w.x2), maxY: Math.max(w.y1, w.y2) }, `wire(${w.net})`);
+                    for (const e of ends)
+                        for (const ib of itemsAt.get(e) ?? [])
+                            extend(r, ib, `item@${e}`);
+                }
+            }
+        }
+        for (const [key, b] of [...boxes.entries()]) {
+            const r = rootOf(key);
+            if (r !== key)
+                extend(r, b, `child ${key}`);
+        }
+        for (const [key, pl] of placed) {
+            if (rootOf(key) !== key)
+                continue;
+            const b = boxes.get(key);
+            if (!b)
+                continue;
+            if (process.env['COPPERHEAD_DRAFT_TRACE'] && (b.maxX - b.minX > 4 * (pl.body.maxX - pl.body.minX) + 30 || b.maxY - b.minY > 4 * (pl.body.maxY - pl.body.minY) + 30)) {
+                trace(`measured ${key}: drawn extent ${(b.maxX - b.minX).toFixed(0)}x${(b.maxY - b.minY).toFixed(0)} mm around a ${(pl.body.maxX - pl.body.minX).toFixed(0)}x${(pl.body.maxY - pl.body.minY).toFixed(0)} body <- ${(dbgSrc.get(key) ?? []).slice(0, 12).join(' ')}`);
+            }
+            measuredOut.set(key, {
+                left: Math.max(0, pl.body.minX - b.minX),
+                right: Math.max(0, b.maxX - pl.body.maxX),
+                top: Math.max(0, pl.body.minY - b.minY),
+                bottom: Math.max(0, b.maxY - pl.body.maxY),
+            });
+        }
+    }
     const allX = [...groupRects.map((r) => r.x1), ...groupRects.map((r) => r.x2)];
     const allY = [...groupRects.map((r) => r.y1), ...groupRects.map((r) => r.y2)];
     const contentW = allX.length ? Math.max(...allX) - Math.min(...allX) : 0;
@@ -2257,11 +5167,15 @@ export function draftSchematicPlacement(validated, projectName, today) {
     // the frame, and an extent wider than the window keeps the centered offset
     // (that overflow was already noted by the fit pass).
     const textBoxes = [
-        ...labels.map((l) => labelTextBox(l.name, l.x, l.y, l.rot)),
+        ...labels.map((l) => labelTextBox(l.name, l.x, l.y, l.rot, l.kind)),
         // power VALUE text is measured by the checker too, and the sweep above
         // may have slid it past its group rect's margin (pic_programmer put a
         // rail name 1 mm over the top edge of a compacted sheet)
         ...extraSymbols.filter((s) => !s.hideValue).map((s) => powerValueBox(s.value, s.valueAt.x, s.valueAt.y)),
+        // group captions: left-top justified at CAPTION_SIZE from the box
+        // corner, the way emit.ts writes them and the checker measures them; a
+        // long caption on a narrow group can outrun the box's right edge
+        ...groupRects.map((r) => ({ minX: r.x1 + 2, minY: r.y1 + 2, maxX: r.x1 + 2 + Math.max(1, r.name.length) * LABEL_ADVANCE * CAPTION_SIZE, maxY: r.y1 + 2 + CAPTION_SIZE })),
     ];
     const fullMinX = Math.min(minX, ...textBoxes.map((b) => b.minX));
     const fullMaxX = Math.max(minX + contentW, ...textBoxes.map((b) => b.maxX));
@@ -2286,7 +5200,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
     // the bottom edge is the engine's own usable bottom, ABOVE the title strip:
     // content that fills the sheet's height exactly would otherwise carry the
     // centering pass's 4-unit downward offset into the reserved corner
-    dy = clampShift(dy, fullMinY, fullMaxY, FRAME, paper.h - FRAME - TITLE_STRIP);
+    dy = clampShift(dy, fullMinY, fullMaxY, FRAME, fit.intoStrip ? paper.h - FRAME : paper.h - FRAME - TITLE_STRIP);
     const shift = (o) => {
         if (o.x !== undefined)
             o.x += dx;
@@ -2362,6 +5276,7 @@ export function draftSchematicPlacement(validated, projectName, today) {
         noConnects,
         rectangles: groupRects.map((r) => ({ x1: r.x1, y1: r.y1, x2: r.x2, y2: r.y2, stroke: 'solid', name: r.name })),
         captions: groupRects.map((r) => ({ text: r.name, x: r.x1 + 2, y: r.y1 + 2, name: r.name })),
+        netColors: netColorsOf(intent.nets, netClasses),
     };
     const report = {
         groups: groupNames.map((g) => ({
@@ -2378,12 +5293,18 @@ export function draftSchematicPlacement(validated, projectName, today) {
         labelCount: labels.length,
         pwrFlags,
         noConnects: noConnects.length,
+        sheetFit: {
+            paper: paper.name,
+            inkUtilization: [...placed.values()].reduce((a, p) => a + p.cellW * p.cellH * U * U, 0) / (usableW(paper) * usableH(paper)),
+            compaction,
+            misses: [...budgetMisses],
+        },
         paper: paper.name,
         notes,
         mergedNets,
         labelOverlaps,
         labelOverlapBudgetExceeded,
     };
-    return { model, report };
+    return { model, report, rects: groupRects, measured: measuredOut, reach: reachOut, wrapped: fit.wrap !== null };
 }
 //# sourceMappingURL=engine.js.map