@nodegx/mcp 0.1.0 → 0.2.0

package/dist/render-harness/measure-from-disk.js

@@ -0,0 +1,2366 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../scripts/devtools/harness-paths.js
+var require_harness_paths = __commonJS({
+  "../../scripts/devtools/harness-paths.js"(exports2, module2) {
+    var fs2 = require("fs");
+    var path2 = require("path");
+    var CHECKOUT_ROOT = path2.resolve(__dirname, "..", "..");
+    var PACKAGED_ROOT = path2.resolve(__dirname, "..");
+    var PACKAGED_DATA = path2.join(__dirname, "data");
+    function firstExisting(candidates) {
+      const probed = [];
+      for (const candidate of candidates) {
+        probed.push(candidate);
+        if (fs2.existsSync(candidate)) return { path: candidate, probed, candidates };
+      }
+      return { path: null, probed, candidates };
+    }
+    function resolveHarnessPath(checkoutRelative, packagedCandidate) {
+      return firstExisting([path2.join(CHECKOUT_ROOT, checkoutRelative), packagedCandidate]);
+    }
+    var VIEWER_DIR = resolveHarnessPath(
+      "packages/noodl-editor/src/external/viewer",
+      path2.join(PACKAGED_ROOT, "src", "external", "viewer")
+    );
+    var CATALOG_JSON = resolveHarnessPath(
+      "packages/noodl-types/src/node-catalog.json",
+      path2.join(PACKAGED_DATA, "node-catalog.json")
+    );
+    var ENRICHED_CATALOG_JSON = resolveHarnessPath(
+      "packages/noodl-types/src/node-catalog-enriched.json",
+      path2.join(PACKAGED_DATA, "node-catalog-enriched.json")
+    );
+    var TOKENS_SRC = resolveHarnessPath(
+      "packages/nodegx-project-contract/tokens.ts",
+      path2.join(PACKAGED_DATA, "tokens.ts")
+    );
+    var WS_MODULE = (() => {
+      const checkout = path2.join(CHECKOUT_ROOT, "node_modules", "ws");
+      const candidates = [checkout, "require('ws')"];
+      if (fs2.existsSync(checkout)) return { path: checkout, probed: [checkout], candidates, bare: false };
+      try {
+        require.resolve("ws");
+        return { path: "ws", probed: candidates, candidates, bare: true };
+      } catch {
+        return { path: null, probed: candidates, candidates, bare: false };
+      }
+    })();
+    module2.exports = {
+      CHECKOUT_ROOT,
+      PACKAGED_ROOT,
+      PACKAGED_DATA,
+      VIEWER_DIR,
+      CATALOG_JSON,
+      ENRICHED_CATALOG_JSON,
+      TOKENS_SRC,
+      WS_MODULE,
+      firstExisting,
+      resolveHarnessPath
+    };
+  }
+});
+
+// ../nodegx-render-measure/src/index.js
+var require_src = __commonJS({
+  "../nodegx-render-measure/src/index.js"(exports2, module2) {
+    "use strict";
+    var DEFAULT_VIEWPORTS = [
+      { name: "desktop", width: 1280, height: 900, mobile: false },
+      { name: "phone", width: 390, height: 844, mobile: true }
+    ];
+    var NAMED_VIEWPORTS = [
+      { name: "desktop", width: 1280, height: 900, mobile: false },
+      { name: "tablet", width: 1024, height: 1366, mobile: false },
+      { name: "phone", width: 390, height: 844, mobile: true }
+    ];
+    var DESKTOP_WIDTH = 1024;
+    var GRID_ITEM_MIN_HEIGHT = 120;
+    var GRID_ITEM_MIN_WIDTH = 300;
+    var GRID_ITEM_PARENT_SHARE = 0.6;
+    var GRID_PARENT_VIEWPORT_SHARE = 0.5;
+    function measureExpression(placeholders, probes = []) {
+      return `(() => {
+  const PLACEHOLDERS = ${JSON.stringify(placeholders)};
+  const PROBES = ${JSON.stringify(probes)};
+  const round = (n) => Math.round(n);
+  const cls = (el) => String(el.className || '').trim().slice(0, 60);
+  const all = [...document.querySelectorAll('body *')];
+
+  // FLD-012 \u2014 one computed style per element, reused by every rule below. 'visible' now needs a
+  // style for EVERY element rather than only for the ones with no offset parent, and four rules
+  // downstream ask for the same element's style again. Without this the change would have paid for
+  // a second 'getComputedStyle' per empty box on every page.
+  const styles = new Map();
+  const styleOf = (el) => {
+    let cs = styles.get(el);
+    if (cs === undefined) {
+      cs = getComputedStyle(el);
+      styles.set(el, cs);
+    }
+    return cs;
+  };
+
+  // FLD-012 (#32) \u2014 'visible' is the population every rule below is computed over, and it used to
+  // mean "the browser gave it a layout box". That is not the same as "a person can see it":
+  // 'offsetParent' is null for 'display: none' but perfectly non-null for 'opacity: 0' and for
+  // 'visibility: hidden'. So an invisible element was being reported as a box a person could see \u2014
+  // by 'empty-decorated-box', and inherited unchanged by 'elements-overflowing', the accent-area
+  // census, the rhythm bands and 'single-column-grid'. This is a correctness fix, not a
+  // suppression: nothing that can be seen is dropped.
+  //
+  // \u26A0\uFE0F 'visibility' is inherited, so the computed value already accounts for a hidden ancestor.
+  // 'opacity' is NOT inherited \u2014 a child of an 'opacity: 0' parent computes to 1 \u2014 so this catches
+  // the element that is itself transparent and not one buried under a faded ancestor. Walking every
+  // ancestor would cost a style read per level per element; the shipped false positives are all the
+  // first kind ('.ndl-controls-radio-2' is 'opacity: 0' on the input itself).
+  // FLD-012 AC3 \u2014 declared OUTSIDE the filter below on purpose: a reverted arm replaces only the
+  // filter, and a counter declared inside it would make the reverted arm throw a ReferenceError
+  // instead of measuring. Left at 0, which is exactly what the old predicate excluded.
+  let transparentExcluded = 0;
+  const visible = all.filter((el) => {
+    const cs = styleOf(el);
+    if (cs.visibility === 'hidden' || cs.opacity === '0') {
+      transparentExcluded += 1;
+      return false;
+    }
+    return el.offsetParent !== null || cs.position === 'fixed';
+  });
+
+  const vw = document.documentElement.clientWidth;
+  const vh = document.documentElement.clientHeight;
+  const overflowing = visible
+    .map((el) => ({ el, w: el.getBoundingClientRect().width }))
+    .filter((x) => x.w > vw + 1)
+    .map((x) => ({ tag: x.el.tagName, cls: cls(x.el), width: round(x.w) }));
+
+  // P88 GAM-020 (D58) \u2014 a Text wider than the box it sits in. RKT-001's corrected clause: the text's
+  // border box against its PARENT's content box. A 'white-space: pre' Text always fits itself, so its
+  // own scrollWidth against its own clientWidth cannot fail (that read 60/60 green on the clipped
+  // build). An inline parent has no content box (clientWidth 0) and is skipped, never judged.
+  const textsWiderThanBox = visible
+    .filter((el) => el.classList.contains('ndl-visual-text') && el.parentElement)
+    .map((el) => {
+      const parent = el.parentElement;
+      const ps = styleOf(parent);
+      const box = parent.clientWidth - (parseFloat(ps.paddingLeft) || 0) - (parseFloat(ps.paddingRight) || 0);
+      return { el, width: el.getBoundingClientRect().width, box };
+    })
+    .filter((x) => x.box > 0 && x.width > x.box + 1)
+    .map((x) => ({ text: x.el.textContent.trim().slice(0, 80), width: round(x.width), parentWidth: round(x.box), cls: cls(x.el) }));
+
+  // AWP-004 \u2014 what is on screen, as opposed to what is in the DOM. The page is
+  // never scrolled when this runs, so a rect is already a document position.
+  // Kimi K3's storefront was 83 texts in the DOM and about three on screen, and
+  // the report called it clean because every check it had was about content
+  // present and wrong rather than content present and unreachable.
+  const onScreen = (el) => {
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < vh && r.right > 0 && r.left < vw;
+  };
+
+  // Below the fold is fine \u2014 that is what scrolling is for. Below the *scrollable
+  // extent* is not: no scroll reaches it, so it is on the page and can never be
+  // seen. Measured directly rather than inferred from a visible-count ratio,
+  // because a correct 82-text page also shows only ~19 at a time and a ratio
+  // cannot tell the two apart.
+  const pageBottom = document.documentElement.scrollHeight;
+  const unreachable = (el) => el.getBoundingClientRect().top >= pageBottom - 1;
+
+  const textEls = visible.filter((el) => el.children.length === 0 && el.textContent.trim().length > 0);
+  const fontWeights = {};
+  const fontSizes = {};
+  for (const el of textEls) {
+    const cs = styleOf(el);
+    fontWeights[cs.fontWeight] = (fontWeights[cs.fontWeight] || 0) + 1;
+    fontSizes[cs.fontSize] = (fontSizes[cs.fontSize] || 0) + 1;
+  }
+
+  const dead = textEls.filter((el) => PLACEHOLDERS.includes(el.textContent.trim()));
+  const byText = {};
+  for (const el of dead) {
+    const t = el.textContent.trim();
+    byText[t] = (byText[t] || 0) + 1;
+  }
+
+  // FLD-012 (#32) \u2014 *"I started ignoring the warning."* Five of ten pages carried this finding
+  // purely for containing a control, and noise in a signal this good is a real cost.
+  //
+  // Two residues survive the 'visible' fix above, because neither is invisible \u2014 they are drawn,
+  // they are just not the author's boxes:
+  //
+  //   1. A FORM CONTROL. It has no children and no text by construction, and the runtime styles it
+  //      \u2014 the deprecated Radio Button is an '<input type="radio">' at 24x24 with a solid border
+  //      ('nodes-deprecated/controls/radiobutton.tsx:62', 'assets/style.css:64'). It is not an empty
+  //      box; it is a control that happens to be childless.
+  //   2. A CONTROL'S OWN FURNITURE \u2014 the parts the runtime draws INSIDE a control, beside its
+  //      input, as plain unclassed '<div>'s: the Slider's track and thumb ('Slider.tsx:146-176')
+  //      and the Radio Button's checked fill dot, which is the one this fixture actually caught \u2014
+  //      a 16x16 absolutely-positioned black div whose parent also holds the radio input. Every
+  //      one of them is drawn, so no visibility test reaches them, and every one is furniture
+  //      rather than a box the author left empty.
+  //
+  // \u{1F534} #32's own suggested discriminator does not reach either of them, and the second half of
+  // this file's earlier scope note was actively dangerous:
+  //   - 'closest('[class*="ndl-controls-"]')' returns null for the track and the thumb \u2014 they are
+  //     unclassed and so is their parent; only their '<input>' SIBLING carries the class.
+  //   - 'appearance: none' is the COMPUTED DEFAULT of an ordinary '<div>' in Chrome, measured on
+  //     this fixture. Skipping on it would suppress every finding on every page, including the
+  //     author's genuinely empty box \u2014 which is exactly the failure mode this rule's presence
+  //     control exists to catch. It is not used here.
+  //
+  // \u26A0\uFE0F The furniture predicate is deliberately narrow, and it is TWO conditions, not one:
+  // absolutely positioned AND a direct sibling of a form control. An author's own empty Group is
+  // neither \u2014 measured on this fixture it is 'position: relative' with four plain div siblings.
+  // It would take positioning a box absolutely AND placing it beside a control in the same parent
+  // to be suppressed by this: small, real, and stated here rather than discovered later.
+  const FORM_CONTROL_TAGS = ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON', 'PROGRESS', 'METER'];
+  const CONTROL_SIBLING_SELECTOR = ':scope > input, :scope > select, :scope > textarea, :scope > button';
+  const isControlFurniture = (el) => {
+    const parent = el.parentElement;
+    if (!parent || !parent.querySelector(CONTROL_SIBLING_SELECTOR)) return false;
+    return styleOf(el).position === 'absolute';
+  };
+
+  const emptyBoxes = visible.filter((el) => {
+    if (el.children.length !== 0 || el.textContent.trim() !== '') return false;
+    const r = el.getBoundingClientRect();
+    if (r.width <= 8 || r.height <= 8) return false;
+    if (FORM_CONTROL_TAGS.indexOf(el.tagName) !== -1) return false;
+    if (isControlFurniture(el)) return false;
+    const cs = styleOf(el);
+    return cs.backgroundColor !== 'rgba(0, 0, 0, 0)' || cs.borderStyle !== 'none';
+  });
+
+  const images = visible.filter((el) => el.tagName === 'IMG');
+  const brokenImages = images.filter((el) => el.complete && el.naturalWidth === 0);
+
+  // VIB-007 M3 \u2014 iconography, which no earlier finding needed and which
+  // 'no-imagery' cannot be honest without: README section 2's tell is "no
+  // imagery AND no iconography", and a page of five Lucide glyphs and no
+  // photographs satisfies only half of it.
+  //
+  // Four shapes, because IconGlyph has four branches and only two of them carry
+  // a class this could key on. Measured against the VIB-006 page rather than
+  // read off the component: the font branch renders
+  // span.lucide.icon-sprout with NO ndl-icon-glyph class on it, so a selector
+  // written from that constant would have counted zero on a page with ten.
+  //
+  //   sprite / inline -> .ndl-icon-glyph
+  //   the Icon node   -> .ndl-visual-icon wrapper
+  //   an inline svg   -> the svg element itself
+  //   a font glyph    -> a ::before whose content is a Private Use Area
+  //                      codepoint, which is what an icon font IS. Restricting
+  //                      to U+E000..U+F8FF is what keeps a bullet, a quote mark
+  //                      or a CSS counter from counting as iconography.
+  //
+  // A Set of ELEMENTS, so the wrapper and the glyph it holds are not two icons.
+  // Over-counting is harmless here and under-counting is not: the predicate is
+  // "is there any iconography at all", so a wrapper counted twice still says
+  // yes, and a glyph missed entirely says no when the answer is yes.
+  const PUA_FIRST = 0xe000;
+  const PUA_LAST = 0xf8ff;
+  const isGlyphContent = (raw) => {
+    if (!raw || raw === 'none' || raw === 'normal') return false;
+    const text = raw.replace(/^["']|["']$/g, '');
+    if (!text.length) return false;
+    for (const ch of text) {
+      const pt = ch.codePointAt(0);
+      if (pt < PUA_FIRST || pt > PUA_LAST) return false;
+    }
+    return true;
+  };
+  const iconEls = new Set();
+  for (const el of visible) {
+    const list = el.classList;
+    if (list && (list.contains('ndl-icon-glyph') || list.contains('ndl-visual-icon'))) {
+      iconEls.add(el);
+      continue;
+    }
+    if (String(el.tagName).toLowerCase() === 'svg') {
+      iconEls.add(el);
+      continue;
+    }
+    if (isGlyphContent(getComputedStyle(el, '::before').content)) iconEls.add(el);
+  }
+
+  // VIB-007 M3 \u2014 the page's full-bleed surfaces and what each is painted with.
+  //
+  // README section 2's first WordPress tell is "one background colour end to
+  // end", and the reading it needs is the number of DISTINCT grounds across the
+  // bands, not across every element: a page whose sections alternate has a
+  // designed rhythm, and a page whose cards and inputs happen to carry three
+  // greys does not. The width filter is the one the rhythm block already uses,
+  // so "band" means the same thing in both readings.
+  //
+  // background-image is read BEFORE background-color and wins, because a
+  // gradient or a photograph sits on top of the colour and is the ground a
+  // person sees. Measured, not assumed: every one of the VIB-006 page's
+  // gradient bands reports backgroundColor rgba(0, 0, 0, 0) and its whole
+  // identity is in background-image, so a colour-only count read 6 grounds on a
+  // page that has 8.
+  const groundCounts = {};
+  for (const el of visible) {
+    const r = el.getBoundingClientRect();
+    if (r.width < vw * 0.6 || r.height < 8) continue;
+    const cs = styleOf(el);
+    const painted =
+      cs.backgroundImage && cs.backgroundImage !== 'none'
+        ? cs.backgroundImage
+        : cs.backgroundColor && cs.backgroundColor !== 'rgba(0, 0, 0, 0)' && cs.backgroundColor !== 'transparent'
+          ? cs.backgroundColor
+          : null;
+    if (!painted) continue;
+    const key = String(painted).slice(0, 120);
+    groundCounts[key] = (groundCounts[key] || 0) + 1;
+  }
+
+  // DSG-006 \xA74 \u2014 "one accent". A designed page carries one chromatic colour as
+  // a background and neutrals for everything else; five accents is decorated
+  // rather than designed. Neutral is decided by *chroma* (max minus min
+  // channel) rather than by matching a palette, so it holds for any token set
+  // and for a project that never adopted one. Area-weighted, because a 4px
+  // chromatic rule and a full-bleed hero are not the same claim.
+  const parseRgb = (s) => {
+    const m = s.match(/rgba?\\(([^)]+)\\)/);
+    if (!m) return null;
+    const p = m[1].split(',').map((x) => parseFloat(x));
+    if (p.length >= 4 && p[3] === 0) return null;
+    return [p[0], p[1], p[2]];
+  };
+  const accentArea = {};
+  const neutralArea = {};
+  for (const el of visible) {
+    const r = el.getBoundingClientRect();
+    const area = r.width * r.height;
+    if (area < 1000) continue;
+    const bg = styleOf(el).backgroundColor;
+    const c = parseRgb(bg);
+    if (!c) continue;
+    const chroma = Math.max(c[0], c[1], c[2]) - Math.min(c[0], c[1], c[2]);
+    const bucket = chroma > 12 ? accentArea : neutralArea;
+    bucket[bg] = (bucket[bg] || 0) + area;
+  }
+  // DSG-006/F41 \u2014 raw area cannot say whether a chromatic colour is an *accent*
+  // or the page's ground, and it is not comparable between viewports: 600k px\xB2
+  // is half of a desktop page and four phone screens. "share" is the fraction
+  // of the viewport the colour covers, which is the number \xA74 is actually
+  // about. The case that named this: haiku and sonnet paint the SAME hue at the
+  // SAME accent count, at 0.524 and 0.013 of the page respectively.
+  // \u26A0\uFE0F No backticks in here \u2014 this whole block is a template literal, and one
+  // in a comment ends the string. It surfaces as a syntax error hundreds of
+  // lines away, which is how it cost a debug cycle the first time.
+  const viewportArea = window.innerWidth * window.innerHeight;
+  const accents = Object.keys(accentArea)
+    .map((color) => ({
+      color,
+      area: round(accentArea[color]),
+      share: viewportArea ? Math.round((1000 * accentArea[color]) / viewportArea) / 1000 : null
+    }))
+    .sort((a, b) => b.area - a.area);
+
+  // DSG-006 \xA71/\xA78 \u2014 vertical rhythm. Measured between the full-width bands of
+  // the page's main stack, not between every pair of siblings: a designed page
+  // repeats two or three spacings, and counting every gap in the DOM would
+  // drown that signal in card padding. The widest-stack parent is chosen by
+  // how many bands it holds, which is what "the page's sections" means when
+  // nothing in the graph labels them as such.
+  // \u26A0\uFE0F Measured as gaps *and* band padding, because in this renderer the two
+  // are interchangeable and the first version of this saw nothing: a stack of
+  // bands that abut at gap 0 and carry their spacing as internal padding is the
+  // normal shape here, so gaps alone reported "1 distinct gap: 0" for a page
+  // with perfectly good rhythm. What the doctrine is about is the number of
+  // distinct vertical spacings on the page, however they are expressed.
+  const bandParents = new Map();
+  for (const el of visible) {
+    const r = el.getBoundingClientRect();
+    if (r.width < vw * 0.6 || r.height < 8) continue;
+    const p = el.parentElement;
+    if (!p) continue;
+    if (!bandParents.has(p)) bandParents.set(p, []);
+    bandParents.get(p).push({ el, r });
+  }
+  let bands = [];
+  for (const set of bandParents.values()) if (set.length > bands.length) bands = set;
+  bands = bands.slice().sort((a, b) => a.r.top - b.r.top);
+
+  const spacingCounts = {};
+  const addSpacing = (v) => {
+    const n = round(v);
+    // Zero is "these abut", not a spacing; a huge value is a page break.
+    if (n <= 0 || n > 400) return;
+    spacingCounts[n] = (spacingCounts[n] || 0) + 1;
+  };
+  for (let i = 1; i < bands.length; i++) addSpacing(bands[i].r.top - bands[i - 1].r.bottom);
+  for (const b of bands) {
+    const cs = styleOf(b.el);
+    addSpacing(parseFloat(cs.paddingTop));
+    addSpacing(parseFloat(cs.paddingBottom));
+  }
+  const spacingValues = Object.keys(spacingCounts)
+    .map(Number)
+    .sort((a, b) => a - b);
+
+  // Repeated sibling sets \u2014 a card grid, seen from the DOM. Two kinds:
+  //   'columns' \u2014 a Columns node's own item wrappers (.column-item), so the
+  //               author asked for a grid explicitly and we know it.
+  //   'siblings' \u2014 identical-looking children of one parent, which is what a
+  //               hand-laid or repeated card row looks like.
+  // Grouping by parent, and by an identity signature within the parent, is what
+  // separates a grid from an ordinary stack of page sections.
+  const byParent = new Map();
+  for (const el of visible) {
+    const p = el.parentElement;
+    if (!p) continue;
+    if (!byParent.has(p)) byParent.set(p, []);
+    byParent.get(p).push(el);
+  }
+  const groups = [];
+  const record = (parent, kids, kind) => {
+    if (kids.length < 3) return;
+    const rects = kids.map((k) => k.getBoundingClientRect());
+    if (rects[0].width < 100) return;
+    groups.push({
+      kind,
+      count: kids.length,
+      columns: new Set(rects.map((r) => round(r.left))).size,
+      rows: new Set(rects.map((r) => round(r.top))).size,
+      itemWidth: round(rects[0].width),
+      itemHeight: round(rects[0].height),
+      parentWidth: round(parent.getBoundingClientRect().width),
+      tag: kids[0].tagName,
+      cls: cls(kids[0])
+    });
+  };
+  for (const [parent, kids] of byParent) {
+    const items = kids.filter((k) => k.classList && k.classList.contains('column-item'));
+    if (items.length >= 3) {
+      record(parent, items, 'columns');
+      continue;
+    }
+    const bySignature = new Map();
+    for (const k of kids) {
+      const sig = k.tagName + '|' + cls(k) + '|' + k.querySelectorAll('*').length;
+      if (!bySignature.has(sig)) bySignature.set(sig, []);
+      bySignature.get(sig).push(k);
+    }
+    for (const set of bySignature.values()) record(parent, set, 'siblings');
+  }
+
+  // LAS-012 \xA73. Content the graph declares for a list, looked for on the page.
+  //
+  // Built from the visible leaf text elements, NOT \`document.body.textContent\`
+  // \u2014 measured, not assumed: render-from-disk injects the whole project as
+  // \`window.projectData\` in a <script> inside <body>, so body text contains
+  // every items array verbatim and the first version of this check found all
+  // six of haiku's missing strings on a page showing none of them.
+  //
+  // \`textContent\` is unaffected by text-transform, so an uppercased heading
+  // still matches its source string.
+  const pageText = textEls.map((el) => el.textContent).join('\\n');
+  const lists = PROBES.map((p) => {
+    const found = p.strings.filter((s) => pageText.indexOf(s) !== -1);
+    return { ...p, found: found.length, missing: p.strings.filter((s) => found.indexOf(s) === -1).slice(0, 3) };
+  });
+
+  // How far down the page anything was actually laid out. A page pinned to the
+  // viewport height with content laid out past it is clipped; a page that is
+  // simply short has nothing past it. That difference is the whole of
+  // \`clipped-page\`, and neither number alone can tell them apart.
+  const contentBottom = visible.reduce((lowest, el) => {
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0 && r.bottom > lowest ? r.bottom : lowest;
+  }, 0);
+
+  return {
+    lists,
+    // FLD-012 AC3 \u2014 the SIZE of the population every rule below is computed over, and the number of
+    // elements the visibility correction took out of it. Reported directly because a rule's finding
+    // count can move for several reasons at once, and 'the fix changed what is measured' is a
+    // different claim from 'the fix changed what is reported'.
+    visibleCount: visible.length,
+    transparentExcluded,
+    layoutWidth: window.innerWidth,
+    clientWidth: vw,
+    clientHeight: vh,
+    scrollWidth: document.documentElement.scrollWidth,
+    pageHeight: document.documentElement.scrollHeight,
+    contentBottom: round(contentBottom),
+    overflowing: overflowing.slice(0, 10),
+    overflowingCount: overflowing.length,
+    textsWiderThanBox: textsWiderThanBox.slice(0, 10),
+    textsWiderThanBoxCount: textsWiderThanBox.length,
+    text: {
+      elements: textEls.length,
+      onScreen: textEls.filter(onScreen).length,
+      unreachable: textEls.filter(unreachable).length,
+      fontWeights,
+      fontSizes,
+      distinctFontSizes: Object.keys(fontSizes).length,
+      // VIB-007 M3 \u2014 the display-type reading. Derived here rather than in
+      // summarise so a client that only keeps the summary still has it.
+      largestFontSize: Object.keys(fontSizes).reduce((max, px) => Math.max(max, parseFloat(px) || 0), 0),
+      bodyFontFamily: getComputedStyle(document.body).fontFamily.slice(0, 80)
+    },
+    placeholders: {
+      count: dead.length,
+      byText,
+      samples: dead.slice(0, 8).map((el) => ({ text: el.textContent.trim(), tag: el.tagName, cls: cls(el) }))
+    },
+    images: {
+      total: images.length,
+      // VIB-007 M3. Deliberately inside the images block rather than beside it: every
+      // consumer that asks "does this page have any pictures" has to ask both
+      // halves, and two sibling fields is how one of them gets forgotten.
+      icons: iconEls.size,
+      onScreen: images.filter(onScreen).length,
+      unreachable: images.filter(unreachable).length,
+      broken: brokenImages.length,
+      brokenSources: brokenImages.slice(0, 8).map((el) => String(el.currentSrc || el.src).slice(0, 160))
+    },
+    emptyDecoratedBoxes: {
+      count: emptyBoxes.length,
+      samples: emptyBoxes.slice(0, 6).map((el) => {
+        const r = el.getBoundingClientRect();
+        return { tag: el.tagName, cls: cls(el), width: round(r.width), height: round(r.height) };
+      })
+    },
+    colors: {
+      distinctAccents: accents.length,
+      accents: accents.slice(0, 6),
+      distinctNeutrals: Object.keys(neutralArea).length,
+      // The denominator behind every "share", emitted so a score can be
+      // recomputed from the report without knowing which viewport produced it.
+      viewportArea: round(viewportArea)
+    },
+    grounds: {
+      distinct: Object.keys(groundCounts).length,
+      values: Object.keys(groundCounts)
+        .map((ground) => ({ ground, count: groundCounts[ground] }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 8)
+    },
+    rhythm: {
+      bands: bands.length,
+      distinctSpacings: spacingValues.length,
+      spacings: spacingValues.slice(0, 12).map((px) => ({ px, count: spacingCounts[px] }))
+    },
+    repeatedGroups: groups.sort((a, b) => b.itemWidth * b.count - a.itemWidth * a.count).slice(0, 12)
+  };
+})()`;
+    }
+    var RenderFinding = {
+      BlankRender: "blank-render",
+      /**
+       * LAS-012 §3 — a list whose rows the graph spells out, and the page does not
+       * contain a single one of them. The one shape this report was structurally
+       * unable to see: every other finding is about content present and wrong, and
+       * a repeater that instantiates nothing emits no elements to judge.
+       */
+      EmptyList: "empty-list",
+      DeadPlaceholderText: "dead-placeholder-text",
+      BrokenImage: "broken-image",
+      /**
+       * AWP-004 §2 — content on the page that no scroll can reach.
+       *
+       * The direct check for F45, and the one that generalises the other two: Kimi
+       * K3's storefront put 83 texts and 10 images in the DOM and stranded 70 and 9
+       * of them below a page that does not scroll, and the report called it
+       * *"Rendered clean: 83 texts, 10 images"*.
+       */
+      ContentNotVisible: "content-not-visible",
+      /** The mechanism behind it: a page pinned to the viewport with content past the fold. */
+      ClippedPage: "clipped-page",
+      /** Elements wider than the viewport inside a page that does not itself scroll sideways. */
+      ElementsOverflowing: "elements-overflowing",
+      /**
+       * P88 GAM-020 (D58) — a Text wider than its parent's content box, so it is cut off or spills. The
+       * text is named. Rocket School's French sentences did this with zero console errors, and every
+       * page-level finding stayed quiet because the page itself kept its width.
+       */
+      TextWiderThanItsBox: "text-wider-than-its-box",
+      SingleColumnGrid: "single-column-grid",
+      MinimumLayoutWidth: "minimum-layout-width",
+      HorizontalOverflow: "horizontal-overflow",
+      FlatTypeScale: "flat-type-scale",
+      EmptyDecoratedBox: "empty-decorated-box",
+      ConsoleError: "console-error",
+      /**
+       * VIB-007 M3 — the three poverty findings.
+       *
+       * 🔴 **Every other finding in this list detects EXCESS or BREAKAGE**, which is
+       * register V10: a page can pass all thirteen of them, render perfectly clean,
+       * and be worth nothing to look at. That is what the entire VIB-001 baseline
+       * is — nine pages ruled SHITTY, and the report called every one of them
+       * clean.
+       *
+       * These three are not invented. Each is one of the WordPress-starter tells
+       * README section 2 lists verbatim, restricted to the ones a render can see:
+       *
+       *   "one background colour end to end"          -> SingleGround
+       *   "no imagery and no iconography anywhere"    -> NoImagery
+       *   "headline under ~48px on desktop"           -> NoDisplayType
+       *
+       * ⚠️ **They are warnings, not errors, and that is a decision rather than an
+       * oversight.** `error` is the severity `noodl-mcp`'s render verdict blocks
+       * "done" on (VIB-007 M1), and README section 2 exempts app-chrome pages (forms,
+       * lists, settings) from the marketing tells — a settings page needs no 72px
+       * headline and refusing to certify one would be the instrument being wrong,
+       * loudly, on every honest project. The instrument cannot currently tell a
+       * landing page from a settings page; until something can, poverty is reported
+       * and does not refuse.
+       */
+      SingleGround: "single-ground",
+      NoImagery: "no-imagery",
+      NoDisplayType: "no-display-type"
+    };
+    var SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
+    var POVERTY_FINDINGS = [RenderFinding.SingleGround, RenderFinding.NoImagery, RenderFinding.NoDisplayType];
+    function isPovertyFinding(finding) {
+      return Boolean(finding) && POVERTY_FINDINGS.indexOf(finding.code) !== -1;
+    }
+    var DISPLAY_TYPE_MIN_PX = 48;
+    var MIN_DISTINCT_GROUNDS = 2;
+    var POVERTY_MIN_TEXTS = 3;
+    var CLIPPED_CONTENT_SLACK = 8;
+    function plural(n, one, many) {
+      return n === 1 ? `1 ${one}` : `${n} ${many}`;
+    }
+    function widestOffender(v) {
+      const widest = (v.overflowing || []).slice().sort((a, b) => b.width - a.width)[0];
+      if (!widest) return null;
+      const named = widest.cls ? `${widest.tag.toLowerCase()}.${widest.cls.split(/\s+/)[0]}` : widest.tag.toLowerCase();
+      return `${named} at ${widest.width}px`;
+    }
+    function summarise(viewports, diagnosis, overridden = {}) {
+      const findings = [];
+      const add = (f) => findings.push(f);
+      for (const [name, v] of Object.entries(viewports)) {
+        if (!v || v.error) continue;
+        const isDesktop = v.requested.width >= DESKTOP_WIDTH;
+        if (v.text.elements === 0 && v.images.total === 0) {
+          add({
+            code: RenderFinding.BlankRender,
+            severity: "error",
+            viewport: name,
+            message: "The page rendered nothing at all \u2014 no text and no images. " + (diagnosis ? diagnosis.message : "No project was available to diagnose it against, so the cause was not determined."),
+            ...diagnosis && diagnosis.cause ? { cause: diagnosis.cause } : {},
+            ...diagnosis && diagnosis.evidence ? { evidence: diagnosis.evidence } : {}
+          });
+          continue;
+        }
+        for (const list of v.lists || []) {
+          if (list.found > 0) continue;
+          add({
+            code: RenderFinding.EmptyList,
+            severity: "error",
+            viewport: name,
+            relatedDiagnostic: "repeater-without-template",
+            message: `The Repeater "${list.label}" in ${list.component} has ${plural(list.rows, "row", "rows")} of ${list.source}, and none of that content is on the page \u2014 so it built nothing. A For Each instantiates the component named on its "template" port once per item and inserts each copy as its own next sibling; with no template, or with the item markup nested underneath it instead, it renders nothing at all. Looked for: ${list.missing.map((s) => `"${s}"`).join(", ")}.`,
+            evidence: { component: list.component, nodeId: list.nodeId, rows: list.rows, missing: list.missing }
+          });
+        }
+        if (v.placeholders.count > 0) {
+          const entries = Object.entries(v.placeholders.byText);
+          const listing = (pairs) => pairs.map(([text, n]) => `${n}\xD7 "${text}"`).join(", ");
+          const total = (pairs) => pairs.reduce((sum, [, n]) => sum + n, 0);
+          const fromInput = entries.filter(([text]) => overridden[text]);
+          const fromCatalog = entries.filter(([text]) => !overridden[text]);
+          if (fromInput.length) {
+            const where = fromInput.map(([text]) => `"${text}" is ${describeSites(overridden[text])}`).join("; ");
+            add({
+              code: RenderFinding.DeadPlaceholderText,
+              severity: "error",
+              viewport: name,
+              relatedDiagnostic: "interfaceless-instance",
+              message: `${plural(total(fromInput), "element shows", "elements show")} the fallback hardcoded on a port that a Component Inputs node also feeds: ${listing(fromInput)}. That value is only ever visible when the input does not arrive, so it did not arrive \u2014 ${where}.`,
+              evidence: v.placeholders.samples.filter((s) => overridden[s.text])
+            });
+          }
+          if (fromCatalog.length) {
+            add({
+              code: RenderFinding.DeadPlaceholderText,
+              severity: "error",
+              viewport: name,
+              relatedDiagnostic: "interfaceless-instance",
+              message: `${plural(total(fromCatalog), "element renders", "elements render")} a node-type default instead of content: ${listing(fromCatalog)}. Nothing set those ports. The usual cause is a component instantiated with parameters its Component Inputs node does not declare, so every value is discarded \u2014 the graph-side name for it is interfaceless-instance.`,
+              evidence: v.placeholders.samples.filter((s) => !overridden[s.text])
+            });
+          }
+        }
+        if (v.images.broken > 0) {
+          add({
+            code: RenderFinding.BrokenImage,
+            severity: "error",
+            viewport: name,
+            message: `${plural(v.images.broken, "image", "images")} of ${v.images.total} failed to load \u2014 the element is in the DOM with naturalWidth 0. A URL that returns 200 can still be the wrong picture; this is only the half a number can see, so look at the screenshot for the rest.`,
+            evidence: v.images.brokenSources
+          });
+        }
+        const measuredVisibility = typeof v.contentBottom === "number" && typeof v.text.unreachable === "number";
+        if (measuredVisibility) {
+          const strandedText = v.text.unreachable;
+          const strandedImages = v.images.unreachable || 0;
+          if (strandedText > 0 || strandedImages > 0) {
+            const parts = [];
+            if (strandedText > 0) parts.push(`${strandedText} of ${v.text.elements} text elements`);
+            if (strandedImages > 0) parts.push(`${strandedImages} of ${v.images.total} images`);
+            add({
+              code: RenderFinding.ContentNotVisible,
+              severity: "error",
+              viewport: name,
+              message: `${parts.join(" and ")} are laid out below ${v.pageHeight}px, which is as far as this page scrolls \u2014 no scroll reaches them, so they are on the page and cannot be seen. Content extends to ${v.contentBottom}px. ${v.text.onScreen} of ${v.text.elements} texts are on screen.`,
+              evidence: {
+                pageHeight: v.pageHeight,
+                contentBottom: v.contentBottom,
+                textElements: v.text.elements,
+                textOnScreen: v.text.onScreen,
+                textUnreachable: strandedText,
+                imagesUnreachable: strandedImages
+              }
+            });
+          }
+          const pinned = Math.abs(v.pageHeight - v.requested.height) <= 1;
+          if (pinned && v.contentBottom > v.pageHeight + CLIPPED_CONTENT_SLACK) {
+            add({
+              code: RenderFinding.ClippedPage,
+              severity: "warning",
+              viewport: name,
+              message: `The page is exactly ${v.pageHeight}px tall \u2014 the viewport height \u2014 and its content runs to ${v.contentBottom}px, so it is clipped at the fold rather than scrolling. A root that clips to the viewport with no scrollbar is the default; a page of this length has to opt into scrolling.`,
+              evidence: { pageHeight: v.pageHeight, contentBottom: v.contentBottom, viewport: v.requested.height }
+            });
+          }
+        }
+        if (isDesktop) {
+          for (const g of v.repeatedGroups) {
+            if (g.count < 3 || g.columns !== 1) continue;
+            if (g.itemWidth < g.parentWidth * GRID_ITEM_PARENT_SHARE) continue;
+            if (g.kind !== "columns") {
+              if (g.itemHeight < GRID_ITEM_MIN_HEIGHT || g.itemWidth < GRID_ITEM_MIN_WIDTH) continue;
+              if (g.parentWidth < v.requested.width * GRID_PARENT_VIEWPORT_SHARE) continue;
+            }
+            add({
+              code: RenderFinding.SingleColumnGrid,
+              severity: g.kind === "columns" ? "warning" : "info",
+              viewport: name,
+              message: `${g.count} repeated items are stacked in one column at ${v.requested.width}px, each ${g.itemWidth}\xD7${g.itemHeight}px inside a ${g.parentWidth}px parent` + (g.kind === "columns" ? '. They are a Columns node\u2019s items, so the layoutString asked for one column \u2014 "1 1 1" is three equal columns, and the count of numbers is the count of columns.' : ". If they are meant to be a grid, a Columns node is the only node that lays items out in one and collapses it on small screens; if they are meant to be full-width bands, this is right."),
+              evidence: g
+            });
+          }
+        }
+        if (v.layoutWidth > v.requested.width + 1) {
+          add({
+            code: RenderFinding.MinimumLayoutWidth,
+            severity: "warning",
+            viewport: name,
+            message: `The page cannot lay out below ${v.layoutWidth}px: asked for ${v.requested.width}px, the browser widened the layout viewport to ${v.layoutWidth}px and scaled the whole page down.` + (widestOffender(v) ? ` The widest element inside it is ${widestOffender(v)}.` : " Nothing wider than the viewport was captured, so the element holding the floor was not identified."),
+            evidence: v.overflowing
+          });
+        } else if (v.scrollWidth > v.clientWidth + 1) {
+          add({
+            code: RenderFinding.HorizontalOverflow,
+            severity: "warning",
+            viewport: name,
+            message: `The page scrolls sideways at ${v.requested.width}px \u2014 content is ${v.scrollWidth}px wide in a ${v.clientWidth}px viewport, with ${plural(v.overflowingCount, "element", "elements")} wider than it.`,
+            evidence: v.overflowing
+          });
+        } else if (v.overflowingCount > 0) {
+          add({
+            code: RenderFinding.ElementsOverflowing,
+            severity: "warning",
+            viewport: name,
+            message: `${plural(v.overflowingCount, "element is", "elements are")} wider than the ${v.clientWidth}px viewport, while the page itself does not scroll sideways \u2014 so each is clipped by an ancestor rather than reachable${widestOffender(v) ? `; the widest is ${widestOffender(v)}` : ""}.`,
+            evidence: v.overflowing
+          });
+        }
+        if (v.textsWiderThanBoxCount > 0) {
+          const first = v.textsWiderThanBox[0];
+          add({
+            code: RenderFinding.TextWiderThanItsBox,
+            severity: "warning",
+            viewport: name,
+            message: `${plural(v.textsWiderThanBoxCount, "text is", "texts are")} wider than the box ${v.textsWiderThanBoxCount === 1 ? "it sits" : "they sit"} in at ${v.requested.width}px, so the line is cut off or spills: "${first.text}" is ${first.width}px in a ${first.parentWidth}px box. A Text sized to its content (sizeMode "contentSize" or "contentWidth") never wraps; "contentHeight" takes its width from the parent and wraps.`,
+            evidence: v.textsWiderThanBox
+          });
+        }
+        if (v.text.elements >= 10) {
+          const weights = Object.keys(v.text.fontWeights);
+          if (weights.length <= 1 || v.text.distinctFontSizes <= 2) {
+            add({
+              code: RenderFinding.FlatTypeScale,
+              severity: "warning",
+              viewport: name,
+              message: `${v.text.elements} text elements render at ${plural(weights.length, "font weight", "font weights")} (${weights.join(", ")}) and ${plural(v.text.distinctFontSizes, "font size", "font sizes")}. Nothing is emphasised over anything else, which is what an unstyled page measures like.`
+            });
+          }
+        }
+        if (v.emptyDecoratedBoxes.count > 0) {
+          add({
+            code: RenderFinding.EmptyDecoratedBox,
+            severity: "warning",
+            viewport: name,
+            message: `${plural(v.emptyDecoratedBoxes.count, "box has", "boxes have")} a background or border and no content \u2014 a card whose contents never arrived, or a decorated Group used as a spacer.`,
+            evidence: v.emptyDecoratedBoxes.samples
+          });
+        }
+        const poorEnoughToJudge = v.text.elements >= POVERTY_MIN_TEXTS;
+        if (poorEnoughToJudge && v.images && typeof v.images.icons === "number" && v.images.total === 0 && v.images.icons === 0) {
+          add({
+            code: RenderFinding.NoImagery,
+            severity: "warning",
+            viewport: name,
+            message: `${v.text.elements} text elements and not one picture or glyph \u2014 no images, no icons. README \xA72's second WordPress-starter tell is "no imagery and no iconography anywhere on the page", and this page measures as exactly that. The Image and Icon nodes are in the kit and the starter modules ship photographs and 1,998 Lucide glyphs.`
+          });
+        }
+        if (poorEnoughToJudge && isDesktop && typeof v.text.largestFontSize === "number" && v.text.largestFontSize > 0 && v.text.largestFontSize < DISPLAY_TYPE_MIN_PX) {
+          add({
+            code: RenderFinding.NoDisplayType,
+            severity: "warning",
+            viewport: name,
+            message: `The largest text on this page renders at ${Math.round(v.text.largestFontSize)}px across ${plural(v.text.distinctFontSizes, "distinct size", "distinct sizes")}. README \xA72 calls a headline under ~${DISPLAY_TYPE_MIN_PX}px on desktop a WordPress-starter tell; nothing on this page is operating as display type.`,
+            evidence: v.text.fontSizes
+          });
+        }
+        if (poorEnoughToJudge && v.grounds && typeof v.grounds.distinct === "number" && v.grounds.distinct < MIN_DISTINCT_GROUNDS) {
+          add({
+            code: RenderFinding.SingleGround,
+            severity: "warning",
+            viewport: name,
+            message: `Every full-width band on this page is painted the same \u2014 ${plural(v.grounds.distinct, "distinct ground", "distinct grounds")} across the whole page. README \xA72's first WordPress-starter tell is "one background colour end to end". A ground can be a colour, a gradient or an image, and alternating them is what makes a page read as sections rather than as one column.`,
+            evidence: v.grounds.values
+          });
+        }
+        if (v.consoleErrors && v.consoleErrors.length) {
+          add({
+            code: RenderFinding.ConsoleError,
+            severity: "warning",
+            viewport: name,
+            message: `The runtime logged ${plural(v.consoleErrors.length, "error", "errors")} while rendering.`,
+            evidence: v.consoleErrors.slice(0, 5)
+          });
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const unique = findings.filter((f) => {
+        const key = `${f.code}|${f.viewport}|${f.message}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+      unique.sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
+      return { findings: unique, summary: summaryLine(viewports, unique) };
+    }
+    function summaryLine(viewports, findings) {
+      const count = (severity) => findings.filter((f) => f.severity === severity).length;
+      const errors = count("error");
+      const warnings = count("warning");
+      const infos = count("info");
+      const live = Object.entries(viewports).filter(([, v]) => v && !v.error);
+      const shape = live.map(([name, v]) => {
+        const counts = typeof v.text.onScreen === "number" ? `${v.text.elements} texts, ${v.text.onScreen} on screen, ${v.images.total} images` : `${v.text.elements} texts, ${v.images.total} images`;
+        return `${name} ${v.requested.width}\xD7${v.pageHeight}px, ${counts}`;
+      }).join("; ");
+      if (!errors && !warnings) {
+        const measured = live.filter(([, v]) => typeof v.text.onScreen === "number");
+        const observations = infos ? ` (${plural(infos, "observation", "observations")})` : "";
+        if (measured.length !== live.length) {
+          return `No findings${observations}, and visibility was not measured \u2014 not a claim the page is on screen: ${shape}.`;
+        }
+        if (measured.some(([, v]) => v.text.onScreen === 0 && v.images.onScreen === 0)) {
+          return `No findings${observations}, but nothing is on screen at the top of the page: ${shape}.`;
+        }
+        return `Rendered clean${observations}: ${shape}.`;
+      }
+      const worst = [...new Set(findings.filter((f) => f.severity !== "info").map((f) => f.code))].slice(0, 4).join(", ");
+      return `${plural(errors, "error", "errors")}, ${plural(warnings, "warning", "warnings")}${infos ? `, ${plural(infos, "observation", "observations")}` : ""} (${worst}). ${shape}.`;
+    }
+    function describeSites(entry) {
+      const sites = entry.sites || [];
+      const named = sites.slice(0, 2).map((s) => `${s.port} in ${s.component}`);
+      const rest = sites.length - named.length;
+      return named.join(" and ") + (rest > 0 ? ` and ${plural(rest, "other place", "other places")}` : "");
+    }
+    var TEXT_BEARING_PORTS = /^(text|label|placeholder|title|caption|heading)$/i;
+    function placeholderStringsFromCatalog(catalog) {
+      const found = /* @__PURE__ */ new Set();
+      for (const node of catalog && catalog.nodes || []) {
+        if (!node.isVisual) continue;
+        for (const port of node.inputs || []) {
+          if (!TEXT_BEARING_PORTS.test(port.name)) continue;
+          if (typeof port.default === "string" && port.default.trim()) found.add(port.default.trim());
+        }
+      }
+      return [...found];
+    }
+    module2.exports = {
+      // Vocabulary — every client must agree on these.
+      DEFAULT_VIEWPORTS,
+      NAMED_VIEWPORTS,
+      DESKTOP_WIDTH,
+      RenderFinding,
+      SEVERITY_ORDER,
+      CLIPPED_CONTENT_SLACK,
+      // VIB-007 M3 — exported because a spec that restates 48 is a second copy of
+      // README §2's number, and the one that drifts is always the copy.
+      DISPLAY_TYPE_MIN_PX,
+      MIN_DISTINCT_GROUNDS,
+      POVERTY_MIN_TEXTS,
+      POVERTY_FINDINGS,
+      isPovertyFinding,
+      // The two halves of the loop: what to evaluate in the page, and what the
+      // numbers that come back mean.
+      measureExpression,
+      summarise,
+      summaryLine,
+      // Helpers the callers share.
+      plural,
+      widestOffender,
+      describeSites,
+      TEXT_BEARING_PORTS,
+      placeholderStringsFromCatalog
+    };
+  }
+});
+
+// ../../scripts/devtools/render-report.js
+var require_render_report = __commonJS({
+  "../../scripts/devtools/render-report.js"(exports2, module2) {
+    var { spawn } = require("child_process");
+    var fs2 = require("fs");
+    var http = require("http");
+    var net = require("net");
+    var os = require("os");
+    var path2 = require("path");
+    var HARNESS_PATHS = require_harness_paths();
+    var RENDER_SCRIPT = path2.join(__dirname, "render-from-disk.js");
+    var VIEWER_DIR = HARNESS_PATHS.VIEWER_DIR.path;
+    var VIEWER_BUNDLE = VIEWER_DIR && path2.join(VIEWER_DIR, "noodl.viewer.js");
+    var CATALOG_JSON = HARNESS_PATHS.CATALOG_JSON.path;
+    var WS_MODULE = HARNESS_PATHS.WS_MODULE.path;
+    var {
+      DEFAULT_VIEWPORTS,
+      DESKTOP_WIDTH,
+      RenderFinding,
+      SEVERITY_ORDER,
+      CLIPPED_CONTENT_SLACK,
+      DISPLAY_TYPE_MIN_PX,
+      MIN_DISTINCT_GROUNDS,
+      POVERTY_MIN_TEXTS,
+      POVERTY_FINDINGS,
+      isPovertyFinding,
+      measureExpression,
+      summarise,
+      summaryLine,
+      plural,
+      widestOffender,
+      describeSites,
+      TEXT_BEARING_PORTS,
+      placeholderStringsFromCatalog
+    } = require_src();
+    function placeholderStrings(catalogPath = CATALOG_JSON) {
+      return placeholderStringsFromCatalog(JSON.parse(fs2.readFileSync(catalogPath, "utf8")));
+    }
+    var PROBE_MIN_WORDS = 2;
+    var PROBE_MIN_LENGTH = 8;
+    var PROBE_MIN_LENGTH_SINGLE_WORD = 12;
+    var PROBE_MAX_STRINGS = 6;
+    function isDistinctive(s) {
+      if (/^[^A-Za-z]*$/.test(s)) return false;
+      const words = s.split(/\s+/).filter(Boolean).length;
+      if (words >= PROBE_MIN_WORDS) return s.length >= PROBE_MIN_LENGTH;
+      return s.length >= PROBE_MIN_LENGTH_SINGLE_WORD;
+    }
+    function readableStrings(items) {
+      const out = [];
+      for (const item of items) {
+        if (!item || typeof item !== "object") {
+          if (typeof item === "string" && isDistinctive(item.trim())) out.push(item.trim());
+          continue;
+        }
+        for (const value of Object.values(item)) {
+          if (typeof value !== "string") continue;
+          const s = value.trim();
+          if (/^(https?:|data:|\/|#|var\()/.test(s)) continue;
+          if (!isDistinctive(s)) continue;
+          out.push(s);
+        }
+      }
+      return [...new Set(out)];
+    }
+    function staticDataItems(node) {
+      const p = node.parameters || {};
+      if (Array.isArray(p.items)) return p.items;
+      if (typeof p.json !== "string" || !p.json.trim()) return null;
+      try {
+        const parsed = JSON.parse(p.json);
+        return Array.isArray(parsed) && parsed.length ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+    function readComponents(projectDir2) {
+      let project;
+      try {
+        project = JSON.parse(fs2.readFileSync(path2.join(projectDir2, "nodegx.project.json"), "utf8"));
+      } catch {
+        return { ok: false, components: [] };
+      }
+      const componentsDir = path2.join(projectDir2, project.structure && project.structure.componentsDir || "components");
+      let registry;
+      try {
+        registry = JSON.parse(fs2.readFileSync(path2.join(componentsDir, "_registry.json"), "utf8"));
+      } catch {
+        return { ok: false, project, components: [] };
+      }
+      const components = [];
+      for (const key of Object.keys(registry.components || {})) {
+        const dir = path2.join(componentsDir, registry.components[key].path);
+        try {
+          const nodesFile = JSON.parse(fs2.readFileSync(path2.join(dir, "nodes.json"), "utf8"));
+          const meta = JSON.parse(fs2.readFileSync(path2.join(dir, "component.json"), "utf8"));
+          const connPath = path2.join(dir, "connections.json");
+          components.push({
+            name: meta.path || "/" + key,
+            nodes: nodesFile.nodes || [],
+            connections: fs2.existsSync(connPath) ? JSON.parse(fs2.readFileSync(connPath, "utf8")).connections || [] : [],
+            // Absent and empty are different things and AWP-001 §3 turns on the
+            // difference: `undefined` means nobody computed this, `[]` means a writer
+            // did and found nothing. Carried through verbatim, decided in one place.
+            declaredRoots: nodesFile.visualRoots
+          });
+        } catch {
+          continue;
+        }
+      }
+      return { ok: true, project, components };
+    }
+    function listProbes(projectDir2) {
+      const probes = [];
+      for (const component of readComponents(projectDir2).components) {
+        const { name, nodes, connections } = component;
+        const byId = new Map(nodes.map((n) => [n.id, n]));
+        for (const node of nodes) {
+          if (node.type !== "For Each") continue;
+          const parameters = node.parameters || {};
+          let items = Array.isArray(parameters.items) && parameters.items.length ? parameters.items : null;
+          let source = "inline items";
+          if (!items) {
+            const feed = connections.find((c) => (c.toId ?? c.targetId) === node.id && (c.toProperty ?? c.targetPort) === "items");
+            const from = feed ? byId.get(feed.fromId ?? feed.sourceId) : void 0;
+            if (from && from.type === "Static Data") {
+              items = staticDataItems(from);
+              source = `Static Data "${from.label || from.id}"`;
+            }
+          }
+          if (!items) continue;
+          const strings = readableStrings(items).slice(0, PROBE_MAX_STRINGS);
+          if (!strings.length) continue;
+          probes.push({
+            component: name,
+            nodeId: node.id,
+            label: node.label || node.id,
+            rows: items.length,
+            source,
+            strings
+          });
+        }
+      }
+      return probes;
+    }
+    function overriddenDefaults(projectDir2) {
+      const { components } = readComponents(projectDir2);
+      const suppliedByInstances = /* @__PURE__ */ new Map();
+      for (const component of components) {
+        for (const node of component.nodes) {
+          const params = node.parameters || {};
+          for (const port of Object.keys(params)) {
+            const value = params[port];
+            if (typeof value !== "string" || !value.trim()) continue;
+            const key = node.type + "\0" + port;
+            if (!suppliedByInstances.has(key)) suppliedByInstances.set(key, /* @__PURE__ */ new Set());
+            suppliedByInstances.get(key).add(value.trim());
+          }
+        }
+      }
+      const found = /* @__PURE__ */ new Map();
+      for (const component of components) {
+        const byId = new Map(component.nodes.map((n) => [n.id, n]));
+        for (const conn of component.connections) {
+          const from = byId.get(conn.sourceId ?? conn.fromId);
+          const to = byId.get(conn.targetId ?? conn.toId);
+          const port = conn.targetPort ?? conn.toProperty;
+          const inputPort = conn.sourcePort ?? conn.fromProperty;
+          if (!from || !to || from.type !== "Component Inputs") continue;
+          if (!TEXT_BEARING_PORTS.test(port)) continue;
+          const hardcoded = (to.parameters || {})[port];
+          if (typeof hardcoded !== "string" || !hardcoded.trim()) continue;
+          const key = hardcoded.trim();
+          const supplied = inputPort && suppliedByInstances.get(component.name + "\0" + inputPort);
+          if (supplied && supplied.has(key)) continue;
+          if (!found.has(key)) found.set(key, { sites: [] });
+          found.get(key).sites.push({ component: component.name, nodeId: to.id, port });
+        }
+      }
+      return found;
+    }
+    var ENRICHED_CATALOG_JSON = HARNESS_PATHS.ENRICHED_CATALOG_JSON.path;
+    var visualTypesCache = /* @__PURE__ */ new Map();
+    function visualTypeNames(catalogPath = ENRICHED_CATALOG_JSON) {
+      if (visualTypesCache.has(catalogPath)) return visualTypesCache.get(catalogPath);
+      let names;
+      try {
+        const catalog = JSON.parse(fs2.readFileSync(catalogPath, "utf8"));
+        names = new Set((catalog.nodes || []).filter((n) => n.isVisual === true).map((n) => n.typeName));
+        if (names.size === 0) names = null;
+      } catch {
+        names = null;
+      }
+      visualTypesCache.set(catalogPath, names);
+      return names;
+    }
+    var CONTENT_BEARING_PORTS = /^(text|label|placeholder|title|caption|heading|src|source|icon)$/i;
+    var CONTAINER_DESPITE_A_CONTENT_PORT = /* @__PURE__ */ new Set(["Page"]);
+    var contentTypesCache = /* @__PURE__ */ new Map();
+    function contentBearingTypeNames(catalogPath = ENRICHED_CATALOG_JSON) {
+      if (contentTypesCache.has(catalogPath)) return contentTypesCache.get(catalogPath);
+      let names;
+      try {
+        const catalog = JSON.parse(fs2.readFileSync(catalogPath, "utf8"));
+        names = new Set(
+          (catalog.nodes || []).filter(
+            (n) => n.isVisual === true && !CONTAINER_DESPITE_A_CONTENT_PORT.has(n.typeName) && (n.inputs || []).some((p) => CONTENT_BEARING_PORTS.test(p.name))
+          ).map((n) => n.typeName)
+        );
+        if (names.size === 0) names = null;
+      } catch {
+        names = null;
+      }
+      contentTypesCache.set(catalogPath, names);
+      return names;
+    }
+    function rootNodes(nodes) {
+      return (nodes || []).filter((n) => n.parent === void 0);
+    }
+    function subtreeNodes(nodes, ids) {
+      const byId = new Map((nodes || []).map((n) => [n.id, n]));
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      const stack = [...ids];
+      while (stack.length) {
+        const id = stack.pop();
+        if (seen.has(id)) continue;
+        seen.add(id);
+        const node = byId.get(id);
+        if (!node) continue;
+        out.push(node);
+        for (const child of node.children || []) stack.push(child);
+      }
+      return out;
+    }
+    function projectVisualPredicate(components) {
+      const catalogVisual = visualTypeNames();
+      const byName = new Map(components.map((c) => [c.name, c]));
+      const memo = /* @__PURE__ */ new Map();
+      const inFlight = /* @__PURE__ */ new Set();
+      const isVisual = (typeName) => {
+        if (catalogVisual && catalogVisual.has(typeName)) return true;
+        if (!byName.has(typeName)) return false;
+        if (memo.has(typeName)) return memo.get(typeName);
+        if (inFlight.has(typeName)) return false;
+        inFlight.add(typeName);
+        const draws = effectiveRoots(byName.get(typeName), isVisual).length > 0;
+        inFlight.delete(typeName);
+        memo.set(typeName, draws);
+        return draws;
+      };
+      return isVisual;
+    }
+    function effectiveRoots(component, isVisual) {
+      if (component.declaredRoots !== void 0) return component.declaredRoots;
+      return rootNodes(component.nodes).filter((n) => isVisual(n.type)).map((n) => n.id);
+    }
+    var BlankCause = {
+      Unreadable: "project-unreadable",
+      NoCatalog: "no-catalog",
+      NoStartPage: "no-start-page",
+      StartPageMissing: "start-page-missing",
+      PageNotRouted: "page-not-routed",
+      PageWithoutPageNode: "page-without-page-node",
+      PageWithoutVisualRoot: "page-without-visual-root",
+      PageHasNoContent: "page-has-no-content",
+      InstancesWithoutVisualRoot: "instances-without-visual-root",
+      Undetermined: "undetermined"
+    };
+    function blankDiagnosis(projectDir2) {
+      const { ok, project, components } = readComponents(projectDir2);
+      if (!ok || !components.length) {
+        return {
+          ok: false,
+          cause: BlankCause.Unreadable,
+          message: "The project could not be read from disk, so there is nothing to diagnose against.",
+          checked: []
+        };
+      }
+      if (!visualTypeNames() || !contentBearingTypeNames()) {
+        return {
+          ok: false,
+          cause: BlankCause.NoCatalog,
+          message: "No generated node catalog in this checkout, so which node types draw is not knowable here and the cause was not determined.",
+          checked: []
+        };
+      }
+      const isVisual = projectVisualPredicate(components);
+      const contentTypes = contentBearingTypeNames();
+      const byName = new Map(components.map((c) => [c.name, c]));
+      const checked = [];
+      const done = (cause, message, evidence) => ({ ok: true, cause, message, evidence, checked });
+      const routers = [];
+      const pageComponents = /* @__PURE__ */ new Set();
+      for (const c of components) {
+        for (const n of c.nodes) {
+          if (n.type === "Router") routers.push({ component: c.name, ...n.parameters || {} });
+          if (n.type === "Page") pageComponents.add(c.name);
+        }
+      }
+      const routed = /* @__PURE__ */ new Set();
+      let startPage;
+      for (const r of routers) {
+        const pages = r.pages || {};
+        for (const route of pages.routes || []) routed.add(route);
+        if (!startPage && pages.startPage) startPage = pages.startPage;
+      }
+      if (!routers.length || !startPage) {
+        return done(
+          BlankCause.NoStartPage,
+          routers.length ? `${plural(routers.length, "Router", "Routers")} in this project, and none names a startPage \u2014 nothing selects a page to show.` : "No Router anywhere in the project, so no page is ever selected to be shown.",
+          { routers: routers.map((r) => r.component) }
+        );
+      }
+      checked.push(`a Router names "${startPage}" as its startPage`);
+      const page = byName.get(startPage);
+      if (!page) {
+        return done(
+          BlankCause.StartPageMissing,
+          `The Router's startPage is "${startPage}" and no component of that name exists in the project.`,
+          { component: startPage, known: [...byName.keys()] }
+        );
+      }
+      if (!routed.has(startPage)) {
+        return done(
+          BlankCause.PageNotRouted,
+          `"${startPage}" is the startPage but no Router lists it in its routes, so the route is never reached.`,
+          { component: startPage, routes: [...routed] }
+        );
+      }
+      checked.push("a Router lists it in its routes");
+      if (!pageComponents.has(startPage)) {
+        return done(
+          BlankCause.PageWithoutPageNode,
+          `"${startPage}" contains no Page node. A page component renders blank without one at its root.`,
+          { component: startPage }
+        );
+      }
+      checked.push("it has a Page node");
+      const pageRoots = effectiveRoots(page, isVisual);
+      if (!pageRoots.length) {
+        return done(
+          BlankCause.PageWithoutVisualRoot,
+          `"${startPage}" has no visual root \u2014 nothing in it is a node that draws, so the component renders nothing.`,
+          { component: startPage }
+        );
+      }
+      checked.push(`its visual root set is ${JSON.stringify(pageRoots)}`);
+      const drawn = subtreeNodes(page.nodes, pageRoots);
+      const carriesContent = (node) => contentTypes.has(node.type) || byName.has(node.type) && componentDrawsContent(node.type);
+      const seenComponents = /* @__PURE__ */ new Set();
+      function componentDrawsContent(name) {
+        if (seenComponents.has(name)) return false;
+        seenComponents.add(name);
+        const c = byName.get(name);
+        if (!c) return false;
+        const nodes = subtreeNodes(c.nodes, effectiveRoots(c, isVisual));
+        const answer = nodes.some((n) => contentTypes.has(n.type) || byName.has(n.type) && componentDrawsContent(n.type));
+        seenComponents.delete(name);
+        return answer;
+      }
+      if (!drawn.some(carriesContent)) {
+        const only = drawn.map((n) => n.type);
+        return done(
+          BlankCause.PageHasNoContent,
+          `Nothing under the visual root of "${startPage}" shows content of its own: it draws ${plural(drawn.length, "node", "nodes")} (${[...new Set(only)].join(", ")}); nothing there is text, an image, or an instance that resolves to either. The page is an empty container.`,
+          { component: startPage, nodes: drawn.length, types: [...new Set(only)] }
+        );
+      }
+      checked.push("it has content-bearing nodes under that root");
+      const instanceTypes = [...new Set(drawn.filter((n) => byName.has(n.type)).map((n) => n.type))];
+      const empty = instanceTypes.filter((t) => effectiveRoots(byName.get(t), isVisual).length === 0);
+      if (empty.length) {
+        return done(
+          BlankCause.InstancesWithoutVisualRoot,
+          `${plural(empty.length, "component has", "components have")} no visual root, so every instance of ${empty.length === 1 ? "it" : "them"} on "${startPage}" renders nothing: ${empty.join(", ")}.`,
+          { component: startPage, components: empty }
+        );
+      }
+      return done(
+        BlankCause.Undetermined,
+        `Checked, and each held: ${checked.join("; ")}. The graph says this page should draw, so the cause is downstream of it \u2014 a runtime error, or content that reached the DOM and is not visible.`,
+        { component: startPage }
+      );
+    }
+    var CHROME_CANDIDATES = {
+      darwin: [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+      ],
+      linux: [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        "/snap/bin/chromium"
+      ],
+      win32: [
+        "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+      ]
+    };
+    function reachableComponents(startName, byName) {
+      const seen = /* @__PURE__ */ new Set();
+      const queue = [startName];
+      while (queue.length) {
+        const name = queue.shift();
+        if (seen.has(name)) continue;
+        seen.add(name);
+        const component = byName.get(name);
+        if (!component) continue;
+        for (const node of component.nodes) {
+          if (byName.has(node.type)) queue.push(node.type);
+          const template = (node.parameters || {}).template;
+          if (typeof template === "string" && byName.has(template)) queue.push(template);
+        }
+      }
+      return seen;
+    }
+    function routedPages(projectDir2) {
+      const { ok, project, components } = readComponents(projectDir2);
+      if (!ok) return { ok: false, pages: [], startPage: void 0, pathType: "hash" };
+      const pathType = project.settings && project.settings.navigationPathType || "hash";
+      const byName = new Map(components.map((c) => [c.name, c]));
+      const routes = [];
+      let startPage;
+      for (const c of components) {
+        for (const n of c.nodes) {
+          if (n.type !== "Router") continue;
+          const pages2 = (n.parameters || {}).pages || {};
+          for (const route of pages2.routes || []) if (!routes.includes(route)) routes.push(route);
+          if (!startPage && pages2.startPage) startPage = pages2.startPage;
+        }
+      }
+      const pages = routes.map((component) => {
+        const c = byName.get(component);
+        const pageNode = c && c.nodes.find((n) => n.type === "Page");
+        const params = pageNode && pageNode.parameters || {};
+        const urlPath = typeof params.urlPath === "string" ? params.urlPath : void 0;
+        const isStart = component === startPage;
+        let unreachable;
+        if (!c) unreachable = "no component of that name exists in the project";
+        else if (!pageNode) unreachable = "the component has no Page node, so it has no URL of its own";
+        else if (!isStart && !urlPath) unreachable = "its Page node sets no urlPath, so there is no URL to navigate to";
+        else if (!isStart && /[{}]/.test(urlPath))
+          unreachable = `its urlPath "${urlPath}" takes a route parameter, which this harness has no value for`;
+        return {
+          component,
+          title: typeof params.title === "string" ? params.title : void 0,
+          urlPath,
+          isStart,
+          reachable: !unreachable,
+          ...unreachable ? { unreachable } : {},
+          url: isStart ? "/" : unreachable ? void 0 : pathType === "hash" ? `/#${urlPath}` : `/${urlPath}`
+        };
+      });
+      return { ok: true, pages, startPage, pathType };
+    }
+    function resolvePageRequest(routes, requested) {
+      const raw = String(requested).trim();
+      const normalised = raw.replace(/^\//, "").replace(/^#/, "").replace(/^\//, "");
+      const registered = routes.pages.map((p) => `${p.isStart ? "/" : p.urlPath || "(no urlPath)"} (${p.component})`).join(", ");
+      if (!routes.pages.length) {
+        return {
+          ok: false,
+          message: `Cannot render the page "${raw}": this project registers no pages at all. A page is reachable only when a Router node lists it in its \`pages\` parameter.`
+        };
+      }
+      if (normalised === "") {
+        const start = routes.pages.find((p) => p.isStart);
+        if (start) return { ok: true, page: start };
+      }
+      let match = routes.pages.find((p) => p.urlPath === normalised) || routes.pages.find((p) => p.component === raw || p.component.replace(/^\//, "") === normalised);
+      if (!match) {
+        const titled = routes.pages.filter((p) => p.title !== void 0 && p.title === raw);
+        if (titled.length > 1) {
+          return {
+            ok: false,
+            message: `Cannot render the page "${raw}": ${titled.length} pages have that title (${titled.map((p) => p.component).join(", ")}). Ask for one by its path.`
+          };
+        }
+        match = titled[0];
+      }
+      if (!match) {
+        return {
+          ok: false,
+          message: `Cannot render the page "${raw}": no page registered at that path. Registered pages: ${registered}.`
+        };
+      }
+      if (!match.reachable) {
+        return {
+          ok: false,
+          message: `The page "${raw}" is registered as ${match.component}, but this harness cannot address it: ${match.unreachable}.`
+        };
+      }
+      return { ok: true, page: match };
+    }
+    function findChrome() {
+      const probed = [];
+      const check = (p) => {
+        probed.push(p);
+        return fs2.existsSync(p) ? p : null;
+      };
+      if (process.env.CHROME_PATH) {
+        const found = check(process.env.CHROME_PATH);
+        if (found) return { chrome: found, probed };
+      }
+      for (const candidate of CHROME_CANDIDATES[process.platform] || []) {
+        const found = check(candidate);
+        if (found) return { chrome: found, probed };
+      }
+      return { chrome: null, probed };
+    }
+    function checkPrerequisites(projectDir2) {
+      const problems = [];
+      if (!projectDir2 || !fs2.existsSync(path2.join(projectDir2, "nodegx.project.json"))) {
+        problems.push(
+          `Not a NodeGX v2 project directory (no nodegx.project.json): ${projectDir2 || "(none given)"}.`
+        );
+      }
+      if (!VIEWER_BUNDLE || !fs2.existsSync(VIEWER_BUNDLE)) {
+        problems.push(
+          `The viewer bundle is missing. Build it first: cd packages/noodl-viewer-react && npx webpack --config webpack-configs/webpack.viewer.prod.js. Probed: ${HARNESS_PATHS.VIEWER_DIR.probed.join(", ")}`
+        );
+      }
+      if (!WS_MODULE) {
+        problems.push(
+          `The "ws" package is missing. Run npm install at the repo root. Probed: ${HARNESS_PATHS.WS_MODULE.probed.join(", ")}`
+        );
+      }
+      if (!CATALOG_JSON) {
+        problems.push(
+          `The node catalog is missing. Probed: ${HARNESS_PATHS.CATALOG_JSON.probed.join(", ")}`
+        );
+      }
+      if (!ENRICHED_CATALOG_JSON) {
+        problems.push(
+          `The enriched node catalog is missing. Probed: ${HARNESS_PATHS.ENRICHED_CATALOG_JSON.probed.join(", ")}`
+        );
+      }
+      const { chrome, probed } = findChrome();
+      if (!chrome) {
+        problems.push(
+          "No Chrome or Chromium binary found. Install Google Chrome, or set CHROME_PATH to one. If you cannot install one, pass allow_unrendered to skip the render check rather than waiting on it. Probed: " + probed.join(", ")
+        );
+      }
+      return { ok: problems.length === 0, problems, chrome };
+    }
+    function parseViewports2(spec) {
+      if (!spec) return DEFAULT_VIEWPORTS;
+      const known = new Map(DEFAULT_VIEWPORTS.map((v) => [v.name, v]));
+      return spec.split(",").map((token) => {
+        const trimmed = token.trim();
+        if (known.has(trimmed)) return known.get(trimmed);
+        const m = /^(\d+)x(\d+)$/.exec(trimmed);
+        if (!m) {
+          const error = new Error(`Unknown viewport "${trimmed}". Use ${[...known.keys()].join(", ")} or WIDTHxHEIGHT.`);
+          error.problems = [error.message];
+          error.actionable = true;
+          error.usage = true;
+          throw error;
+        }
+        const width = Number(m[1]);
+        return { name: trimmed, width, height: Number(m[2]), mobile: width < 500 };
+      });
+    }
+    function freePort() {
+      return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+          const { port } = server.address();
+          server.close(() => resolve(port));
+        });
+      });
+    }
+    var wait = (ms) => new Promise((r) => setTimeout(r, ms));
+    function httpJson(port, urlPath) {
+      return new Promise((resolve, reject) => {
+        const req = http.get({ host: "127.0.0.1", port, path: urlPath, timeout: 3e3 }, (res) => {
+          let body = "";
+          res.on("data", (d) => body += d);
+          res.on("end", () => {
+            try {
+              resolve(JSON.parse(body));
+            } catch (e) {
+              reject(e);
+            }
+          });
+        });
+        req.on("timeout", () => {
+          req.destroy();
+          reject(new Error("timeout"));
+        });
+        req.on("error", reject);
+      });
+    }
+    function settleSummary(settles) {
+      if (!settles || !settles.length) return void 0;
+      const waited = settles.reduce((n, s) => n + s.waitedMs, 0);
+      const ceiling = settles.reduce((n, s) => n + s.ceilingMs, 0);
+      return {
+        count: settles.length,
+        waitedMs: waited,
+        /** What the fixed timers would have slept for the same run. */
+        fixedTimerMs: ceiling,
+        savedMs: ceiling - waited,
+        atCeiling: settles.filter((s) => !s.quiet).length,
+        rows: settles
+      };
+    }
+    function connect(wsUrl, onEvent) {
+      const WebSocket = require(WS_MODULE);
+      return new Promise((resolve, reject) => {
+        const ws = new WebSocket(wsUrl, { maxPayload: 512 * 1024 * 1024 });
+        let nextId = 0;
+        const pending = /* @__PURE__ */ new Map();
+        ws.on(
+          "open",
+          () => resolve({
+            send(method, params) {
+              const id = ++nextId;
+              ws.send(JSON.stringify({ id, method, params }));
+              return new Promise((res, rej) => pending.set(id, { res, rej }));
+            },
+            close() {
+              ws.close();
+            }
+          })
+        );
+        ws.on("error", reject);
+        ws.on("message", (data) => {
+          const msg = JSON.parse(data);
+          if (msg.id && pending.has(msg.id)) {
+            const { res, rej } = pending.get(msg.id);
+            pending.delete(msg.id);
+            msg.error ? rej(new Error(msg.error.message)) : res(msg.result);
+          } else if (msg.method && onEvent) {
+            onEvent(msg);
+          }
+        });
+      });
+    }
+    async function evaluate(client, expression) {
+      const r = await client.send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true });
+      if (r.exceptionDetails) {
+        throw new Error((r.exceptionDetails.exception || {}).description || r.exceptionDetails.text);
+      }
+      return r.result.value;
+    }
+    var BOOT_MS = 3500;
+    var REFLOW_MS = 1200;
+    var PAGE_NAV_MS = 2e3;
+    var PAGE_TABS = 4;
+    var QUIET_MS = 150;
+    var SETTLE_POLL_MS = 25;
+    function settleExpression(ceilingMs, rafs) {
+      return `(async () => {
+  const started = Date.now();
+  const deadline = started + ${ceilingMs};
+  const left = () => Math.max(0, deadline - Date.now());
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const reasons = [];
+
+  // 1. The document. In hash routing a route change is not a document load at
+  //    all, so this is already 'complete' and costs nothing \u2014 which is most of
+  //    where PAGE_NAV_MS was going.
+  if (document.readyState !== 'complete') {
+    reasons.push('load');
+    await Promise.race([
+      new Promise((res) => window.addEventListener('load', res, { once: true })),
+      sleep(left())
+    ]);
+  }
+
+  // 2. Fonts. Measured text is compared against the font sets, and a page read
+  //    mid-swap reports the fallback family as if the author had chosen it.
+  try {
+    if (document.fonts && document.fonts.status !== 'loaded') {
+      reasons.push('fonts');
+      await Promise.race([document.fonts.ready, sleep(left())]);
+    }
+  } catch (e) {
+    /* no Font Loading API: fall through to the quiet window */
+  }
+
+  // 3. Images still in flight. \`broken-image\` is counted from naturalWidth, and
+  //    an image that has not loaded YET is indistinguishable from one that never
+  //    will \u2014 this is the finding a too-eager budget invents.
+  const pending = () => Array.prototype.filter.call(document.images, (im) => !im.complete).length;
+  if (pending()) reasons.push('images');
+  while (left() > 0 && pending() > 0) await sleep(${SETTLE_POLL_MS});
+
+  // 4. Two frames \u2014 which is also what lets step 5 see anything. A transition
+  //    does not exist until the style recalc that starts it, so asking for the
+  //    running animations before a frame has passed returns an empty list and
+  //    the wait below is skipped on exactly the pages that need it.
+  for (let i = 0; i < ${rafs} && left() > 0; i++) {
+    // Raced against a sleep: a headless page that is never composited never
+    // fires rAF, and an unraced await would burn the whole budget waiting for a
+    // frame that is not coming \u2014 turning every settle back into the fixed timer.
+    await Promise.race([new Promise((res) => requestAnimationFrame(() => res())), sleep(50)]);
+  }
+
+  // 5. \u{1F534} CSS transitions and animations, which are the reason this step exists.
+  //
+  //    MEASURED, not anticipated: \`project-examples/lessons/snacks\` at 390px has
+  //    ONE element still at opacity 0 at 190ms and opaque at 1200ms. FLD-012's
+  //    \`visible\` correctly excludes a transparent element, so the eager read
+  //    counted 9 text elements where the fixed timer counted 10 \u2014 and
+  //    \`flat-type-scale\` gates at **>= 10**. A settle budget with this step
+  //    missing does not report a page differently; it DELETES a real finding and
+  //    reports the page clean.
+  //
+  //    \u26A0\uFE0F Only animations that will actually END are waited for. A spinner
+  //    iterates forever, and \`await\`ing its \`finished\` would spend the entire
+  //    budget on every page that has one \u2014 which is the fixed timer again, on the
+  //    pages least able to afford it.
+  try {
+    const finite = (document.getAnimations ? document.getAnimations() : []).filter((anim) => {
+      try {
+        const timing = anim.effect.getComputedTiming();
+        return Number.isFinite(timing.iterations) && Number.isFinite(timing.endTime);
+      } catch (e) {
+        return false;
+      }
+    });
+    if (finite.length) {
+      reasons.push('animations:' + finite.length);
+      await Promise.race([Promise.allSettled(finite.map((anim) => anim.finished)), sleep(left())]);
+    }
+  } catch (e) {
+    /* no Web Animations API: the quiet window is the only guard left */
+  }
+
+  // 6. And finally the quiet window.
+  let lastChange = Date.now();
+  const observer = new MutationObserver(() => {
+    lastChange = Date.now();
+  });
+  observer.observe(document.documentElement, {
+    subtree: true,
+    childList: true,
+    attributes: true,
+    characterData: true
+  });
+  try {
+    while (left() > 0 && Date.now() - lastChange < ${QUIET_MS}) await sleep(${SETTLE_POLL_MS});
+  } finally {
+    observer.disconnect();
+  }
+
+  return {
+    waitedMs: Date.now() - started,
+    ceilingMs: ${ceilingMs},
+    // \u{1F534} The honest field. \`false\` means the budget ran out and this is the OLD
+    // fixed-timer behaviour \u2014 the same wait, and the same reading. A run where
+    // this is false everywhere has not been sped up; it has been re-measured.
+    quiet: Date.now() - lastChange >= ${QUIET_MS},
+    waitedFor: reasons
+  };
+})()`;
+    }
+    var RENDER_PROFILE_PREFIX = "nodegx-render-";
+    function reapOrphanedRenderProcesses() {
+      const reaped = [];
+      try {
+        const ps = require("child_process").execFileSync("ps", ["-Ao", "pid=,ppid=,command="], {
+          encoding: "utf8",
+          maxBuffer: 8 * 1024 * 1024
+        });
+        for (const line of ps.split("\n")) {
+          const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+          if (!m) continue;
+          const [, pid, ppid, command] = m;
+          if (ppid !== "1") continue;
+          const isOurServer = command.includes(RENDER_SCRIPT);
+          const isOurChrome = command.includes(`--user-data-dir=`) && command.includes(RENDER_PROFILE_PREFIX);
+          if (!isOurServer && !isOurChrome) continue;
+          try {
+            process.kill(Number(pid), "SIGKILL");
+            reaped.push(`${pid} ${isOurServer ? "render-from-disk" : "chrome"}`);
+          } catch {
+          }
+        }
+      } catch {
+        return [];
+      }
+      try {
+        for (const name of fs2.readdirSync(os.tmpdir())) {
+          if (!name.startsWith(RENDER_PROFILE_PREFIX)) continue;
+          const dir = path2.join(os.tmpdir(), name);
+          try {
+            if (Date.now() - fs2.statSync(dir).mtimeMs < 60 * 60 * 1e3) continue;
+            fs2.rmSync(dir, { recursive: true, force: true });
+          } catch {
+          }
+        }
+      } catch {
+      }
+      if (reaped.length) console.error(`[render] reaped ${reaped.length} orphaned process(es): ${reaped.join(", ")}`);
+      return reaped;
+    }
+    async function unthrottle(client) {
+      for (const [method, params] of [
+        ["Emulation.setFocusEmulationEnabled", { enabled: true }],
+        ["Page.setWebLifecycleState", { state: "active" }]
+      ]) {
+        try {
+          await client.send(method, params);
+        } catch {
+        }
+      }
+    }
+    async function attachTab({ wsUrl, servePort, settles, label }) {
+      const consoleErrors = [];
+      const listeners = /* @__PURE__ */ new Set();
+      const client = await connect(wsUrl, (msg) => {
+        for (const listener of listeners) listener(msg);
+        if (msg.method === "Runtime.exceptionThrown") {
+          const d = msg.params.exceptionDetails || {};
+          consoleErrors.push(String(d.exception && d.exception.description || d.text || "").slice(0, 300));
+        } else if (msg.method === "Runtime.consoleAPICalled" && msg.params.type === "error") {
+          consoleErrors.push(
+            msg.params.args.map((a) => String(a.value !== void 0 ? a.value : a.description || "")).join(" ").slice(0, 300)
+          );
+        }
+      });
+      await client.send("Page.enable", {});
+      await client.send("Runtime.enable", {});
+      const settle = async (what, ceilingMs, rafs) => {
+        const stat = await evaluate(client, settleExpression(ceilingMs, rafs));
+        settles.push({ what, ...label ? { tab: label } : {}, ...stat });
+        return stat;
+      };
+      const goto = async (urlPath, ceilingMs) => {
+        await client.send("Page.navigate", { url: `http://127.0.0.1:${servePort}${urlPath}` });
+        await settle(`navigate ${urlPath}`, ceilingMs, 2);
+      };
+      return {
+        client,
+        consoleErrors,
+        settle,
+        goto,
+        evaluate: (expression) => evaluate(client, expression),
+        /**
+         * Go to another route and let it settle.
+         *
+         * UNI-010 §8.2. `PAGE_NAV_MS` rather than `BOOT_MS`: the runtime is already
+         * booted, and in the default `hash` mode this is a `hashchange` the router
+         * listens for rather than a document load. The viewport emulation set by
+         * `setViewport` survives it — `Emulation.setDeviceMetricsOverride` is
+         * per-session, not per-document — so a caller that has already sized the
+         * page does not have to size it again.
+         */
+        navigate: (urlPath) => goto(urlPath, PAGE_NAV_MS),
+        /** Hear every CDP event on this tab. Returns the function that stops it. */
+        onEvent(listener) {
+          listeners.add(listener);
+          return () => listeners.delete(listener);
+        },
+        async setViewport(vp) {
+          await client.send("Emulation.setDeviceMetricsOverride", {
+            width: vp.width,
+            height: vp.height,
+            deviceScaleFactor: 1,
+            mobile: Boolean(vp.mobile)
+          });
+          await settle(`viewport ${vp.name}`, REFLOW_MS, 2);
+        },
+        close() {
+          try {
+            client.close();
+          } catch {
+          }
+        }
+      };
+    }
+    async function withRenderedPage(options, fn) {
+      const { projectDir: projectDir2, backendPort, editorTokens = false, chromeArgs = [], beforeBoot } = options;
+      reapOrphanedRenderProcesses();
+      const pre = checkPrerequisites(projectDir2);
+      if (!pre.ok) {
+        const error = new Error(pre.problems.join(" "));
+        error.problems = pre.problems;
+        error.actionable = true;
+        throw error;
+      }
+      const servePort = await freePort();
+      const cdpPort = await freePort();
+      const serverArgs = [RENDER_SCRIPT, projectDir2, "--port", String(servePort)];
+      if (backendPort) serverArgs.push("--backend-port", String(backendPort));
+      if (editorTokens) serverArgs.push("--editor-tokens");
+      const server = spawn(process.execPath, serverArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
+      });
+      let serverLog = "";
+      server.stdout.on("data", (d) => serverLog += d);
+      server.stderr.on("data", (d) => serverLog += d);
+      const profile = fs2.mkdtempSync(path2.join(os.tmpdir(), "nodegx-render-"));
+      const chrome = spawn(
+        pre.chrome,
+        [
+          "--headless=new",
+          `--remote-debugging-port=${cdpPort}`,
+          `--user-data-dir=${profile}`,
+          "--no-first-run",
+          "--no-default-browser-check",
+          "--hide-scrollbars",
+          "--disable-gpu",
+          // P112-S14-KEYCHAIN: on macOS a page that touches storage makes Chrome open the login keychain. With no
+          // keychain where `HOME` points (an empty HOME, a CI user) the OS shows "Keychain Not Found" on the person's
+          // screen and Chrome waits for the answer, so the render hangs until its 240 s kill. A throwaway profile
+          // needs no real keychain.
+          "--use-mock-keychain",
+          // Caller-supplied flags, for drives that need a capability this browser
+          // does not have by default — a synthetic microphone and camera
+          // (`--use-fake-device-for-media-stream`) being the case that added this.
+          // Appended last so a drive can override a default above it.
+          ...chromeArgs,
+          "about:blank"
+        ],
+        { stdio: "ignore" }
+      );
+      const extraTabs = [];
+      let browserClient;
+      let cleanedUp = false;
+      const cleanup = (client2) => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        for (const tab of extraTabs) tab.close();
+        try {
+          if (browserClient) browserClient.close();
+        } catch {
+        }
+        try {
+          if (client2) client2.close();
+        } catch {
+        }
+        chrome.kill();
+        server.kill();
+        fs2.rm(profile, { recursive: true, force: true }, () => {
+        });
+      };
+      const onSignal = (signal) => () => {
+        cleanup(void 0);
+        process.exit(signal === "SIGINT" ? 130 : 143);
+      };
+      const handlers = [
+        ["SIGINT", onSignal("SIGINT")],
+        ["SIGTERM", onSignal("SIGTERM")],
+        ["SIGHUP", onSignal("SIGHUP")],
+        ["exit", () => cleanup(void 0)]
+      ];
+      for (const [event, handler] of handlers) process.once(event, handler);
+      const releaseHandlers = () => {
+        for (const [event, handler] of handlers) process.removeListener(event, handler);
+      };
+      let client;
+      try {
+        let targets;
+        for (let i = 0; i < 40 && !targets; i++) {
+          await wait(250);
+          try {
+            targets = await httpJson(cdpPort, "/json/list");
+          } catch {
+          }
+        }
+        if (!targets) throw new Error(`Chrome never opened a debugging port (${pre.chrome}).`);
+        const target = targets.find((t) => t.type === "page");
+        const settles = [];
+        const main2 = await attachTab({ wsUrl: target.webSocketDebuggerUrl, servePort, settles });
+        client = main2.client;
+        const openTab = async (label) => {
+          if (!browserClient) {
+            const version = await httpJson(cdpPort, "/json/version");
+            browserClient = await connect(version.webSocketDebuggerUrl);
+            await unthrottle(main2.client);
+          }
+          const { targetId } = await browserClient.send("Target.createTarget", { url: "about:blank" });
+          let described;
+          for (let i = 0; i < 40 && !described; i++) {
+            const list = await httpJson(cdpPort, "/json/list");
+            described = list.find((t) => t.id === targetId && t.webSocketDebuggerUrl);
+            if (!described) await wait(50);
+          }
+          if (!described) throw new Error("a tab was created and never appeared in /json/list with a debugger URL");
+          const tab = await attachTab({ wsUrl: described.webSocketDebuggerUrl, servePort, settles, label });
+          await unthrottle(tab.client);
+          tab.targetId = targetId;
+          extraTabs.push(tab);
+          return tab;
+        };
+        const closeTab = async (tab) => {
+          tab.close();
+          const at = extraTabs.indexOf(tab);
+          if (at !== -1) extraTabs.splice(at, 1);
+          try {
+            if (tab.targetId) await browserClient.send("Target.closeTarget", { targetId: tab.targetId });
+          } catch {
+          }
+        };
+        if (beforeBoot) await beforeBoot(main2);
+        await main2.client.send("Page.navigate", { url: `http://127.0.0.1:${servePort}/` });
+        await main2.settle("boot", BOOT_MS, 2);
+        return await fn({
+          client,
+          consoleErrors: main2.consoleErrors,
+          settles,
+          serverLog: () => serverLog,
+          servePort,
+          evaluate: main2.evaluate,
+          goto: main2.goto,
+          navigate: main2.navigate,
+          settle: main2.settle,
+          setViewport: main2.setViewport,
+          onEvent: main2.onEvent,
+          openTab,
+          closeTab
+        });
+      } finally {
+        cleanup(client);
+        releaseHandlers();
+      }
+    }
+    async function renderReport2(options) {
+      const {
+        projectDir: projectDir2,
+        viewports = DEFAULT_VIEWPORTS,
+        screenshot = "full",
+        screenshotPages = "start",
+        deviceScaleFactor = 0.5,
+        backendPort,
+        editorTokens = false,
+        renderRoutedPages = true,
+        page: requestedPage,
+        concurrency = PAGE_TABS
+      } = options;
+      const started = Date.now();
+      const routes = routedPages(projectDir2);
+      let focus;
+      if (requestedPage !== void 0) {
+        const resolved = resolvePageRequest(routes, requestedPage);
+        if (!resolved.ok) {
+          const error = new Error(resolved.message);
+          error.problems = [resolved.message];
+          error.actionable = true;
+          throw error;
+        }
+        focus = resolved.page;
+      }
+      return withRenderedPage({ projectDir: projectDir2, backendPort, editorTokens }, async (page) => {
+        const overridden = Object.fromEntries(overriddenDefaults(projectDir2));
+        const placeholders = [.../* @__PURE__ */ new Set([...placeholderStrings(), ...Object.keys(overridden)])];
+        const allProbes = listProbes(projectDir2);
+        const { components: projectComponents } = readComponents(projectDir2);
+        const byName = new Map(projectComponents.map((c) => [c.name, c]));
+        const reachBy = new Map(routes.pages.map((p) => [p.component, reachableComponents(p.component, byName)]));
+        const unplaced = allProbes.filter((probe) => ![...reachBy.values()].some((set) => set.has(probe.component)));
+        const probesFor = (pageComponent) => {
+          const reach = reachBy.get(pageComponent);
+          const own = reach ? allProbes.filter((probe) => reach.has(probe.component)) : allProbes;
+          return pageComponent === routes.startPage ? [...own, ...unplaced] : own;
+        };
+        const subject = focus || routes.pages.find((pg) => pg.isStart);
+        const subjectComponent = subject ? subject.component : routes.startPage;
+        const focusedOffStart = Boolean(focus && !focus.isStart);
+        if (focusedOffStart) await page.navigate(focus.url);
+        const measured = {};
+        const screenshots = [];
+        const capture = async (vp, raw, component, subject2, client = page.client) => {
+          const shot = await client.send("Page.captureScreenshot", {
+            format: "png",
+            captureBeyondViewport: screenshot === "full",
+            optimizeForSpeed: true,
+            ...screenshot === "full" ? {
+              clip: {
+                x: 0,
+                y: 0,
+                width: vp.width,
+                // Chrome refuses beyond 16384px; a page taller than that is
+                // already the finding.
+                height: Math.min(raw.pageHeight, 16384),
+                scale: deviceScaleFactor
+              }
+            } : {}
+          });
+          return { name: vp.name, page: component, subject: subject2, mimeType: "image/png", base64: shot.data };
+        };
+        const expression = measureExpression(placeholders, probesFor(subjectComponent));
+        let loggedThrough = 0;
+        for (const vp of viewports) {
+          const loggedBefore = loggedThrough;
+          await page.setViewport(vp);
+          const raw = await page.evaluate(expression);
+          loggedThrough = page.consoleErrors.length;
+          measured[vp.name] = {
+            requested: { width: vp.width, height: vp.height },
+            ...raw,
+            consoleErrors: page.consoleErrors.slice(loggedBefore, loggedThrough)
+          };
+          if (screenshot !== "none") {
+            screenshots.push(await capture(vp, raw, subjectComponent, true));
+          }
+        }
+        const blank = Object.values(measured).some((v) => v && !v.error && v.text.elements === 0 && v.images.total === 0);
+        const diagnosable = blank && !focusedOffStart;
+        const { findings: rawFindings, summary } = summarise(
+          measured,
+          diagnosable ? blankDiagnosis(projectDir2) : void 0,
+          overridden
+        );
+        const findings = !focusedOffStart ? rawFindings : rawFindings.map((f) => ({
+          ...f,
+          page: subjectComponent,
+          message: f.code === RenderFinding.BlankRender ? `The routed page "${subjectComponent}" rendered nothing at all \u2014 no text and no images. Only the start page is diagnosed against the graph, so the cause was not determined here.` : `On the routed page "${subjectComponent}": ${f.message}`
+        }));
+        const pageReports = [];
+        const extraFindings = [];
+        let sweep;
+        if (focus) {
+          pageReports.push({ ...focus, measured: true, viewports: measured });
+        } else if (renderRoutedPages) {
+          const rows = new Array(routes.pages.length);
+          const findingsByPage = new Array(routes.pages.length);
+          const shotsByPage = new Array(routes.pages.length);
+          const todo = [];
+          routes.pages.forEach((p, i) => {
+            if (p.isStart) {
+              rows[i] = { ...p, measured: true, viewports: measured };
+            } else if (!p.reachable) {
+              rows[i] = { ...p, measured: false };
+            } else {
+              todo.push({ p, i });
+            }
+          });
+          const measureRoutedPage = async (p, i, tab, firstInTab) => {
+            let loggedThrough2 = tab.consoleErrors.length;
+            await tab.goto(p.url, firstInTab ? BOOT_MS : PAGE_NAV_MS);
+            const pageExpression = measureExpression(placeholders, probesFor(p.component));
+            const pageMeasured = {};
+            const shots = [];
+            for (const vp of viewports) {
+              const loggedBefore = loggedThrough2;
+              await tab.setViewport(vp);
+              const raw = await tab.evaluate(pageExpression);
+              loggedThrough2 = tab.consoleErrors.length;
+              pageMeasured[vp.name] = {
+                requested: { width: vp.width, height: vp.height },
+                ...raw,
+                consoleErrors: tab.consoleErrors.slice(loggedBefore, loggedThrough2)
+              };
+              if (screenshot !== "none" && screenshotPages === "all") {
+                shots.push(await capture(vp, raw, p.component, false, tab.client));
+              }
+            }
+            const perPage = summarise(pageMeasured, void 0, overridden);
+            findingsByPage[i] = perPage.findings.map((f) => ({
+              ...f,
+              page: p.component,
+              message: f.code === RenderFinding.BlankRender ? `The routed page "${p.component}" rendered nothing at all \u2014 no text and no images. Only the start page is diagnosed against the graph, so the cause was not determined here.` : `On the routed page "${p.component}": ${f.message}`
+            }));
+            shotsByPage[i] = shots;
+            rows[i] = { ...p, measured: true, viewports: pageMeasured, summary: perPage.summary };
+          };
+          if (todo.length) {
+            const lanes = Math.max(1, Math.min(Math.floor(Number(concurrency)) || 1, todo.length));
+            let cursor = 0;
+            const lane = async (tab, ownTab) => {
+              let firstInTab = ownTab;
+              for (; ; ) {
+                const at = cursor++;
+                if (at >= todo.length) return;
+                await measureRoutedPage(todo[at].p, todo[at].i, tab, firstInTab);
+                firstInTab = false;
+              }
+            };
+            const helpers = [];
+            try {
+              for (let k = 1; k < lanes; k++) helpers.push(await page.openTab(`tab${k}`));
+              await Promise.all([lane(page, false), ...helpers.map((tab) => lane(tab, true))]);
+            } finally {
+              for (const tab of helpers) await page.closeTab(tab);
+            }
+            sweep = { pages: todo.length, tabs: lanes };
+          }
+          for (const row of rows) if (row) pageReports.push(row);
+          for (const list of findingsByPage) if (list) extraFindings.push(...list);
+          for (const list of shotsByPage) if (list) screenshots.push(...list);
+          if (pageReports.some((p) => p.measured && !p.isStart)) await page.navigate("/");
+        }
+        const allFindings = [...findings, ...extraFindings];
+        let allSummary = extraFindings.length ? summaryLine(measured, allFindings) : summary;
+        if (focus) {
+          allSummary += ` (page "${focus.isStart ? "/" : focus.urlPath}" only \u2014 the rest of this project was not looked at.)`;
+        }
+        const skipped = pageReports.filter((p) => !p.measured);
+        if (skipped.length) {
+          allSummary += ` \u26A0\uFE0F ${skipped.length} of ${pageReports.length} routed ${skipped.length === 1 ? "page was" : "pages were"} not measured, so this says nothing about ${skipped.length === 1 ? "it" : "them"}: ` + skipped.map((p) => `${p.component} (${p.unreachable})`).join("; ") + ".";
+        }
+        const project = JSON.parse(fs2.readFileSync(path2.join(projectDir2, "nodegx.project.json"), "utf8"));
+        const log = page.serverLog();
+        return {
+          report: {
+            project: projectDir2,
+            projectName: project.name,
+            durationMs: Date.now() - started,
+            /**
+             * FLD-011 — what the settle budget actually cost, beside what the fixed
+             * timers it replaced would have.
+             *
+             * 🔴 `atCeiling` is the field that keeps the speed claim honest: those
+             * settles waited the full old timer and read what the old code read. A
+             * run where `atCeiling` equals `count` was not made faster at all, and
+             * `savedMs` on such a run is zero rather than a number to quote.
+             */
+            settle: settleSummary(page.settles),
+            ...sweep ? { sweep } : {},
+            tokens: (log.match(/\[render\] design tokens: (.*)/) || [])[1] || "unknown",
+            components: (log.match(/\[render\] rootComponent=\S+\s+(\d+) components/) || [])[1],
+            viewports: measured,
+            pages: pageReports,
+            findings: allFindings,
+            summary: allSummary
+          },
+          screenshots
+        };
+      });
+    }
+    module2.exports = {
+      renderReport: renderReport2,
+      // Exported so a session-teardown hook, a CI step or a spec can reap without
+      // starting a drive — the leak outlives the run that caused it.
+      reapOrphanedRenderProcesses,
+      routedPages,
+      resolvePageRequest,
+      reachableComponents,
+      withRenderedPage,
+      summarise,
+      measureExpression,
+      listProbes,
+      readComponents,
+      blankDiagnosis,
+      overriddenDefaults,
+      rootNodes,
+      effectiveRoots,
+      projectVisualPredicate,
+      visualTypeNames,
+      contentBearingTypeNames,
+      BlankCause,
+      placeholderStrings,
+      // VIB-007 M3 — the poverty thresholds, so a spec reads README §2's number
+      // rather than restating it.
+      DISPLAY_TYPE_MIN_PX,
+      MIN_DISTINCT_GROUNDS,
+      POVERTY_MIN_TEXTS,
+      POVERTY_FINDINGS,
+      isPovertyFinding,
+      checkPrerequisites,
+      findChrome,
+      freePort,
+      // HLS-015 — the CDP pair, exported so a drive that boots something OTHER than a project
+      // directory can still talk to a page. `withRenderedPage` boots the viewer against project
+      // FILES; `nodegx deploy`'s output is a finished site with no project in it, so it needs the
+      // plumbing without the booting. The alternative was a second copy of `connect` in a sibling
+      // script, which is the thing the comment above `withRenderedPage` says not to do.
+      connect,
+      evaluate,
+      httpJson,
+      parseViewports: parseViewports2,
+      RenderFinding,
+      DEFAULT_VIEWPORTS,
+      DESKTOP_WIDTH,
+      // FLD-011 — the default tab count, so a spec asserts the shipped number rather than restating it.
+      PAGE_TABS,
+      VIEWER_BUNDLE,
+      RENDER_SCRIPT
+    };
+  }
+});
+
+// ../../scripts/devtools/measure-from-disk.js
+var fs = require("fs");
+var path = require("path");
+var { renderReport, parseViewports } = require_render_report();
+var argv = process.argv.slice(2);
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--out",
+  "--out-dir",
+  "--viewports",
+  "--screenshot",
+  "--scale",
+  "--backend-port",
+  "--page",
+  "--concurrency"
+]);
+var flag = (name, fallback) => {
+  const i = argv.indexOf(name);
+  return i === -1 ? fallback : argv[i + 1];
+};
+var projectDir = argv.find((a, i) => !a.startsWith("--") && !VALUE_FLAGS.has(argv[i - 1]));
+var asJson = argv.includes("--json");
+function viewportsOrExit(spec) {
+  try {
+    return parseViewports(spec);
+  } catch (e) {
+    if (!e.usage) throw e;
+    console.error(e.message);
+    process.exit(2);
+  }
+}
+function pageSlug(component) {
+  const slug = String(component).replace(/^\/+/, "").replace(/__page__/g, "page").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return slug || "page";
+}
+function printHuman(report, files) {
+  console.log(`${report.projectName}  \u2014  ${report.summary}`);
+  console.log(`  tokens: ${report.tokens}   ${report.durationMs}ms`);
+  for (const [name, v] of Object.entries(report.viewports)) {
+    console.log(
+      `  ${name.padEnd(8)} ${v.requested.width}px \u2192 layout ${v.layoutWidth}px, page ${v.pageHeight}px, ${v.text.elements} texts / ${v.text.distinctFontSizes} sizes / weights ${Object.keys(v.text.fontWeights).join("+") || "none"}, ${v.images.total} images (${v.images.broken} broken), ${v.placeholders.count} placeholders`
+    );
+  }
+  if (report.pages && report.pages.length) {
+    const measured = report.pages.filter((p) => p.measured);
+    console.log(`  pages: ${measured.length}/${report.pages.length} measured \u2014 ${measured.map((p) => p.component).join(", ")}`);
+    for (const p of report.pages.filter((page) => !page.measured)) {
+      console.log(`  [skipped] ${p.component} \u2014 ${p.unreachable}`);
+    }
+  }
+  for (const f of report.findings) {
+    console.log(`  [${f.severity}] ${f.viewport}: ${f.code} \u2014 ${f.message}`);
+  }
+  for (const file of files) console.log(`  wrote ${file}`);
+}
+async function main() {
+  if (!projectDir) {
+    console.error(
+      "usage: measure-from-disk.js <project-dir> [--json] [--out prefix] [--out-dir dir] [--viewports desktop,phone] [--page quiz]"
+    );
+    process.exit(2);
+  }
+  const outDir = flag("--out-dir");
+  const { report, screenshots } = await renderReport({
+    projectDir,
+    viewports: viewportsOrExit(flag("--viewports")),
+    screenshot: flag("--screenshot", "full"),
+    // 🔴 The sweep is what makes `--out-dir` mean "every page", and it is off by default in
+    // `renderReport` so that `render_report` keeps costing what it costs. Asking for the images
+    // is the act that turns it on; nothing else in this script does.
+    screenshotPages: outDir ? "all" : "start",
+    deviceScaleFactor: Number(flag("--scale", 0.5)),
+    backendPort: flag("--backend-port") ? Number(flag("--backend-port")) : void 0,
+    editorTokens: argv.includes("--editor-tokens"),
+    page: flag("--page"),
+    // FLD-011 — `--concurrency 1` is the serial sweep, and it is here so the arms
+    // that grade the parallel one are two runs of the SAME build differing by a
+    // number, rather than a run of this build against a `git show HEAD:` copy.
+    ...flag("--concurrency") ? { concurrency: Number(flag("--concurrency")) } : {}
+  });
+  const out = flag("--out");
+  const files = [];
+  if (out) {
+    for (const shot of screenshots.filter((shot2) => shot2.subject !== false)) {
+      const file = `${out}-${shot.name}.png`;
+      fs.writeFileSync(file, Buffer.from(shot.base64, "base64"));
+      report.viewports[shot.name].screenshot = file;
+      files.push(file);
+    }
+  }
+  if (outDir) {
+    fs.mkdirSync(outDir, { recursive: true });
+    const pageByComponent = new Map((report.pages || []).map((pg) => [pg.component, pg]));
+    const taken = /* @__PURE__ */ new Set();
+    for (const shot of screenshots) {
+      let stem = `${pageSlug(shot.page)}-${shot.name}`;
+      if (taken.has(stem)) {
+        let n = 2;
+        while (taken.has(`${stem}-${n}`)) n += 1;
+        stem = `${stem}-${n}`;
+      }
+      taken.add(stem);
+      const file = path.join(outDir, `${stem}.png`);
+      fs.writeFileSync(file, Buffer.from(shot.base64, "base64"));
+      const row = pageByComponent.get(shot.page);
+      if (row && row.viewports && row.viewports[shot.name]) row.viewports[shot.name].screenshot = file;
+      if (shot.subject && report.viewports[shot.name]) report.viewports[shot.name].screenshot = file;
+      files.push(file);
+    }
+  }
+  if (asJson) {
+    const payload = argv.includes("--inline-screenshots") ? { ...report, screenshots } : report;
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    printHuman(report, files);
+  }
+}
+main().catch((e) => {
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        { error: { actionable: Boolean(e.actionable), message: e.message, problems: e.problems ?? [e.message] } },
+        null,
+        2
+      )
+    );
+  } else if (e.actionable) {
+    console.error("Cannot render:");
+    for (const problem of e.problems) console.error(`  - ${problem}`);
+  } else {
+    console.error("MEASURE FAILED:", e.message);
+  }
+  process.exit(1);
+});