@litfamily/litopencode 1.0.31 → 1.0.32

package/skills/lit-schematic/scripts/lib/svg.mjs

@@ -0,0 +1,82 @@
+// SVG string building for lit-schematic. Every drawing is authored in millimetres: the
+// viewBox unit is 1 mm at final print size, so stroke widths and font sizes are physical
+// and the QA gate can check them without knowing the page.
+
+export const MM_PER_PT = 25.4 / 72;
+export const PT_PER_MM = 72 / 25.4;
+export const ptToMm = (pt) => pt * MM_PER_PT;
+export const mmToPt = (mm) => mm * PT_PER_MM;
+
+export function n(value) {
+  if (!Number.isFinite(value)) throw new Error(`lit-schematic: non-finite coordinate ${value}`);
+  const text = (Math.round(value * 100) / 100).toFixed(2).replace(/\.?0+$/u, "");
+  return text === "-0" ? "0" : text;
+}
+
+export const esc = (text) => String(text)
+  .replaceAll("&", "&")
+  .replaceAll("<", "&lt;")
+  .replaceAll(">", "&gt;")
+  .replaceAll('"', "&quot;");
+
+export function attrs(pairs = {}) {
+  return Object.entries(pairs)
+    .filter(([, value]) => value !== undefined && value !== null && value !== false)
+    .map(([key, value]) => ` ${key}="${esc(typeof value === "number" ? n(value) : String(value))}"`)
+    .join("");
+}
+
+export const el = (tag, pairs, ...children) => {
+  const body = children.flat().filter((child) => child !== undefined && child !== null && child !== false).join("");
+  return body ? `<${tag}${attrs(pairs)}>${body}</${tag}>` : `<${tag}${attrs(pairs)}/>`;
+};
+
+export function pathOf(points, closed = false) {
+  if (!points.length) return "";
+  return points.map(([x, y], index) => `${index ? "L" : "M"}${n(x)} ${n(y)}`).join("") + (closed ? "Z" : "");
+}
+
+export const hasHangul = (text) => /[ᄀ-ᇿ㄰-㆏가-힯]/u.test(String(text));
+
+// A conservative width estimate in em units, used for label placement and by the QA gate.
+// Arial-like Latin and Pretendard Hangul; it overestimates slightly so a pass is safe.
+export function textWidthEm(text) {
+  let units = 0;
+  for (const ch of String(text)) {
+    if (/\s/u.test(ch)) units += 0.28;
+    else if (hasHangul(ch)) units += 0.96;
+    else if (/[ilIj.,:;!|'`]/u.test(ch)) units += 0.3;
+    else if (/[ftr()[\]{}/\\-]/u.test(ch)) units += 0.38;
+    else if (/[MWmw@%]/u.test(ch)) units += 0.86;
+    else if (/[A-Z0-9#&]/u.test(ch)) units += 0.68;
+    else units += 0.56;
+  }
+  return units;
+}
+
+// Box of a single-line label: [x0, y0, x1, y1] for a baseline at y with the given anchor.
+export function textBox(x, y, text, size, anchor = "start") {
+  const width = textWidthEm(text) * size;
+  const left = anchor === "middle" ? x - width / 2 : anchor === "end" ? x - width : x;
+  return [left, y - size * 0.8, left + width, y + size * 0.22];
+}
+
+export function svgDocument({ width, height, title, desc = "", mode, lang = "en", body, defs = "", style = "", extra = {} }) {
+  if (!title) throw new Error("lit-schematic: a drawing needs a title (accessible name)");
+  const head = [
+    `<title id="schematic-title">${esc(title)}</title>`,
+    desc ? `<desc id="schematic-desc">${esc(desc)}</desc>` : "",
+    style ? `<style>${style}</style>` : "",
+    defs ? `<defs>${defs}</defs>` : "",
+  ].join("");
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<svg xmlns="http://www.w3.org/2000/svg"${attrs({
+    width: `${n(width)}mm`,
+    height: `${n(height)}mm`,
+    viewBox: `0 0 ${n(width)} ${n(height)}`,
+    role: "img",
+    "aria-labelledby": desc ? "schematic-title schematic-desc" : "schematic-title",
+    "xml:lang": lang,
+    "data-schematic-mode": mode,
+    ...extra,
+  })}>${head}${body}</svg>\n`;
+}

package/skills/lit-schematic/scripts/lib/theme.mjs

@@ -0,0 +1,115 @@
+import { hasHangul, ptToMm } from "./svg.mjs";
+
+// Latin text defaults to a TrueType face because Chrome embeds TrueType in a PDF as real text
+// (CID TrueType), while CFF and variable fonts such as Pretendard become Type 3 glyphs, which
+// some journal checkers reject. Hangul labels use Pretendard for every glyph of the label.
+export const FONT_LATIN = "Arial, Helvetica, 'Liberation Sans', sans-serif";
+export const FONT_KOREAN = "Pretendard, 'Apple SD Gothic Neo', 'Noto Sans KR', 'Malgun Gothic', sans-serif";
+export const fontFor = (text) => (hasHangul(text) ? FONT_KOREAN : FONT_LATIN);
+
+// P&ID ink on an ISO A-series sheet drawn at 1:1, in millimetres. Line weight is the tone
+// hierarchy of a P&ID: equipment and main process lines carry the sheet, signals stay light.
+// Pipe classes step down the ISO 128 width series (0.7, 0.5, 0.35, 0.18) so a main process
+// line, a minor process line, a utility line and an instrument connection never look alike.
+export const PID = Object.freeze({
+  ink: "#000000",
+  paper: "#ffffff",
+  weight: Object.freeze({
+    frame: 0.7,
+    equipment: 0.5,
+    major: 0.7,
+    minor: 0.5,
+    utility: 0.35,
+    symbol: 0.35,
+    signal: 0.25,
+    connection: 0.18,
+    leader: 0.18,
+    grid: 0.18,
+    detail: 0.18,
+  }),
+  text: Object.freeze({ tag: 2.5, label: 2.5, line: 2.2, equipment: 3.0, note: 2.5, title: 5, small: 2.2 }),
+  minTextMm: 2.0,
+  minStrokeMm: 0.13,
+});
+
+// Okabe–Ito: eight hues that stay distinct for the common colour-vision deficiencies.
+export const OKABE_ITO = Object.freeze({
+  black: "#000000",
+  orange: "#E69F00",
+  sky: "#56B4E9",
+  green: "#009E73",
+  yellow: "#F0E442",
+  blue: "#0072B2",
+  vermillion: "#D55E00",
+  purple: "#CC79A7",
+});
+
+export const GREYS = Object.freeze(["#000000", "#333333", "#555555", "#777777", "#999999", "#BBBBBB", "#DDDDDD", "#F2F2F2", "#FFFFFF"]);
+
+// Stream roles for apparatus figures. A role keeps one colour across every panel of a figure,
+// and every role is distinguishable under deuteranopia and protanopia (checked by PALETTE.CVD).
+export const STREAM = Object.freeze({
+  gas: Object.freeze({ color: OKABE_ITO.blue, dash: null, label: "Gas" }),
+  liquid: Object.freeze({ color: OKABE_ITO.sky, dash: null, label: "Liquid" }),
+  coolant: Object.freeze({ color: OKABE_ITO.green, dash: null, label: "Coolant" }),
+  heating: Object.freeze({ color: OKABE_ITO.vermillion, dash: null, label: "Heating medium" }),
+  vent: Object.freeze({ color: "#777777", dash: "1.2 0.8", label: "Vent" }),
+  signal: Object.freeze({ color: "#555555", dash: "0.9 0.6", label: "Signal" }),
+  sample: Object.freeze({ color: OKABE_ITO.purple, dash: null, label: "Sample" }),
+  vacuum: Object.freeze({ color: OKABE_ITO.orange, dash: "2 0.8", label: "Vacuum" }),
+});
+
+// Journal figures: type and line sizes at final print size.
+export const JOURNAL = Object.freeze({
+  width: Object.freeze({ single: 85, onehalf: 120, double: 178 }),
+  maxHeight: 230,
+  textPt: 7,
+  minTextPt: 6,
+  panelPt: 8,
+  linePt: 0.75,
+  minLinePt: 0.35,
+  get text() { return ptToMm(this.textPt); },
+  get panel() { return ptToMm(this.panelPt); },
+  get line() { return ptToMm(this.linePt); },
+});
+
+// Isometric illustration tokens, light paper. These are the grey palette's shades (the opt-in
+// quiet look) and the strokes, outlines and halo shared by every palette.
+export const ISO = Object.freeze({
+  paper: "#ffffff",
+  face: "#ffffff",
+  top: "#fbfbf9",
+  shade: Object.freeze(["#d6d6d2", "#e1e1dd", "#eaeae6", "#f3f3f0"]),
+  section: "#c9c9c4",
+  cavity: Object.freeze(["#b9bcbf", "#c6c9cc", "#d2d4d6", "#dcdee0"]),
+  hi: "#222226",
+  mid: "#6f6f75",
+  lo: "#a9a9ae",
+  faint: "#d0d0d3",
+  lit: "#000000",
+  accent: OKABE_ITO.blue,
+  halo: "#7d7d74",
+  haloOpacity: 0.28,
+  liquid: "#cfe3ee",
+  liquidEdge: "#8fb6cc",
+  gas: "#eef4f8",
+  weight: 0.2,
+});
+
+// Material palette, the isometric default: each base is the mid tone of a real finish, and the
+// view derives a light-to-shadow ramp from it. Colour names what a part is made of; the accent
+// is signal red, a hue no common finish uses, for the one part the text is about.
+export const MATERIAL = Object.freeze({
+  concrete: "#b9b2a3",
+  steel: "#4f86b5",
+  stainless: "#aab6c2",
+  frame: "#5f8f4e",
+  copper: "#c8743a",
+  brass: "#c9a227",
+  cast: "#4a4f57",
+  insulation: "#d3d7d4",
+  rubber: "#2f3133",
+  glass: "#bfe0e8",
+  accent: "#d1493f",
+  liquid: "#8cc3e0",
+});

package/skills/lit-schematic/scripts/motion.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// Turns a drawing that moves into a short loop: MP4 for slides and players, an animated WebP
+// and a GIF for READMEs and chat.
+//
+//   node motion.mjs <scene.mjs> --out <dir> [--name loop] [--seconds 4] [--fps 24] [--width 1280]
+//                   [--small 720] [--formats mp4,webp,gif]
+//
+// <scene.mjs> exports frame(t) -> SVG string for t in [0, 1); frame(0) must equal the frame
+// after the last one, so the loop closes without a jump. Every frame is drawn by the kit and
+// rasterised by headless Chrome, so the film is deterministic: the same scene gives the same
+// frames. Encoding uses ffmpeg (MP4, GIF) and img2webp (WebP). Nothing is installed: a missing
+// tool stops the run with ENCODER_REQUIRED and the line for the user to run.
+
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { findChrome, renderPng, svgSize } from "./render.mjs";
+
+export function findTool(name, env = process.env) {
+  const dirs = (env.PATH ?? "").split(process.platform === "win32" ? ";" : ":").filter(Boolean);
+  for (const dir of [...dirs, "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"]) {
+    const file = join(dir, process.platform === "win32" ? `${name}.exe` : name);
+    if (existsSync(file)) return file;
+  }
+  return null;
+}
+
+const INSTALL = {
+  ffmpeg: "macOS: brew install ffmpeg · Debian/Ubuntu: sudo apt install ffmpeg · Windows: winget install ffmpeg",
+  img2webp: "macOS: brew install webp · Debian/Ubuntu: sudo apt install webp · Windows: winget install Google.Libwebp",
+};
+
+function run(bin, args) {
+  const result = spawnSync(bin, args, { encoding: "utf8", timeout: 600_000 });
+  if (result.error) throw new Error(`ENCODE_FAILED ${bin}: ${result.error.message}`);
+  if (result.status !== 0) throw new Error(`ENCODE_FAILED ${bin} exited ${result.status}: ${(result.stderr || "").split("\n").filter(Boolean).slice(-2).join(" ")}`);
+}
+
+export function renderMotion({ frame, out, name = "loop", seconds = 4, fps = 24, width = 1280, small = 720, formats = ["mp4", "webp", "gif"], onFrame = null, which = findTool, chromePath = findChrome() }) {
+  const chrome = chromePath;
+  if (!chrome) throw new Error("RENDERER_REQUIRED no Chrome or Chromium found. Install Google Chrome or set CHROME_PATH, then retry.");
+  const need = new Set(formats.flatMap((f) => (f === "webp" ? ["ffmpeg", "img2webp"] : ["ffmpeg"])));
+  const tools = {};
+  for (const tool of need) {
+    tools[tool] = which(tool);
+    if (!tools[tool]) throw new Error(`ENCODER_REQUIRED ${tool} not found. This script never installs software. ${INSTALL[tool]}`);
+  }
+  mkdirSync(out, { recursive: true });
+  const work = mkdtempSync(join(tmpdir(), "lit-schematic-motion-"));
+  try {
+    const count = Math.round(seconds * fps);
+    const frames = join(work, "frames");
+    mkdirSync(frames);
+    let size = null;
+    for (let i = 0; i < count; i++) {
+      const svg = frame(i / count);
+      size ??= svgSize(svg);
+      const dpi = (width / size.width) * 25.4;
+      renderPng({ chrome, svg, out: join(frames, `f${String(i).padStart(4, "0")}.png`), dpi, verify: false });
+      onFrame?.(i + 1, count);
+    }
+    const even = "scale=trunc(iw/2)*2:trunc(ih/2)*2";
+    const results = {};
+    const input = ["-y", "-loglevel", "error", "-framerate", String(fps), "-i", join(frames, "f%04d.png")];
+    if (formats.includes("mp4")) {
+      const file = join(out, `${name}.mp4`);
+      run(tools.ffmpeg, [...input, "-vf", `${even},format=yuv420p`, "-c:v", "libx264", "-crf", "18", "-preset", "slow", "-movflags", "+faststart", file]);
+      results.mp4 = file;
+    }
+    if (formats.includes("gif")) {
+      const file = join(out, `${name}.gif`);
+      run(tools.ffmpeg, [...input, "-vf", `scale=${small}:-1:flags=lanczos,split[a][b];[a]palettegen=max_colors=128:stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=4`, "-loop", "0", file]);
+      results.gif = file;
+    }
+    if (formats.includes("webp")) {
+      const smallDir = join(work, "small");
+      mkdirSync(smallDir);
+      run(tools.ffmpeg, [...input, "-vf", `scale=${small}:-1:flags=lanczos`, join(smallDir, "s%04d.png")]);
+      const file = join(out, `${name}.webp`);
+      const delay = String(Math.round(1000 / fps));
+      const list = readdirSync(smallDir).filter((f) => f.endsWith(".png")).sort();
+      run(tools.img2webp, ["-loop", "0", "-lossy", "-q", "78", "-m", "4", ...list.flatMap((f) => ["-d", delay, join(smallDir, f)]), "-o", file]);
+      results.webp = file;
+    }
+    return { frames: count, fps, seconds, width, files: Object.fromEntries(Object.entries(results).map(([k, f]) => [k, { file: f, bytes: statSync(f).size }])) };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+async function main(argv) {
+  const args = argv.slice(2);
+  const value = (flag, fallback) => { const i = args.indexOf(flag); return i >= 0 ? args[i + 1] : fallback; };
+  const scene = args[0];
+  if (!scene || scene.startsWith("--") || !value("--out")) {
+    console.error("Usage: node motion.mjs <scene.mjs exporting frame(t)> --out <dir> [--name loop] [--seconds 4] [--fps 24] [--width 1280] [--small 720] [--formats mp4,webp,gif]");
+    return 2;
+  }
+  const mod = await import(pathToFileURL(resolve(scene)).href);
+  if (typeof mod.frame !== "function") {
+    console.error(`MOTION_SCENE ${scene} must export frame(t) returning an SVG string`);
+    return 2;
+  }
+  try {
+    const result = renderMotion({
+      frame: mod.frame,
+      out: resolve(value("--out")),
+      name: value("--name", "loop"),
+      seconds: Number(value("--seconds", 4)),
+      fps: Number(value("--fps", 24)),
+      width: Number(value("--width", 1280)),
+      small: Number(value("--small", 720)),
+      formats: value("--formats", "mp4,webp,gif").split(","),
+      onFrame: (i, n) => { if (i === n || i % 24 === 0) console.error(`frame ${i}/${n}`); },
+    });
+    for (const [kind, { file, bytes }] of Object.entries(result.files)) console.log(`MOTION_${kind.toUpperCase()} ${file} ${(bytes / 1024).toFixed(0)} KB`);
+    console.log(`MOTION_DONE ${result.frames} frames at ${result.fps} fps (${result.seconds} s)`);
+    return 0;
+  } catch (error) {
+    console.error(error.message);
+    return /REQUIRED/u.test(error.message) ? 2 : 1;
+  }
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  main(process.argv).then((code) => { process.exitCode = code; });
+}

package/skills/lit-schematic/scripts/qa.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// The lit-schematic QA gate.
+//
+//   node qa.mjs drawing.svg                       static checks; exit 1 on any FAIL
+//   node qa.mjs drawing.svg --json                the same result as JSON
+//   node qa.mjs drawing.svg --png d.png --pdf d.pdf [--dpi 600]
+//                                                 also checks the exports are whole, the PNG
+//                                                 says its resolution and the PDF has the SVG's size
+//   node qa.mjs --codes                           list every check code and what it means
+//
+// Options: --mode pid|pfd|journal|iso|figure (default: the root's data-schematic-mode),
+// --min-pt <n> minimum text size at print, --min-stroke-mm <n>.
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { CODES, check, formatReport } from "./lib/qa-core.mjs";
+import { pngInfo } from "./lib/png.mjs";
+import { svgSize } from "./render.mjs";
+
+export function checkExports({ svg, png, pdf, dpi = 600 }) {
+  const findings = [];
+  const add = (code, message) => findings.push({ code, level: "FAIL", message });
+  const size = svgSize(svg);
+  if (png) {
+    try {
+      const info = pngInfo(readFileSync(png));
+      if (!info.closed) add("PNG.CLOSED", `${png} is truncated or has a bad chunk checksum`);
+      if (!info.dpi || info.dpi + 0.5 < dpi) add("PNG.DPI", `${png} declares ${info.dpi ?? "no"} dpi; ${dpi} dpi is required`);
+      const expected = Math.round((size.width / 25.4) * (info.dpi ?? dpi));
+      if (info.dpi && Math.abs(info.width - expected) > Math.max(3, expected * 0.01)) add("PNG.DPI", `${png} is ${info.width} px wide; ${expected} px is the drawing width at ${info.dpi} dpi`);
+    } catch (error) {
+      add("PNG.CLOSED", `${png}: ${error.message}`);
+    }
+  }
+  if (pdf) {
+    try {
+      const bytes = readFileSync(pdf);
+      const head = bytes.subarray(0, 5).toString("latin1");
+      const tail = bytes.subarray(Math.max(0, bytes.length - 1024)).toString("latin1");
+      if (head !== "%PDF-" || !tail.includes("%%EOF")) add("PDF.CLOSED", `${pdf} lacks a PDF header or end-of-file marker`);
+      const box = /\/MediaBox\s*\[\s*([-\d.]+)\s+([-\d.]+)\s+([-\d.]+)\s+([-\d.]+)\s*\]/u.exec(bytes.toString("latin1"));
+      if (!box) add("PDF.SIZE", `${pdf} has no readable MediaBox`);
+      else {
+        const w = ((Number(box[3]) - Number(box[1])) * 25.4) / 72;
+        const h = ((Number(box[4]) - Number(box[2])) * 25.4) / 72;
+        if (Math.abs(w - size.width) > 1 || Math.abs(h - size.height) > 1) add("PDF.SIZE", `${pdf} page is ${w.toFixed(1)} x ${h.toFixed(1)} mm; the drawing is ${size.width.toFixed(1)} x ${size.height.toFixed(1)} mm`);
+      }
+    } catch (error) {
+      add("PDF.CLOSED", `${pdf}: ${error.message}`);
+    }
+  }
+  return findings;
+}
+
+function main(argv) {
+  const args = argv.slice(2);
+  const value = (flag) => { const i = args.indexOf(flag); return i >= 0 ? args[i + 1] : undefined; };
+  if (args.includes("--codes")) {
+    for (const [code, meaning] of Object.entries(CODES)) console.log(`${code.padEnd(20)} ${meaning}`);
+    console.log(`${"PNG.CLOSED".padEnd(20)} The PNG is truncated or a chunk checksum is wrong.`);
+    console.log(`${"PNG.DPI".padEnd(20)} The PNG does not declare the required resolution or is the wrong pixel width.`);
+    console.log(`${"PDF.CLOSED".padEnd(20)} The PDF lacks its header or end-of-file marker.`);
+    console.log(`${"PDF.SIZE".padEnd(20)} The PDF page size differs from the drawing size.`);
+    return 0;
+  }
+  const flagged = new Set(["--mode", "--min-pt", "--min-stroke-mm", "--png", "--pdf", "--dpi"]);
+  const input = args.find((a, i) => !a.startsWith("--") && !flagged.has(args[i - 1]));
+  if (!input) {
+    console.error("Usage: node qa.mjs drawing.svg [--json] [--mode pid|pfd|journal|iso|figure] [--min-pt 6] [--png file --pdf file --dpi 600] | --codes");
+    return 2;
+  }
+  const svg = readFileSync(resolve(input), "utf8");
+  const result = check(svg, {
+    mode: value("--mode"),
+    minTextPt: value("--min-pt") ? Number(value("--min-pt")) : undefined,
+    minStrokeMm: value("--min-stroke-mm") ? Number(value("--min-stroke-mm")) : undefined,
+  });
+  if (value("--png") || value("--pdf")) {
+    const extra = checkExports({ svg, png: value("--png") && resolve(value("--png")), pdf: value("--pdf") && resolve(value("--pdf")), dpi: Number(value("--dpi") ?? 600) });
+    result.findings.push(...extra);
+    result.fails += extra.length;
+    if (extra.length) result.verdict = "FAIL";
+  }
+  if (args.includes("--json")) console.log(JSON.stringify({ file: input, ...result }, null, 2));
+  else console.log(formatReport(result, input));
+  return result.verdict === "PASS" ? 0 : 1;
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  process.exitCode = main(process.argv);
+}

package/skills/lit-schematic/scripts/render.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+// Renders a lit-schematic SVG through headless Chrome.
+//
+//   node render.mjs drawing.svg --png drawing.png [--dpi 600]       raster at print size, pHYs written
+//   node render.mjs drawing.svg --pdf drawing.pdf                   vector PDF at the SVG's mm size
+//   node render.mjs drawing.svg --crop x,y,w,h --png close.png      one region (viewBox mm) at --dpi
+//   node render.mjs drawing.svg --sheet sweep.png [--grid 3x2]      close-up contact sheet of the whole drawing
+//
+// It never installs anything. Without Chrome it exits 2 with RENDERER_REQUIRED and the setup
+// line for the user to run. Every launch uses a throwaway profile, a mock keychain and a basic
+// password store, so no keychain dialog reaches the desktop, and the profile is removed after.
+
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { findPretendard } from "./lib/fonts.mjs";
+import { inkGrid, missingInk, pngInfo, withDpi } from "./lib/png.mjs";
+
+export const CHROME_FLAGS = Object.freeze([
+  "--headless=new", "--use-mock-keychain", "--password-store=basic", "--no-first-run",
+  "--no-default-browser-check", "--disable-gpu", "--hide-scrollbars", "--disable-extensions",
+]);
+const PX_PER_MM = 96 / 25.4;
+const MAX_SIDE = 16000;
+// Headless Chrome returns a screenshot larger than about 100 million pixels with only its first
+// tiles painted and no error (an A2 sheet at 600 dpi is 139 Mpx). Stay well under that.
+const MAX_PIXELS = 80e6;
+
+// The device scale and the dpi actually used for a page of cssW x cssH CSS pixels.
+export function rasterScale(cssW, cssH, dpi) {
+  let scale = dpi / 96;
+  if (Math.max(cssW, cssH) * scale > MAX_SIDE) scale = MAX_SIDE / Math.max(cssW, cssH);
+  if (cssW * cssH * scale * scale > MAX_PIXELS) scale = Math.sqrt(MAX_PIXELS / (cssW * cssH));
+  const used = Math.min(dpi, Math.floor(scale * 96));
+  return { scale: used / 96, dpi: used };
+}
+
+export function findChrome(env = process.env) {
+  const candidates = [
+    env.CHROME_PATH,
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing",
+    "/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser",
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+  ].filter(Boolean);
+  return candidates.find((file) => existsSync(file)) ?? null;
+}
+
+export function svgSize(svg) {
+  const root = svg.match(/<svg\b[^>]*>/u)?.[0];
+  if (!root) throw new Error("SVG_MISSING no <svg> root");
+  const get = (name) => root.match(new RegExp(`\\s${name}="([^"]+)"`, "u"))?.[1];
+  const view = get("viewBox")?.trim().split(/[\s,]+/u).map(Number);
+  const toMm = (value) => {
+    const m = /^([\d.]+)\s*(mm|cm|in|pt|px)?$/u.exec(value ?? "");
+    if (!m) return null;
+    const v = Number(m[1]);
+    return { mm: v, cm: v * 10, in: v * 25.4, pt: (v * 25.4) / 72, px: v / PX_PER_MM, undefined: v / PX_PER_MM }[m[2]];
+  };
+  const width = toMm(get("width"));
+  const height = toMm(get("height"));
+  if (!view || view.length !== 4 || !width || !height) throw new Error("SVG_SIZE the root needs a viewBox and a physical width and height (for example width=\"178mm\")");
+  return { width, height, view };
+}
+
+function fontFace() {
+  const font = findPretendard();
+  if (!font) return "";
+  return `@font-face{font-family:Pretendard;src:url("${pathToFileURL(font.file).href}");font-weight:100 900}`;
+}
+
+const stripProlog = (svg) => svg.replace(/^\s*<\?xml[^>]*>\s*/u, "");
+
+function page({ svg, widthMm, heightMm, body }) {
+  return `<!doctype html><html><head><meta charset="utf-8"><style>${fontFace()}@page{size:${widthMm}mm ${heightMm}mm;margin:0}html,body{margin:0;padding:0;background:#ffffff}svg{display:block}</style></head><body>${body ?? stripProlog(svg)}</body></html>`;
+}
+
+function runChrome(chrome, args, html, work) {
+  const file = join(work, "page.html");
+  writeFileSync(file, html);
+  const profile = mkdtempSync(join(work, "profile-"));
+  try {
+    const result = spawnSync(chrome, [...CHROME_FLAGS, `--user-data-dir=${profile}`, ...args, pathToFileURL(file).href], { encoding: "utf8", timeout: 180_000 });
+    if (result.error) throw new Error(`RENDER_FAILED ${result.error.message}`);
+    if (result.status !== 0) throw new Error(`RENDER_FAILED chrome exited ${result.status}: ${(result.stderr || "").split("\n").slice(-3).join(" ")}`);
+  } finally {
+    rmSync(profile, { recursive: true, force: true });
+  }
+}
+
+// `verify: false` skips the reference render, for film frames far below the size that can fail.
+export function renderPng({ chrome, svg, out, dpi = 600, crop = null, verify = true }) {
+  const size = svgSize(svg);
+  let source = svg;
+  let widthMm = size.width;
+  let heightMm = size.height;
+  if (crop) {
+    const [x, y, w, h] = crop;
+    const sx = size.width / size.view[2];
+    widthMm = w * sx;
+    heightMm = h * sx;
+    source = svg.replace(/<svg\b[^>]*>/u, (root) => root
+      .replace(/\sviewBox="[^"]*"/u, ` viewBox="${x} ${y} ${w} ${h}"`)
+      .replace(/\swidth="[^"]*"/u, ` width="${widthMm}mm"`)
+      .replace(/\sheight="[^"]*"/u, ` height="${heightMm}mm"`));
+  }
+  const cssW = Math.ceil(widthMm * PX_PER_MM);
+  const cssH = Math.ceil(heightMm * PX_PER_MM);
+  const work = mkdtempSync(join(tmpdir(), "lit-schematic-render-"));
+  try {
+    const raw = join(work, "raw.png");
+    const html = page({ svg: source, widthMm, heightMm });
+    // A small reference render shows where ink belongs; a cell inked there and blank in the full
+    // render means the browser stopped painting part of the page. That limit depends on the
+    // drawing as well as the size, so step the dpi down until the whole page arrives.
+    const ref = join(work, "ref.png");
+    if (verify) runChrome(chrome, ["--force-device-scale-factor=0.5", `--window-size=${cssW},${cssH}`, `--screenshot=${ref}`], html, work);
+    const reference = verify ? inkGrid(readFileSync(ref)) : null;
+    let { dpi: used } = rasterScale(cssW, cssH, dpi);
+    for (let attempt = 0; ; attempt++) {
+      runChrome(chrome, [`--force-device-scale-factor=${used / 96}`, `--window-size=${cssW},${cssH}`, `--screenshot=${raw}`], html, work);
+      const blank = verify ? missingInk(reference, inkGrid(readFileSync(raw))) : [];
+      if (!blank.length) break;
+      if (attempt === 3) throw new Error(`RENDER_INCOMPLETE ${blank.length} of 36 regions came out blank at ${used} dpi though they hold ink; render --crop regions instead`);
+      used = Math.floor(used * 0.85);
+    }
+    const png = withDpi(readFileSync(raw), used);
+    writeFileSync(out, png);
+    return { out, ...pngInfo(png), requestedDpi: dpi };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+export function renderPdf({ chrome, svg, out }) {
+  const size = svgSize(svg);
+  const work = mkdtempSync(join(tmpdir(), "lit-schematic-render-"));
+  try {
+    runChrome(chrome, ["--no-pdf-header-footer", `--print-to-pdf=${resolve(out)}`], page({ svg, widthMm: size.width, heightMm: size.height }), work);
+    return { out, widthMm: size.width, heightMm: size.height };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+// One image of every region of the drawing enlarged, labelled with its viewBox box, so the
+// close-up sweep is a single file to read.
+export function renderSheet({ chrome, svg, out, grid = [3, 2], cellPx = 640 }) {
+  const size = svgSize(svg);
+  const [vx, vy, vw, vh] = size.view;
+  const [cols, rows] = grid;
+  const cw = vw / cols;
+  const ch = vh / rows;
+  const cellH = Math.round((cellPx * ch) / cw);
+  const inner = stripProlog(svg);
+  const cells = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const box = [vx + c * cw, vy + r * ch, cw, ch].map((v) => Math.round(v * 10) / 10);
+      const copy = inner.replace(/<svg\b[^>]*>/u, (root) => root
+        .replace(/\sviewBox="[^"]*"/u, ` viewBox="${box.join(" ")}"`)
+        .replace(/\swidth="[^"]*"/u, ` width="${cellPx}px"`)
+        .replace(/\sheight="[^"]*"/u, ` height="${cellH}px"`))
+        .replaceAll(/\sid="([^"]+)"/gu, ` id="$1-${r}-${c}"`);
+      cells.push(`<figure style="margin:0;border:1px solid #999"><figcaption style="font:12px Arial;padding:2px 4px;background:#f2f2f2">crop ${box.join(",")}</figcaption>${copy}</figure>`);
+    }
+  }
+  const body = `<div style="display:grid;grid-template-columns:repeat(${cols},${cellPx + 2}px);gap:8px;padding:8px">${cells.join("")}</div>`;
+  const cssW = cols * (cellPx + 10) + 16;
+  const cssH = rows * (cellH + 30) + 16;
+  const work = mkdtempSync(join(tmpdir(), "lit-schematic-render-"));
+  try {
+    const raw = join(work, "raw.png");
+    runChrome(chrome, ["--force-device-scale-factor=1.5", `--window-size=${cssW},${cssH}`, `--screenshot=${raw}`], page({ svg, widthMm: cssW / PX_PER_MM, heightMm: cssH / PX_PER_MM, body }), work);
+    writeFileSync(out, readFileSync(raw));
+    return { out, cells: cols * rows };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+function main(argv) {
+  const args = argv.slice(2);
+  const value = (flag) => { const i = args.indexOf(flag); return i >= 0 ? args[i + 1] : undefined; };
+  const input = args.find((a, i) => !a.startsWith("--") && !(i > 0 && args[i - 1].startsWith("--") && args[i - 1] !== "--help"));
+  if (!input || args.includes("--help")) {
+    console.error("Usage: node render.mjs drawing.svg [--png out.png] [--dpi 600] [--pdf out.pdf] [--crop x,y,w,h] [--sheet sweep.png --grid 3x2]");
+    return 2;
+  }
+  const chrome = findChrome();
+  if (!chrome) {
+    console.error("RENDERER_REQUIRED no Chrome or Chromium found. This script never installs software. Install Google Chrome, or set CHROME_PATH to a Chrome/Chromium binary, then retry.");
+    return 2;
+  }
+  const svg = readFileSync(resolve(input), "utf8");
+  const dpi = Number(value("--dpi") ?? 600);
+  const crop = value("--crop")?.split(",").map(Number);
+  let did = false;
+  if (value("--png")) {
+    const r = renderPng({ chrome, svg, out: resolve(value("--png")), dpi, crop });
+    console.log(`RENDER_PNG ${r.out} ${r.width}x${r.height} px ${r.dpi} dpi${r.dpi < dpi ? ` (reduced from ${dpi}: the image would exceed what one browser frame paints; render crops for more)` : ""}`);
+    did = true;
+  }
+  if (value("--pdf")) {
+    const r = renderPdf({ chrome, svg, out: resolve(value("--pdf")) });
+    console.log(`RENDER_PDF ${r.out} ${Math.round(r.widthMm * 10) / 10} x ${Math.round(r.heightMm * 10) / 10} mm`);
+    did = true;
+  }
+  if (value("--sheet")) {
+    const grid = (value("--grid") ?? "3x2").split("x").map(Number);
+    const r = renderSheet({ chrome, svg, out: resolve(value("--sheet")), grid });
+    console.log(`RENDER_SHEET ${r.out} ${r.cells} close-ups of ${basename(input)}`);
+    did = true;
+  }
+  if (!did) {
+    console.error("Nothing to do: pass --png, --pdf or --sheet.");
+    return 2;
+  }
+  return 0;
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  try {
+    process.exitCode = main(process.argv);
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}