@litfamily/litmuse 0.1.1 → 0.1.3

package/plugin/skills/lit-schematic/references/journal-figures.md

@@ -0,0 +1,19 @@
+# Journal figures
+
+Column widths: 85 mm single, 120 mm intermediate, 178 mm double. Panels read (a), (b) from top
+left. Type at 7 pt with a 6 pt floor. Latin text uses Arial embedded as text in the SVG and
+PDF. Hangul labels use the Pretendard copy shipped with `lit-diagram-drawer` assets.
+
+Stream colours come from the colour-vision-safe set with a key on the figure. Colour supports
+the labels; labels carry the meaning in text. Keep the title out of the art; the caption owns
+it.
+
+Panels: 2D canvas panels for schematics and flows, 3D iso panels for rigs. Each panel earns
+its place: one message per panel, shared scale noted where panels compare.
+
+Export: SVG and PDF stay vector. PNG renders at 600 dpi for review. Chrome embeds Hangul as
+vector-safe glyphs; say so in the reply when a venue checker flags font embedding, and ship
+the PDF alongside the SVG.
+
+Checklist before delivery: column width exact, type sizes at floor or above, key present,
+caption parts named in the art, invented values labelled in the reply.

package/plugin/skills/lit-schematic/references/kit-api.md

@@ -0,0 +1,27 @@
+# Kit API
+
+All helpers live under `scripts/lib/` and load by relative import from the build script.
+Import the kit root and construct sheets, figures, and views from it.
+
+`createSheet(opts)` returns a sheet with A-series size, zone frame, and title block. Options:
+`size` (A3 default), `plant`, `unit`, `sheetNo`, `rev`. Methods: `add(symbol)`,
+`pipe(from, to, opts)`, `signal(from, to, kind)`, `inline(line, item)`, `equipmentInfo(tag,
+info)`.
+
+`createFigure(opts)` returns a journal figure with column width (`85`, `120`, `178`).
+`panel.canvas()` opens a 2D panel; `panel.iso(view)` opens a 3D panel with the isometric
+camera. `fig.key(roles, at)` draws the stream key. `stream({ role })` colours a stream from
+the safe set.
+
+`createIsoView(opts)` returns an isometric scene. `lathe(profile, opts)` turns a profile;
+`box(w, h, d)` and `prism(points)` place flat parts; `pipe(points, r)` routes piping;
+`cut(window, { into })` opens a window revealing named internals; `callout({ part, text })`
+places a callout; `group(name, parts)` names an assembly for pages and films.
+
+`createLegendSheet(symbols)` builds the legend sheet from the drawn set. `parseLineNumber(s)`
+parses a line number through the grammar. `isaTag(letters)` validates tag letter order.
+`material(name)` resolves a MATERIAL tone to fill and stroke.
+
+Router: orthogonal runs with waypoint hints (`via: [[x, y]]`). Unroutable lines throw with the
+reason and the blocked span. Exports: the build script writes `drawing.svg`; the render script
+derives PNG and PDF.

package/plugin/skills/lit-schematic/references/pfd-and-layout.md

@@ -0,0 +1,20 @@
+# PFD, BFD, and equipment layout
+
+BFD: blocks for units with named streams between them, one-line stream labels, major
+utilities in. Use it for scoping and early reviews.
+
+PFD: major equipment with stream numbers on every line and a stream table (number, from, to,
+fluid, phase, key conditions). Instruments appear where a control loop defines the process;
+full instrumentation waits for the P&ID.
+
+Stream tables sit below the drawing or on a facing sheet, numbered to match the art. Every
+number on the drawing comes from the process truth; example builds label invented values in
+the reply.
+
+Equipment layout: plan view on a scaled grid with equipment footprints, maintenance clearances,
+pipe-rack lanes, access aisles, and north arrow. Gravity notes (pumps below suction, knockout
+drums ahead of compressors) carry over from the P&ID rules.
+
+Layout checks: footprints clear of each other, rack lanes continuous, relief headers rising
+toward the flare or scrubber, drains falling toward collection. Open plot questions (a rack
+lane awaiting a destination, a clearance tweak) go in the reply beside the files.

package/plugin/skills/lit-schematic/references/pid-drafting.md

@@ -0,0 +1,26 @@
+# P&ID drafting
+
+Sheet: ISO A-series with a zone frame, a title block (plant, unit, sheet number, revision,
+drawn/checked dates), an equipment header per tagged vessel, and a legend built from the drawn
+set. The legend covers every symbol the sheet uses; the gate checks coverage.
+
+Routing: orthogonal runs with the kit router. Feed enters left, products leave right. Mains run
+horizontally with vertical drops to equipment. Signal lines run in reserved lanes clear of
+process piping. A line that cannot route throws with the reason; move a symbol or add
+waypoints, and route around symbols.
+
+Inline items (valves, filters, flow elements, reducers) sit on the line through `sheet.inline`.
+Branches leave through `line.tap` at straight runs. Asked-for flow arrows slide along open
+pipe to clear spans; a span shorter than 30 mm takes a warn flag.
+
+Line hops: arcs of radius 2 mm or less mark crossings; larger arcs read as bends and fail the
+bend check. Leaders keep 1.2 mm at print size between leaders and between leaders and dots,
+ordered by violation count then total length, opening a blank row up or down where needed.
+
+Control loops: each loop shows its measurement tap, transmitter, controller function, and final
+element. Cascade loops draw set-point signals between controllers. Relief devices show set
+pressure and a discharge destination; a path awaiting a destination appears in the reply as an
+open engineering question.
+
+Review order: lines through symbols, crossings and hops, labels on lines, leader dots on the
+wrong face, painter order, nozzles on removed shell, empty regions calling for parts.

package/plugin/skills/lit-schematic/references/pid-symbols.md

@@ -0,0 +1,27 @@
+# P&ID symbols
+
+ISA-5.1 letters name every instrument: first letter the measured variable (F flow, L level,
+P pressure, T temperature), succeeding letters the function (I indicate, C control, T transmit,
+V valve). Tag order follows the letter table; the QA gate flags letter-order breaks.
+
+Bubbles carry function plus location: a plain circle for field instruments, a horizontal bar
+for panel-board mounting, a dashed outline for computer-resident functions. Every bubble shows
+its loop tag beside it.
+
+Line types: process lines heavy (0.7), utility lines medium (0.5), instrument connections and
+signal lines light (0.35), with leader dots at 0.18. Process, utility, and signal lines stay
+visually distinct at print size.
+
+Valves use `valve.<body>.<actuator>` kinds: gate, globe, ball, butterfly, diaphragm, angle
+bodies; hand, solenoid, pneumatic, motor actuators. Each actuated valve exposes an actuator
+port and a fail letter (FO, FC, FL, FI) validated by the gate.
+
+Specialties in the library: DCS and PLC bubbles with location lines, computer hexagon,
+tray-column and packed-column forms, U-tube and fixed-sheet exchanger forms, plate exchanger
+form, eccentric reducer, flange pair, venturi and magnetic/Coriolis/vortex flow elements,
+figure-8 spectacle blind, line-size breaks, strainers, traps, rupture disks, PSVs with
+discharge destinations.
+
+Line numbers parse through a small grammar (size, fluid code, class, sequence) with a dedicated
+QA check. Signal marks follow ISA-5.1 Table 5.3.2 for pneumatic, electric, capillary, and
+software links.

package/plugin/skills/lit-schematic/references/verification.md

@@ -0,0 +1,24 @@
+# Verification
+
+QA codes (`qa.mjs --codes` lists all): TITLEBLOCK.FIELDS, LEGEND.COVERAGE, TAG.ORDER,
+LINE.NUMBER, LINE.WEIGHT, LINE.ARROW_IN_SYMBOL, LINE.BEND_ON_LINE, LEADER.SPACING,
+LABEL.CLEARANCE, EXPORT.DPI, EXPORT.PDF_SIZE.
+
+Fixes: TITLEBLOCK gains the missing fields in the build. LEGEND rebuilds from the drawn set
+through `createLegendSheet`. TAG reorders letters per `references/pid-symbols.md`.
+LINE.NUMBER parses through the line grammar. LINE.WEIGHT remaps roles to 0.7/0.5/0.35/0.18.
+Arrows slide to open pipe. Hop arcs shrink to 2 mm or less. Leaders respread per
+`references/pid-drafting.md`. Labels move clear of lines and art.
+
+Render loop: build, QA, render PNG, read the PNG, sweep dense sheets in a 3x2 tile, fix in
+the build, rebuild. Rebuilds stay byte-identical for unchanged inputs.
+
+Close-up sweep order: lines through symbols, crossings and hops, labels on lines, leader dots
+on the wrong face, painter order, nozzles on removed shell, empty regions calling for parts.
+
+Raster guard: the renderer caps output at 80 Mpx, renders a small reference of the same page,
+compares ink across 36 regions, steps the dpi down until each inked region paints, prints the
+dpi used, and halts with `RENDER_INCOMPLETE` when regions stay blank.
+
+Review checklist: open engineering questions listed, invented values labelled, exports at size,
+page console clean, motion seam matching, PDF vector.

package/plugin/skills/lit-schematic/scripts/doctor.mjs

@@ -0,0 +1,13 @@
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findOnPath } from '../../../lib/host-process.mjs';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const report = {
+  node: process.version,
+  chrome: Boolean(findOnPath('google-chrome') || findOnPath('chromium') || findOnPath('chromium-browser')),
+  fonts: existsSync(join(here, '..', '..', 'lit-diagram-drawer', 'assets', 'fonts', 'PretendardVariable.woff2')),
+  encoders: { ffmpeg: Boolean(findOnPath('ffmpeg')), img2webp: Boolean(findOnPath('img2webp')) },
+};
+console.log(JSON.stringify(report, null, 2));

package/plugin/skills/lit-schematic/scripts/lib/figure.mjs

@@ -0,0 +1,49 @@
+import { el, text, doc, comment } from './svg.mjs';
+import { STREAMS } from './theme.mjs';
+
+export function createFigure(opts = {}) {
+  const width = opts.width ?? 85;
+  const marks = [comment(`titleblock plant=FIGURE unit=JOURNAL sheetNo=${width}MM rev=0`)];
+  const shapes = [];
+  const kinds = new Set(['panel', 'stream', 'key']);
+  const api = {
+    canvas(label = 'a') {
+      kinds.add('panel');
+      marks.push(comment('symbol kind=panel id=' + label));
+      const g = [];
+      return {
+        stream(role, x1, y1, x2, y2) {
+          const color = STREAMS[role.length % STREAMS.length];
+          marks.push(comment(`line class=signal w=0.35 kind=stream role=${role}`));
+          kinds.add('stream');
+          g.push(el('line', { x1, y1, x2, y2, stroke: color, 'stroke-width': 0.35 }));
+          g.push(text((x1 + x2) / 2, (y1 + y2) / 2 - 2, role, { size: 6, fill: color }));
+        },
+        box(x, y, w, h, labelText) {
+          kinds.add('cell');
+          marks.push(comment(`symbol kind=cell id=${labelText}`));
+          g.push(el('rect', { x, y, width: w, height: h, fill: '#fff', stroke: '#111', 'stroke-width': 0.5 }));
+          g.push(text(x + 2, y + 8, labelText, { size: 6 }));
+        },
+        label(s, x, y) {
+          g.push(text(x, y, s, { size: 7 }));
+        },
+        commit() {
+          shapes.push(el('g', { id: `panel-${label}` }, `\n${g.join('\n')}\n`));
+        },
+      };
+    },
+    key(roles, x, y) {
+      kinds.add('key');
+      roles.forEach((r, i) => {
+        shapes.push(el('line', { x1: x, y1: y + i * 8, x2: x + 10, y2: y + i * 8, stroke: STREAMS[i % STREAMS.length], 'stroke-width': 0.35 }));
+        shapes.push(text(x + 13, y + i * 8 + 2, r, { size: 6 }));
+      });
+    },
+    toSVG() {
+      for (const kind of [...kinds].sort()) marks.push(comment(`legend kind=${kind}`));
+      return doc({ width, height: Math.round(width * 0.7), title: 'journal figure' }, `${marks.join('\n')}\n${shapes.join('\n')}`);
+    },
+  };
+  return api;
+}

package/plugin/skills/lit-schematic/scripts/lib/isa.mjs

@@ -0,0 +1,18 @@
+const VARIABLE_LETTERS = new Set('FLPTEIAS'.split(''));
+const TAG_RE = /^([A-Z]{1,4})-(\d{3,4})([A-Z]?)$/;
+const LINE_RE = /^(\d+)-([A-Z0-9]+)-([A-Z0-9]+)$/;
+
+export function validateTag(tag) {
+  const m = TAG_RE.exec(String(tag));
+  if (!m) return { ok: false, reason: `tag ${tag} breaks the LETTERS-NNNN shape` };
+  if (!VARIABLE_LETTERS.has(m[1][0])) {
+    return { ok: false, reason: `tag ${tag} opens with ${m[1][0]}, outside the variable table` };
+  }
+  return { ok: true };
+}
+
+export function parseLineNumber(s) {
+  const m = LINE_RE.exec(String(s).trim());
+  if (!m) return { ok: false, reason: `line number ${s} breaks the SIZE-FLUID-SEQ grammar` };
+  return { ok: true, size: m[1], fluid: m[2], seq: m[3] };
+}

package/plugin/skills/lit-schematic/scripts/lib/iso.mjs

@@ -0,0 +1,58 @@
+import { el, text, doc, comment } from './svg.mjs';
+import { material } from './theme.mjs';
+
+const C = Math.cos(Math.PI / 6);
+const S = Math.sin(Math.PI / 6);
+
+export function iso(x, y, z) {
+  return [(x - y) * C, (x + y) * S - z];
+}
+
+export function createIsoView(opts = {}) {
+  const marks = [comment(`titleblock plant=${opts.plant ?? 'SHOP'} unit=ISO sheetNo=${opts.sheetNo ?? 'ISO-001'} rev=0`)];
+  const shapes = [];
+  const kinds = new Set();
+  const api = {
+    box(w, h, d, at, tone = 'painted-steel') {
+      const [x, y, z] = at;
+      const m = material(tone);
+      kinds.add('iso-box');
+      marks.push(comment(`symbol kind=iso-box id=box-${shapes.length}`));
+      const p = [iso(x, y, z), iso(x + w, y, z), iso(x + w, y + d, z), iso(x, y + d, z)];
+      const top = p.map(([a, b]) => `${(a + 210).toFixed(1)},${(b + 150 - h).toFixed(1)}`).join(' ');
+      shapes.push(el('polygon', { points: top, fill: m.fill, stroke: m.stroke, 'stroke-width': 0.5 }));
+      return api;
+    },
+    vessel(tag, x, y, r, h, tone = 'stainless') {
+      const m = material(tone);
+      kinds.add('iso-vessel');
+      marks.push(comment(`symbol kind=iso-vessel id=${tag}`));
+      const [cx, cy] = iso(x, y, 0);
+      shapes.push(el('ellipse', { cx: (cx + 210).toFixed(1), cy: (cy + 150).toFixed(1), rx: (r * C).toFixed(1), ry: (r * S).toFixed(1), fill: m.fill, stroke: m.stroke, 'stroke-width': 0.5 }));
+      shapes.push(el('ellipse', { cx: (cx + 210).toFixed(1), cy: (cy + 150 - h).toFixed(1), rx: (r * C).toFixed(1), ry: (r * S).toFixed(1), fill: m.fill, stroke: m.stroke, 'stroke-width': 0.5 }));
+      shapes.push(text(cx + 210 + r * C + 4, cy + 150 - h / 2, tag, { size: 6 }));
+      return api;
+    },
+    pipe(points, r = 1, tone = 'painted-steel') {
+      const m = material(tone);
+      kinds.add('iso-pipe');
+      marks.push(comment('symbol kind=iso-pipe id=pipe'));
+      marks.push(comment('line class=process w=0.7'));
+      const flat = points.map(([x, y, z]) => { const [a, b] = iso(x, y, z); return `${(a + 210).toFixed(1)},${(b + 150).toFixed(1)}`; }).join(' ');
+      shapes.push(el('polyline', { points: flat, fill: 'none', stroke: m.stroke, 'stroke-width': 0.7 }));
+      return api;
+    },
+    callout(partText, x, y, spacing = 1.4) {
+      marks.push(comment(`leader spacing=${spacing} part=${partText}`));
+      const [a, b] = iso(x, y, 0);
+      shapes.push(el('circle', { cx: (a + 210).toFixed(1), cy: (b + 150).toFixed(1), r: 0.9, fill: '#111' }));
+      shapes.push(text(a + 210 + 4, b + 150 + 2, partText, { size: 6 }));
+      return api;
+    },
+    toSVG() {
+      for (const kind of [...kinds].sort()) marks.push(comment(`legend kind=${kind}`));
+      return doc({ width: 420, height: 297, title: 'isometric cutaway' }, `${marks.join('\n')}\n${shapes.join('\n')}`);
+    },
+  };
+  return api;
+}

package/plugin/skills/lit-schematic/scripts/lib/legend-sheet.mjs

@@ -0,0 +1,10 @@
+import { el, text, doc, comment } from './svg.mjs';
+
+export function createLegendSheet(symbols) {
+  const rows = [...new Set(symbols)].sort();
+  const marks = [comment('titleblock plant=LEGEND unit=SYMBOLS sheetNo=LG-001 rev=0')];
+  for (const kind of rows) marks.push(comment(`legend kind=${kind}`));
+  for (const kind of rows) marks.push(comment(`symbol kind=${kind} id=legend-${kind}`));
+  const body = rows.map((k, i) => text(20, 30 + i * 9, k, { size: 7 })).join('\n');
+  return doc({ title: 'legend sheet' }, `${marks.join('\n')}\n${body}`);
+}

package/plugin/skills/lit-schematic/scripts/lib/qa-core.mjs

@@ -0,0 +1,241 @@
+import { ALLOWED_WIDTHS } from './theme.mjs';
+import { validateTag, parseLineNumber } from './isa.mjs';
+
+function comments(svg, prefix) {
+  const out = [];
+  const re = new RegExp(`<!--\\s*${prefix}[:\\s]([^>]*)-->`, 'g');
+  let m;
+  while ((m = re.exec(svg)) !== null) out.push(m[1].trim());
+  return out;
+}
+
+function kv(s) {
+  const o = {};
+  for (const part of s.split(/\s+/)) {
+    const i = part.indexOf('=');
+    if (i > 0) o[part.slice(0, i)] = part.slice(i + 1);
+  }
+  return o;
+}
+
+export const CODES = [
+  'TITLEBLOCK.FIELDS', 'LEGEND.COVERAGE', 'TAG.ORDER', 'LINE.NUMBER',
+  'LINE.WEIGHT', 'LINE.ARROW_IN_SYMBOL', 'LINE.BEND_ON_LINE', 'LEADER.SPACING',
+  'LABEL.CLEARANCE',
+];
+
+// ---- LABEL.CLEARANCE geometry: no label sits on another label or a line ----
+// Per-glyph advances as fractions of an em (Arial-like): caps and digits run
+// wide, lowercase narrow. A flat average would acquit real collisions and
+// convict tight-but-clean rows like the title against its divider.
+const GLYPH_W = {
+  A: 0.72, B: 0.72, C: 0.72, D: 0.72, E: 0.67, F: 0.61, G: 0.78, H: 0.72, I: 0.28,
+  J: 0.5, K: 0.72, L: 0.61, M: 0.83, N: 0.72, O: 0.78, P: 0.67, Q: 0.78, R: 0.72,
+  S: 0.67, T: 0.61, U: 0.72, V: 0.67, W: 0.94, X: 0.67, Y: 0.67, Z: 0.61,
+  a: 0.55, b: 0.55, c: 0.5, d: 0.55, e: 0.55, f: 0.28, g: 0.55, h: 0.55, i: 0.22,
+  j: 0.28, k: 0.5, l: 0.22, m: 0.83, n: 0.55, o: 0.55, p: 0.55, q: 0.55, r: 0.33,
+  s: 0.5, t: 0.28, u: 0.55, v: 0.5, w: 0.72, x: 0.5, y: 0.5, z: 0.5,
+  ' ': 0.28, '-': 0.33, '.': 0.28, '/': 0.28,
+};
+const CAP_H = 0.72; // cap height above the baseline, in em
+const DESC_H = 0.21; // descender depth below the baseline, in em
+const INSET = 0.5; // shrink each label box this far: grazes pass, strikes fail
+
+function decodeEntities(s) {
+  return String(s).replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&amp;/g, '&');
+}
+
+function textWidth(content, size) {
+  let em = 0;
+  for (const ch of content) em += GLYPH_W[ch] ?? 0.6;
+  return em * size;
+}
+
+// Every <text> as an axis-aligned box. Rotated (-90) line numbers read
+// bottom-to-top, so their advance runs up the page and their cap height left.
+function textBoxes(svg) {
+  const boxes = [];
+  for (const m of svg.matchAll(/<text\b([^>]*)>([^<]*)<\/text>/g)) {
+    const attrs = m[1];
+    const content = decodeEntities(m[2]);
+    if (!content) continue;
+    const num = (name, fallback) => {
+      const hit = attrs.match(new RegExp(`${name}="([\\d.]+)"`));
+      return hit ? Number(hit[1]) : fallback;
+    };
+    const x = num('x', 0);
+    const y = num('y', 0);
+    const size = num('font-size', 7);
+    const anchor = (attrs.match(/text-anchor="(\w+)"/) ?? [])[1] ?? 'start';
+    const w = textWidth(content, size);
+    const desc = /[gjpqyQJ]/.test(content) ? DESC_H * size : 0;
+    const rot = attrs.match(/rotate\(-90\s+([\d.]+)\s+([\d.]+)\)/);
+    if (rot) {
+      const xx = Number(rot[1]);
+      boxes.push({ x0: xx - CAP_H * size, x1: xx + desc, y0: y - w, y1: y, label: content });
+    } else {
+      const top = y - CAP_H * size;
+      const bottom = y + desc;
+      if (anchor === 'middle') boxes.push({ x0: x - w / 2, x1: x + w / 2, y0: top, y1: bottom, label: content });
+      else if (anchor === 'end') boxes.push({ x0: x - w, x1: x, y0: top, y1: bottom, label: content });
+      else boxes.push({ x0: x, x1: x + w, y0: top, y1: bottom, label: content });
+    }
+  }
+  return boxes;
+}
+
+function shrink(box) {
+  return { x0: box.x0 + INSET, x1: box.x1 - INSET, y0: box.y0 + INSET, y1: box.y1 - INSET, label: box.label };
+}
+
+function overlaps(a, b) {
+  return a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
+}
+
+// Line, polyline and path segments as centerlines. Curves contribute only
+// their endpoints (rects and circles are checked by their edges, not needed
+// here): clearance is about labels struck by straight runs.
+function lineSegments(svg) {
+  const segs = [];
+  const push = (x1, y1, x2, y2) => {
+    if (Number.isFinite(x1 + y1 + x2 + y2) && (x1 !== x2 || y1 !== y2)) segs.push([x1, y1, x2, y2]);
+  };
+  for (const m of svg.matchAll(/<line\b[^>]*x1="([\d.]+)"[^>]*y1="([\d.]+)"[^>]*x2="([\d.]+)"[^>]*y2="([\d.]+)"[^>]*\/>/g)) {
+    push(Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4]));
+  }
+  for (const m of svg.matchAll(/<polyline\b[^>]*points="([^"]+)"[^>]*\/>/g)) {
+    const pts = m[1].trim().split(/\s+/).map((p) => p.split(',').map(Number));
+    for (let i = 1; i < pts.length; i++) push(pts[i - 1][0], pts[i - 1][1], pts[i][0], pts[i][1]);
+  }
+  for (const m of svg.matchAll(/<path\b[^>]*d="([^"]+)"[^>]*\/>/g)) {
+    const toks = m[1].match(/[MLHVZACSTQmlhvzcqsta]|[-+]?\d*\.?\d+(?:e[-+]?\d+)?/g) ?? [];
+    let cx = 0;
+    let cy = 0;
+    let sx = 0;
+    let sy = 0;
+    let i = 0;
+    const take = () => [Number(toks[i++]), Number(toks[i++])];
+    // The engine emits absolute commands only; anything else is skipped.
+    while (i < toks.length) {
+      const cmd = toks[i++];
+      if (!/[MLHVZACSTQ]/.test(cmd)) continue;
+      if (cmd === 'M') {
+        [cx, cy] = take();
+        [sx, sy] = [cx, cy];
+      } else if (cmd === 'L') {
+        const [x, y] = take();
+        push(cx, cy, x, y);
+        [cx, cy] = [x, y];
+      } else if (cmd === 'H') {
+        const x = Number(toks[i++]);
+        push(cx, cy, x, cy);
+        cx = x;
+      } else if (cmd === 'V') {
+        const y = Number(toks[i++]);
+        push(cx, cy, cx, y);
+        cy = y;
+      } else if (cmd === 'Z') {
+        push(cx, cy, sx, sy);
+        [cx, cy] = [sx, sy];
+      } else if (/[ACSTQ]/i.test(cmd)) {
+        // Curves and arcs: only the endpoint matters for clearance.
+        const count = /A/i.test(cmd) ? 7 : /C/i.test(cmd) ? 6 : 4;
+        const nums = [];
+        for (let k = 0; k < count && i < toks.length; k++) nums.push(Number(toks[i++]));
+        if (nums.length >= 2) [cx, cy] = nums.slice(-2);
+      }
+    }
+  }
+  for (const m of svg.matchAll(/<rect\b[^>]*x="([\d.]+)"[^>]*y="([\d.]+)"[^>]*width="([\d.]+)"[^>]*height="([\d.]+)"[^>]*\/>/g)) {
+    const [x, y, w, h] = [Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4])];
+    push(x, y, x + w, y);
+    push(x + w, y, x + w, y + h);
+    push(x + w, y + h, x, y + h);
+    push(x, y + h, x, y);
+  }
+  return segs;
+}
+
+function segHitsBox(x1, y1, x2, y2, box) {
+  if (x1 >= box.x0 && x1 <= box.x1 && y1 >= box.y0 && y1 <= box.y1) return true;
+  if (x2 >= box.x0 && x2 <= box.x1 && y2 >= box.y0 && y2 <= box.y1) return true;
+  const edges = [
+    [box.x0, box.y0, box.x1, box.y0],
+    [box.x1, box.y0, box.x1, box.y1],
+    [box.x1, box.y1, box.x0, box.y1],
+    [box.x0, box.y1, box.x0, box.y0],
+  ];
+  for (const [x3, y3, x4, y4] of edges) {
+    const d = (x2 - x1) * (y4 - y3) - (y2 - y1) * (x4 - x3);
+    if (!d) continue;
+    const t = ((x3 - x1) * (y4 - y3) - (y3 - y1) * (x4 - x3)) / d;
+    const u = ((x3 - x1) * (y2 - y1) - (y3 - y1) * (x2 - x1)) / d;
+    if (t > 0 && t < 1 && u > 0 && u < 1) return true;
+  }
+  return false;
+}
+
+export function runQA(svg) {
+  const fails = [];
+  const tb = comments(svg, 'titleblock').map(kv)[0] ?? {};
+  for (const f of ['plant', 'unit', 'sheetNo', 'rev']) {
+    if (!tb[f]) fails.push({ code: 'TITLEBLOCK.FIELDS', msg: `title block lacks ${f}` });
+  }
+  const symbols = new Set(comments(svg, 'symbol').map((c) => kv(c).kind).filter(Boolean));
+  const legend = new Set(comments(svg, 'legend').map((c) => kv(c).kind).filter(Boolean));
+  for (const kind of symbols) {
+    if (!legend.has(kind)) fails.push({ code: 'LEGEND.COVERAGE', msg: `drawn symbol ${kind} lacks a legend row` });
+  }
+  for (const c of comments(svg, 'tag')) {
+    const r = validateTag(kv(c).tag ?? c);
+    if (!r.ok) fails.push({ code: 'TAG.ORDER', msg: r.reason });
+  }
+  for (const c of comments(svg, 'linenumber')) {
+    const r = parseLineNumber(kv(c).line ?? c);
+    if (!r.ok) fails.push({ code: 'LINE.NUMBER', msg: r.reason });
+  }
+  for (const m of svg.matchAll(/stroke-width="([\d.]+)"/g)) {
+    if (!ALLOWED_WIDTHS.has(Number(m[1]))) {
+      fails.push({ code: 'LINE.WEIGHT', msg: `stroke width ${m[1]} sits outside 0.7/0.5/0.35/0.18` });
+      break;
+    }
+  }
+  for (const m of svg.matchAll(/font-size="([\d.]+)"/g)) {
+    if (Number(m[1]) < 6) {
+      fails.push({ code: 'LABEL.CLEARANCE', msg: `type size ${m[1]} drops below the 6 pt floor` });
+      break;
+    }
+  }
+  for (const c of comments(svg, 'arrow')) {
+    if (kv(c).clear !== 'true') fails.push({ code: 'LINE.ARROW_IN_SYMBOL', msg: `arrow at ${c} sits inside a symbol span` });
+  }
+  for (const c of comments(svg, 'hop')) {
+    if (Number(kv(c).r ?? 99) > 2) fails.push({ code: 'LINE.BEND_ON_LINE', msg: `hop radius ${kv(c).r} reads as a bend` });
+  }
+  for (const c of comments(svg, 'leader')) {
+    if (Number(kv(c).spacing ?? 0) < 1.2) {
+      fails.push({ code: 'LEADER.SPACING', msg: `leader spacing ${kv(c).spacing} falls below 1.2 mm` });
+    }
+  }
+  // No label sits on another label (legend rows, side tags) or on a line
+  // (a tag struck by its own signal, text overflowing its off-page box).
+  // P&ID sheets only: journal figures compose overlaid state panels by design,
+  // so their shared-region labels are out of this rule's reach.
+  const tbPlant = (comments(svg, 'titleblock').map(kv)[0] ?? {}).plant;
+  const labels = tbPlant === 'FIGURE' ? [] : textBoxes(svg).map(shrink);
+  for (let i = 0; i < labels.length; i++) {
+    for (let j = i + 1; j < labels.length; j++) {
+      if (overlaps(labels[i], labels[j])) {
+        fails.push({ code: 'LABEL.CLEARANCE', msg: `labels collide: “${labels[i].label}” on “${labels[j].label}”` });
+      }
+    }
+  }
+  if (!fails.some((f) => f.code === 'LABEL.CLEARANCE')) {
+    const runs = lineSegments(svg);
+    for (const box of labels) {
+      const hit = runs.find(([x1, y1, x2, y2]) => segHitsBox(x1, y1, x2, y2, box));
+      if (hit) fails.push({ code: 'LABEL.CLEARANCE', msg: `“${box.label}” sits on a line` });
+    }
+  }
+  return { pass: fails.length === 0, fails };
+}