copperhead 0.10.0 → 0.11.0

package/src/kicad/draft/symsource.ts

@@ -308,14 +308,26 @@ export class SymbolSource {
     return [...this.libs].sort();
   }
 
-  /** Write an engine-generated symbol block into the vendored cache (power lib). */
+  /**
+   * Write an engine-generated symbol block into the vendored cache (power lib).
+   *
+   * A generated block is the engine's, not a vendor's: when the engine's
+   * drawing of a rail or ground changes, the cached copy must follow, or every
+   * embedded power symbol on the sheet raises a lib_symbol_mismatch warning
+   * against the stale library (the triangle-ground redraw hit 111 of them on
+   * esp32-amp). A block already cached byte-for-byte is left alone.
+   */
   async vendorGenerated(libId: string, block: string): Promise<void> {
     const lib = libId.slice(0, libId.indexOf(':'));
     const name = libId.slice(libId.indexOf(':') + 1);
     const file = path.join(this.cacheDir(), vendorFileName(lib));
     await mkdir(this.cacheDir(), { recursive: true });
-    const text = existsSync(file) ? await readFile(file, 'utf8') : emptyVendorLib();
-    if (!extractSymbolBlock(text, name)) await writeFile(file, appendToVendorLib(text, block), 'utf8');
+    let text = existsSync(file) ? await readFile(file, 'utf8') : emptyVendorLib();
+    const cached = extractSymbolBlock(text, name);
+    if (cached !== block) {
+      if (cached) text = text.replace(cached + '\n', '').replace(cached, '');
+      await writeFile(file, appendToVendorLib(text, block), 'utf8');
+    }
     this.libs.add(lib);
   }
 
@@ -473,15 +485,16 @@ export function powerSymbolSource(rawNet: string, kind: 'rail' | 'ground'): { li
   const name = powerNetToken(rawNet);
   const libId = `copperhead_power:${name}`;
   // Symbol space is Y-up and the schematic transform flips it: negative-Y
-  // graphics here render BELOW the connection point on the sheet. Ground bars
-  // hang below their pin (angle 270 = line toward -Y body); rail bars sit
-  // above (angle 90).
+  // graphics here render BELOW the connection point on the sheet. A ground
+  // hangs below its pin (angle 270 = line toward -Y body) as a stem and an
+  // open triangle, the reference-ground glyph; a rail rises above (angle 90)
+  // as a stem and a filled arrowhead, the way KiCad's own +3V3 draws. Both
+  // reach 2.54 from the pin, inside the 2-unit box the engine reserves.
   const body =
     kind === 'ground'
       ? `\t(symbol "${name}_0_1"
-\t\t(polyline (pts (xy -1.27 -1.27) (xy 1.27 -1.27)) (stroke (width 0.254) (type default)) (fill (type none)))
-\t\t(polyline (pts (xy -0.762 -1.778) (xy 0.762 -1.778)) (stroke (width 0.254) (type default)) (fill (type none)))
-\t\t(polyline (pts (xy -0.254 -2.286) (xy 0.254 -2.286)) (stroke (width 0.254) (type default)) (fill (type none)))
+\t\t(polyline (pts (xy 0 0) (xy 0 -1.27)) (stroke (width 0.254) (type default)) (fill (type none)))
+\t\t(polyline (pts (xy -1.27 -1.27) (xy 1.27 -1.27) (xy 0 -2.54) (xy -1.27 -1.27)) (stroke (width 0.254) (type default)) (fill (type none)))
 \t)
 \t(symbol "${name}_1_1"
 \t\t(pin power_in line (at 0 0 270) (length 0) hide
@@ -490,7 +503,8 @@ export function powerSymbolSource(rawNet: string, kind: 'rail' | 'ground'): { li
 \t\t)
 \t)`
       : `\t(symbol "${name}_0_1"
-\t\t(polyline (pts (xy -1.27 1.27) (xy 1.27 1.27)) (stroke (width 0.254) (type default)) (fill (type none)))
+\t\t(polyline (pts (xy 0 0) (xy 0 1.27)) (stroke (width 0.254) (type default)) (fill (type none)))
+\t\t(polyline (pts (xy -0.762 1.27) (xy 0 2.54) (xy 0.762 1.27) (xy -0.762 1.27)) (stroke (width 0.254) (type default)) (fill (type outline)))
 \t)
 \t(symbol "${name}_1_1"
 \t\t(pin power_in line (at 0 0 90) (length 0) hide

package/src/kicad/emit.ts

@@ -41,6 +41,8 @@ export interface EmitSymbol {
   value: string;
   footprint: string;
   at: { x: number; y: number; rot: number };
+  /** KiCad `(mirror x|y)`: y flips the symbol left-for-right (a transistor whose base must face right). */
+  mirror?: 'x' | 'y';
   /** Reference/Value text anchors (absolute). Hidden properties reuse the origin. */
   refAt: { x: number; y: number };
   valueAt: { x: number; y: number };
@@ -55,6 +57,38 @@ export interface EmitSymbol {
   unit?: number;
 }
 
+/** Flag outline of a global label: KiCad's shape vocabulary, chosen from the
+ * electrical type of the pin the label serves (`shape` is cosmetic in ERC). */
+export type LabelShape = 'input' | 'output' | 'bidirectional' | 'passive';
+
+export interface EmitLabel {
+  name: string;
+  x: number;
+  y: number;
+  /** KiCad's own rotation: text extends right (0), up (90), left (180) or
+   * down (270) from the anchor, in schematic Y-down coordinates. */
+  rot: number;
+  /** A `global` label draws as a bordered flag whose tip sits on the wire
+   * end; a `local` one is bare text standing on its wire. Nets that leave a
+   * wired run through a stub carry global flags everywhere (a local and a
+   * global label of one name do not connect in KiCad); a net wired whole
+   * keeps a plain local name on the run. Unstated means local. */
+  kind?: 'local' | 'global';
+  /** Flag shape of a global label; unstated means passive (a plain box). */
+  shape?: LabelShape;
+}
+
+/** Font height, mm, of a group caption; bold so a subsystem title reads at
+ * arm's length on an A1/A2 sheet. */
+export const CAPTION_SIZE = 3.5;
+/** Font height, mm, of every net label. */
+export const LABEL_SIZE = 1.27;
+/** Stroke thickness, mm, of label text and the flag outline drawn with it;
+ * KiCad's default is size/8 ≈ 0.16, too faint against a coloured wire. */
+export const LABEL_THICKNESS = 0.2;
+/** Wire stroke width, mm; 0 would mean KiCad's default of 0.1524. */
+export const WIRE_WIDTH = 0.254;
+
 export interface PlacementModel {
   projectName: string;
   paper: string;
@@ -64,10 +98,12 @@ export interface PlacementModel {
   symbols: EmitSymbol[];
   wires: { x1: number; y1: number; x2: number; y2: number; net: string; index: number }[];
   junctions: { x: number; y: number }[];
-  labels: { name: string; x: number; y: number; rot: number }[];
+  labels: EmitLabel[];
   noConnects: { x: number; y: number }[];
   rectangles: { x1: number; y1: number; x2: number; y2: number; stroke: 'solid' | 'dash'; name: string }[];
   captions: { text: string; x: number; y: number; name: string }[];
+  /** Wire and label colour per net, RGB 0..255; nets absent here draw in the theme default. */
+  netColors?: Record<string, [number, number, number]>;
 }
 
 /**
@@ -147,11 +183,15 @@ export function emitSchematic(model: PlacementModel): string {
     L.push(`\t(no_connect (at ${knum(n.x)} ${knum(n.y)}) (uuid ${q(id(`no_connect/${knum(n.x)},${knum(n.y)}`))}))`);
   }
 
+  const colorOf = (net: string): string => {
+    const c = model.netColors?.[net];
+    return c ? ` (color ${c[0]} ${c[1]} ${c[2]} 1)` : '';
+  };
   const wires = [...model.wires].sort((a, b) => a.net.localeCompare(b.net) || a.index - b.index);
   for (const w of wires) {
     L.push('\t(wire');
     L.push(`\t\t(pts (xy ${knum(w.x1)} ${knum(w.y1)}) (xy ${knum(w.x2)} ${knum(w.y2)}))`);
-    L.push('\t\t(stroke (width 0) (type default))');
+    L.push(`\t\t(stroke (width ${knum(WIRE_WIDTH)}) (type default)${colorOf(w.net)})`);
     L.push(`\t\t(uuid ${q(id(`wire/${w.net}/${w.index}`))})`);
     L.push('\t)');
   }
@@ -168,18 +208,36 @@ export function emitSchematic(model: PlacementModel): string {
   const caps = [...model.captions].sort((a, b) => a.name.localeCompare(b.name));
   for (const c of caps) {
     L.push(`\t(text ${q(c.text)} (at ${knum(c.x)} ${knum(c.y)} 0)`);
-    L.push('\t\t(effects (font (size 2 2)) (justify left top))');
+    L.push(`\t\t(effects (font (size ${knum(CAPTION_SIZE)} ${knum(CAPTION_SIZE)}) bold) (justify left top))`);
     L.push(`\t\t(uuid ${q(id(`caption/${c.name}`))})`);
     L.push('\t)');
   }
 
   const labels = [...model.labels].sort((a, b) => a.name.localeCompare(b.name) || a.x - b.x || a.y - b.y);
   for (const lb of labels) {
+    const uuid = q(id(`label/${lb.name}/${knum(lb.x)},${knum(lb.y)}`));
+    if (lb.kind === 'global') {
+      // eeschema's own encoding of a flag: the stored angle is the true one
+      // and the justification names the side of the anchor the text is on
+      // (left = extends right/up, right = extends left/down)
+      const rot = ((lb.rot % 360) + 360) % 360;
+      const justify = rot === 180 || rot === 270 ? 'right' : 'left';
+      L.push(`\t(global_label ${q(lb.name)} (shape ${lb.shape ?? 'passive'}) (at ${knum(lb.x)} ${knum(lb.y)} ${knum(rot)}) (fields_autoplaced yes)`);
+      L.push(`\t\t(effects (font (size ${knum(LABEL_SIZE)} ${knum(LABEL_SIZE)}) (thickness ${knum(LABEL_THICKNESS)})${colorOf(lb.name)}) (justify ${justify}))`);
+      L.push(`\t\t(uuid ${uuid})`);
+      L.push(`\t\t(property "Intersheetrefs" "\${INTERSHEET_REFS}" (at ${knum(lb.x)} ${knum(lb.y)} 0)`);
+      L.push(`\t\t\t(effects (font (size ${knum(LABEL_SIZE)} ${knum(LABEL_SIZE)})) hide)`);
+      L.push('\t\t)');
+      L.push('\t)');
+      continue;
+    }
+    // a local label never draws upside down: 180/270 are drawn as 0/90 with
+    // the justification mirrored, which is how eeschema itself stores them
     const justify = lb.rot === 180 || lb.rot === 270 ? 'right bottom' : 'left bottom';
     const drawRot = lb.rot === 180 ? 0 : lb.rot === 270 ? 90 : lb.rot;
     L.push(`\t(label ${q(lb.name)} (at ${knum(lb.x)} ${knum(lb.y)} ${knum(drawRot)})`);
-    L.push(`\t\t(effects (font (size 1.27 1.27)) (justify ${justify}))`);
-    L.push(`\t\t(uuid ${q(id(`label/${lb.name}/${knum(lb.x)},${knum(lb.y)}`))})`);
+    L.push(`\t\t(effects (font (size ${knum(LABEL_SIZE)} ${knum(LABEL_SIZE)}) (thickness ${knum(LABEL_THICKNESS)})${colorOf(lb.name)}) (justify ${justify}))`);
+    L.push(`\t\t(uuid ${uuid})`);
     L.push('\t)');
   }
 
@@ -196,16 +254,22 @@ export function emitSchematic(model: PlacementModel): string {
     L.push('\t(symbol');
     L.push(`\t\t(lib_id ${q(s.libId)})`);
     L.push(`\t\t(at ${knum(s.at.x)} ${knum(s.at.y)} ${knum(s.at.rot)})`);
+    if (s.mirror) L.push(`\t\t(mirror ${s.mirror})`);
     L.push(`\t\t(unit ${unit})`);
     L.push('\t\t(exclude_from_sim no)');
     L.push('\t\t(in_bom yes)');
     L.push('\t\t(on_board yes)');
     L.push('\t\t(dnp no)');
     L.push(`\t\t(uuid ${q(sid)})`);
-    L.push(`\t\t(property "Reference" ${q(s.ref)} (at ${knum(s.refAt.x)} ${knum(s.refAt.y)} 0)`);
+    // KiCad adds the symbol's rotation to a property's angle when it draws
+    // the text, so a part turned 90 or 270 stores 90 to keep its reference
+    // and value reading horizontally (every rotated resistor in KiCad's own
+    // demos does). Storing 0 stood the bootstrap caps' values on end.
+    const fieldRot = s.at.rot % 180 === 90 ? 90 : 0;
+    L.push(`\t\t(property "Reference" ${q(s.ref)} (at ${knum(s.refAt.x)} ${knum(s.refAt.y)} ${fieldRot})`);
     L.push(`\t\t\t(effects (font (size 1.27 1.27))${hideRef})`);
     L.push('\t\t)');
-    L.push(`\t\t(property "Value" ${q(s.value)} (at ${knum(s.valueAt.x)} ${knum(s.valueAt.y)} 0)`);
+    L.push(`\t\t(property "Value" ${q(s.value)} (at ${knum(s.valueAt.x)} ${knum(s.valueAt.y)} ${fieldRot})`);
     L.push(`\t\t\t(effects (font (size 1.27 1.27))${hideValue})`);
     L.push('\t\t)');
     L.push(`\t\t(property "Footprint" ${q(s.footprint)} (at ${knum(s.at.x)} ${knum(s.at.y)} 0)`);

package/src/kicad/legibility.ts

@@ -183,12 +183,29 @@ function transformBounds(at: { x: number; y: number; rot: number }, mirror: 'x'
 }
 
 /** Conservative text box, centered on the anchor; vertical when rotated 90/270. */
-function textBounds(t: { text: string; x: number; y: number; rot: number; height: number }): Bounds {
+function textBounds(t: {
+  text: string;
+  x: number;
+  y: number;
+  rot: number;
+  height: number;
+  justifyH?: 'left' | 'right' | null;
+  justifyV?: 'top' | 'bottom' | null;
+}): Bounds {
   const w = Math.max(1, t.text.length) * TEXT_ADVANCE * t.height;
   const h = t.height;
   const vertical = Math.abs(t.rot % 180) === 90;
   const [bw, bh] = vertical ? [h, w] : [w, h];
-  return { minX: t.x - bw / 2, minY: t.y - bh / 2, maxX: t.x + bw / 2, maxY: t.y + bh / 2 };
+  // A free text is centred on its anchor unless its effects justify it: the
+  // engine's group captions are `left top`, so their box runs right and down
+  // from the anchor. Measuring those as centred put half the caption's width
+  // left of the group box and flagged a caption 12 mm inside the frame as
+  // out of it (esp32-amp, A1 at full width).
+  const jh = vertical ? null : (t.justifyH ?? null);
+  const jv = vertical ? null : (t.justifyV ?? null);
+  const minX = jh === 'left' ? t.x : jh === 'right' ? t.x - bw : t.x - bw / 2;
+  const minY = jv === 'top' ? t.y : jv === 'bottom' ? t.y - bh : t.y - bh / 2;
+  return { minX, minY, maxX: minX + bw, maxY: minY + bh };
 }
 
 /**
@@ -210,19 +227,44 @@ function textBounds(t: { text: string; x: number; y: number; rot: number; height
  * of them on the wrong side of the anchor either invents a collision with the
  * symbol the label serves or hides a real one.
  */
-function labelBounds(l: { name: string; x: number; y: number; rot: number; height: number; justify?: 'left' | 'right' | null }): Bounds {
+function labelBounds(l: { name: string; x: number; y: number; rot: number; height: number; justify?: 'left' | 'right' | null; kind?: string }): Bounds {
   const w = Math.max(1, l.name.length) * TEXT_ADVANCE * l.height;
   const h = l.height;
   const rot = ((l.rot % 360) + 360) % 360;
+  if (l.kind === 'global_label' || l.kind === 'hierarchical_label') {
+    // A flag is drawn two heights tall, CENTRED on the anchor line, with its
+    // outline (a margin each side of the text plus the pointed tip) running
+    // away from the anchor in the angle's direction; the stored justification
+    // only restates that direction. Measured from eeschema's own outline.
+    const fw = w + 2 * h;
+    if (rot === 90) return { minX: l.x - h, minY: l.y - fw, maxX: l.x + h, maxY: l.y };
+    if (rot === 270) return { minX: l.x - h, minY: l.y, maxX: l.x + h, maxY: l.y + fw };
+    if (rot === 180) return { minX: l.x - fw, minY: l.y - h, maxX: l.x, maxY: l.y + h };
+    return { minX: l.x, minY: l.y - h, maxX: l.x + fw, maxY: l.y + h };
+  }
   const justified = l.justify ?? (rot === 180 || rot === 270 ? 'right' : 'left');
   if (rot === 90 || rot === 270) {
     return justified === 'left'
       ? { minX: l.x - h / 2, minY: l.y - w, maxX: l.x + h / 2, maxY: l.y }
       : { minX: l.x - h / 2, minY: l.y, maxX: l.x + h / 2, maxY: l.y + w };
   }
+  // Vertically the text STANDS on its anchor: eeschema draws a horizontal
+  // label bottom-justified, so the box runs one height above the anchor line
+  // and nothing below it. Measuring it centred put half the box below the
+  // wire the label sits on and called every label on a horizontal wire "text
+  // on a wire" — the ordinary way a person names a wire.
   return justified === 'right'
-    ? { minX: l.x - w, minY: l.y - h / 2, maxX: l.x, maxY: l.y + h / 2 }
-    : { minX: l.x, minY: l.y - h / 2, maxX: l.x + w, maxY: l.y + h / 2 };
+    ? { minX: l.x - w, minY: l.y - h, maxX: l.x, maxY: l.y }
+    : { minX: l.x, minY: l.y - h, maxX: l.x + w, maxY: l.y };
+}
+
+/** Does the wire lie behind a flag's tip, along the direction the flag's text does NOT extend? */
+function onPoleSide(w: WireSeg, l: { x: number; y: number; rot: number }): boolean {
+  const r = ((l.rot % 360) + 360) % 360;
+  if (r === 0) return Math.max(w.x1, w.x2) <= l.x + TOL;
+  if (r === 180) return Math.min(w.x1, w.x2) >= l.x - TOL;
+  if (r === 90) return Math.min(w.y1, w.y2) >= l.y - TOL;
+  return Math.max(w.y1, w.y2) <= l.y + TOL;
 }
 
 function segIntersectsBounds(s: WireSeg, b: Bounds): boolean {
@@ -397,7 +439,11 @@ function checkSheet(
   const labelBoxes = sheet.labels.map((l) => ({
     l,
     box: labelBounds(l),
-    attached: sheet.wires.filter((w) => pointOnSeg(l.x, l.y, w)),
+    // a plain label stands above its wire, so every wire through the anchor
+    // is its attachment; a flag is drawn centred on the anchor line, so a
+    // wire continuing under the text runs through the flag — only the wire
+    // behind the tip (the pole side) attaches it
+    attached: sheet.wires.filter((w) => pointOnSeg(l.x, l.y, w) && (l.kind === 'label' || onPoleSide(w, l))),
   }));
 
   // --- groups (design C1): sheet rectangles with a caption in the top band ---
@@ -529,6 +575,9 @@ function checkSheet(
   // --- label-orientation: rotated where a horizontal draw would collide with nothing ---
   for (const lb of labelBoxes) {
     if (Math.abs(lb.l.rot % 180) !== 90) continue;
+    // a flag continuing a vertical wire is oriented by that wire, not by
+    // taste: turning it horizontal would hang it sideways off the wire end
+    if (lb.l.kind !== 'label' && lb.attached.some((w) => Math.abs(w.x1 - w.x2) < TOL)) continue;
     const horizontal = labelBounds({ ...lb.l, rot: 0 });
     const collides =
       realSyms.some((s) => s.body && boundsOverlap(horizontal, s.body)) ||

package/src/kicad/score.ts

@@ -1,4 +1,4 @@
-import { readSheetGeometry, type SheetGeometry, type Bounds } from './sexp.js';
+import { readSheetGeometry, pinsOfUnit, pinAbsolute, type SheetGeometry, type Bounds } from './sexp.js';
 import { checkLegibility, type LegibilityReport } from './legibility.js';
 import type { LegibilityUserConfig } from '../config.js';
 
@@ -25,12 +25,23 @@ export interface ScoreMetric {
 export interface ScoreReport {
   composite: number;
   metrics: ScoreMetric[];
+  /**
+   * Wiring style, scored without the drafting standard's conventions. The
+   * composite above needs group boxes, captions and a title block, so a
+   * hand-drawn sheet that lacks them is capped at 40 whatever its craft.
+   * This block measures only how the parts connect — the thing a reader of
+   * any schematic judges first — and is never capped, so an engine draft
+   * and the human drawing of the same circuit compare on one scale.
+   */
+  style: { composite: number; metrics: ScoreMetric[] };
   /** Applied error-finding cap, or null. */
   cap: { appliedAt: number; reason: string } | null;
   legibility: { error: number; advisory: number };
 }
 
 const DEFAULT_WEIGHTS: Record<string, number> = {
+  'pin-attachment': 10,
+  'island-parts': 5,
   'wire-crossings': 10,
   'wire-bends': 5,
   'wire-length': 5,
@@ -46,6 +57,23 @@ const DEFAULT_WEIGHTS: Record<string, number> = {
   'pair-symmetry': 5,
 };
 
+/**
+ * Weights of the convention-free style composite. Calibrated on the KiCad
+ * demo corpus (fifteen hand-drawn projects, 17 to 1138 parts): a person wires
+ * 90 to 100 % of two-pin parts straight to another part, leaves 0 to 2 % as
+ * label-only islands, draws 0.3 to 1.2 power symbols per part and, outside
+ * bus-heavy boards, under one label per part. Engine drafts before pin
+ * attachment measured 14 to 53 % attached and 9 to 13 % islands.
+ */
+const STYLE_WEIGHTS: Record<string, number> = {
+  'pin-attachment': 30,
+  'island-parts': 20,
+  'power-symbol-economy': 15,
+  'labels-per-part': 15,
+  'crossings-per-wire': 10,
+  'straight-wire-ratio': 10,
+};
+
 /** Composite is capped this far below the Tier A floor when errors exist. */
 const DEFAULT_FLOOR = 85;
 const ERROR_CAP = 40;
@@ -81,6 +109,124 @@ function properCrossing(a: Seg, b: Seg): boolean {
   return vx > hx1 + 0.01 && vx < hx2 - 0.01 && hy > vy1 + 0.01 && hy < vy2 - 0.01;
 }
 
+/** Library prefixes whose multi-pin symbols are not ICs for the style metrics. */
+const NOT_IC = /^(Connector|Switch|TestPoint|Mechanical|Jumper|Graphic|Device:Crystal|Device:Q_|Device:D_|Device:LED)/;
+
+export interface WiringStyle {
+  parts: number;
+  ics: number;
+  twoPin: number;
+  powerSymbols: number;
+  labels: number;
+  /** two-pin parts with at least one pin wired straight to another part */
+  twoPinAttached: number;
+  /** two-pin parts whose every pin ends in a label or nothing */
+  twoPinIslands: number;
+  icPins: number;
+  icPinsWired: number;
+  icPinsLabelled: number;
+}
+
+/**
+ * How the parts of a sheet set connect, by following wires from each placed
+ * pin: to another part's pin, to a power symbol, to a net label, or nowhere.
+ * Wire joins are endpoint-to-endpoint and endpoint-onto-segment (a T), the
+ * same two ways KiCad itself joins them.
+ */
+export function measureWiringStyle(sheets: SheetGeometry[]): WiringStyle {
+  const W: WiringStyle = { parts: 0, ics: 0, twoPin: 0, powerSymbols: 0, labels: 0, twoPinAttached: 0, twoPinIslands: 0, icPins: 0, icPinsWired: 0, icPinsLabelled: 0 };
+  const key = (x: number, y: number): string => `${Math.round(x * 100)},${Math.round(y * 100)}`;
+  for (const sh of sheets) {
+    const parent = new Map<string, string>();
+    const find = (k: string): string => {
+      let r = k;
+      while (parent.get(r) !== r) r = parent.get(r)!;
+      while (parent.get(k) !== r) {
+        const n = parent.get(k)!;
+        parent.set(k, r);
+        k = n;
+      }
+      return r;
+    };
+    const add = (k: string): void => {
+      if (!parent.has(k)) parent.set(k, k);
+    };
+    const union = (a: string, b: string): void => {
+      add(a);
+      add(b);
+      const ra = find(a);
+      const rb = find(b);
+      if (ra !== rb) parent.set(ra, rb);
+    };
+    for (const w of sh.wires) union(key(w.x1, w.y1), key(w.x2, w.y2));
+    const placed = sh.symbols.map((s) => ({
+      s,
+      pins: pinsOfUnit(sh.libPins.get(s.libId) ?? [], s.unit).map((p) => pinAbsolute(s.at, s.mirror, p)),
+    }));
+    for (const { pins } of placed) for (const p of pins) add(key(p.x, p.y));
+    for (const l of sh.labels) add(key(l.x, l.y));
+    // a point on a segment's interior joins it (T junction); index segments by
+    // their fixed coordinate so this stays linear in practice
+    const horiz = new Map<number, Seg[]>();
+    const vert = new Map<number, Seg[]>();
+    for (const w of sh.wires) {
+      if (Math.abs(w.y1 - w.y2) < 0.01) horiz.set(Math.round(w.y1 * 100), [...(horiz.get(Math.round(w.y1 * 100)) ?? []), w]);
+      else if (Math.abs(w.x1 - w.x2) < 0.01) vert.set(Math.round(w.x1 * 100), [...(vert.get(Math.round(w.x1 * 100)) ?? []), w]);
+    }
+    for (const k of [...parent.keys()]) {
+      const [xs, ys] = k.split(',');
+      const x = Number(xs) / 100;
+      const y = Number(ys) / 100;
+      for (const w of horiz.get(Number(ys)) ?? []) {
+        if (x > Math.min(w.x1, w.x2) + 0.01 && x < Math.max(w.x1, w.x2) - 0.01) union(k, key(w.x1, w.y1));
+      }
+      for (const w of vert.get(Number(xs)) ?? []) {
+        if (y > Math.min(w.y1, w.y2) + 0.01 && y < Math.max(w.y1, w.y2) - 0.01) union(k, key(w.x1, w.y1));
+      }
+    }
+    const compOf = (x: number, y: number): string => find(key(x, y));
+    const labelComps = new Set(sh.labels.map((l) => compOf(l.x, l.y)));
+    const pinComps = new Map<string, { ref: string; power: boolean }[]>();
+    for (const { s, pins } of placed) {
+      for (const p of pins) {
+        const c = compOf(p.x, p.y);
+        pinComps.set(c, [...(pinComps.get(c) ?? []), { ref: s.ref, power: s.isPower }]);
+      }
+    }
+    W.labels += sh.labels.length;
+    for (const { s, pins } of placed) {
+      if (s.isPower) {
+        W.powerSymbols++;
+        continue;
+      }
+      if (!pins.length) continue;
+      W.parts++;
+      const kinds = pins.map((p) => {
+        const c = compOf(p.x, p.y);
+        const others = (pinComps.get(c) ?? []).filter((o) => o.ref !== s.ref);
+        if (others.some((o) => !o.power)) return 'part';
+        if (others.some((o) => o.power)) return 'power';
+        if (labelComps.has(c)) return 'label';
+        return 'open';
+      });
+      if (pins.length === 2) {
+        W.twoPin++;
+        if (kinds.includes('part')) W.twoPinAttached++;
+        else if (kinds.every((k) => k === 'label' || k === 'open')) W.twoPinIslands++;
+      }
+      if (pins.length >= 3 && !NOT_IC.test(s.libId)) {
+        W.ics++;
+        for (const k of kinds) {
+          W.icPins++;
+          if (k === 'part') W.icPinsWired++;
+          else if (k === 'label') W.icPinsLabelled++;
+        }
+      }
+    }
+  }
+  return W;
+}
+
 export interface ScoreOptions {
   docsDir?: string | null;
   config?: LegibilityUserConfig;
@@ -259,6 +405,13 @@ export function scoreFromGeometry(
   }
   const pairSymmetry = pairs ? symmetric / pairs : 1;
 
+  // wiring style: how the parts connect (see STYLE_WEIGHTS for the calibration)
+  const ws = measureWiringStyle(sheets);
+  const attachment = ws.twoPin ? ws.twoPinAttached / ws.twoPin : 1;
+  const islands = ws.twoPin ? ws.twoPinIslands / ws.twoPin : 0;
+  const powerPerPart = ws.parts ? ws.powerSymbols / ws.parts : 0;
+  const labelsPerPart = ws.parts ? ws.labels / ws.parts : 0;
+
   const horizLabels = labels.length
     ? labels.filter((l) => Math.abs(l.rot % 180) !== 90).length / labels.length
     : 1;
@@ -267,7 +420,15 @@ export function scoreFromGeometry(
 
   // ---- normalize to [0,1] goodness and compose ----
   const raw: Record<string, { raw: number; score: number }> = {
+    'pin-attachment': { raw: attachment, score: Math.min(1, attachment / 0.9) },
+    'island-parts': { raw: islands, score: Math.max(0, 1 - islands / 0.2) },
+    'power-symbol-economy': { raw: powerPerPart, score: powerPerPart <= 0.8 ? 1 : 0.8 / powerPerPart },
+    'labels-per-part': { raw: labelsPerPart, score: labelsPerPart <= 1 ? 1 : 1 / labelsPerPart },
     'wire-crossings': { raw: crossings, score: 1 / (1 + crossings) },
+    // the absolute count above floors at zero on any large board; per wire it
+    // stays comparable across sizes (the 1138-part demo crosses 0.77 per wire,
+    // the 89-part one 0.03)
+    'crossings-per-wire': { raw: segs.length ? crossings / segs.length : 0, score: 1 / (1 + 10 * (segs.length ? crossings / segs.length : 0)) },
     'wire-bends': { raw: bends, score: 1 / (1 + bends / 8) },
     'wire-length': { raw: totalLen, score: 1 / (1 + totalLen / (4 * diag)) },
     'label-to-wire-ratio': { raw: labelRatio, score: labelRatio <= 1.5 ? 1 : 1.5 / labelRatio },
@@ -281,15 +442,26 @@ export function scoreFromGeometry(
     'whitespace-balance': { raw: centroidOff, score: Math.max(0, 1 - centroidOff) },
     'pair-symmetry': { raw: pairSymmetry, score: pairSymmetry },
   };
-  const totalWeight = Object.values(weights).reduce((a, b) => a + b, 0) || 1;
-  const metrics: ScoreMetric[] = Object.entries(raw).map(([name, m]) => ({
+  const totalWeight = Object.entries(weights).reduce((a, [k, v]) => a + (k in raw ? v : 0), 0) || 1;
+  const metrics: ScoreMetric[] = Object.entries(raw)
+    .filter(([name]) => name in weights)
+    .map(([name, m]) => ({
+      name,
+      raw: m.raw,
+      score: m.score,
+      weight: weights[name]!,
+      contribution: (100 * weights[name]! * m.score) / totalWeight,
+    }));
+  let composite = metrics.reduce((a, m) => a + m.contribution, 0);
+  const styleTotal = Object.values(STYLE_WEIGHTS).reduce((a, b) => a + b, 0);
+  const styleMetrics: ScoreMetric[] = Object.entries(STYLE_WEIGHTS).map(([name, weight]) => ({
     name,
-    raw: m.raw,
-    score: m.score,
-    weight: weights[name]!,
-    contribution: (100 * weights[name]! * m.score) / totalWeight,
+    raw: raw[name]!.raw,
+    score: raw[name]!.score,
+    weight,
+    contribution: (100 * weight * raw[name]!.score) / styleTotal,
   }));
-  let composite = metrics.reduce((a, m) => a + m.contribution, 0);
+  const styleComposite = Math.round(styleMetrics.reduce((a, m) => a + m.contribution, 0) * 100) / 100;
 
   let cap: ScoreReport['cap'] = null;
   if (legibility.counts.error > 0) {
@@ -306,6 +478,7 @@ export function scoreFromGeometry(
   return {
     composite: Math.round(composite * 100) / 100,
     metrics,
+    style: { composite: styleComposite, metrics: styleMetrics },
     cap,
     legibility: legibility.counts,
   };
@@ -319,5 +492,11 @@ export function formatScore(report: ScoreReport): string {
       `  ${m.name}: raw ${Math.round(m.raw * 10000) / 10000}, score ${Math.round(m.score * 1000) / 1000}, weight ${m.weight}, contributes ${Math.round(m.contribution * 100) / 100}`,
     );
   }
+  if (report.style) {
+    lines.push(`wiring style: ${report.style.composite}/100 (convention-free, never capped)`);
+    for (const m of report.style.metrics) {
+      lines.push(`  ${m.name}: raw ${Math.round(m.raw * 10000) / 10000}, score ${Math.round(m.score * 1000) / 1000}, weight ${m.weight}`);
+    }
+  }
   return lines.join('\n');
 }

package/src/kicad/sexp.ts

@@ -335,6 +335,11 @@ export interface TextItem {
   /** Font height in mm (KiCad `(size h w)`); 1.27 when unstated. */
   height: number;
   hidden: boolean;
+  /** `(justify …)` components, or null when unspecified: KiCad anchors a
+   * free text at its centre unless the effects say otherwise, and the
+   * engine's group captions say `left top`. */
+  justifyH: 'left' | 'right' | null;
+  justifyV: 'top' | 'bottom' | null;
 }
 
 export interface LabelItem {
@@ -400,10 +405,16 @@ function effectsOf(node: SexpNode[]): { height: number; hidden: boolean } {
   const effects = child(node, 'effects');
   const font = effects ? child(effects, 'font') : undefined;
   const size = font ? child(font, 'size') : undefined;
-  // hidden: legacy bare `hide` atom, or v9 `(hide yes)`
+  // hidden: legacy bare `hide` atom, v9 `(hide yes)` inside effects, or
+  // KiCad 10's `(hide yes)` as a direct child of the property (a sheet
+  // re-saved by eeschema 10 flagged every hidden power reference as text
+  // on a wire until this was read)
   const hideNode = effects ? child(effects, 'hide') : undefined;
+  const hideProp = child(node, 'hide');
   const hidden =
-    (effects?.some((c) => c === 'hide') ?? false) || (hideNode !== undefined && atomAt(hideNode, 1) !== 'no');
+    (effects?.some((c) => c === 'hide') ?? false) ||
+    (hideNode !== undefined && atomAt(hideNode, 1) !== 'no') ||
+    (hideProp !== undefined && atomAt(hideProp, 1) !== 'no');
   return { height: size ? num(size, 1, 1.27) : 1.27, hidden };
 }
 
@@ -483,7 +494,7 @@ function libBodyBounds(root: SexpNode[]): Map<string, Bounds | null> {
   return map;
 }
 
-function textItemsOf(sym: SexpNode[]): TextItem[] {
+function textItemsOf(sym: SexpNode[], symRot = 0): TextItem[] {
   const out: TextItem[] = [];
   for (const p of children(sym, 'property')) {
     const key = atomAt(p, 1);
@@ -494,9 +505,18 @@ function textItemsOf(sym: SexpNode[]): TextItem[] {
       text: atomAt(p, 2) ?? '',
       x: num(at, 1),
       y: num(at, 2),
-      rot: num(at, 3),
+      // KiCad draws a property at its stored angle PLUS the symbol's: a
+      // resistor turned 90 stores 90 on its fields to read horizontally,
+      // and a field stored at 0 on that resistor stands on end. The
+      // checker measures what is drawn.
+      rot: (((num(at, 3) + symRot) % 360) + 360) % 360,
       height: fx.height,
       hidden: fx.hidden,
+      // property text keeps the centred measurement: its justification is
+      // relative to the symbol's own rotation and mirror, which the checker
+      // does not model, and the engine emits it centred
+      justifyH: null,
+      justifyV: null,
     });
   }
   return out;
@@ -544,7 +564,18 @@ export async function readSheetGeometry(rootSch: string): Promise<SheetGeometry[
     const texts: TextItem[] = children(sheet.root, 'text').map((t) => {
       const at = child(t, 'at');
       const fx = effectsOf(t);
-      return { text: atomAt(t, 1) ?? '', x: num(at, 1), y: num(at, 2), rot: num(at, 3), height: fx.height, hidden: fx.hidden };
+      const effects = child(t, 'effects');
+      const justify = effects ? child(effects, 'justify') : undefined;
+      return {
+        text: atomAt(t, 1) ?? '',
+        x: num(at, 1),
+        y: num(at, 2),
+        rot: num(at, 3),
+        height: fx.height,
+        hidden: fx.hidden,
+        justifyH: justify?.some((c) => c === 'right') ? 'right' : justify?.some((c) => c === 'left') ? 'left' : null,
+        justifyV: justify?.some((c) => c === 'bottom') ? 'bottom' : justify?.some((c) => c === 'top') ? 'top' : null,
+      };
     });
     const rectangles: RectItem[] = children(sheet.root, 'rectangle').map((r) => {
       const s = child(r, 'start');
@@ -576,7 +607,7 @@ export async function readSheetGeometry(rootSch: string): Promise<SheetGeometry[
         mirror,
         isPower: isPowerSymbol(sym.libId, powerSyms),
         unit: sym.unit,
-        props: textItemsOf(node),
+        props: textItemsOf(node, sym.at.rot),
       })),
       wires,
       labels,