@invarn/cibuild 2.9.5 → 2.9.7

package/dist/src/yaml/steps/structural-facts.js

@@ -1,3276 +0,0 @@
-/**
- * Structural-facts deriver — Signal A of the UI-fidelity structural pass.
- *
- * Pure and platform-agnostic: it takes a per-node layout dump (clipped +
- * unclipped bounds in px, parent) emitted alongside the render and derives
- * intent-agnostic geometric facts the fidelity judge should check instead of
- * discovering them by eye:
- *
- *   - `overflow`          — a node extends past its parent's box (parent does
- *                           NOT clip, so the excess is visibly sticking out).
- *   - `clipped_by_parent` — a node extends past a CLIPPING parent's box, so the
- *                           excess is cut away (the motivating euro-coin case).
- *   - `off_screen`        — a node extends past the root canvas.
- *   - `overlap`           — two siblings overlap by a significant area.
- *
- * The deriver does NOT judge or score; it reports facts. The verdict stays the
- * agent's. This is the brain of Signal A; the render-side emission + facts
- * artifact wiring live in the render step (a separate slice).
- */
-/** Placement drift at or below this many dp is sub-pixel/rounding noise, not
- *  a misplacement — same reasoning as the size-delta floor. */
-export const DEFAULT_PLACEMENT_TOLERANCE_DP = 2;
-/** Captured-root vs declared-frame tolerance (dp): sub-pixel rounding must not
- *  read as a mis-sized wrapper root. */
-export const DEFAULT_FRAME_TOLERANCE_DP = 1;
-const EDGE_ORDER = ['left', 'top', 'right', 'bottom'];
-const DEFAULT_TOLERANCE_PX = 0.5;
-const DEFAULT_OVERLAP_MIN_RATIO = 0.1;
-/**
- * By how much `inner` extends past `outer` on each edge (positive = exceeds).
- * left/top excess is `outer - inner`; right/bottom excess is `inner - outer`.
- */
-function edgeExcess(inner, outer, tolerancePx) {
-    const raw = {
-        left: outer.left - inner.left,
-        top: outer.top - inner.top,
-        right: inner.right - outer.right,
-        bottom: inner.bottom - outer.bottom,
-    };
-    const edges = [];
-    const px = {};
-    for (const edge of EDGE_ORDER) {
-        if (raw[edge] > tolerancePx) {
-            edges.push(edge);
-            px[edge] = raw[edge];
-        }
-    }
-    return { edges, px };
-}
-function area(b) {
-    return Math.max(0, b.right - b.left) * Math.max(0, b.bottom - b.top);
-}
-/**
- * The box a node actually PAINTS, in layout px — its painted ink when the node
- * declares where its ink sits, else its layout bounds (icon-ink-ratio 02 Half B).
- *
- * An `Icon` reports the container it sits in, not the glyph: `ic_filter` paints
- * 20x14 of a 24x24 viewport, offset 2 in and 5 down. Intersecting containers
- * therefore answered a question nobody asked — a badge tucked in an icon's corner
- * "overlapped" a glyph it visually clears — while the design side of the
- * comparison has always been the Figma PATH box, which is pure ink.
- *
- * Falls back to the bounds, never to a guess, in all three blind cases: no
- * `paintedInk` (the node paints no painter, so its box IS its ink),
- * `unmeasurable` (the paths could not be read), and an extent with NO ORIGIN
- * (a pre-origin dump — the size cannot place the ink, and assuming it centred
- * would invent the number this capture exists to stop inventing).
- */
-function paintedBox(node) {
-    const p = node.paintedInk;
-    if (!p || p.kind !== 'vector')
-        return node.bounds;
-    const v = p.viewport;
-    const ink = p.ink;
-    const finite = (n) => typeof n === 'number' && Number.isFinite(n);
-    if (!v || !ink || !finite(v.w) || !finite(v.h) || v.w <= 0 || v.h <= 0)
-        return node.bounds;
-    if (![ink.w, ink.h, ink.x, ink.y].every(finite))
-        return node.bounds;
-    const scaleX = (node.bounds.right - node.bounds.left) / v.w;
-    const scaleY = (node.bounds.bottom - node.bounds.top) / v.h;
-    const left = node.bounds.left + ink.x * scaleX;
-    const top = node.bounds.top + ink.y * scaleY;
-    return { left, top, right: left + ink.w * scaleX, bottom: top + ink.h * scaleY };
-}
-/**
- * Node ids that appear on MORE THAN ONE node of the dump (testTag collisions),
- * mapped to their instance count. Every id-keyed lookup (parent pairing,
- * geometry, placement) is last-wins for such an id, so facts derived through it
- * would compare arbitrary instances — consumers withhold them and report the
- * collision as a `duplicate_tag` fact instead.
- */
-export function duplicatedNodeIds(nodes) {
-    const counts = new Map();
-    for (const node of nodes)
-        counts.set(node.id, (counts.get(node.id) ?? 0) + 1);
-    for (const [id, count] of counts) {
-        if (count < 2)
-            counts.delete(id);
-    }
-    return counts;
-}
-export function deriveStructuralFacts(dump, options = {}) {
-    const tolerancePx = options.tolerancePx ?? DEFAULT_TOLERANCE_PX;
-    const overlapMinRatio = options.overlapMinRatio ?? DEFAULT_OVERLAP_MIN_RATIO;
-    const byId = new Map(dump.nodes.map((n) => [n.id, n]));
-    const facts = [];
-    // testTag collisions first: the fact that explains every withheld comparison
-    // below. Parent-relative overflow/clip is skipped when the node OR its parent
-    // carries a duplicated tag — the byId pairing is last-wins, so the measured
-    // box could belong to any instance. Off-screen (node vs canvas, no pairing)
-    // and overlaps (measured between two concrete node objects) still derive.
-    const duplicates = duplicatedNodeIds(dump.nodes);
-    for (const tag of [...duplicates.keys()].sort()) {
-        facts.push({ kind: 'duplicate_tag', tag, instanceCount: duplicates.get(tag) });
-    }
-    // Overflow / clip vs the direct parent, plus off-screen vs the canvas.
-    for (const node of dump.nodes) {
-        const parent = node.parentId && !duplicates.has(node.id) && !duplicates.has(node.parentId)
-            ? byId.get(node.parentId)
-            : undefined;
-        if (parent) {
-            if (node.unclippedBounds) {
-                // New dump: measure the child's TRUE extent against the parent's box, so
-                // a clamping parent no longer hides the excess. An exceeding edge is
-                // `clipped_by_parent` when that edge was actually clamped (the unclipped
-                // extent runs past the visible `bounds`), else it visibly `overflow`s.
-                const parentBox = parent.unclippedBounds ?? parent.bounds;
-                const over = edgeExcess(node.unclippedBounds, parentBox, tolerancePx);
-                if (over.edges.length > 0) {
-                    const cut = edgeExcess(node.unclippedBounds, node.bounds, tolerancePx);
-                    const clippedEdges = [];
-                    const overflowEdges = [];
-                    for (const edge of over.edges) {
-                        if (cut.px[edge] != null)
-                            clippedEdges.push(edge);
-                        else
-                            overflowEdges.push(edge);
-                    }
-                    if (clippedEdges.length > 0) {
-                        const clippedPx = {};
-                        for (const edge of clippedEdges)
-                            clippedPx[edge] = cut.px[edge];
-                        facts.push({
-                            kind: 'clipped_by_parent',
-                            nodeId: node.id,
-                            clipperId: parent.id,
-                            edges: clippedEdges,
-                            clippedPx,
-                        });
-                    }
-                    if (overflowEdges.length > 0) {
-                        const overflowPx = {};
-                        for (const edge of overflowEdges)
-                            overflowPx[edge] = over.px[edge];
-                        facts.push({
-                            kind: 'overflow',
-                            nodeId: node.id,
-                            parentId: parent.id,
-                            edges: overflowEdges,
-                            overflowPx,
-                        });
-                    }
-                }
-            }
-            else {
-                // Legacy dump (no unclippedBounds): clipped bounds + the clipsChildren hint.
-                const { edges, px } = edgeExcess(node.bounds, parent.bounds, tolerancePx);
-                if (edges.length > 0) {
-                    if (parent.clipsChildren) {
-                        facts.push({
-                            kind: 'clipped_by_parent',
-                            nodeId: node.id,
-                            clipperId: parent.id,
-                            edges,
-                            clippedPx: px,
-                        });
-                    }
-                    else {
-                        facts.push({
-                            kind: 'overflow',
-                            nodeId: node.id,
-                            parentId: parent.id,
-                            edges,
-                            overflowPx: px,
-                        });
-                    }
-                }
-            }
-        }
-        // Off-screen uses the true extent when available, so a node positioned past
-        // the canvas surfaces even if it is clamped to the screen.
-        const offBox = node.unclippedBounds ?? node.bounds;
-        const offscreen = edgeExcess(offBox, dump.canvas, tolerancePx);
-        if (offscreen.edges.length > 0) {
-            facts.push({
-                kind: 'off_screen',
-                nodeId: node.id,
-                edges: offscreen.edges,
-                offscreenPx: offscreen.px,
-            });
-        }
-    }
-    // Significant overlaps between siblings (same parent).
-    const groups = new Map();
-    for (const node of dump.nodes) {
-        const key = node.parentId ?? 'root';
-        const arr = groups.get(key) ?? [];
-        arr.push(node);
-        groups.set(key, arr);
-    }
-    for (const siblings of groups.values()) {
-        for (let i = 0; i < siblings.length; i++) {
-            for (let j = i + 1; j < siblings.length; j++) {
-                const a = siblings[i];
-                const b = siblings[j];
-                // Measured on what each sibling PAINTS, not on the box it occupies
-                // (icon-ink-ratio 02 Half B). The ratio uses the painted areas for the
-                // same reason: a generous container would dilute every ratio it joins.
-                const ab = paintedBox(a);
-                const bb = paintedBox(b);
-                const ix = Math.min(ab.right, bb.right) - Math.max(ab.left, bb.left);
-                const iy = Math.min(ab.bottom, bb.bottom) - Math.max(ab.top, bb.top);
-                if (ix <= tolerancePx || iy <= tolerancePx)
-                    continue;
-                const smaller = Math.min(area(ab), area(bb));
-                const ratio = smaller > 0 ? (ix * iy) / smaller : 0;
-                if (ratio < overlapMinRatio)
-                    continue;
-                const [first, second] = a.id <= b.id ? [a.id, b.id] : [b.id, a.id];
-                facts.push({
-                    kind: 'overlap',
-                    nodeIds: [first, second],
-                    overlapPx: { width: ix, height: iy },
-                    ratio,
-                });
-            }
-        }
-    }
-    return facts;
-}
-const GEOMETRY_DIMENSIONS = ['width', 'height', 'x', 'y'];
-const DEFAULT_GEOMETRY_TOLERANCE_PX = 1;
-/**
- * Per-element dimensional deltas between a GENERATED geometry (render layout) and
- * a REFERENCE geometry (design numbers), both in the same unit. Only elements
- * present on both sides, and only dimensions supplied on both, are compared.
- * Port of `packages/cli/lib/fidelity-geometry-diff.mjs`.
- */
-export function diffKeyGeometry(generated, reference, options = {}) {
-    if (!reference)
-        return [];
-    const tolerancePx = options.tolerancePx ?? DEFAULT_GEOMETRY_TOLERANCE_PX;
-    const out = [];
-    for (const elementId of Object.keys(generated)) {
-        const g = generated[elementId];
-        const r = reference[elementId];
-        if (!g || !r)
-            continue;
-        const deltas = [];
-        for (const dimension of GEOMETRY_DIMENSIONS) {
-            const gv = g[dimension];
-            const rv = r[dimension];
-            if (typeof gv !== 'number' || typeof rv !== 'number')
-                continue;
-            const delta = gv - rv;
-            if (Math.abs(delta) > tolerancePx) {
-                deltas.push({ dimension, generated: gv, reference: rv, delta });
-            }
-        }
-        if (deltas.length > 0)
-            out.push({ elementId, deltas });
-    }
-    return out;
-}
-/** The metrics a `type_metric` fact can report, in the order a finding reads
- *  them: the size first (it explains the others), then tracking, then leading. */
-export const TYPE_METRIC_KEYS = ['fontSize', 'letterSpacing', 'lineHeight'];
-function isNonEmptyRecord(value) {
-    return !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
-}
-/**
- * Assemble the `AppearanceReference` from a screen's reference params. Issue 05
- * decouples the appearance container from `reference_geometry`: the reference is
- * built when ANY of geometry / text / color is present, with `elementIds` = the
- * UNION of their keys (geometry first, then text, then color — deduped, order
- * preserved). So a run carrying `reference_color` but no `reference_geometry` now
- * yields a reference (→ color facts), while a geometry-only run is byte-identical
- * to before (color/text keys are a subset). `text`/`color` are attached only when
- * present. No reference of any kind → null (no appearance container).
- */
-export function buildAppearanceReferenceFromParams(params) {
-    const hasGeom = isNonEmptyRecord(params.refGeom);
-    const hasText = isNonEmptyRecord(params.refText);
-    const hasColor = isNonEmptyRecord(params.refColor);
-    const hasSpans = isNonEmptyRecord(params.refSpans);
-    const hasLines = isNonEmptyRecord(params.refLines);
-    const hasTypeface = isNonEmptyRecord(params.refTypeface);
-    if (!hasGeom && !hasText && !hasColor && !hasSpans && !hasLines && !hasTypeface)
-        return null;
-    const elementIds = [];
-    const seen = new Set();
-    const addKeys = (record) => {
-        for (const key of Object.keys(record ?? {})) {
-            if (!seen.has(key)) {
-                seen.add(key);
-                elementIds.push(key);
-            }
-        }
-    };
-    if (hasGeom)
-        addKeys(params.refGeom);
-    if (hasText)
-        addKeys(params.refText);
-    if (hasColor)
-        addKeys(params.refColor);
-    if (hasSpans)
-        addKeys(params.refSpans);
-    if (hasLines)
-        addKeys(params.refLines);
-    if (hasTypeface)
-        addKeys(params.refTypeface);
-    const reference = { baseline: params.baseline, elementIds };
-    if (hasText)
-        reference.text = params.refText;
-    if (hasColor)
-        reference.color = params.refColor;
-    if (hasSpans)
-        reference.spans = params.refSpans;
-    if (hasLines)
-        reference.lines = params.refLines;
-    if (hasTypeface)
-        reference.typeface = params.refTypeface;
-    return reference;
-}
-/**
- * Map a previous catalog render's persisted appearance snapshot
- * (`StructuralAppearance.rendered` — element ids + per-element colors) into the
- * `previous_render` AppearanceReference the next render diffs against. The
- * no-Figma drift path: the colors/ids the next render compares itself to are the
- * LAST render's, so a diverging fill surfaces as a regression (drift), marked
- * `baseline: 'previous_render'`, distinct from a design divergence.
- *
- * Pure (no I/O) — the testable core the thin catalog-fetch adapter wraps,
- * mirroring how the geometry baseline reuses the previous render's persisted
- * `geometry`. `color` is carried only when the previous render exposed colors;
- * a previous render with no extractable color yields a presence-only reference
- * (element ids, no color). A genuinely absent previous render (no snapshot) →
- * null, so the next render carries no appearance container, exactly as before.
- * `color` (issue 01/02) and `text` (issue 03) are each carried only when the
- * previous render exposed them; an empty map is no signal on that axis.
- */
-export function appearanceReferenceFromPreviousRender(previous) {
-    if (!previous || !Array.isArray(previous.elementIds))
-        return null;
-    const reference = {
-        baseline: 'previous_render',
-        elementIds: [...previous.elementIds],
-    };
-    if (previous.color && Object.keys(previous.color).length > 0) {
-        reference.color = previous.color;
-    }
-    if (previous.text && Object.keys(previous.text).length > 0) {
-        reference.text = previous.text;
-    }
-    // The previous render's RESOLVED typeface (typeface issue 05): the drift
-    // reference that catches a previously-correct element silently falling back
-    // on a later build. Design (Figma-supplied) typeface stays authoritative when
-    // present — this is the secondary signal.
-    if (previous.typeface && Object.keys(previous.typeface).length > 0) {
-        reference.typeface = previous.typeface;
-    }
-    return reference;
-}
-/**
- * Element-presence facts from the set difference of the rendered element-id set
- * and the reference element-id set, keyed on the stable element id shared with
- * Signal B. An id present in the reference but not rendered is `element_missing`;
- * an id rendered but not in the reference is `element_extra`.
- *
- * Pure and platform-agnostic: it takes two id collections and is order-
- * independent — the result depends only on the two SETS, not on input order or
- * duplicates. Output is sorted (missing before extra, each by id) so callers get
- * a deterministic list. The deriver reports facts only; significance is a later,
- * separately-wired concern.
- */
-export function derivePresenceFacts(renderedIds, referenceIds) {
-    const rendered = new Set(renderedIds);
-    const reference = new Set(referenceIds);
-    const facts = [];
-    for (const elementId of [...reference].filter((id) => !rendered.has(id)).sort()) {
-        facts.push({ kind: 'element_missing', elementId });
-    }
-    for (const elementId of [...rendered].filter((id) => !reference.has(id)).sort()) {
-        facts.push({ kind: 'element_extra', elementId });
-    }
-    return facts;
-}
-/** True when a text value carries an actual signal (a non-empty string). */
-function hasText(value) {
-    return typeof value === 'string' && value.length > 0;
-}
-/**
- * Copy/text facts from the per-element comparison of rendered text vs reference
- * text, keyed on the stable element id shared with Signal B. For each element the
- * REFERENCE declares text for: identical text → no fact; a different rendered
- * string → `text_mismatch` (both strings attached); empty/absent rendered text →
- * `text_missing`. An element with no reference text signal produces no fact —
- * absence of a signal is never reported as a divergence, so a rendered string the
- * reference never declared is silent.
- *
- * Pure and platform-agnostic; order-independent and deterministic (output sorted
- * by element id). The deriver reports facts only; significance is a later,
- * separately-wired concern.
- */
-export function deriveCopyFacts(rendered, reference) {
-    const facts = [];
-    for (const elementId of Object.keys(reference).sort()) {
-        const referenceText = reference[elementId];
-        if (!hasText(referenceText))
-            continue; // no reference signal → no fact
-        const renderedText = rendered[elementId];
-        if (!hasText(renderedText)) {
-            facts.push({ kind: 'text_missing', elementId, reference: referenceText });
-        }
-        else if (renderedText !== referenceText) {
-            facts.push({ kind: 'text_mismatch', elementId, rendered: renderedText, reference: referenceText });
-        }
-    }
-    return facts;
-}
-/**
- * Span facts (issue 16 + color spans) from the per-element comparison of
- * rendered styled extents vs the declared reference span, keyed on the stable
- * element id. Channel-scoped: a `background` declaration (highlight chip)
- * compares against background-carrying rendered spans; a `color` declaration
- * (partial foreground emphasis) against color-carrying ones — a color-only
- * rendered span never satisfies a chip declaration. A channel-less
- * declaration ({text} only) keeps its legacy semantics (any extent matches).
- *
- * Capability gate: the COLOR channel compares only when `colorCapable` is
- * true (the dump's `spanChannels` marker includes "color") — an old
- * emitter's silence is "cannot see", never "no color span rendered". Within
- * a capable dump, an ABSENT `textSpans` is a real absence for a color
- * declaration (the segment rendered unstyled); background/legacy
- * declarations keep the old-package tolerance (no spans array → no fact).
- * A wrong extent on either channel is one `span_mismatch`; a matching extent
- * whose color diverges is a `span_color_mismatch` carrying both hex values.
- *
- * Pure and platform-agnostic; order-independent and deterministic (output
- * sorted by element id). The deriver reports facts only; significance is a
- * later, separately-wired concern.
- */
-export function deriveSpanFacts(rendered, reference, colorCapable) {
-    const facts = [];
-    for (const elementId of Object.keys(reference).sort()) {
-        const declared = reference[elementId];
-        const declaredText = declared && typeof declared === 'object' ? declared.text : undefined;
-        if (!declared || !hasText(declaredText))
-            continue; // no reference signal → no fact
-        const spans = rendered[elementId];
-        const all = Array.isArray(spans) ? spans : null;
-        const wantsBackground = hasText(declared.background);
-        const wantsColor = hasText(declared.color) && colorCapable === true;
-        let extentOk = true;
-        const scopedExtents = [];
-        // Background / channel-less half.
-        if (wantsBackground || !hasText(declared.color)) {
-            if (all === null) {
-                // Node emitted no spans: old package / spanless text — blind on this
-                // half. Only a capable color declaration can still speak below.
-                if (!wantsColor)
-                    continue;
-            }
-            else {
-                const pool = wantsBackground ? all.filter((s) => hasText(s?.background)) : all;
-                const extents = pool.map((s) => s?.text).filter(hasText);
-                scopedExtents.push(...extents);
-                if (!extents.some((t) => t === declaredText))
-                    extentOk = false;
-            }
-        }
-        // Color half (capability-gated above).
-        let renderedColorForExtent = null;
-        if (wantsColor) {
-            const pool = (all ?? []).filter((s) => hasText(s?.color));
-            scopedExtents.push(...pool.map((s) => s?.text).filter(hasText));
-            const matches = pool.filter((s) => s?.text === declaredText);
-            if (matches.length === 0) {
-                extentOk = false;
-            }
-            else {
-                const declaredColor = String(declared.color).toLowerCase();
-                const hit = matches.some((s) => String(s.color).toLowerCase() === declaredColor);
-                if (!hit)
-                    renderedColorForExtent = String(matches[0].color).toLowerCase();
-            }
-        }
-        if (!extentOk) {
-            facts.push({
-                kind: 'span_mismatch',
-                elementId,
-                rendered: [...new Set(scopedExtents)].join(', '),
-                reference: declaredText,
-            });
-            continue;
-        }
-        if (renderedColorForExtent !== null) {
-            facts.push({
-                kind: 'span_color_mismatch',
-                elementId,
-                extent: declaredText,
-                rendered: renderedColorForExtent,
-                reference: String(declared.color).toLowerCase(),
-            });
-        }
-    }
-    return facts;
-}
-/**
- * Line facts (issue 18) from the per-element comparison of the rendered
- * laid-out lines vs the declared reference split, keyed on the stable element
- * id. For each element the REFERENCE declares a split for: rendered line
- * texts equal to the declared line texts (same count, same order) → no fact;
- * anything else — the break on a different word, a dropped break (fewer
- * lines), an extra break — is ONE `line_break_mismatch` carrying both splits
- * newline-joined. An element whose node emitted NO lines produces no fact —
- * old committed packages don't emit `textLines`, and absence of a signal is
- * never reported as a divergence (regenerating the package picks it up).
- *
- * Pure and platform-agnostic; order-independent and deterministic (output
- * sorted by element id). The deriver reports facts only; significance is a
- * later, separately-wired concern.
- */
-export function deriveLineFacts(rendered, reference) {
-    const facts = [];
-    for (const elementId of Object.keys(reference).sort()) {
-        const declared = reference[elementId];
-        if (!Array.isArray(declared))
-            continue;
-        const declaredLines = declared.filter(hasText);
-        if (declaredLines.length === 0)
-            continue; // no reference signal → no fact
-        const lines = rendered[elementId];
-        if (!Array.isArray(lines))
-            continue; // node emitted no lines → no signal
-        const renderedLines = lines.map((l) => l.text).filter(hasText);
-        if (renderedLines.length === declaredLines.length &&
-            renderedLines.every((t, i) => t === declaredLines[i])) {
-            continue;
-        }
-        facts.push({
-            kind: 'line_break_mismatch',
-            elementId,
-            rendered: renderedLines.join('\n'),
-            reference: declaredLines.join('\n'),
-        });
-    }
-    return facts;
-}
-const COLOR_CHANNELS = ['fill', 'text'];
-/** Parse a #rrggbb / rrggbb hex string into 0–255 channels (case-insensitive). */
-function parseHex(hex) {
-    const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim());
-    if (!m)
-        return null;
-    const n = parseInt(m[1], 16);
-    return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
-}
-/** One sRGB channel (0–1) → linear-light. */
-function srgbToLinear(c) {
-    return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
-}
-/** The CIELAB f() companding function. */
-function labF(t) {
-    return t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
-}
-// D65 reference white (CIE 1931 2°), scaled to Y=100.
-const D65 = [95.047, 100.0, 108.883];
-/**
- * Convert an sRGB hex string to CIELAB (D65). White → ~[100,0,0], black → L 0.
- * Returns [0,0,0] for an unparseable string so a malformed color never throws
- * (the deriver guards on signal presence separately).
- */
-export function hexToLab(hex) {
-    const rgb = parseHex(hex);
-    if (!rgb)
-        return [0, 0, 0];
-    const [r, g, b] = rgb.map((v) => srgbToLinear(v / 255));
-    // linear sRGB → XYZ (D65), scaled to 0–100
-    const X = (r * 0.4124564 + g * 0.3575761 + b * 0.1804375) * 100;
-    const Y = (r * 0.2126729 + g * 0.7151522 + b * 0.072175) * 100;
-    const Z = (r * 0.0193339 + g * 0.119192 + b * 0.9503041) * 100;
-    const fx = labF(X / D65[0]);
-    const fy = labF(Y / D65[1]);
-    const fz = labF(Z / D65[2]);
-    return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
-}
-const deg2rad = (d) => (d * Math.PI) / 180;
-const rad2deg = (r) => (r * 180) / Math.PI;
-/**
- * CIEDE2000 colour-difference ΔE00 between two CIELAB colours (kL=kC=kH=1).
- * Implements Sharma, Wu & Dalal (2005); validated against their supplementary
- * test data. Pure and symmetric; identical colours give 0.
- */
-export function ciede2000(lab1, lab2) {
-    const [L1, a1, b1] = lab1;
-    const [L2, a2, b2] = lab2;
-    const C1 = Math.sqrt(a1 * a1 + b1 * b1);
-    const C2 = Math.sqrt(a2 * a2 + b2 * b2);
-    const Cbar = (C1 + C2) / 2;
-    const Cbar7 = Math.pow(Cbar, 7);
-    const G = 0.5 * (1 - Math.sqrt(Cbar7 / (Cbar7 + 6103515625))); // 25^7 = 6103515625
-    const a1p = (1 + G) * a1;
-    const a2p = (1 + G) * a2;
-    const C1p = Math.sqrt(a1p * a1p + b1 * b1);
-    const C2p = Math.sqrt(a2p * a2p + b2 * b2);
-    const h1p = hueDeg(b1, a1p);
-    const h2p = hueDeg(b2, a2p);
-    const dLp = L2 - L1;
-    const dCp = C2p - C1p;
-    let dhp = 0;
-    if (C1p * C2p !== 0) {
-        dhp = h2p - h1p;
-        if (dhp > 180)
-            dhp -= 360;
-        else if (dhp < -180)
-            dhp += 360;
-    }
-    const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(deg2rad(dhp / 2));
-    const Lbarp = (L1 + L2) / 2;
-    const Cbarp = (C1p + C2p) / 2;
-    let hbarp;
-    if (C1p * C2p === 0) {
-        hbarp = h1p + h2p;
-    }
-    else if (Math.abs(h1p - h2p) > 180) {
-        hbarp = h1p + h2p < 360 ? (h1p + h2p + 360) / 2 : (h1p + h2p - 360) / 2;
-    }
-    else {
-        hbarp = (h1p + h2p) / 2;
-    }
-    const T = 1 -
-        0.17 * Math.cos(deg2rad(hbarp - 30)) +
-        0.24 * Math.cos(deg2rad(2 * hbarp)) +
-        0.32 * Math.cos(deg2rad(3 * hbarp + 6)) -
-        0.2 * Math.cos(deg2rad(4 * hbarp - 63));
-    const dTheta = 30 * Math.exp(-(((hbarp - 275) / 25) ** 2));
-    const Cbarp7 = Math.pow(Cbarp, 7);
-    const Rc = 2 * Math.sqrt(Cbarp7 / (Cbarp7 + 6103515625));
-    const Sl = 1 + (0.015 * (Lbarp - 50) ** 2) / Math.sqrt(20 + (Lbarp - 50) ** 2);
-    const Sc = 1 + 0.045 * Cbarp;
-    const Sh = 1 + 0.015 * Cbarp * T;
-    const Rt = -Math.sin(deg2rad(2 * dTheta)) * Rc;
-    const termL = dLp / Sl;
-    const termC = dCp / Sc;
-    const termH = dHp / Sh;
-    return Math.sqrt(termL * termL + termC * termC + termH * termH + Rt * termC * termH);
-}
-/** atan2(b, a) in degrees, normalised to [0, 360). */
-function hueDeg(b, a) {
-    if (a === 0 && b === 0)
-        return 0;
-    const deg = rad2deg(Math.atan2(b, a));
-    return deg >= 0 ? deg : deg + 360;
-}
-/**
- * Border facts (property-recognizer 01) — the design's `stroke` against the
- * render's captured border. THE case this exists for: an 18dp badge with a 4dp
- * white ring inside it rendered as a plain green blob, about which the gate said
- * nothing at all, because the design's stroke lived in an authoring hint and the
- * dump captured no border. Nothing compared, so an unmeasured property read as a
- * pass.
- *
- * The DESIGN is the only side that raises the question, exactly as with alpha: an
- * entry with no declared `stroke` is skipped, so a wrapper adding a ring the
- * design never asked for is not something this calls wrong.
- *
- * Three kinds, because they are three different fixes — absent / wrong colour /
- * wrong thickness. Folding width into `border` would report "the ring is the
- * wrong colour" about a ring whose colour is exactly right.
- *
- * `capable` gates the ABSENCE case only, and both directions of that gate are
- * wrong in a way worth naming: without it, a border-blind dump would fire
- * `border_missing` on every stroked design in the catalogue; with it applied too
- * broadly, a real divergence on a capable dump would go unreported. A colour or
- * width difference is a genuine measurement either way — only "I saw no border"
- * depends on being able to see borders at all.
- *
- * Pure and platform-agnostic; deterministic (sorted by element id). Mirrors the
- * CLI preview twin in `packages/cli/lib/fidelity-structural.mjs`.
- */
-export function deriveBorderFacts(rendered, reference, capable) {
-    const facts = [];
-    for (const elementId of Object.keys(reference).sort()) {
-        const ref = reference[elementId];
-        if (!ref || !hasText(ref.stroke))
-            continue;
-        const ren = rendered[elementId];
-        const renderedStroke = ren ? ren.stroke : undefined;
-        if (!hasText(renderedStroke)) {
-            if (capable) {
-                const width = ref.strokeWeight;
-                facts.push({
-                    kind: 'border_missing',
-                    elementId,
-                    reference: ref.stroke,
-                    ...(typeof width === 'number' ? { referenceWidth: width } : {}),
-                });
-            }
-            continue;
-        }
-        if (renderedStroke.toLowerCase() !== ref.stroke.toLowerCase()) {
-            facts.push({
-                kind: 'border',
-                elementId,
-                rendered: renderedStroke,
-                reference: ref.stroke,
-            });
-        }
-        // Width only when the DESIGN states one — an undeclared weight says nothing
-        // about thickness, the same asymmetry alpha uses. 0.5dp is the floor below
-        // which two rings are the same ring.
-        const refW = ref.strokeWeight;
-        const renW = ren ? ren.strokeWeight : undefined;
-        if (typeof refW === 'number' && typeof renW === 'number' && Math.abs(refW - renW) > 0.5) {
-            facts.push({ kind: 'border_width', elementId, rendered: renW, reference: refW });
-        }
-    }
-    return facts;
-}
-/**
- * Color facts from the per-element, per-channel comparison of rendered vs
- * reference color, keyed on the stable element id shared with Signal B. For each
- * element/channel the REFERENCE declares a color for and the render also exposes
- * one: identical color → no fact; any divergence → a `color` fact carrying the
- * channel (fill vs text), both hex values, and the CIEDE2000 ΔE as the metric.
- * Fill and text are distinct channels, so a correct background with a wrong text
- * color and the reverse are separate facts, never collapsed. A missing rendered
- * or reference color for a channel is no signal → no fact.
- *
- * Pure and platform-agnostic; order-independent and deterministic (output sorted
- * by element id then channel, fill before text). Measurement only — significance
- * is a later, separately-wired concern.
- */
-export function deriveColorFacts(rendered, reference) {
-    const facts = [];
-    for (const elementId of Object.keys(reference).sort()) {
-        const refColors = reference[elementId];
-        const renColors = rendered[elementId];
-        if (!refColors)
-            continue;
-        for (const channel of COLOR_CHANNELS) {
-            const referenceColor = refColors[channel];
-            const renderedColor = renColors ? renColors[channel] : undefined;
-            if (!hasText(referenceColor) || !hasText(renderedColor))
-                continue; // no signal
-            // Opacity (issue 14b): graded only when the DESIGN states a translucency —
-            // an opaque design says nothing about alpha, so a render reporting one is not
-            // a divergence — and only past a rounding step. Independent of the hex
-            // compare: the colour can be right while the state (disabled vs enabled) is
-            // wrong, and a matching hex gives ΔE 0, which would never flag.
-            const referenceAlpha = refColors[`${channel}Alpha`];
-            const renderedAlpha = renColors ? renColors[`${channel}Alpha`] : undefined;
-            if (typeof referenceAlpha === 'number') {
-                const renA = typeof renderedAlpha === 'number' ? renderedAlpha : 1;
-                if (Math.abs(referenceAlpha - renA) > 0.01) {
-                    facts.push({ kind: 'color_alpha', elementId, channel, rendered: renA, reference: referenceAlpha });
-                }
-            }
-            if (renderedColor.toLowerCase() === referenceColor.toLowerCase())
-                continue; // matching
-            facts.push({
-                kind: 'color',
-                elementId,
-                channel,
-                rendered: renderedColor,
-                reference: referenceColor,
-                deltaE: ciede2000(hexToLab(renderedColor), hexToLab(referenceColor)),
-            });
-        }
-    }
-    return facts;
-}
-/** Map a weight-name token (regular, semibold, …) to its OpenType numeric weight. */
-const WEIGHT_NAMES = {
-    thin: 100,
-    hairline: 100,
-    extralight: 200,
-    ultralight: 200,
-    light: 300,
-    normal: 400,
-    regular: 400,
-    book: 400,
-    medium: 500,
-    semibold: 600,
-    demibold: 600,
-    bold: 700,
-    extrabold: 800,
-    ultrabold: 800,
-    black: 900,
-    heavy: 900,
-};
-/** The canonical comparison form of a typeface: a normalized family key and an
- *  effective numeric weight. A weight-name suffix on the family ("Poppins
- *  SemiBold", "fira_sans_medium") is stripped from the family and, when no explicit
- *  numeric weight is supplied, becomes the weight. An explicit numeric `weight`
- *  always wins (it is the measured resolved value). Returns null when there is no
- *  family signal (no font to compare). */
-function normalizeTypeface(spec) {
-    const raw = typeof spec?.family === 'string' ? spec.family.trim() : '';
-    if (raw.length === 0)
-        return null;
-    // Split into tokens on separators (hyphen, underscore, space) — the boundaries
-    // every real encoding uses between family and a weight suffix: PostScript names
-    // ("Poppins-SemiBold"), resource names ("fira_sans_medium"), and design specs
-    // ("Fira Sans" + numeric weight). The family key collapses to alphanumerics
-    // below, so a multi-token family ("Fira Sans") still matches a glued one.
-    const tokens = raw.split(/[\s\-_]+/).filter((t) => t.length > 0);
-    let derivedWeight;
-    // Strip recognized weight-name tokens off the END of the family (a leading
-    // weight token is part of the family identity, e.g. "Black Ops One").
-    while (tokens.length > 1) {
-        const candidate = tokens[tokens.length - 1].toLowerCase();
-        if (candidate in WEIGHT_NAMES) {
-            derivedWeight = WEIGHT_NAMES[candidate];
-            tokens.pop();
-        }
-        else {
-            break;
-        }
-    }
-    const family = tokens.join('').toLowerCase().replace(/[^a-z0-9]/g, '');
-    const explicit = typeof spec?.weight === 'number' && Number.isFinite(spec.weight) ? spec.weight : undefined;
-    const weight = explicit ?? derivedWeight ?? 400;
-    return { family, weight };
-}
-/**
- * Typeface facts from the per-element comparison of the RESOLVED render font vs the
- * DESIGN reference font, keyed on the stable element id shared with Signal B. For
- * each element the reference declares a typeface for and the render also resolved
- * one: normalize both (family-name + weight-encoding) and emit a `typeface` fact
- * when the normalized family OR weight differs. A normalization-equivalent pair
- * ("Poppins-SemiBold" vs "Poppins" + 600) yields no fact. A missing rendered or
- * reference font for an element is no signal → no fact (graceful, no false
- * positive). The fact carries the raw `rendered`/`reference` specs as given, so the
- * finding names the actual fonts.
- *
- * Pure and platform-agnostic; order-independent and deterministic (output sorted by
- * element id). Measurement only — significance is a later, separately-wired concern.
- */
-export function deriveTypefaceFacts(rendered, reference) {
-    const facts = [];
-    for (const elementId of Object.keys(reference).sort()) {
-        const refNorm = normalizeTypeface(reference[elementId]);
-        const renNorm = normalizeTypeface(rendered[elementId]);
-        if (!refNorm || !renNorm)
-            continue; // no signal on one side → no fact
-        if (refNorm.family === renNorm.family && refNorm.weight === renNorm.weight)
-            continue; // equivalent
-        facts.push({
-            kind: 'typeface',
-            elementId,
-            channel: 'text',
-            rendered: rendered[elementId],
-            reference: reference[elementId],
-        });
-    }
-    return facts;
-}
-/**
- * Sub-unit tolerance for a type metric, in sp.
- *
- * Design tools and layout engines disagree in the last fraction of a point: a
- * design exported at 15.999 against a style declaring 16 is the same type, and a
- * fact for it would flap on every render forever. The band is deliberately well
- * under the smallest difference anyone authors — no design system steps type by
- * a tenth of a point — so it absorbs representation noise without absorbing a
- * real divergence. The MEASUREMENT it guards is exact; this only decides whether
- * there is anything to report (ADR-0004: strict, not loosen).
- */
-const TYPE_METRIC_TOLERANCE_SP = 0.25;
-/** A finite number, or undefined — the only values a metric may compare on. A
- *  NaN/Infinity that reached the dump is no measurement, not a zero. */
-function finiteMetric(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-/**
- * Type-metric facts from the per-element comparison of the LAID-OUT metrics
- * against the design's, keyed on the stable element id shared with Signal B.
- *
- * For each element the reference declares and the render measured, each of the
- * three metrics is compared independently and emits its own fact when the two
- * differ by more than the sub-unit tolerance. A metric missing on EITHER side is
- * no signal and yields no fact — a design that declares no tracking is not
- * asserting zero, and a style that leaves leading Unspecified has not chosen a
- * value to be wrong about.
- *
- * Pure and platform-agnostic; deterministic (sorted by element id, then by the
- * metric order a finding reads them in). Measurement only — significance and
- * wording live downstream.
- */
-export function deriveTypeMetricFacts(rendered, reference) {
-    const facts = [];
-    for (const elementId of Object.keys(reference).sort()) {
-        const ref = reference[elementId];
-        const ren = rendered[elementId];
-        if (!ref || !ren)
-            continue;
-        for (const metric of TYPE_METRIC_KEYS) {
-            const referenceValue = finiteMetric(ref[metric]);
-            const renderedValue = finiteMetric(ren[metric]);
-            if (referenceValue === undefined || renderedValue === undefined)
-                continue;
-            if (Math.abs(renderedValue - referenceValue) <= TYPE_METRIC_TOLERANCE_SP)
-                continue;
-            facts.push({
-                kind: 'type_metric',
-                elementId,
-                channel: 'text',
-                metric,
-                rendered: renderedValue,
-                reference: referenceValue,
-            });
-        }
-    }
-    return facts;
-}
-const DEFAULT_SIZE_TOLERANCE_DP = 1;
-/** Per-edge overhang (clip) delta tolerance, dp. Logged-in Δ9 flags, guest Δ2 passes. */
-const DEFAULT_OVERHANG_TOLERANCE_DP = 2;
-// ---- Text-aware size band (line-box residue) ----
-//
-// JVM (Robolectric) text metrics differ from Figma's nominal line boxes by
-// roughly ±2dp per laid-out line, so a text-driven element legitimately renders
-// a few dp off its design size. The SIGNIFICANCE flag (`sizeFlag`) gets a band
-// scaled by the element's subtree line count — the MEASUREMENT (deltas) stays
-// exact, and non-text elements keep the strict band (ADR-0004: strict, not
-// loosen). Calibrated on the logged noise cases: a 1-line pill gets ±4dp
-// (covers +4/−3), a 3-line card ±8dp (covers −7); the cap keeps the ≥15dp
-// fixed-size bug class (e.g. 328 vs 343) failing no matter how tall the stack.
-/** Per laid-out text line of JVM font-metric residue (dp). */
-const TEXT_LINE_RESIDUE_DP = 2;
-/** Box rounding on a text-driven element (dp), on top of the per-line residue. */
-const TEXT_BOX_RESIDUE_DP = 2;
-/** Ceiling for the text-driven size band (dp). */
-const TEXT_SIZE_SLACK_MAX_DP = 8;
-/** Laid-out lines one node contributes: the `textLines` count when the emitter
- *  tracked them, else 1 for a text-carrying node (old packages), else 0. */
-function nodeTextLines(node) {
-    if (Array.isArray(node.textLines))
-        return node.textLines.length;
-    return typeof node.text === 'string' && node.text.length > 0 ? 1 : 0;
-}
-/**
- * Total laid-out text lines in `elementId`'s subtree (the element node plus
- * every descendant). 0 = the element renders no text — not text-driven.
- * Visits node OBJECTS (never re-follows one), so a malformed parent cycle or
- * a duplicated id cannot loop.
- */
-function subtreeTextLineCount(elementId, byId, childrenByParent) {
-    const root = byId.get(elementId);
-    if (!root)
-        return 0;
-    let lines = 0;
-    const visited = new Set();
-    const stack = [root];
-    while (stack.length > 0) {
-        const node = stack.pop();
-        if (visited.has(node))
-            continue;
-        visited.add(node);
-        lines += nodeTextLines(node);
-        for (const child of childrenByParent.get(node.id) ?? [])
-            stack.push(child);
-    }
-    return lines;
-}
-/**
- * One element's render ancestry: every ancestor id from its IMMEDIATE parent up
- * to the root (icon-ink-ratio 05). Empty for a root node.
- *
- * Ids, not nodes, because the judge compares them against DESIGN keys — a render
- * parent is usually an untagged layout node whose id is a Compose number, and it
- * gets identified by the declared elements inside it rather than by its name.
- *
- * Guards against a parent cycle the same way `subtreeTextLineCount` does: a
- * malformed dump must not hang a build.
- */
-function ancestorChain(elementId, byId) {
-    const out = [];
-    const seen = new Set([elementId]);
-    let cursor = byId.get(elementId)?.parentId ?? null;
-    while (cursor != null && !seen.has(cursor)) {
-        seen.add(cursor);
-        out.push(cursor);
-        cursor = byId.get(cursor)?.parentId ?? null;
-    }
-    return out;
-}
-/** The size band for one element: the line-scaled text band when its subtree
- *  lays out text (never stricter than the caller's tolerance), else strict. */
-function sizeBandDp(subtreeLines, sizeTolerancePx) {
-    if (subtreeLines <= 0)
-        return sizeTolerancePx;
-    return Math.max(sizeTolerancePx, Math.min(TEXT_SIZE_SLACK_MAX_DP, TEXT_BOX_RESIDUE_DP + TEXT_LINE_RESIDUE_DP * subtreeLines));
-}
-/** An element only "overflows" a frame when its rendered overhang exceeds this, dp. */
-const OVERHANG_MIN_DP = 0.5;
-const OVERHANG_EDGES = ['left', 'top', 'right', 'bottom'];
-const DIMENSION_SHORT = {
-    width: 'w',
-    height: 'h',
-    x: 'x',
-    y: 'y',
-};
-const numOrNaN = (v) => (typeof v === 'number' ? v : NaN);
-/**
- * Per-edge overhang of one element vs its frame (the element's parent in the
- * layout dump). Returns null when the element is fully contained (no edge
- * overflows), the frame is absent from the render, or the frame isn't declared in
- * `referenceGeometry` (so the design overhang can't be computed — an advisory
- * covers that case). Frame-relative edge overhang is the real clip and IS flagged;
- * absolute canvas x/y stays suppressed elsewhere (canvas-width artifact).
- */
-/** The size axis a clip edge bears on: top/bottom → height, left/right → width. */
-function edgeAxis(edge) {
-    return edge === 'top' || edge === 'bottom' ? 'height' : 'width';
-}
-function computeOverhang(elementId, elementDp, byId, generated, referenceGeometry, overhangTolerancePx, sizeTolerancePx, duplicates) {
-    const node = byId.get(elementId);
-    const frameId = node?.parentId;
-    if (!frameId)
-        return undefined;
-    // A duplicated frame tag resolves last-wins in `generated`/`byId`, so the
-    // overhang would measure against an arbitrary instance — withheld (the
-    // duplicate_tag fact carries the collision).
-    if (duplicates?.has(frameId))
-        return undefined;
-    const frameDp = generated[frameId];
-    if (!frameDp)
-        return undefined;
-    const frameRef = referenceGeometry[frameId];
-    const elRef = referenceGeometry[elementId];
-    if (!frameRef || !elRef)
-        return undefined; // frame undeclared → advisory, not error
-    const elX = elementDp.x ?? NaN;
-    const elY = elementDp.y ?? NaN;
-    const fX = frameDp.x ?? NaN;
-    const fY = frameDp.y ?? NaN;
-    // Rendered AND design overhang per edge (dp); positive = element extends past
-    // the frame. Both sides are compared so a clip the design requires but the
-    // render omits (a MISSING clip — render contained/tangent) surfaces too.
-    const renderedRaw = {
-        left: fX - elX,
-        top: fY - elY,
-        right: elX + elementDp.width - (fX + frameDp.width),
-        bottom: elY + elementDp.height - (fY + frameDp.height),
-    };
-    const designRaw = {
-        left: numOrNaN(frameRef.x) - numOrNaN(elRef.x),
-        top: numOrNaN(frameRef.y) - numOrNaN(elRef.y),
-        right: numOrNaN(elRef.x) + numOrNaN(elRef.w) - (numOrNaN(frameRef.x) + numOrNaN(frameRef.w)),
-        bottom: numOrNaN(elRef.y) + numOrNaN(elRef.h) - (numOrNaN(frameRef.y) + numOrNaN(frameRef.h)),
-    };
-    // An edge is a candidate when EITHER side overflows it — so over-, under-,
-    // missing-, and spurious-clip all qualify (not just render-side overflow).
-    const candidates = OVERHANG_EDGES.filter((e) => renderedRaw[e] > OVERHANG_MIN_DP || designRaw[e] > OVERHANG_MIN_DP);
-    if (candidates.length === 0)
-        return undefined; // neither side overflows — not a clip element
-    const rendered = {};
-    const design = {};
-    const deltas = [];
-    for (const edge of candidates) {
-        const dRaw = designRaw[edge];
-        if (!Number.isFinite(dRaw))
-            continue; // design coords missing for this edge
-        rendered[edge] = Math.round(renderedRaw[edge]);
-        design[edge] = dRaw;
-        const delta = renderedRaw[edge] - dRaw;
-        if (Math.abs(delta) > overhangTolerancePx)
-            deltas.push({ edge, delta: Math.round(delta) });
-    }
-    if (Object.keys(rendered).length === 0)
-        return undefined;
-    // Why is the clip wrong? Trace each flagged edge to the element's OWN size: a
-    // clip is `sizeDriven` when the element's rendered size on that axis differs
-    // from its design size, and `frameRelative` when that wrong size also matches
-    // the frame's rendered size (while the design sizes differ) — the
-    // fillMaxHeight/matchParentSize signature whose fix is a fixed size, not a
-    // re-tuned clip. This is the diagnosis the judge must not wave off as "intended".
-    const elSize = { width: elementDp.width, height: elementDp.height };
-    const frameSize = { width: frameDp.width, height: frameDp.height };
-    const elDesign = { width: numOrNaN(elRef.w), height: numOrNaN(elRef.h) };
-    const frameDesign = { width: numOrNaN(frameRef.w), height: numOrNaN(frameRef.h) };
-    // Frame-relative position per axis (NOT absolute x/y — that's the suppressed
-    // canvas artifact; this offset is what actually sets the clip).
-    const elRelPos = { width: elX - fX, height: elY - fY };
-    const elRelPosDesign = {
-        width: numOrNaN(elRef.x) - numOrNaN(frameRef.x),
-        height: numOrNaN(elRef.y) - numOrNaN(frameRef.y),
-    };
-    let sizeDriven = false;
-    let frameRelative = false;
-    let positionDriven = false;
-    for (const { edge } of deltas) {
-        const axis = edgeAxis(edge);
-        const elD = elDesign[axis];
-        if (Number.isFinite(elD) && Math.abs(elSize[axis] - elD) > sizeTolerancePx) {
-            sizeDriven = true;
-            const frameD = frameDesign[axis];
-            if (Math.abs(elSize[axis] - frameSize[axis]) <= sizeTolerancePx &&
-                Number.isFinite(frameD) &&
-                Math.abs(elD - frameD) > sizeTolerancePx) {
-                frameRelative = true;
-            }
-        }
-        const relD = elRelPosDesign[axis];
-        if (Number.isFinite(relD) && Math.abs(elRelPos[axis] - relD) > sizeTolerancePx) {
-            positionDriven = true;
-        }
-    }
-    return { unit: 'dp', rendered, design, deltas, clipFlag: deltas.length > 0, sizeDriven, frameRelative, positionDriven };
-}
-/** Auto-generated (untagged) node id, e.g. "node-11" — a `testTag` gives a real id. */
-const UNTAGGED_ID = /^node-\d+$/;
-/**
- * Node ids the derived facts name (`nodeId`/`nodeIds`/`clipperId`). A synthetic
- * node can participate in a judged finding (the deriver runs over ALL dump
- * nodes), and without its box the finding's scene is undrawable — the fact
- * already puts the synthetic name in the customer-facing text, so persisting
- * its box adds nothing new. Bounded by the fact count.
- */
-function factNamedNodeIds(facts) {
-    const ids = new Set();
-    for (const fact of facts) {
-        const f = fact;
-        if (typeof f.nodeId === 'string')
-            ids.add(f.nodeId);
-        if (typeof f.clipperId === 'string')
-            ids.add(f.clipperId);
-        if (Array.isArray(f.nodeIds)) {
-            for (const id of f.nodeIds)
-                if (typeof id === 'string')
-                    ids.add(id);
-        }
-    }
-    return ids;
-}
-/** Rendered geometry per node, normalised px → dp via density (unclipped extent). */
-function generatedGeometryDp(dump, density) {
-    const d = density > 0 ? density : 1;
-    const out = {};
-    for (const node of dump.nodes) {
-        const b = node.unclippedBounds ?? node.bounds;
-        if (!b)
-            continue;
-        out[node.id] = {
-            width: (b.right - b.left) / d,
-            height: (b.bottom - b.top) / d,
-            x: b.left / d,
-            y: b.top / d,
-        };
-    }
-    return out;
-}
-/**
- * The persisted precision of a rendered box: 2 decimals. The paint is sub-dp,
- * and quantizing the box to whole dp moved it up to half a dp off the pixels
- * it describes — visibly mis-wrapped once evidence is magnified. Comparison
- * semantics do not move: deltas are computed from raw values and persisted
- * integer-rounded, the flag bands read raw deltas, and the judge rounds
- * rendered boxes back to whole dp on read.
- */
-function roundMeasure(value) {
-    return Number(value.toFixed(2));
-}
-function referenceGeometryToDiffShape(referenceGeometry) {
-    const out = {};
-    for (const id of Object.keys(referenceGeometry)) {
-        const g = referenceGeometry[id];
-        if (!g || typeof g !== 'object')
-            continue;
-        const r = { width: NaN, height: NaN };
-        if (typeof g.w === 'number')
-            r.width = g.w;
-        if (typeof g.h === 'number')
-            r.height = g.h;
-        if (typeof g.x === 'number')
-            r.x = g.x;
-        if (typeof g.y === 'number')
-            r.y = g.y;
-        out[id] = r;
-    }
-    return out;
-}
-/**
- * Assemble the inline `structural` block (ADR-0004): Signal-A facts always, plus
- * the Signal-B geometry block when `referenceGeometry` is supplied. Size (w/h)
- * deltas drive `sizeFlag`/`summary.clean`; x/y position deltas are reported but
- * never flagged (canvas-width artifact). Mirrors Invarn's `buildStructuralBlock`.
- */
-export function buildStructuralBlock(dump, referenceGeometry, density, options = {}, appearanceReference, referenceFrame, anchorFrame) {
-    const facts = deriveStructuralFacts(dump);
-    const d = typeof density === 'number' && density > 0 ? density : 1;
-    const sizeTolerancePx = options.sizeTolerancePx ?? DEFAULT_SIZE_TOLERANCE_DP;
-    const overhangTolerancePx = options.overhangTolerancePx ?? DEFAULT_OVERHANG_TOLERANCE_DP;
-    // Design-frame anchor (composition runs): assert the captured root against
-    // the declared frame. A mismatch is an authoring fact about the WRAPPER
-    // (mis-sized root) and withholds placement facts for the State — measured
-    // against a wrong canvas they would be garbage, not drift.
-    let placement;
-    if (referenceFrame &&
-        typeof referenceFrame.w === 'number' &&
-        typeof referenceFrame.h === 'number') {
-        const capturedW = (dump.canvas.right - dump.canvas.left) / d;
-        const capturedH = (dump.canvas.bottom - dump.canvas.top) / d;
-        const frameDeltas = [];
-        if (Math.abs(capturedW - referenceFrame.w) > DEFAULT_FRAME_TOLERANCE_DP) {
-            frameDeltas.push({ dimension: 'w', delta: Math.round(capturedW - referenceFrame.w) });
-        }
-        if (Math.abs(capturedH - referenceFrame.h) > DEFAULT_FRAME_TOLERANCE_DP) {
-            frameDeltas.push({ dimension: 'h', delta: Math.round(capturedH - referenceFrame.h) });
-        }
-        if (frameDeltas.length > 0) {
-            facts.push({
-                kind: 'frame_mismatch',
-                declared: { w: referenceFrame.w, h: referenceFrame.h },
-                captured: { w: Math.round(capturedW), h: Math.round(capturedH) },
-                deltas: frameDeltas,
-            });
-            placement = { withheld: true, reason: 'frame_mismatch' };
-        }
-        else {
-            placement = { withheld: false };
-        }
-    }
-    // Frame-anchored component runs (coverage-gaps issue 01): no composition
-    // frame was asserted, but the design frame arrives as an ANCHOR PROBE. When
-    // the captured root MATCHES it within the frame tolerance, ADR-0004's
-    // canvas-width-artifact rationale for advisory x/y provably does not apply —
-    // the render is at design scale — so the run earns the same placement check
-    // a composition run gets (x/y flags via placement facts, zero new shapes).
-    // A root that does not match stays exactly as before: no fact, no placement
-    // container, x/y advisory — the probe must never start an invalidation
-    // storm for legacy content-sized wrappers.
-    if (!placement &&
-        anchorFrame &&
-        typeof anchorFrame.w === 'number' &&
-        typeof anchorFrame.h === 'number') {
-        const capturedW = (dump.canvas.right - dump.canvas.left) / d;
-        const capturedH = (dump.canvas.bottom - dump.canvas.top) / d;
-        if (Math.abs(capturedW - anchorFrame.w) <= DEFAULT_FRAME_TOLERANCE_DP &&
-            Math.abs(capturedH - anchorFrame.h) <= DEFAULT_FRAME_TOLERANCE_DP) {
-            placement = { withheld: false };
-        }
-    }
-    let geometry;
-    const duplicates = duplicatedNodeIds(dump.nodes);
-    const generated = generatedGeometryDp(dump, d);
-    if (referenceGeometry && Object.keys(referenceGeometry).length > 0) {
-        const ref = referenceGeometryToDiffShape(referenceGeometry);
-        const byId = new Map(dump.nodes.map((n) => [n.id, n]));
-        const childrenByParent = new Map();
-        for (const node of dump.nodes) {
-            if (!node.parentId)
-                continue;
-            const siblings = childrenByParent.get(node.parentId) ?? [];
-            siblings.push(node);
-            childrenByParent.set(node.parentId, siblings);
-        }
-        const deltasByElement = new Map(diffKeyGeometry(generated, ref, { tolerancePx: 0 }).map((g) => [g.elementId, g.deltas]));
-        const elements = [];
-        for (const id of Object.keys(ref)) {
-            // A duplicated tag's generated geometry is last-wins (an arbitrary
-            // instance) — its size/clip comparison is withheld; the deriver's
-            // duplicate_tag fact carries the collision.
-            if (duplicates.has(id))
-                continue;
-            const g = generated[id];
-            const r = ref[id];
-            if (!r)
-                continue;
-            if (!g) {
-                // Declared but absent from the render. Persist the design box alone —
-                // the same field, built the same way as the compared path below — so
-                // the absence keeps the design's record of WHERE instead of taking it
-                // down with the element.
-                const design = {
-                    w: Number.isNaN(r.width) ? undefined : r.width,
-                    h: Number.isNaN(r.height) ? undefined : r.height,
-                };
-                if (typeof r.x === 'number')
-                    design.x = r.x;
-                if (typeof r.y === 'number')
-                    design.y = r.y;
-                elements.push({ id, design });
-                continue;
-            }
-            const rawDeltas = deltasByElement.get(id) ?? [];
-            const deltas = [];
-            // Text-aware significance band (line-box residue): the deltas below stay
-            // exact; only the flag uses the band.
-            const band = sizeBandDp(subtreeTextLineCount(id, byId, childrenByParent), sizeTolerancePx);
-            let sizeFlag = false;
-            for (const { dimension, delta } of rawDeltas) {
-                const rounded = Math.round(delta);
-                if (rounded === 0)
-                    continue;
-                deltas.push({ dimension: DIMENSION_SHORT[dimension], delta: rounded });
-                if ((dimension === 'width' || dimension === 'height') && Math.abs(delta) > band) {
-                    sizeFlag = true;
-                }
-            }
-            const design = {
-                w: Number.isNaN(r.width) ? undefined : r.width,
-                h: Number.isNaN(r.height) ? undefined : r.height,
-            };
-            // x/y carry coordinates (not flags) so the stored render is a complete
-            // clip reference; design x/y only when the reference declared them.
-            if (typeof r.x === 'number')
-                design.x = r.x;
-            if (typeof r.y === 'number')
-                design.y = r.y;
-            const element = {
-                id,
-                rendered: { w: roundMeasure(g.width), h: roundMeasure(g.height), x: roundMeasure(g.x ?? 0), y: roundMeasure(g.y ?? 0) },
-                design,
-                deltas,
-                sizeFlag,
-            };
-            // Signal B v2: per-edge overhang (clip) for an element that overflows its
-            // declared frame. Separate from sizeFlag — an element can match size but
-            // mis-clip (the euro-coin case) or vice-versa.
-            const overhang = computeOverhang(id, g, byId, generated, referenceGeometry, overhangTolerancePx, sizeTolerancePx, duplicates);
-            if (overhang)
-                element.overhang = overhang;
-            // What the element PAINTS, verbatim from the dump: an icon's layout box is
-            // its container, and the reference's key is the glyph.
-            const paintedInk = byId.get(id)?.paintedInk;
-            if (paintedInk)
-                element.paintedInk = paintedInk;
-            // The render's ancestry (icon-ink-ratio 05). Always set when the node is in
-            // the dump, empty chain included: an absent field means "this render predates
-            // ancestry", which is what keeps the nesting check silent on old renders
-            // instead of guessing at a tree it cannot see.
-            if (byId.has(id))
-                element.ancestors = ancestorChain(id, byId);
-            elements.push(element);
-        }
-        geometry = { unit: 'dp', density: d, elements };
-        // Placement facts (composition runs, frame asserted OK): member-root x/y
-        // vs the declared design geometry, root-space dp — directly comparable
-        // because the root is frame-sized. Load-bearing here, unlike the advisory
-        // x/y deltas on geometry elements (the canvas-width artifact does not
-        // apply to a frame-sized surface render).
-        if (placement && !placement.withheld) {
-            const placementFacts = [];
-            for (const id of Object.keys(ref)) {
-                // Same last-wins ambiguity as geometry: a duplicated member tag's
-                // rendered position is an arbitrary instance's — withheld.
-                if (duplicates.has(id))
-                    continue;
-                const g = generated[id];
-                const r = referenceGeometry[id];
-                if (!g || !r || typeof r.x !== 'number' || typeof r.y !== 'number')
-                    continue;
-                const gx = g.x ?? 0;
-                const gy = g.y ?? 0;
-                const placementDeltas = [];
-                if (Math.abs(gx - r.x) > DEFAULT_PLACEMENT_TOLERANCE_DP) {
-                    placementDeltas.push({ dimension: 'x', delta: Math.round(gx - r.x) });
-                }
-                if (Math.abs(gy - r.y) > DEFAULT_PLACEMENT_TOLERANCE_DP) {
-                    placementDeltas.push({ dimension: 'y', delta: Math.round(gy - r.y) });
-                }
-                if (placementDeltas.length > 0) {
-                    placementFacts.push({
-                        elementId: id,
-                        expected: { x: r.x, y: r.y },
-                        actual: { x: Math.round(gx), y: Math.round(gy) },
-                        deltas: placementDeltas,
-                    });
-                }
-            }
-            placement.facts = placementFacts;
-        }
-    }
-    let maxSizeDeltaDp = null;
-    let maxClipDeltaDp = null;
-    if (geometry) {
-        maxSizeDeltaDp = 0;
-        maxClipDeltaDp = 0;
-        for (const el of geometry.elements) {
-            for (const { dimension, delta } of el.deltas ?? []) {
-                if (dimension !== 'w' && dimension !== 'h')
-                    continue;
-                const abs = Math.abs(delta);
-                if (abs > maxSizeDeltaDp)
-                    maxSizeDeltaDp = abs;
-            }
-            for (const { delta } of el.overhang?.deltas ?? []) {
-                const abs = Math.abs(delta);
-                if (abs > maxClipDeltaDp)
-                    maxClipDeltaDp = abs;
-            }
-        }
-    }
-    const sizeIssue = !!geometry && geometry.elements.some((e) => e.sizeFlag);
-    const clipIssue = !!geometry && geometry.elements.some((e) => e.overhang?.clipFlag);
-    const placementIssue = !!placement?.facts && placement.facts.length > 0;
-    const summary = {
-        clean: facts.length === 0 && !sizeIssue && !clipIssue && !placementIssue,
-        factCount: facts.length,
-        maxSizeDeltaDp,
-        maxClipDeltaDp,
-    };
-    // Description vs comparison: rendered boxes persist for every authored-tag
-    // node and every fact-named node, reference or not — a description of what
-    // rasterized. The comparison fields (design/deltas/sizeFlag/overhang) exist
-    // only on the reference-declared elements assembled above, and the summary
-    // is computed BEFORE this extension, so geometry presence can never affect
-    // verdict outcomes (no reference → max deltas stay null). Duplicated tags
-    // stay out everywhere: last-wins geometry is ambiguous, and the
-    // duplicate_tag fact carries the collision.
-    {
-        const emitted = new Set((geometry?.elements ?? []).map((e) => e.id));
-        const factNamed = factNamedNodeIds(facts);
-        const described = [];
-        for (const node of dump.nodes) {
-            if (emitted.has(node.id) || duplicates.has(node.id))
-                continue;
-            if (UNTAGGED_ID.test(node.id) && !factNamed.has(node.id))
-                continue;
-            const g = generated[node.id];
-            if (!g)
-                continue;
-            emitted.add(node.id);
-            described.push({
-                id: node.id,
-                rendered: { w: roundMeasure(g.width), h: roundMeasure(g.height), x: roundMeasure(g.x ?? 0), y: roundMeasure(g.y ?? 0) },
-            });
-        }
-        if (geometry)
-            geometry.elements.push(...described);
-        else
-            geometry = { unit: 'dp', density: d, elements: described };
-    }
-    const block = { summary, facts };
-    if (geometry)
-        block.geometry = geometry;
-    if (placement)
-        block.placement = placement;
-    // Signal C (additive): when a reference is supplied, emit the appearance
-    // container — presence facts (element id set diff), plus copy facts (rendered
-    // vs reference text) when the reference carries text, plus color facts
-    // (rendered vs reference color, CIEDE2000 ΔE) when it carries color. The
-    // container's mere presence (carrying a baseline) means "Signal C ran," even
-    // with zero facts. Absent reference → no container, so screens without Signal C
-    // behave exactly as before.
-    if (appearanceReference) {
-        // The render's own appearance — element ids + per-node text/colors. Used both
-        // to derive facts vs the reference AND persisted as the `rendered` snapshot so
-        // a later no-Figma render can use this render as its previous-render baseline.
-        const renderedIds = dump.nodes.map((n) => n.id);
-        const renderedText = {};
-        const renderedColor = {};
-        const renderedSpans = {};
-        const renderedLines = {};
-        const renderedTypeface = {};
-        const renderedTypeMetrics = {};
-        for (const node of dump.nodes) {
-            if (typeof node.text === 'string')
-                renderedText[node.id] = node.text;
-            if (Array.isArray(node.textSpans))
-                renderedSpans[node.id] = node.textSpans;
-            if (Array.isArray(node.textLines))
-                renderedLines[node.id] = node.textLines;
-            const colors = {};
-            if (typeof node.fillColor === 'string')
-                colors.fill = node.fillColor;
-            if (typeof node.textColor === 'string')
-                colors.text = node.textColor;
-            if (typeof node.fillAlpha === 'number')
-                colors.fillAlpha = node.fillAlpha;
-            if (typeof node.textAlpha === 'number')
-                colors.textAlpha = node.textAlpha;
-            // The rendered border (property-recognizer 01), keyed as `stroke` so the
-            // design and render sides line up. `borderWidth` is already DP.
-            if (typeof node.borderColor === 'string')
-                colors.stroke = node.borderColor;
-            if (typeof node.borderWidth === 'number')
-                colors.strokeWeight = node.borderWidth;
-            if (colors.fill !== undefined || colors.text !== undefined || colors.stroke !== undefined) {
-                renderedColor[node.id] = colors;
-            }
-            // The resolved-typeface enrichment (issue 03): the font that actually painted.
-            const tf = node.resolvedTypeface;
-            if (tf && typeof tf.family === 'string' && tf.family.length > 0) {
-                renderedTypeface[node.id] = typeof tf.weight === 'number' ? { family: tf.family, weight: tf.weight } : { family: tf.family };
-            }
-            // The laid-out type metrics (typography facts 01), kept in their own map:
-            // they are captured independently of the family above and must stay
-            // comparable when it is absent.
-            const tm = node.typeMetrics;
-            if (tm && typeof tm === 'object') {
-                const metrics = {};
-                for (const key of TYPE_METRIC_KEYS) {
-                    const value = tm[key];
-                    if (typeof value === 'number' && Number.isFinite(value))
-                        metrics[key] = value;
-                }
-                if (Object.keys(metrics).length > 0)
-                    renderedTypeMetrics[node.id] = metrics;
-            }
-        }
-        // Presence facts: element_extra requires the COMPLETE reference element
-        // inventory, which only the previous_render baseline carries (the prior
-        // render's full persisted id set, via appearanceReferenceFromPreviousRender).
-        // The figma baseline's ids come from reference_geometry — a deliberately
-        // PARTIAL design annotation — so element_extra there falsely flags every
-        // untagged rendered element (noise). element_missing is the opposite shape
-        // (coverage-gaps issue 03): every declared key is a deliberate, named,
-        // load-bearing element, so a declared id matching NO rendered node is a real
-        // absence, noise-free on EITHER baseline. Derive both on previous_render,
-        // missing-only on figma; the pure deriver itself is unchanged.
-        const presenceFacts = derivePresenceFacts(renderedIds, appearanceReference.elementIds);
-        const appearanceFacts = appearanceReference.baseline === 'previous_render'
-            ? presenceFacts
-            : presenceFacts.filter((f) => f.kind === 'element_missing');
-        if (appearanceReference.text) {
-            appearanceFacts.push(...deriveCopyFacts(renderedText, appearanceReference.text));
-        }
-        if (appearanceReference.spans) {
-            appearanceFacts.push(...deriveSpanFacts(renderedSpans, appearanceReference.spans, 
-            // Color-span capability: the emitter declares the channels it can
-            // report; a dump predating the marker is color-blind.
-            Array.isArray(dump.spanChannels) && dump.spanChannels.includes('color')));
-        }
-        if (appearanceReference.lines) {
-            appearanceFacts.push(...deriveLineFacts(renderedLines, appearanceReference.lines));
-        }
-        if (appearanceReference.color) {
-            appearanceFacts.push(...deriveColorFacts(renderedColor, appearanceReference.color));
-        }
-        // Typeface facts (issue 03): resolved (painted) font vs the reference font.
-        // The capture seam (TextRunShaper) is API 31+ — a proof that rendered below
-        // that cannot carry resolved typefaces, so the check is reported as NOT RUN
-        // (an advisory), never silently passed. An ABSENT renderSdk means the dump
-        // predates the emitter generation that captures typefaces at all (it stamps
-        // renderSdk unconditionally) — same not-run advisory, never a silent pass
-        // (coverage-gaps issue 04).
-        const advisories = [];
-        if (appearanceReference.typeface) {
-            if (typeof dump.renderSdk !== 'number') {
-                advisories.push('typeface check requires render SDK >= 31; this proof declared no render SDK ' +
-                    '(an older package) — typeface facts were not derived (not checked, not passing)');
-            }
-            else if (dump.renderSdk < 31) {
-                advisories.push('typeface check requires render SDK >= 31; this proof rendered at SDK ' +
-                    dump.renderSdk +
-                    ' — typeface facts were not derived (not checked, not passing)');
-            }
-            else {
-                appearanceFacts.push(...deriveTypefaceFacts(renderedTypeface, appearanceReference.typeface));
-            }
-            // Type metrics ride the same reference channel but NOT the SDK guard: the
-            // shaping seam that gates the family capture has nothing to do with
-            // reading a style, and a proof rendered below SDK 31 still lays its text
-            // out at a size. Gating them together would make a font size uncomparable
-            // on exactly the older packages that most need checking.
-            appearanceFacts.push(...deriveTypeMetricFacts(renderedTypeMetrics, appearanceReference.typeface));
-        }
-        // Border facts (property-recognizer 01). `styleChannels` is the emitter's own
-        // declaration that it can see borders; a package predating border capture
-        // lacks it, and that silence is "cannot see a border", never "no border was
-        // drawn". The advisory NAMES the elements — an unnamed "not checked" is a
-        // statement nobody can act on, which is the same silence in a new place.
-        if (appearanceReference.color) {
-            const borderCapable = Array.isArray(dump.styleChannels) && dump.styleChannels.includes('border');
-            appearanceFacts.push(...deriveBorderFacts(renderedColor, appearanceReference.color, borderCapable));
-            if (!borderCapable) {
-                const declared = Object.keys(appearanceReference.color)
-                    .filter((key) => hasText(appearanceReference.color?.[key]?.stroke))
-                    .sort();
-                if (declared.length > 0) {
-                    advisories.push('border check requires a render package that captures one; this proof declared no ' +
-                        'style channels (an older package) — the design stroke on ' +
-                        declared.join(', ') +
-                        ' was not checked, not passing');
-                }
-            }
-        }
-        const rendered = { elementIds: [...renderedIds].sort() };
-        if (Object.keys(renderedText).length > 0)
-            rendered.text = renderedText;
-        if (Object.keys(renderedColor).length > 0)
-            rendered.color = renderedColor;
-        if (Object.keys(renderedTypeface).length > 0)
-            rendered.typeface = renderedTypeface;
-        block.appearance = { baseline: appearanceReference.baseline, facts: appearanceFacts, rendered };
-        if (advisories.length > 0)
-            block.appearance.advisories = advisories;
-    }
-    return block;
-}
-/** Human label for a fact, used in the review obligation. */
-function factLabel(fact) {
-    if (fact.kind === 'overlap')
-        return `${fact.nodeIds[0]}↔${fact.nodeIds[1]}`;
-    if (fact.kind === 'frame_mismatch')
-        return 'frame';
-    if (fact.kind === 'duplicate_tag')
-        return fact.tag;
-    return fact.nodeId;
-}
-/** Compact "size +15×+15" delta description for a geometry row. */
-function sizeDeltaText(element) {
-    const byDim = {};
-    for (const { dimension, delta } of element.deltas ?? [])
-        byDim[dimension] = delta;
-    const signed = (n) => (n > 0 ? `+${n}` : `${n}`);
-    const w = byDim.w ?? 0;
-    const h = byDim.h ?? 0;
-    return `size ${signed(w)}×${signed(h)}`;
-}
-const signedDelta = (n) => (n > 0 ? `+${n}` : `${n}`);
-/** The review scaffold speaks in the judge's numbers: every rendered box is
- *  read at whole dp, exactly as the judge quantizes on read — the persisted
- *  box carries 2-decimal precision for display, and a row here must say what
- *  the verdict's finding would say. */
-const judgeDp = (n) => Math.round(n);
-/** "bottom 16dp" — flagged overhang edges, rendered side. */
-function clipRenderedText(overhang) {
-    return overhang.deltas.map((d) => `${d.edge} ${overhang.rendered[d.edge]}dp`).join(', ');
-}
-/** "bottom 25dp" — flagged overhang edges, design side. */
-function clipDesignText(overhang) {
-    return overhang.deltas.map((d) => `${d.edge} ${overhang.design[d.edge]}dp`).join(', ');
-}
-/**
- * "clip bottom 16dp vs design 25dp (-9) — driven by the element's own size
- * (h 71 vs 81dp) tracking the frame (parent-relative); reproduce at the fixed
- * design size" — the overhang mismatch to reconcile PLUS its cause when the clip
- * is driven by the element's own (frame-relative) size, so the judge can't file
- * it as an intended clip.
- */
-function clipDeltaText(overhang, element) {
-    const base = 'clip ' +
-        overhang.deltas
-            .map((d) => `${d.edge} ${overhang.rendered[d.edge]}dp vs design ${overhang.design[d.edge]}dp (${signedDelta(d.delta)})`)
-            .join('; ');
-    const causes = [];
-    if (overhang.sizeDriven) {
-        // Report only the dimensions whose size actually differs from design.
-        // (An overhang exists only on a reference-compared element, so design AND
-        // rendered are present here at runtime; the null checks are for the type.)
-        const sizeParts = [];
-        const designW = element.design?.w;
-        const designH = element.design?.h;
-        const renderedW = element.rendered?.w;
-        const renderedH = element.rendered?.h;
-        if (designW != null && renderedW != null && judgeDp(renderedW) !== designW)
-            sizeParts.push(`w ${judgeDp(renderedW)} vs ${designW}dp`);
-        if (designH != null && renderedH != null && judgeDp(renderedH) !== designH)
-            sizeParts.push(`h ${judgeDp(renderedH)} vs ${designH}dp`);
-        const sizeText = sizeParts.join(', ');
-        const frameSuffix = overhang.frameRelative ? ' tracking the frame (parent-relative)' : '';
-        causes.push(sizeText ? `the element's own size (${sizeText})${frameSuffix}` : `the element's own size${frameSuffix}`);
-    }
-    if (overhang.positionDriven)
-        causes.push("the element's position relative to the frame");
-    if (causes.length === 0)
-        return base;
-    const fix = overhang.sizeDriven && overhang.positionDriven
-        ? 'reproduce at the fixed design size and reposition to the design offset'
-        : overhang.sizeDriven
-            ? 'reproduce at the fixed design size'
-            : 'reposition to the design offset';
-    return `${base} — driven by ${causes.join(' and ')}; ${fix}`;
-}
-/** One-line description of a fact for a fact-only review row. */
-function factText(fact) {
-    switch (fact.kind) {
-        case 'frame_mismatch':
-            return (`wrapper root ${fact.captured.w}×${fact.captured.h}dp differs from the declared ` +
-                `design frame ${fact.declared.w}×${fact.declared.h}dp — size the wrapper root to the ` +
-                'frame (placement facts are withheld until it matches)');
-        case 'duplicate_tag':
-            return (`testTag "${fact.tag}" is shared by ${fact.instanceCount} nodes — geometry facts for ` +
-                `it are withheld; give each instance a unique testTag (e.g. suffix _0/_1/_2) and re-run`);
-        case 'overlap':
-            return `overlap ${fact.overlapPx.width}×${fact.overlapPx.height}px (ratio ${fact.ratio.toFixed(2)})`;
-        case 'overflow':
-            return `overflow past ${fact.parentId} (${fact.edges.join(',')})`;
-        case 'clipped_by_parent':
-            return `clipped by ${fact.clipperId} (${fact.edges.join(',')})`;
-        case 'off_screen':
-            return `off-screen (${fact.edges.join(',')})`;
-        default:
-            return fact.kind;
-    }
-}
-/**
- * Build the run-only `review` scaffold from an assembled structural block:
- * size-flagged geometry elements first (load-bearing), then every structural
- * fact, each as a row with a null `verdict` the agent must replace.
- */
-export function buildReviewScaffold(structural) {
-    const facts = Array.isArray(structural.facts) ? structural.facts : [];
-    const geometry = structural.geometry ?? null;
-    const mustExplain = [];
-    const rows = [];
-    // A size delta and a clip (overhang) delta are separate signals — emit a row
-    // for each so neither is silently rolled into the other. One mustExplain entry
-    // per element even when both fire.
-    for (const el of geometry ? geometry.elements : []) {
-        let flagged = false;
-        if (el.sizeFlag) {
-            // A size flag exists only on a reference-compared element, so design and
-            // rendered are present here at runtime; the optional chaining is for the
-            // type.
-            rows.push({
-                element: el.id,
-                rendered: `${el.rendered ? judgeDp(el.rendered.w) : undefined}×${el.rendered ? judgeDp(el.rendered.h) : undefined}dp`,
-                design: `${el.design?.w}×${el.design?.h}dp`,
-                fact: sizeDeltaText(el),
-                verdict: null,
-            });
-            flagged = true;
-        }
-        if (el.overhang?.clipFlag) {
-            rows.push({
-                element: el.id,
-                rendered: clipRenderedText(el.overhang),
-                design: clipDesignText(el.overhang),
-                fact: clipDeltaText(el.overhang, el),
-                verdict: null,
-            });
-            flagged = true;
-        }
-        if (flagged && !mustExplain.includes(el.id))
-            mustExplain.push(el.id);
-    }
-    for (const fact of facts) {
-        const label = factLabel(fact);
-        if (mustExplain.includes(label))
-            continue;
-        mustExplain.push(label);
-        rows.push({ element: label, rendered: null, design: null, fact: factText(fact), verdict: null });
-    }
-    return { verdict: null, mustExplain, rows };
-}
-/**
- * Render-side embedded form of the deriver.
- *
- * The Android render runs as a single self-contained generated script (see
- * `generateAndroidRenderScript`), so render-side pure logic is embedded as a
- * JS-source string and concatenated in — exactly like `RENDER_SCRIPT_TRIM_STAGE`.
- * The typed `deriveStructuralFacts` above stays the canonical, tested spec; the
- * `parity` test asserts this embedded port produces identical facts on shared
- * fixtures so the two cannot drift.
- *
- * `deriveStructuralFacts` here is pure; `deriveAndWriteFacts` references runtime
- * globals (`fs`, `path`, `artifactsDir`, `log`) defined in the main script and
- * is only invoked from there — harmless to define in the eval sandbox.
- */
-export const RENDER_SCRIPT_FACTS_STAGE = String.raw `
-// ---- structural-facts stage (UI-fidelity Signal A) ----
-
-function deriveStructuralFacts(dump, options) {
-  var opts = options || {};
-  var tolerancePx = opts.tolerancePx == null ? 0.5 : opts.tolerancePx;
-  var overlapMinRatio = opts.overlapMinRatio == null ? 0.1 : opts.overlapMinRatio;
-  var EDGE_ORDER = ['left', 'top', 'right', 'bottom'];
-
-  function edgeExcess(inner, outer) {
-    var raw = {
-      left: outer.left - inner.left,
-      top: outer.top - inner.top,
-      right: inner.right - outer.right,
-      bottom: inner.bottom - outer.bottom,
-    };
-    var edges = [];
-    var px = {};
-    for (var i = 0; i < EDGE_ORDER.length; i++) {
-      var edge = EDGE_ORDER[i];
-      if (raw[edge] > tolerancePx) {
-        edges.push(edge);
-        px[edge] = raw[edge];
-      }
-    }
-    return { edges: edges, px: px };
-  }
-
-  function area(b) {
-    return Math.max(0, b.right - b.left) * Math.max(0, b.bottom - b.top);
-  }
-
-  // What the node PAINTS, not the box it occupies (icon-ink-ratio 02 Half B).
-  // Falls back to the bounds for no ink, unmeasurable ink, and an extent with no
-  // origin (a pre-origin dump) — never to a guessed inset.
-  function paintedBox(node) {
-    var p = node.paintedInk;
-    if (!p || p.kind !== 'vector') return node.bounds;
-    var v = p.viewport;
-    var ink = p.ink;
-    function fin(n) { return typeof n === 'number' && isFinite(n); }
-    if (!v || !ink || !fin(v.w) || !fin(v.h) || v.w <= 0 || v.h <= 0) return node.bounds;
-    if (!fin(ink.w) || !fin(ink.h) || !fin(ink.x) || !fin(ink.y)) return node.bounds;
-    var scaleX = (node.bounds.right - node.bounds.left) / v.w;
-    var scaleY = (node.bounds.bottom - node.bounds.top) / v.h;
-    var left = node.bounds.left + ink.x * scaleX;
-    var top = node.bounds.top + ink.y * scaleY;
-    return { left: left, top: top, right: left + ink.w * scaleX, bottom: top + ink.h * scaleY };
-  }
-
-  var byId = {};
-  var idCounts = {};
-  for (var n = 0; n < dump.nodes.length; n++) {
-    byId[dump.nodes[n].id] = dump.nodes[n];
-    idCounts[dump.nodes[n].id] = (idCounts[dump.nodes[n].id] || 0) + 1;
-  }
-  var facts = [];
-
-  // testTag collisions first: id lookups are last-wins for a duplicated tag, so
-  // parent-relative overflow/clip through it is withheld rather than guessed.
-  // Off-screen and overlaps (no id pairing) still derive.
-  var duplicateTags = [];
-  for (var dk in idCounts) {
-    if (Object.prototype.hasOwnProperty.call(idCounts, dk) && idCounts[dk] > 1) duplicateTags.push(dk);
-  }
-  duplicateTags.sort();
-  for (var dt = 0; dt < duplicateTags.length; dt++) {
-    facts.push({ kind: 'duplicate_tag', tag: duplicateTags[dt], instanceCount: idCounts[duplicateTags[dt]] });
-  }
-
-  for (var k = 0; k < dump.nodes.length; k++) {
-    var node = dump.nodes[k];
-    var parent = node.parentId && idCounts[node.id] === 1 && idCounts[node.parentId] === 1 ? byId[node.parentId] : undefined;
-    if (parent) {
-      if (node.unclippedBounds) {
-        var parentBox = parent.unclippedBounds || parent.bounds;
-        var over = edgeExcess(node.unclippedBounds, parentBox);
-        if (over.edges.length > 0) {
-          var cut = edgeExcess(node.unclippedBounds, node.bounds);
-          var clippedEdges = [];
-          var overflowEdges = [];
-          for (var oe = 0; oe < over.edges.length; oe++) {
-            var edge = over.edges[oe];
-            if (cut.px[edge] != null) clippedEdges.push(edge); else overflowEdges.push(edge);
-          }
-          if (clippedEdges.length > 0) {
-            var clippedPx = {};
-            for (var ce = 0; ce < clippedEdges.length; ce++) clippedPx[clippedEdges[ce]] = cut.px[clippedEdges[ce]];
-            facts.push({ kind: 'clipped_by_parent', nodeId: node.id, clipperId: parent.id, edges: clippedEdges, clippedPx: clippedPx });
-          }
-          if (overflowEdges.length > 0) {
-            var overflowPx = {};
-            for (var ov = 0; ov < overflowEdges.length; ov++) overflowPx[overflowEdges[ov]] = over.px[overflowEdges[ov]];
-            facts.push({ kind: 'overflow', nodeId: node.id, parentId: parent.id, edges: overflowEdges, overflowPx: overflowPx });
-          }
-        }
-      } else {
-        var ex = edgeExcess(node.bounds, parent.bounds);
-        if (ex.edges.length > 0) {
-          if (parent.clipsChildren) {
-            facts.push({ kind: 'clipped_by_parent', nodeId: node.id, clipperId: parent.id, edges: ex.edges, clippedPx: ex.px });
-          } else {
-            facts.push({ kind: 'overflow', nodeId: node.id, parentId: parent.id, edges: ex.edges, overflowPx: ex.px });
-          }
-        }
-      }
-    }
-    var offBox = node.unclippedBounds || node.bounds;
-    var off = edgeExcess(offBox, dump.canvas);
-    if (off.edges.length > 0) {
-      facts.push({ kind: 'off_screen', nodeId: node.id, edges: off.edges, offscreenPx: off.px });
-    }
-  }
-
-  var groups = {};
-  for (var g = 0; g < dump.nodes.length; g++) {
-    var node2 = dump.nodes[g];
-    var key = node2.parentId == null ? ' root' : node2.parentId;
-    if (!groups[key]) groups[key] = [];
-    groups[key].push(node2);
-  }
-  var keys = Object.keys(groups);
-  for (var gk = 0; gk < keys.length; gk++) {
-    var siblings = groups[keys[gk]];
-    for (var i2 = 0; i2 < siblings.length; i2++) {
-      for (var j2 = i2 + 1; j2 < siblings.length; j2++) {
-        var a = siblings[i2];
-        var b = siblings[j2];
-        var ab = paintedBox(a);
-        var bb = paintedBox(b);
-        var ix = Math.min(ab.right, bb.right) - Math.max(ab.left, bb.left);
-        var iy = Math.min(ab.bottom, bb.bottom) - Math.max(ab.top, bb.top);
-        if (ix <= tolerancePx || iy <= tolerancePx) continue;
-        var smaller = Math.min(area(ab), area(bb));
-        var ratio = smaller > 0 ? (ix * iy) / smaller : 0;
-        if (ratio < overlapMinRatio) continue;
-        var ids = a.id <= b.id ? [a.id, b.id] : [b.id, a.id];
-        facts.push({ kind: 'overlap', nodeIds: ids, overlapPx: { width: ix, height: iy }, ratio: ratio });
-      }
-    }
-  }
-
-  return facts;
-}
-
-// Read the layout-dump sidecar emitted next to the render, copy it to the
-// artifacts dir, derive structural facts, and write them as a build artifact.
-// Best-effort: a missing/malformed sidecar logs and leaves the paths null so
-// the render never fails on a structural-pass problem (graceful degradation).
-function deriveAndWriteFacts(entry, layoutSourcePath) {
-  var dump;
-  try {
-    dump = JSON.parse(fs.readFileSync(layoutSourcePath, 'utf-8'));
-  } catch (readError) {
-    log('no usable layout dump for ' + entry.screen + ' (skipping structural facts): ' +
-      (readError && readError.message ? readError.message : String(readError)));
-    return;
-  }
-  if (!dump || typeof dump !== 'object' || !dump.canvas || !Array.isArray(dump.nodes)) {
-    log('layout dump for ' + entry.screen + ' is not a {canvas,nodes} object (skipping structural facts)');
-    return;
-  }
-
-  var layoutRelative = 'ui-fidelity/layout/' + entry.screen + '.json';
-  var factsRelative = 'ui-fidelity/facts/' + entry.screen + '.json';
-  try {
-    fs.copyFileSync(layoutSourcePath, path.resolve(artifactsDir, layoutRelative));
-    entry.layout_path = layoutRelative;
-    var facts = deriveStructuralFacts(dump);
-    fs.writeFileSync(
-      path.resolve(artifactsDir, factsRelative),
-      JSON.stringify({ screen: entry.screen, facts: facts }, null, 2) + '\n'
-    );
-    entry.facts_path = factsRelative;
-    log('structural facts for ' + entry.screen + ': ' + facts.length + ' fact(s) -> ' + factsRelative);
-  } catch (writeError) {
-    log('could not write structural facts for ' + entry.screen + ': ' +
-      (writeError && writeError.message ? writeError.message : String(writeError)));
-  }
-}
-`;
-/**
- * Evaluates the embedded facts stage and returns its pure `deriveStructuralFacts`,
- * so the parity test exercises exactly the code that ships in the runtime script
- * (mirrors `getPostProcessorInternals`). `deriveAndWriteFacts` references runtime
- * globals only when called, so defining it in the sandbox is harmless.
- */
-export function getStructuralFactsStageInternals() {
-    const factory = new Function(RENDER_SCRIPT_FACTS_STAGE +
-        '\nreturn { deriveStructuralFacts: deriveStructuralFacts };');
-    return factory();
-}
-/**
- * Render-side embedded form of the Signal-B differ + structural-block assembler.
- *
- * Concatenated into the generated render script alongside `RENDER_SCRIPT_FACTS_STAGE`
- * (function declarations hoist, so order does not matter — `buildStructuralBlock`
- * calls the facts stage's `deriveStructuralFacts`). `assembleStructural` references
- * runtime globals (`fs`, `path`, `log`) defined in the main script and is only
- * invoked from there. Kept byte-equivalent to the typed `buildStructuralBlock` /
- * `diffKeyGeometry` above by the parity test, so run-side and preview-side (Invarn)
- * structural blocks cannot drift.
- */
-export const RENDER_SCRIPT_GEOMETRY_STAGE = String.raw `
-// ---- key-geometry stage (UI-fidelity Signal B) ----
-
-function diffKeyGeometry(generated, reference, options) {
-  if (!reference) return [];
-  var opts = options || {};
-  var tolerancePx = opts.tolerancePx == null ? 1 : opts.tolerancePx;
-  var DIMS = ['width', 'height', 'x', 'y'];
-  var out = [];
-  var ids = Object.keys(generated);
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var g = generated[elementId];
-    var r = reference[elementId];
-    if (!g || !r) continue;
-    var deltas = [];
-    for (var d = 0; d < DIMS.length; d++) {
-      var dim = DIMS[d];
-      var gv = g[dim];
-      var rv = r[dim];
-      if (typeof gv !== 'number' || typeof rv !== 'number') continue;
-      var delta = gv - rv;
-      if (Math.abs(delta) > tolerancePx) {
-        deltas.push({ dimension: dim, generated: gv, reference: rv, delta: delta });
-      }
-    }
-    if (deltas.length > 0) out.push({ elementId: elementId, deltas: deltas });
-  }
-  return out;
-}
-
-function generatedGeometryDp(dump, density) {
-  var d = density > 0 ? density : 1;
-  var out = {};
-  for (var i = 0; i < dump.nodes.length; i++) {
-    var node = dump.nodes[i];
-    var b = node.unclippedBounds || node.bounds;
-    if (!b) continue;
-    out[node.id] = {
-      width: (b.right - b.left) / d,
-      height: (b.bottom - b.top) / d,
-      x: b.left / d,
-      y: b.top / d,
-    };
-  }
-  return out;
-}
-
-function referenceGeometryToDiffShape(referenceGeometry) {
-  var out = {};
-  var ids = Object.keys(referenceGeometry);
-  for (var i = 0; i < ids.length; i++) {
-    var id = ids[i];
-    var g = referenceGeometry[id];
-    if (!g || typeof g !== 'object') continue;
-    var r = { width: NaN, height: NaN };
-    if (typeof g.w === 'number') r.width = g.w;
-    if (typeof g.h === 'number') r.height = g.h;
-    if (typeof g.x === 'number') r.x = g.x;
-    if (typeof g.y === 'number') r.y = g.y;
-    out[id] = r;
-  }
-  return out;
-}
-
-// The persisted precision of a rendered box: 2 decimals. The paint is sub-dp,
-// and quantizing the box to whole dp moved it up to half a dp off the pixels
-// it describes — visibly mis-wrapped once evidence is magnified. Comparison
-// semantics do not move: deltas are computed from raw values and persisted
-// integer-rounded, the flag bands read raw deltas, and the judge rounds
-// rendered boxes back to whole dp on read. Mirrors the typed roundMeasure.
-function roundMeasure(value) {
-  return Number(value.toFixed(2));
-}
-
-var OVERHANG_EDGES = ['left', 'top', 'right', 'bottom'];
-var OVERHANG_MIN_DP = 0.5;
-
-function overhangNum(v) { return typeof v === 'number' ? v : NaN; }
-function edgeAxis(edge) { return edge === 'top' || edge === 'bottom' ? 'height' : 'width'; }
-
-// Per-edge overhang of one element vs its frame (the element's parent in the
-// dump). Frame-relative edge overhang is the real clip and IS flagged; absolute
-// canvas x/y stays suppressed (canvas-width artifact). sizeDriven/frameRelative
-// trace a flagged clip to the element's own (frame-relative) size. Returns
-// undefined when the element is fully contained, the frame is absent from the
-// render, or the frame isn't declared in referenceGeometry (an advisory covers that).
-function computeOverhang(elementId, elementDp, byId, generated, referenceGeometry, overhangTolerancePx, sizeTolerancePx, duplicates) {
-  var node = byId[elementId];
-  var frameId = node ? node.parentId : null;
-  if (!frameId) return undefined;
-  // A duplicated frame tag resolves last-wins in generated/byId, so the overhang
-  // would measure against an arbitrary instance — withheld (duplicate_tag fact).
-  if (duplicates && duplicates[frameId] > 1) return undefined;
-  var frameDp = generated[frameId];
-  if (!frameDp) return undefined;
-  var frameRef = referenceGeometry[frameId];
-  var elRef = referenceGeometry[elementId];
-  if (!frameRef || !elRef) return undefined;
-  var elX = elementDp.x == null ? NaN : elementDp.x;
-  var elY = elementDp.y == null ? NaN : elementDp.y;
-  var fX = frameDp.x == null ? NaN : frameDp.x;
-  var fY = frameDp.y == null ? NaN : frameDp.y;
-  var renderedRaw = {
-    left: fX - elX,
-    top: fY - elY,
-    right: elX + elementDp.width - (fX + frameDp.width),
-    bottom: elY + elementDp.height - (fY + frameDp.height),
-  };
-  var designRaw = {
-    left: overhangNum(frameRef.x) - overhangNum(elRef.x),
-    top: overhangNum(frameRef.y) - overhangNum(elRef.y),
-    right: overhangNum(elRef.x) + overhangNum(elRef.w) - (overhangNum(frameRef.x) + overhangNum(frameRef.w)),
-    bottom: overhangNum(elRef.y) + overhangNum(elRef.h) - (overhangNum(frameRef.y) + overhangNum(frameRef.h)),
-  };
-  // Candidate when EITHER side overflows — over/under/missing/spurious clip all qualify.
-  var candidates = [];
-  for (var ce = 0; ce < OVERHANG_EDGES.length; ce++) {
-    var ed = OVERHANG_EDGES[ce];
-    if (renderedRaw[ed] > OVERHANG_MIN_DP || designRaw[ed] > OVERHANG_MIN_DP) candidates.push(ed);
-  }
-  if (candidates.length === 0) return undefined;
-  var rendered = {};
-  var design = {};
-  var deltas = [];
-  var has = false;
-  for (var c = 0; c < candidates.length; c++) {
-    var edge = candidates[c];
-    var dRaw = designRaw[edge];
-    if (!isFinite(dRaw)) continue;
-    rendered[edge] = Math.round(renderedRaw[edge]);
-    design[edge] = dRaw;
-    has = true;
-    var delta = renderedRaw[edge] - dRaw;
-    if (Math.abs(delta) > overhangTolerancePx) deltas.push({ edge: edge, delta: Math.round(delta) });
-  }
-  if (!has) return undefined;
-
-  var elSize = { width: elementDp.width, height: elementDp.height };
-  var frameSize = { width: frameDp.width, height: frameDp.height };
-  var elDesign = { width: overhangNum(elRef.w), height: overhangNum(elRef.h) };
-  var frameDesign = { width: overhangNum(frameRef.w), height: overhangNum(frameRef.h) };
-  var elRelPos = { width: elX - fX, height: elY - fY };
-  var elRelPosDesign = {
-    width: overhangNum(elRef.x) - overhangNum(frameRef.x),
-    height: overhangNum(elRef.y) - overhangNum(frameRef.y),
-  };
-  var sizeDriven = false;
-  var frameRelative = false;
-  var positionDriven = false;
-  for (var sd = 0; sd < deltas.length; sd++) {
-    var axis = edgeAxis(deltas[sd].edge);
-    var elD = elDesign[axis];
-    if (isFinite(elD) && Math.abs(elSize[axis] - elD) > sizeTolerancePx) {
-      sizeDriven = true;
-      var frameD = frameDesign[axis];
-      if (Math.abs(elSize[axis] - frameSize[axis]) <= sizeTolerancePx && isFinite(frameD) && Math.abs(elD - frameD) > sizeTolerancePx) {
-        frameRelative = true;
-      }
-    }
-    var relD = elRelPosDesign[axis];
-    if (isFinite(relD) && Math.abs(elRelPos[axis] - relD) > sizeTolerancePx) {
-      positionDriven = true;
-    }
-  }
-
-  return { unit: 'dp', rendered: rendered, design: design, deltas: deltas, clipFlag: deltas.length > 0, sizeDriven: sizeDriven, frameRelative: frameRelative, positionDriven: positionDriven };
-}
-
-// Signal C: element-presence facts from the set difference of rendered vs
-// reference element ids. Order-independent; output sorted (missing before extra,
-// each by id). Mirrors the typed derivePresenceFacts.
-function derivePresenceFacts(renderedIds, referenceIds) {
-  var rendered = {};
-  for (var i = 0; i < renderedIds.length; i++) rendered[renderedIds[i]] = true;
-  var reference = {};
-  for (var j = 0; j < referenceIds.length; j++) reference[referenceIds[j]] = true;
-  var facts = [];
-  var missing = [];
-  for (var rk in reference) { if (Object.prototype.hasOwnProperty.call(reference, rk) && !rendered[rk]) missing.push(rk); }
-  missing.sort();
-  for (var m = 0; m < missing.length; m++) facts.push({ kind: 'element_missing', elementId: missing[m] });
-  var extra = [];
-  for (var ek in rendered) { if (Object.prototype.hasOwnProperty.call(rendered, ek) && !reference[ek]) extra.push(ek); }
-  extra.sort();
-  for (var x = 0; x < extra.length; x++) facts.push({ kind: 'element_extra', elementId: extra[x] });
-  return facts;
-}
-
-// Signal C: copy/text facts from rendered vs reference text per element. Only
-// elements the reference declares text for are compared; identical → no fact,
-// different → text_mismatch, empty/absent render → text_missing. Order-
-// independent; output sorted by id. Mirrors the typed deriveCopyFacts.
-function copyHasText(value) { return typeof value === 'string' && value.length > 0; }
-function deriveCopyFacts(rendered, reference) {
-  var facts = [];
-  var ids = [];
-  for (var rk in reference) { if (Object.prototype.hasOwnProperty.call(reference, rk)) ids.push(rk); }
-  ids.sort();
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var referenceText = reference[elementId];
-    if (!copyHasText(referenceText)) continue;
-    var renderedText = rendered[elementId];
-    if (!copyHasText(renderedText)) {
-      facts.push({ kind: 'text_missing', elementId: elementId, reference: referenceText });
-    } else if (renderedText !== referenceText) {
-      facts.push({ kind: 'text_mismatch', elementId: elementId, rendered: renderedText, reference: referenceText });
-    }
-  }
-  return facts;
-}
-
-// Signal C: span facts (issue 16 + color spans) from declared styled-segment
-// extents vs the rendered spans per element, channel-scoped: a background
-// declaration compares against background-carrying spans, a color declaration
-// against color-carrying ones. The COLOR channel is capability-gated on the
-// dump's spanChannels marker — an old emitter's silence is "cannot see",
-// never "no color span rendered". A wrong extent is one span_mismatch; a
-// matching extent whose color diverges is a span_color_mismatch.
-// Order-independent; output sorted by id. Mirrors the typed deriveSpanFacts.
-function deriveSpanFacts(rendered, reference, colorCapable) {
-  var facts = [];
-  var ids = [];
-  for (var rk in reference) { if (Object.prototype.hasOwnProperty.call(reference, rk)) ids.push(rk); }
-  ids.sort();
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var declared = reference[elementId];
-    var declaredText = declared && typeof declared === 'object' ? declared.text : undefined;
-    if (!declared || !copyHasText(declaredText)) continue;
-    var spans = rendered[elementId];
-    var all = Array.isArray(spans) ? spans : null;
-    var wantsBackground = copyHasText(declared.background);
-    var wantsColor = copyHasText(declared.color) && colorCapable === true;
-
-    var extentOk = true;
-    var scopedExtents = [];
-    var s;
-    // Background / channel-less half. A channel-less declaration keeps its
-    // legacy semantics: any rendered span extent satisfies it.
-    if (wantsBackground || !copyHasText(declared.color)) {
-      if (all === null) {
-        // Node emitted no spans: old package / spanless text — blind on this
-        // half; only a capable color declaration can still speak below.
-        if (!wantsColor) continue;
-      } else {
-        var poolBg = [];
-        for (s = 0; s < all.length; s++) {
-          if (!wantsBackground || copyHasText(all[s] && all[s].background)) poolBg.push(all[s]);
-        }
-        var bgMatched = false;
-        for (s = 0; s < poolBg.length; s++) {
-          var t = poolBg[s] && poolBg[s].text;
-          if (!copyHasText(t)) continue;
-          scopedExtents.push(t);
-          if (t === declaredText) bgMatched = true;
-        }
-        if (!bgMatched) extentOk = false;
-      }
-    }
-    // Color half (capability-gated above).
-    var renderedColorForExtent = null;
-    if (wantsColor) {
-      var poolColor = [];
-      var source = all === null ? [] : all;
-      for (s = 0; s < source.length; s++) {
-        if (copyHasText(source[s] && source[s].color)) poolColor.push(source[s]);
-      }
-      var colorMatches = [];
-      for (s = 0; s < poolColor.length; s++) {
-        var ct = poolColor[s] && poolColor[s].text;
-        if (!copyHasText(ct)) continue;
-        scopedExtents.push(ct);
-        if (ct === declaredText) colorMatches.push(poolColor[s]);
-      }
-      if (colorMatches.length === 0) {
-        extentOk = false;
-      } else {
-        var declaredColor = String(declared.color).toLowerCase();
-        var colorHit = false;
-        for (s = 0; s < colorMatches.length; s++) {
-          if (String(colorMatches[s].color).toLowerCase() === declaredColor) { colorHit = true; break; }
-        }
-        if (!colorHit) renderedColorForExtent = String(colorMatches[0].color).toLowerCase();
-      }
-    }
-
-    if (!extentOk) {
-      var uniqueExtents = [];
-      for (s = 0; s < scopedExtents.length; s++) {
-        if (uniqueExtents.indexOf(scopedExtents[s]) === -1) uniqueExtents.push(scopedExtents[s]);
-      }
-      facts.push({ kind: 'span_mismatch', elementId: elementId, rendered: uniqueExtents.join(', '), reference: declaredText });
-      continue;
-    }
-    if (renderedColorForExtent !== null) {
-      facts.push({
-        kind: 'span_color_mismatch',
-        elementId: elementId,
-        extent: declaredText,
-        rendered: renderedColorForExtent,
-        reference: String(declared.color).toLowerCase(),
-      });
-    }
-  }
-  return facts;
-}
-
-// Signal C: line facts (issue 18) from the declared line split vs the rendered
-// laid-out lines per element. Only elements the reference declares a split for
-// are compared; a node that emitted no textLines (old package / no laid-out
-// text) produces no fact — absence of a signal is never a divergence.
-// Order-independent; output sorted by id. Mirrors the typed deriveLineFacts.
-function deriveLineFacts(rendered, reference) {
-  var facts = [];
-  var ids = [];
-  for (var rk in reference) { if (Object.prototype.hasOwnProperty.call(reference, rk)) ids.push(rk); }
-  ids.sort();
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var declared = reference[elementId];
-    if (!Array.isArray(declared)) continue;
-    var declaredLines = [];
-    for (var d = 0; d < declared.length; d++) {
-      if (copyHasText(declared[d])) declaredLines.push(declared[d]);
-    }
-    if (declaredLines.length === 0) continue;
-    var lines = rendered[elementId];
-    if (!Array.isArray(lines)) continue;
-    var renderedLines = [];
-    for (var l = 0; l < lines.length; l++) {
-      if (copyHasText(lines[l] && lines[l].text)) renderedLines.push(lines[l].text);
-    }
-    var equal = renderedLines.length === declaredLines.length;
-    if (equal) {
-      for (var e = 0; e < renderedLines.length; e++) {
-        if (renderedLines[e] !== declaredLines[e]) { equal = false; break; }
-      }
-    }
-    if (equal) continue;
-    facts.push({ kind: 'line_break_mismatch', elementId: elementId, rendered: renderedLines.join('\n'), reference: declaredLines.join('\n') });
-  }
-  return facts;
-}
-
-// Signal C: color facts (CIEDE2000 ΔE). hexToLab + ciede2000 + deriveColorFacts
-// mirror the typed module; deltaE is the measurement only, no significance.
-var COLOR_CHANNELS = ['fill', 'text'];
-function colorParseHex(hex) {
-  var m = /^#?([0-9a-fA-F]{6})$/.exec(String(hex).trim());
-  if (!m) return null;
-  var n = parseInt(m[1], 16);
-  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
-}
-function colorSrgbToLinear(c) {
-  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
-}
-function colorLabF(t) {
-  return t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
-}
-function hexToLab(hex) {
-  var rgb = colorParseHex(hex);
-  if (!rgb) return [0, 0, 0];
-  var r = colorSrgbToLinear(rgb[0] / 255);
-  var g = colorSrgbToLinear(rgb[1] / 255);
-  var b = colorSrgbToLinear(rgb[2] / 255);
-  var X = (r * 0.4124564 + g * 0.3575761 + b * 0.1804375) * 100;
-  var Y = (r * 0.2126729 + g * 0.7151522 + b * 0.072175) * 100;
-  var Z = (r * 0.0193339 + g * 0.119192 + b * 0.9503041) * 100;
-  var fx = colorLabF(X / 95.047);
-  var fy = colorLabF(Y / 100.0);
-  var fz = colorLabF(Z / 108.883);
-  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
-}
-function colorDeg2rad(d) { return (d * Math.PI) / 180; }
-function colorRad2deg(r) { return (r * 180) / Math.PI; }
-function colorHueDeg(b, a) {
-  if (a === 0 && b === 0) return 0;
-  var deg = colorRad2deg(Math.atan2(b, a));
-  return deg >= 0 ? deg : deg + 360;
-}
-function ciede2000(lab1, lab2) {
-  var L1 = lab1[0], a1 = lab1[1], b1 = lab1[2];
-  var L2 = lab2[0], a2 = lab2[1], b2 = lab2[2];
-  var C1 = Math.sqrt(a1 * a1 + b1 * b1);
-  var C2 = Math.sqrt(a2 * a2 + b2 * b2);
-  var Cbar = (C1 + C2) / 2;
-  var Cbar7 = Math.pow(Cbar, 7);
-  var G = 0.5 * (1 - Math.sqrt(Cbar7 / (Cbar7 + 6103515625)));
-  var a1p = (1 + G) * a1;
-  var a2p = (1 + G) * a2;
-  var C1p = Math.sqrt(a1p * a1p + b1 * b1);
-  var C2p = Math.sqrt(a2p * a2p + b2 * b2);
-  var h1p = colorHueDeg(b1, a1p);
-  var h2p = colorHueDeg(b2, a2p);
-  var dLp = L2 - L1;
-  var dCp = C2p - C1p;
-  var dhp = 0;
-  if (C1p * C2p !== 0) {
-    dhp = h2p - h1p;
-    if (dhp > 180) dhp -= 360;
-    else if (dhp < -180) dhp += 360;
-  }
-  var dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(colorDeg2rad(dhp / 2));
-  var Lbarp = (L1 + L2) / 2;
-  var Cbarp = (C1p + C2p) / 2;
-  var hbarp;
-  if (C1p * C2p === 0) {
-    hbarp = h1p + h2p;
-  } else if (Math.abs(h1p - h2p) > 180) {
-    hbarp = (h1p + h2p) < 360 ? (h1p + h2p + 360) / 2 : (h1p + h2p - 360) / 2;
-  } else {
-    hbarp = (h1p + h2p) / 2;
-  }
-  var T = 1 - 0.17 * Math.cos(colorDeg2rad(hbarp - 30)) + 0.24 * Math.cos(colorDeg2rad(2 * hbarp)) +
-    0.32 * Math.cos(colorDeg2rad(3 * hbarp + 6)) - 0.2 * Math.cos(colorDeg2rad(4 * hbarp - 63));
-  var dTheta = 30 * Math.exp(-Math.pow((hbarp - 275) / 25, 2));
-  var Cbarp7 = Math.pow(Cbarp, 7);
-  var Rc = 2 * Math.sqrt(Cbarp7 / (Cbarp7 + 6103515625));
-  var Sl = 1 + (0.015 * Math.pow(Lbarp - 50, 2)) / Math.sqrt(20 + Math.pow(Lbarp - 50, 2));
-  var Sc = 1 + 0.045 * Cbarp;
-  var Sh = 1 + 0.015 * Cbarp * T;
-  var Rt = -Math.sin(colorDeg2rad(2 * dTheta)) * Rc;
-  var termL = dLp / Sl, termC = dCp / Sc, termH = dHp / Sh;
-  return Math.sqrt(termL * termL + termC * termC + termH * termH + Rt * termC * termH);
-}
-function deriveColorFacts(rendered, reference) {
-  var facts = [];
-  var ids = [];
-  for (var rk in reference) { if (Object.prototype.hasOwnProperty.call(reference, rk)) ids.push(rk); }
-  ids.sort();
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var refColors = reference[elementId];
-    var renColors = rendered[elementId];
-    if (!refColors) continue;
-    for (var c = 0; c < COLOR_CHANNELS.length; c++) {
-      var channel = COLOR_CHANNELS[c];
-      var referenceColor = refColors[channel];
-      var renderedColor = renColors ? renColors[channel] : undefined;
-      if (!copyHasText(referenceColor) || !copyHasText(renderedColor)) continue;
-      // Opacity (issue 14b): graded only when the DESIGN states a translucency —
-      // an opaque design says nothing about alpha, so a render reporting one is
-      // not a divergence — and only past a rounding step. Kept ahead of the hex
-      // compare because the two are independent: the colour can be right while
-      // the state (disabled vs enabled) is wrong.
-      var referenceAlpha = refColors[channel + 'Alpha'];
-      var renderedAlpha = renColors ? renColors[channel + 'Alpha'] : undefined;
-      if (typeof referenceAlpha === 'number') {
-        var renA = typeof renderedAlpha === 'number' ? renderedAlpha : 1;
-        if (Math.abs(referenceAlpha - renA) > 0.01) {
-          facts.push({
-            kind: 'color_alpha', elementId: elementId, channel: channel,
-            rendered: renA, reference: referenceAlpha,
-          });
-        }
-      }
-      if (renderedColor.toLowerCase() === referenceColor.toLowerCase()) continue;
-      facts.push({
-        kind: 'color', elementId: elementId, channel: channel,
-        rendered: renderedColor, reference: referenceColor,
-        deltaE: ciede2000(hexToLab(renderedColor), hexToLab(referenceColor)),
-      });
-    }
-  }
-  return facts;
-}
-
-// Border facts (property-recognizer 01) — the runner twin of deriveBorderFacts.
-// The design's stroke against the render's captured border; the DESIGN is the
-// only side that raises the question, and "capable" gates the ABSENCE case only,
-// because a border-blind dump cannot tell "no ring drawn" from "I cannot see
-// rings". Patching only the typed copy would make the local preview and the real
-// gate disagree, silently.
-function deriveBorderFacts(rendered, reference, capable) {
-  var facts = [];
-  var ids = Object.keys(reference).sort();
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var ref = reference[elementId];
-    if (!ref || !copyHasText(ref.stroke)) continue;
-    var ren = rendered[elementId];
-    var renderedStroke = ren ? ren.stroke : undefined;
-    if (!copyHasText(renderedStroke)) {
-      if (capable) {
-        var missing = { kind: 'border_missing', elementId: elementId, reference: ref.stroke };
-        if (typeof ref.strokeWeight === 'number') missing.referenceWidth = ref.strokeWeight;
-        facts.push(missing);
-      }
-      continue;
-    }
-    if (renderedStroke.toLowerCase() !== ref.stroke.toLowerCase()) {
-      facts.push({
-        kind: 'border', elementId: elementId,
-        rendered: renderedStroke, reference: ref.stroke,
-      });
-    }
-    var refW = ref.strokeWeight;
-    var renW = ren ? ren.strokeWeight : undefined;
-    if (typeof refW === 'number' && typeof renW === 'number' && Math.abs(refW - renW) > 0.5) {
-      facts.push({ kind: 'border_width', elementId: elementId, rendered: renW, reference: refW });
-    }
-  }
-  return facts;
-}
-
-// Signal C: typeface facts (issue 03) — the RESOLVED (painted, post-fallback)
-// font vs the reference font. Mirrors the typed normalizeTypeface /
-// deriveTypefaceFacts: a weight-name suffix on the family is stripped and, when
-// no explicit numeric weight exists, becomes the weight; an explicit numeric
-// weight always wins; no family signal on either side → no fact.
-var TYPEFACE_WEIGHT_NAMES = {
-  thin: 100, hairline: 100, extralight: 200, ultralight: 200, light: 300,
-  normal: 400, regular: 400, book: 400, medium: 500, semibold: 600,
-  demibold: 600, bold: 700, extrabold: 800, ultrabold: 800, black: 900, heavy: 900,
-};
-function normalizeTypeface(spec) {
-  var raw = spec && typeof spec.family === 'string' ? spec.family.replace(/^\s+|\s+$/g, '') : '';
-  if (raw.length === 0) return null;
-  var tokens = [];
-  var rawTokens = raw.split(/[\s\-_]+/);
-  for (var t = 0; t < rawTokens.length; t++) { if (rawTokens[t].length > 0) tokens.push(rawTokens[t]); }
-  var derivedWeight;
-  while (tokens.length > 1) {
-    var candidate = tokens[tokens.length - 1].toLowerCase();
-    if (Object.prototype.hasOwnProperty.call(TYPEFACE_WEIGHT_NAMES, candidate)) {
-      derivedWeight = TYPEFACE_WEIGHT_NAMES[candidate];
-      tokens.pop();
-    } else {
-      break;
-    }
-  }
-  var family = tokens.join('').toLowerCase().replace(/[^a-z0-9]/g, '');
-  var explicit = spec && typeof spec.weight === 'number' && isFinite(spec.weight) ? spec.weight : undefined;
-  var weight = explicit != null ? explicit : (derivedWeight != null ? derivedWeight : 400);
-  return { family: family, weight: weight };
-}
-function deriveTypefaceFacts(rendered, reference) {
-  var facts = [];
-  var ids = [];
-  for (var rk in reference) { if (Object.prototype.hasOwnProperty.call(reference, rk)) ids.push(rk); }
-  ids.sort();
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var refNorm = normalizeTypeface(reference[elementId]);
-    var renNorm = normalizeTypeface(rendered[elementId]);
-    if (!refNorm || !renNorm) continue;
-    if (refNorm.family === renNorm.family && refNorm.weight === renNorm.weight) continue;
-    facts.push({
-      kind: 'typeface', elementId: elementId, channel: 'text',
-      rendered: rendered[elementId], reference: reference[elementId],
-    });
-  }
-  return facts;
-}
-
-// Signal C: type-metric facts (typography facts 01) — the laid-out size,
-// tracking and leading against the design's, in sp. Mirrors the typed
-// deriveTypeMetricFacts: one fact PER METRIC (finding identity is
-// screen+element+category, so folding metrics into one fact would collapse them
-// into one finding and drop the rest), both sides must declare the metric, and a
-// sub-unit difference is representation noise rather than a divergence.
-var TYPE_METRIC_KEYS = ['fontSize', 'letterSpacing', 'lineHeight'];
-var TYPE_METRIC_TOLERANCE_SP = 0.25;
-function finiteMetric(value) {
-  return typeof value === 'number' && isFinite(value) ? value : undefined;
-}
-function deriveTypeMetricFacts(rendered, reference) {
-  var facts = [];
-  var ids = [];
-  for (var rk in reference) { if (Object.prototype.hasOwnProperty.call(reference, rk)) ids.push(rk); }
-  ids.sort();
-  for (var i = 0; i < ids.length; i++) {
-    var elementId = ids[i];
-    var ref = reference[elementId];
-    var ren = rendered[elementId];
-    if (!ref || !ren) continue;
-    for (var m = 0; m < TYPE_METRIC_KEYS.length; m++) {
-      var metric = TYPE_METRIC_KEYS[m];
-      var referenceValue = finiteMetric(ref[metric]);
-      var renderedValue = finiteMetric(ren[metric]);
-      if (referenceValue === undefined || renderedValue === undefined) continue;
-      if (Math.abs(renderedValue - referenceValue) <= TYPE_METRIC_TOLERANCE_SP) continue;
-      facts.push({
-        kind: 'type_metric', elementId: elementId, channel: 'text', metric: metric,
-        rendered: renderedValue, reference: referenceValue,
-      });
-    }
-  }
-  return facts;
-}
-
-// Signal C: assemble the AppearanceReference from a screen's reference params
-// (issue 05). Built when ANY of geometry/text/color is present; elementIds is the
-// UNION of their keys (geometry, then text, then color — deduped). Mirrors the
-// typed buildAppearanceReferenceFromParams. Decouples the appearance container
-// from reference_geometry so a reference_color-only run still yields color facts.
-function appearanceParamsNonEmpty(value) {
-  return !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
-}
-function buildAppearanceReferenceFromParams(params) {
-  var p = params || {};
-  var hasGeom = appearanceParamsNonEmpty(p.refGeom);
-  var hasText = appearanceParamsNonEmpty(p.refText);
-  var hasColor = appearanceParamsNonEmpty(p.refColor);
-  var hasSpans = appearanceParamsNonEmpty(p.refSpans);
-  var hasLines = appearanceParamsNonEmpty(p.refLines);
-  var hasTypeface = appearanceParamsNonEmpty(p.refTypeface);
-  if (!hasGeom && !hasText && !hasColor && !hasSpans && !hasLines && !hasTypeface) return null;
-  var elementIds = [];
-  var seen = {};
-  function addKeys(record) {
-    if (!record) return;
-    var keys = Object.keys(record);
-    for (var i = 0; i < keys.length; i++) {
-      if (!Object.prototype.hasOwnProperty.call(seen, keys[i])) {
-        seen[keys[i]] = true;
-        elementIds.push(keys[i]);
-      }
-    }
-  }
-  if (hasGeom) addKeys(p.refGeom);
-  if (hasText) addKeys(p.refText);
-  if (hasColor) addKeys(p.refColor);
-  if (hasSpans) addKeys(p.refSpans);
-  if (hasLines) addKeys(p.refLines);
-  if (hasTypeface) addKeys(p.refTypeface);
-  var reference = { baseline: p.baseline, elementIds: elementIds };
-  if (hasText) reference.text = p.refText;
-  if (hasColor) reference.color = p.refColor;
-  if (hasSpans) reference.spans = p.refSpans;
-  if (hasLines) reference.lines = p.refLines;
-  if (hasTypeface) reference.typeface = p.refTypeface;
-  return reference;
-}
-
-// Text-aware size band (line-box residue): JVM text metrics differ ~2dp per
-// laid-out line from the design's nominal line boxes, so text-driven elements
-// get a line-scaled significance band (capped) while measurements stay exact
-// and non-text elements keep the strict band. Mirrors the typed sizeBandDp.
-var TEXT_LINE_RESIDUE_DP = 2;
-var TEXT_BOX_RESIDUE_DP = 2;
-var TEXT_SIZE_SLACK_MAX_DP = 8;
-
-function nodeTextLines(node) {
-  if (Array.isArray(node.textLines)) return node.textLines.length;
-  return typeof node.text === 'string' && node.text.length > 0 ? 1 : 0;
-}
-
-// Total laid-out lines in the element's subtree; visits node OBJECTS so a
-// malformed parent cycle or duplicated id cannot loop.
-function subtreeTextLineCount(elementId, byId, childrenByParent) {
-  var root = byId[elementId];
-  if (!root) return 0;
-  var lines = 0;
-  var visited = [];
-  var stack = [root];
-  while (stack.length > 0) {
-    var node = stack.pop();
-    if (visited.indexOf(node) !== -1) continue;
-    visited.push(node);
-    lines += nodeTextLines(node);
-    var children = childrenByParent[node.id] || [];
-    for (var ci = 0; ci < children.length; ci++) stack.push(children[ci]);
-  }
-  return lines;
-}
-
-function sizeBandDp(subtreeLines, sizeTolerancePx) {
-  if (subtreeLines <= 0) return sizeTolerancePx;
-  var band = TEXT_BOX_RESIDUE_DP + TEXT_LINE_RESIDUE_DP * subtreeLines;
-  if (band > TEXT_SIZE_SLACK_MAX_DP) band = TEXT_SIZE_SLACK_MAX_DP;
-  return band > sizeTolerancePx ? band : sizeTolerancePx;
-}
-
-// The element's render ancestry, immediate parent first (icon-ink-ratio 05).
-// Empty for a root. Cycle-guarded like subtreeTextLineCount above.
-function ancestorChain(elementId, byId) {
-  var out = [];
-  var seen = [elementId];
-  var node = byId[elementId];
-  var cursor = node && node.parentId != null ? node.parentId : null;
-  while (cursor != null && seen.indexOf(cursor) === -1) {
-    seen.push(cursor);
-    out.push(cursor);
-    var next = byId[cursor];
-    cursor = next && next.parentId != null ? next.parentId : null;
-  }
-  return out;
-}
-
-function buildStructuralBlock(dump, referenceGeometry, density, options, appearanceReference, referenceFrame, anchorFrame) {
-  var opts = options || {};
-  var DIMENSION_SHORT = { width: 'w', height: 'h', x: 'x', y: 'y' };
-  var FRAME_TOLERANCE_DP = 1;
-  var facts = deriveStructuralFacts(dump);
-  var d = typeof density === 'number' && density > 0 ? density : 1;
-  var sizeTolerancePx = opts.sizeTolerancePx == null ? 1 : opts.sizeTolerancePx;
-  var overhangTolerancePx = opts.overhangTolerancePx == null ? 2 : opts.overhangTolerancePx;
-
-  // Design-frame anchor (composition runs): assert the captured root against
-  // the declared frame; a mismatch is a wrapper-authoring fact and withholds
-  // placement facts for the State (they'd be garbage on a wrong canvas).
-  var placement;
-  if (referenceFrame && typeof referenceFrame.w === 'number' && typeof referenceFrame.h === 'number') {
-    var capturedW = (dump.canvas.right - dump.canvas.left) / d;
-    var capturedH = (dump.canvas.bottom - dump.canvas.top) / d;
-    var frameDeltas = [];
-    if (Math.abs(capturedW - referenceFrame.w) > FRAME_TOLERANCE_DP) {
-      frameDeltas.push({ dimension: 'w', delta: Math.round(capturedW - referenceFrame.w) });
-    }
-    if (Math.abs(capturedH - referenceFrame.h) > FRAME_TOLERANCE_DP) {
-      frameDeltas.push({ dimension: 'h', delta: Math.round(capturedH - referenceFrame.h) });
-    }
-    if (frameDeltas.length > 0) {
-      facts.push({
-        kind: 'frame_mismatch',
-        declared: { w: referenceFrame.w, h: referenceFrame.h },
-        captured: { w: Math.round(capturedW), h: Math.round(capturedH) },
-        deltas: frameDeltas,
-      });
-      placement = { withheld: true, reason: 'frame_mismatch' };
-    } else {
-      placement = { withheld: false };
-    }
-  }
-
-  // Frame-anchored component runs (coverage-gaps issue 01): the design frame
-  // as an ANCHOR PROBE — a matching captured root earns the composition-style
-  // placement check (x/y flags); a non-matching root changes NOTHING (no fact,
-  // no placement, x/y stays advisory).
-  if (!placement && anchorFrame && typeof anchorFrame.w === 'number' && typeof anchorFrame.h === 'number') {
-    var anchorW = (dump.canvas.right - dump.canvas.left) / d;
-    var anchorH = (dump.canvas.bottom - dump.canvas.top) / d;
-    if (
-      Math.abs(anchorW - anchorFrame.w) <= FRAME_TOLERANCE_DP &&
-      Math.abs(anchorH - anchorFrame.h) <= FRAME_TOLERANCE_DP
-    ) {
-      placement = { withheld: false };
-    }
-  }
-
-  var geometry;
-  // testTag collisions: a duplicated tag's generated geometry is last-wins (an
-  // arbitrary instance), so its size/clip/placement comparisons are withheld.
-  var dupCounts = {};
-  for (var dci = 0; dci < dump.nodes.length; dci++) {
-    dupCounts[dump.nodes[dci].id] = (dupCounts[dump.nodes[dci].id] || 0) + 1;
-  }
-  var generated = generatedGeometryDp(dump, d);
-  if (referenceGeometry && Object.keys(referenceGeometry).length > 0) {
-    var ref = referenceGeometryToDiffShape(referenceGeometry);
-    var byId = {};
-    for (var bi = 0; bi < dump.nodes.length; bi++) byId[dump.nodes[bi].id] = dump.nodes[bi];
-    var childrenByParent = {};
-    for (var cp = 0; cp < dump.nodes.length; cp++) {
-      var cnode = dump.nodes[cp];
-      if (!cnode.parentId) continue;
-      if (!childrenByParent[cnode.parentId]) childrenByParent[cnode.parentId] = [];
-      childrenByParent[cnode.parentId].push(cnode);
-    }
-    var rawList = diffKeyGeometry(generated, ref, { tolerancePx: 0 });
-    var deltasByElement = {};
-    for (var i = 0; i < rawList.length; i++) deltasByElement[rawList[i].elementId] = rawList[i].deltas;
-    var elements = [];
-    var refIds = Object.keys(ref);
-    for (var k = 0; k < refIds.length; k++) {
-      var id = refIds[k];
-      if (dupCounts[id] > 1) continue;
-      var g = generated[id];
-      var r = ref[id];
-      if (!r) continue;
-      if (!g) {
-        // Declared but absent from the render: persist the design box alone,
-        // so the absence keeps the design's record of WHERE instead of taking
-        // it down with the element.
-        var absentDesign = { w: isNaN(r.width) ? undefined : r.width, h: isNaN(r.height) ? undefined : r.height };
-        if (typeof r.x === 'number') absentDesign.x = r.x;
-        if (typeof r.y === 'number') absentDesign.y = r.y;
-        elements.push({ id: id, design: absentDesign });
-        continue;
-      }
-      var rawDeltas = deltasByElement[id] || [];
-      var deltas = [];
-      // Text-aware significance band (line-box residue): deltas stay exact;
-      // only the flag uses the band.
-      var band = sizeBandDp(subtreeTextLineCount(id, byId, childrenByParent), sizeTolerancePx);
-      var sizeFlag = false;
-      for (var j = 0; j < rawDeltas.length; j++) {
-        var dimension = rawDeltas[j].dimension;
-        var rounded = Math.round(rawDeltas[j].delta);
-        if (rounded === 0) continue;
-        deltas.push({ dimension: DIMENSION_SHORT[dimension], delta: rounded });
-        if ((dimension === 'width' || dimension === 'height') && Math.abs(rawDeltas[j].delta) > band) {
-          sizeFlag = true;
-        }
-      }
-      var element = {
-        id: id,
-        rendered: { w: roundMeasure(g.width), h: roundMeasure(g.height), x: roundMeasure(g.x), y: roundMeasure(g.y) },
-        design: { w: isNaN(r.width) ? undefined : r.width, h: isNaN(r.height) ? undefined : r.height },
-        deltas: deltas,
-        sizeFlag: sizeFlag,
-      };
-      if (typeof r.x === 'number') element.design.x = r.x;
-      if (typeof r.y === 'number') element.design.y = r.y;
-      var overhang = computeOverhang(id, g, byId, generated, referenceGeometry, overhangTolerancePx, sizeTolerancePx, dupCounts);
-      if (overhang) element.overhang = overhang;
-      // What the element PAINTS, verbatim from the dump (icon-ink-ratio 01): an
-      // icon's layout box is its container and the reference's key is the glyph,
-      // so without this the judge compares a container against ink.
-      var paintedInk = byId[id] ? byId[id].paintedInk : undefined;
-      if (paintedInk) element.paintedInk = paintedInk;
-      // Render ancestry (icon-ink-ratio 05) — the CHAIN, because Compose omits
-      // untagged layout nodes and an immediate parent cannot see past the gap.
-      // Absent (not empty) when the node is not in the dump, so the judge can tell
-      // "no ancestry measured" from "measured, at the root".
-      if (byId[id]) element.ancestors = ancestorChain(id, byId);
-      elements.push(element);
-    }
-    geometry = { unit: 'dp', density: d, elements: elements };
-
-    // Placement facts (composition runs, frame asserted OK): member-root x/y
-    // vs the declared design geometry, root-space dp — directly comparable
-    // because the root is frame-sized. Load-bearing here, unlike the advisory
-    // x/y deltas on geometry elements.
-    if (placement && !placement.withheld) {
-      var PLACEMENT_TOLERANCE_DP = 2;
-      var placementFacts = [];
-      var pIds = Object.keys(ref);
-      for (var pi = 0; pi < pIds.length; pi++) {
-        var pid = pIds[pi];
-        if (dupCounts[pid] > 1) continue;
-        var pg = generated[pid];
-        var pr = referenceGeometry[pid];
-        if (!pg || !pr || typeof pr.x !== 'number' || typeof pr.y !== 'number') continue;
-        var gx = pg.x == null ? 0 : pg.x;
-        var gy = pg.y == null ? 0 : pg.y;
-        var placementDeltas = [];
-        if (Math.abs(gx - pr.x) > PLACEMENT_TOLERANCE_DP) {
-          placementDeltas.push({ dimension: 'x', delta: Math.round(gx - pr.x) });
-        }
-        if (Math.abs(gy - pr.y) > PLACEMENT_TOLERANCE_DP) {
-          placementDeltas.push({ dimension: 'y', delta: Math.round(gy - pr.y) });
-        }
-        if (placementDeltas.length > 0) {
-          placementFacts.push({
-            elementId: pid,
-            expected: { x: pr.x, y: pr.y },
-            actual: { x: Math.round(gx), y: Math.round(gy) },
-            deltas: placementDeltas,
-          });
-        }
-      }
-      placement.facts = placementFacts;
-    }
-  }
-
-  var maxSizeDeltaDp = null;
-  var maxClipDeltaDp = null;
-  if (geometry) {
-    maxSizeDeltaDp = 0;
-    maxClipDeltaDp = 0;
-    for (var e = 0; e < geometry.elements.length; e++) {
-      var els = geometry.elements[e].deltas || [];
-      for (var di = 0; di < els.length; di++) {
-        if (els[di].dimension !== 'w' && els[di].dimension !== 'h') continue;
-        var abs = Math.abs(els[di].delta);
-        if (abs > maxSizeDeltaDp) maxSizeDeltaDp = abs;
-      }
-      var oh = geometry.elements[e].overhang;
-      if (oh) {
-        for (var od = 0; od < oh.deltas.length; od++) {
-          var oabs = Math.abs(oh.deltas[od].delta);
-          if (oabs > maxClipDeltaDp) maxClipDeltaDp = oabs;
-        }
-      }
-    }
-  }
-
-  var sizeIssue = false;
-  var clipIssue = false;
-  if (geometry) {
-    for (var s = 0; s < geometry.elements.length; s++) {
-      if (geometry.elements[s].sizeFlag) sizeIssue = true;
-      if (geometry.elements[s].overhang && geometry.elements[s].overhang.clipFlag) clipIssue = true;
-    }
-  }
-  var placementIssue = !!(placement && placement.facts && placement.facts.length > 0);
-  var summary = {
-    clean: facts.length === 0 && !sizeIssue && !clipIssue && !placementIssue,
-    factCount: facts.length,
-    maxSizeDeltaDp: maxSizeDeltaDp,
-    maxClipDeltaDp: maxClipDeltaDp,
-  };
-
-  // Description vs comparison: rendered boxes persist for every authored-tag
-  // node and every fact-named node, reference or not — a description of what
-  // rasterized. The comparison fields (design/deltas/sizeFlag/overhang) exist
-  // only on the reference-declared elements assembled above, and the summary
-  // is computed BEFORE this extension, so geometry presence can never affect
-  // verdict outcomes (no reference → max deltas stay null). Duplicated tags
-  // stay out everywhere: last-wins geometry is ambiguous, and the
-  // duplicate_tag fact carries the collision.
-  var UNTAGGED_ID_RE = /^node-\d+$/;
-  var factNamed = {};
-  for (var fni = 0; fni < facts.length; fni++) {
-    var ffact = facts[fni];
-    if (typeof ffact.nodeId === 'string') factNamed[ffact.nodeId] = true;
-    if (typeof ffact.clipperId === 'string') factNamed[ffact.clipperId] = true;
-    if (Array.isArray(ffact.nodeIds)) {
-      for (var fnj = 0; fnj < ffact.nodeIds.length; fnj++) {
-        if (typeof ffact.nodeIds[fnj] === 'string') factNamed[ffact.nodeIds[fnj]] = true;
-      }
-    }
-  }
-  var emitted = {};
-  if (geometry) {
-    for (var emi = 0; emi < geometry.elements.length; emi++) emitted[geometry.elements[emi].id] = true;
-  }
-  var described = [];
-  for (var dni = 0; dni < dump.nodes.length; dni++) {
-    var dnode = dump.nodes[dni];
-    if (emitted[dnode.id] || dupCounts[dnode.id] > 1) continue;
-    if (UNTAGGED_ID_RE.test(dnode.id) && !factNamed[dnode.id]) continue;
-    var dg = generated[dnode.id];
-    if (!dg) continue;
-    emitted[dnode.id] = true;
-    described.push({
-      id: dnode.id,
-      rendered: { w: roundMeasure(dg.width), h: roundMeasure(dg.height), x: roundMeasure(dg.x == null ? 0 : dg.x), y: roundMeasure(dg.y == null ? 0 : dg.y) },
-    });
-  }
-  if (geometry) {
-    for (var dpi = 0; dpi < described.length; dpi++) geometry.elements.push(described[dpi]);
-  } else {
-    geometry = { unit: 'dp', density: d, elements: described };
-  }
-
-  var block = { summary: summary, facts: facts };
-  if (geometry) block.geometry = geometry;
-  if (placement) block.placement = placement;
-  // Signal C (additive): emit the appearance container when a reference is
-  // supplied — presence facts plus, when the reference carries text, copy facts.
-  // Container presence (with a baseline) means "Signal C ran."
-  if (appearanceReference) {
-    // The render's own appearance — ids + per-node text/colors. Used to derive
-    // facts vs the reference AND persisted as the rendered snapshot (baseline
-    // source for the next no-Figma render).
-    var renderedIds = [];
-    var renderedText = {};
-    var renderedColor = {};
-    var renderedSpans = {};
-    var renderedLinesMap = {};
-    var renderedTypeface = {};
-    var renderedTypeMetrics = {};
-    for (var ri = 0; ri < dump.nodes.length; ri++) {
-      var rnode = dump.nodes[ri];
-      renderedIds.push(rnode.id);
-      if (typeof rnode.text === 'string') renderedText[rnode.id] = rnode.text;
-      if (Array.isArray(rnode.textSpans)) renderedSpans[rnode.id] = rnode.textSpans;
-      if (Array.isArray(rnode.textLines)) renderedLinesMap[rnode.id] = rnode.textLines;
-      var colors = {};
-      var hasColor = false;
-      if (typeof rnode.fillColor === 'string') { colors.fill = rnode.fillColor; hasColor = true; }
-      if (typeof rnode.textColor === 'string') { colors.text = rnode.textColor; hasColor = true; }
-      if (typeof rnode.fillAlpha === 'number') { colors.fillAlpha = rnode.fillAlpha; }
-      if (typeof rnode.textAlpha === 'number') { colors.textAlpha = rnode.textAlpha; }
-      // The rendered border (property-recognizer 01), keyed as "stroke" to match
-      // the design side. borderWidth is already DP — never divided by density.
-      // hasColor flips here too: a ring is the element's only paint on a
-      // stroke-only rule, and dropping the entry would lose the comparison.
-      if (typeof rnode.borderColor === 'string') { colors.stroke = rnode.borderColor; hasColor = true; }
-      if (typeof rnode.borderWidth === 'number') { colors.strokeWeight = rnode.borderWidth; }
-      if (hasColor) renderedColor[rnode.id] = colors;
-      // The resolved-typeface enrichment (issue 03): the font that actually painted.
-      var rtf = rnode.resolvedTypeface;
-      if (rtf && typeof rtf.family === 'string' && rtf.family.length > 0) {
-        renderedTypeface[rnode.id] = typeof rtf.weight === 'number' ? { family: rtf.family, weight: rtf.weight } : { family: rtf.family };
-      }
-      // The laid-out type metrics (typography facts 01) — their own map, so a
-      // size stays comparable on a dump whose family capture is absent.
-      var rtm = rnode.typeMetrics;
-      if (rtm && typeof rtm === 'object') {
-        var metrics = {};
-        var hasMetric = false;
-        for (var tmk = 0; tmk < TYPE_METRIC_KEYS.length; tmk++) {
-          var mkey = TYPE_METRIC_KEYS[tmk];
-          var mval = rtm[mkey];
-          if (typeof mval === 'number' && isFinite(mval)) { metrics[mkey] = mval; hasMetric = true; }
-        }
-        if (hasMetric) renderedTypeMetrics[rnode.id] = metrics;
-      }
-    }
-    // Presence facts: element_extra needs the COMPLETE reference inventory —
-    // only the previous_render baseline carries it (figma's ids are a partial
-    // annotation, so extra there is noise — issue 04). element_missing is
-    // noise-free on either baseline: a declared id with no rendered node is a
-    // real absence (coverage-gaps issue 03). Missing-only on figma.
-    var presenceFacts = derivePresenceFacts(renderedIds, appearanceReference.elementIds);
-    var appearanceFacts = appearanceReference.baseline === 'previous_render'
-      ? presenceFacts
-      : presenceFacts.filter(function (f) { return f.kind === 'element_missing'; });
-    if (appearanceReference.text) {
-      var copyFacts = deriveCopyFacts(renderedText, appearanceReference.text);
-      for (var cf = 0; cf < copyFacts.length; cf++) appearanceFacts.push(copyFacts[cf]);
-    }
-    if (appearanceReference.spans) {
-      // Color-span capability: the emitter declares the channels it can
-      // report; a dump predating the marker is color-blind.
-      var colorSpanCapable = Array.isArray(dump.spanChannels) && dump.spanChannels.indexOf('color') !== -1;
-      var spanFacts = deriveSpanFacts(renderedSpans, appearanceReference.spans, colorSpanCapable);
-      for (var sf = 0; sf < spanFacts.length; sf++) appearanceFacts.push(spanFacts[sf]);
-    }
-    if (appearanceReference.lines) {
-      var lineFacts = deriveLineFacts(renderedLinesMap, appearanceReference.lines);
-      for (var lf = 0; lf < lineFacts.length; lf++) appearanceFacts.push(lineFacts[lf]);
-    }
-    if (appearanceReference.color) {
-      var colorFacts = deriveColorFacts(renderedColor, appearanceReference.color);
-      for (var cof = 0; cof < colorFacts.length; cof++) appearanceFacts.push(colorFacts[cof]);
-    }
-    // Typeface facts (issue 03): the capture seam (TextRunShaper) is API 31+ —
-    // a proof rendered below that is reported as NOT RUN (advisory), never a
-    // silent pass. An ABSENT renderSdk predates the typeface-capturing emitter
-    // entirely — same advisory (coverage-gaps issue 04).
-    var appearanceAdvisories = [];
-    if (appearanceReference.typeface) {
-      if (typeof dump.renderSdk !== 'number') {
-        appearanceAdvisories.push(
-          'typeface check requires render SDK >= 31; this proof declared no render SDK ' +
-            '(an older package) — typeface facts were not derived (not checked, not passing)'
-        );
-      } else if (dump.renderSdk < 31) {
-        appearanceAdvisories.push(
-          'typeface check requires render SDK >= 31; this proof rendered at SDK ' +
-            dump.renderSdk +
-            ' — typeface facts were not derived (not checked, not passing)'
-        );
-      } else {
-        var typefaceFacts = deriveTypefaceFacts(renderedTypeface, appearanceReference.typeface);
-        for (var tff = 0; tff < typefaceFacts.length; tff++) appearanceFacts.push(typefaceFacts[tff]);
-      }
-      // Type metrics ride the same reference channel but NOT the SDK guard —
-      // reading a style has nothing to do with the per-glyph shaping seam, and a
-      // proof rendered below SDK 31 still lays its text out at a size.
-      var metricFacts = deriveTypeMetricFacts(renderedTypeMetrics, appearanceReference.typeface);
-      for (var tmf = 0; tmf < metricFacts.length; tmf++) appearanceFacts.push(metricFacts[tmf]);
-    }
-    // Border facts (property-recognizer 01). styleChannels is the emitter's own
-    // declaration that it can see borders; a package predating border capture
-    // lacks it, and that silence is "cannot see a border", never "no border was
-    // drawn". The advisory NAMES the elements — an unnamed "not checked" is a
-    // statement nobody can act on.
-    if (appearanceReference.color) {
-      var borderCapable = Array.isArray(dump.styleChannels) &&
-        dump.styleChannels.indexOf('border') !== -1;
-      var borderFacts = deriveBorderFacts(renderedColor, appearanceReference.color, borderCapable);
-      for (var bf = 0; bf < borderFacts.length; bf++) appearanceFacts.push(borderFacts[bf]);
-      if (!borderCapable) {
-        var strokeKeys = Object.keys(appearanceReference.color).filter(function (k) {
-          return copyHasText(appearanceReference.color[k] && appearanceReference.color[k].stroke);
-        }).sort();
-        if (strokeKeys.length > 0) {
-          appearanceAdvisories.push(
-            'border check requires a render package that captures one; this proof declared no ' +
-              'style channels (an older package) — the design stroke on ' +
-              strokeKeys.join(', ') +
-              ' was not checked, not passing'
-          );
-        }
-      }
-    }
-    var sortedIds = renderedIds.slice().sort();
-    var rendered = { elementIds: sortedIds };
-    if (Object.keys(renderedText).length > 0) rendered.text = renderedText;
-    if (Object.keys(renderedColor).length > 0) rendered.color = renderedColor;
-    if (Object.keys(renderedTypeface).length > 0) rendered.typeface = renderedTypeface;
-    block.appearance = { baseline: appearanceReference.baseline, facts: appearanceFacts, rendered: rendered };
-    if (appearanceAdvisories.length > 0) block.appearance.advisories = appearanceAdvisories;
-  }
-  return block;
-}
-
-function factLabel(fact) {
-  if (fact.kind === 'overlap') return fact.nodeIds[0] + '↔' + fact.nodeIds[1];
-  if (fact.kind === 'frame_mismatch') return 'frame';
-  if (fact.kind === 'duplicate_tag') return fact.tag;
-  return fact.nodeId;
-}
-
-function sizeDeltaText(element) {
-  var byDim = {};
-  for (var i = 0; i < element.deltas.length; i++) byDim[element.deltas[i].dimension] = element.deltas[i].delta;
-  function signed(n) { return n > 0 ? '+' + n : '' + n; }
-  var w = byDim.w == null ? 0 : byDim.w;
-  var h = byDim.h == null ? 0 : byDim.h;
-  return 'size ' + signed(w) + '×' + signed(h);
-}
-
-function signedDelta(n) { return n > 0 ? '+' + n : '' + n; }
-function clipRenderedText(overhang) {
-  var parts = [];
-  for (var i = 0; i < overhang.deltas.length; i++) {
-    var edge = overhang.deltas[i].edge;
-    parts.push(edge + ' ' + overhang.rendered[edge] + 'dp');
-  }
-  return parts.join(', ');
-}
-function clipDesignText(overhang) {
-  var parts = [];
-  for (var i = 0; i < overhang.deltas.length; i++) {
-    var edge = overhang.deltas[i].edge;
-    parts.push(edge + ' ' + overhang.design[edge] + 'dp');
-  }
-  return parts.join(', ');
-}
-function clipDeltaText(overhang, element) {
-  var parts = [];
-  for (var i = 0; i < overhang.deltas.length; i++) {
-    var edge = overhang.deltas[i].edge;
-    parts.push(edge + ' ' + overhang.rendered[edge] + 'dp vs design ' + overhang.design[edge] + 'dp (' + signedDelta(overhang.deltas[i].delta) + ')');
-  }
-  var base = 'clip ' + parts.join('; ');
-  var causes = [];
-  if (overhang.sizeDriven) {
-    var sizeParts = [];
-    // The scaffold speaks in the judge's numbers: rendered boxes read at whole
-    // dp, exactly as the judge quantizes on read (the persisted box carries
-    // 2-decimal precision for display). Mirrors the typed judgeDp.
-    if (element.design.w != null && Math.round(element.rendered.w) !== element.design.w) sizeParts.push('w ' + Math.round(element.rendered.w) + ' vs ' + element.design.w + 'dp');
-    if (element.design.h != null && Math.round(element.rendered.h) !== element.design.h) sizeParts.push('h ' + Math.round(element.rendered.h) + ' vs ' + element.design.h + 'dp');
-    var sizeText = sizeParts.join(', ');
-    var frameSuffix = overhang.frameRelative ? ' tracking the frame (parent-relative)' : '';
-    causes.push(sizeText ? "the element's own size (" + sizeText + ')' + frameSuffix : "the element's own size" + frameSuffix);
-  }
-  if (overhang.positionDriven) causes.push("the element's position relative to the frame");
-  if (causes.length === 0) return base;
-  var fix = (overhang.sizeDriven && overhang.positionDriven)
-    ? 'reproduce at the fixed design size and reposition to the design offset'
-    : overhang.sizeDriven
-      ? 'reproduce at the fixed design size'
-      : 'reposition to the design offset';
-  return base + ' — driven by ' + causes.join(' and ') + '; ' + fix;
-}
-
-function factText(fact) {
-  if (fact.kind === 'frame_mismatch') {
-    return 'wrapper root ' + fact.captured.w + '×' + fact.captured.h + 'dp differs from the declared ' +
-      'design frame ' + fact.declared.w + '×' + fact.declared.h + 'dp — size the wrapper root to the ' +
-      'frame (placement facts are withheld until it matches)';
-  }
-  if (fact.kind === 'duplicate_tag') {
-    return 'testTag "' + fact.tag + '" is shared by ' + fact.instanceCount + ' nodes — geometry facts for ' +
-      'it are withheld; give each instance a unique testTag (e.g. suffix _0/_1/_2) and re-run';
-  }
-  if (fact.kind === 'overlap') return 'overlap ' + fact.overlapPx.width + '×' + fact.overlapPx.height + 'px (ratio ' + fact.ratio.toFixed(2) + ')';
-  if (fact.kind === 'overflow') return 'overflow past ' + fact.parentId + ' (' + fact.edges.join(',') + ')';
-  if (fact.kind === 'clipped_by_parent') return 'clipped by ' + fact.clipperId + ' (' + fact.edges.join(',') + ')';
-  if (fact.kind === 'off_screen') return 'off-screen (' + fact.edges.join(',') + ')';
-  return fact.kind;
-}
-
-// The run-only verdict obligation: each size-flagged geometry element and each
-// structural fact becomes a row whose verdict the agent MUST fill, plus a
-// mustExplain list — computed on the runner so it rides in the result no matter
-// how the result is read. Mirrors Invarn's buildReviewScaffold.
-function buildReviewScaffold(structural) {
-  var facts = structural && Array.isArray(structural.facts) ? structural.facts : [];
-  var geometry = structural && structural.geometry ? structural.geometry : null;
-  var mustExplain = [];
-  var rows = [];
-  if (geometry) {
-    for (var i = 0; i < geometry.elements.length; i++) {
-      var el = geometry.elements[i];
-      var flagged = false;
-      if (el.sizeFlag) {
-        rows.push({
-          element: el.id,
-          rendered: Math.round(el.rendered.w) + '×' + Math.round(el.rendered.h) + 'dp',
-          design: el.design.w + '×' + el.design.h + 'dp',
-          fact: sizeDeltaText(el),
-          verdict: null,
-        });
-        flagged = true;
-      }
-      if (el.overhang && el.overhang.clipFlag) {
-        rows.push({
-          element: el.id,
-          rendered: clipRenderedText(el.overhang),
-          design: clipDesignText(el.overhang),
-          fact: clipDeltaText(el.overhang, el),
-          verdict: null,
-        });
-        flagged = true;
-      }
-      if (flagged && mustExplain.indexOf(el.id) === -1) mustExplain.push(el.id);
-    }
-  }
-  for (var f = 0; f < facts.length; f++) {
-    var label = factLabel(facts[f]);
-    if (mustExplain.indexOf(label) !== -1) continue;
-    mustExplain.push(label);
-    rows.push({ element: label, rendered: null, design: null, fact: factText(facts[f]), verdict: null });
-  }
-  return { verdict: null, mustExplain: mustExplain, rows: rows };
-}
-
-// Assemble the inline structural block (Signal A facts + Signal B geometry) onto
-// the screen entry from the same layout dump the facts stage uses. Best-effort:
-// a missing/malformed dump leaves entry.structural unset (graceful degradation).
-function assembleStructural(entry, layoutSourcePath, allReferenceGeometry, density, allReferenceText, allReferenceColor, referenceBaseline, allReferenceFrame, proofKind, allReferenceSpans, allReferenceLines, allReferenceTypeface) {
-  var dump;
-  try {
-    dump = JSON.parse(fs.readFileSync(layoutSourcePath, 'utf-8'));
-  } catch (readError) {
-    return;
-  }
-  if (!dump || typeof dump !== 'object' || !dump.canvas || !Array.isArray(dump.nodes)) return;
-  var refGeom =
-    allReferenceGeometry && typeof allReferenceGeometry === 'object' && !Array.isArray(allReferenceGeometry)
-      ? allReferenceGeometry[entry.screen]
-      : null;
-  // Design-frame anchor: composition runs ASSERT the frame (the door requires
-  // it there; a mismatch is a wrapper-authoring fact). A component run must
-  // never grow that assertion — its frame instead rides as the ANCHOR PROBE
-  // (coverage-gaps issue 01): a root that happens to match the design frame
-  // earns the composition-style x/y placement check, a root that does not is
-  // untouched.
-  var frameEntry =
-    allReferenceFrame && typeof allReferenceFrame === 'object' && !Array.isArray(allReferenceFrame)
-      ? allReferenceFrame[entry.screen]
-      : null;
-  var declaredFrame =
-    frameEntry && typeof frameEntry === 'object' && !Array.isArray(frameEntry) &&
-    typeof frameEntry.w === 'number' && typeof frameEntry.h === 'number'
-      ? frameEntry
-      : null;
-  var refFrame = proofKind === 'composition' ? declaredFrame : null;
-  var anchorFrame = proofKind === 'composition' ? null : declaredFrame;
-  // Signal C reference (issue 05): the appearance container is assembled when ANY
-  // of reference_geometry / reference_text / reference_color is declared for the
-  // screen — its element-id set is the UNION of their keys. So a no-Figma run
-  // carrying only reference_color (the drift path) still emits color facts,
-  // without needing reference_geometry. The run-level reference_baseline marks
-  // 'figma' (design divergences, default) or 'previous_render' (regressions/drift).
-  var baseline = referenceBaseline === 'previous_render' ? 'previous_render' : 'figma';
-  var refText =
-    allReferenceText && typeof allReferenceText === 'object' && !Array.isArray(allReferenceText)
-      ? allReferenceText[entry.screen]
-      : null;
-  var refColor =
-    allReferenceColor && typeof allReferenceColor === 'object' && !Array.isArray(allReferenceColor)
-      ? allReferenceColor[entry.screen]
-      : null;
-  var refSpans =
-    allReferenceSpans && typeof allReferenceSpans === 'object' && !Array.isArray(allReferenceSpans)
-      ? allReferenceSpans[entry.screen]
-      : null;
-  var refLines =
-    allReferenceLines && typeof allReferenceLines === 'object' && !Array.isArray(allReferenceLines)
-      ? allReferenceLines[entry.screen]
-      : null;
-  var refTypeface =
-    allReferenceTypeface && typeof allReferenceTypeface === 'object' && !Array.isArray(allReferenceTypeface)
-      ? allReferenceTypeface[entry.screen]
-      : null;
-  var appearanceReference = buildAppearanceReferenceFromParams({
-    refGeom: refGeom,
-    refText: refText,
-    refColor: refColor,
-    refSpans: refSpans,
-    refLines: refLines,
-    refTypeface: refTypeface,
-    baseline: baseline,
-  });
-  try {
-    entry.structural = buildStructuralBlock(dump, refGeom, density, undefined, appearanceReference, refFrame, anchorFrame);
-    // Bake the verdict obligation onto the run result so it survives any read
-    // path (waited run or polled build result), not just the Invarn read path.
-    entry.structural.review = buildReviewScaffold(entry.structural);
-    var sm = entry.structural.summary;
-    log(
-      'structural for ' + entry.screen + ': clean=' + sm.clean + ', facts=' + sm.factCount +
-        ', mustExplain=' + entry.structural.review.mustExplain.length +
-        (sm.maxSizeDeltaDp != null ? ', maxSizeDeltaDp=' + sm.maxSizeDeltaDp : '')
-    );
-  } catch (assembleError) {
-    log('could not assemble structural block for ' + entry.screen + ': ' +
-      (assembleError && assembleError.message ? assembleError.message : String(assembleError)));
-  }
-}
-`;
-/**
- * Evaluates the embedded facts + geometry stages together (mirroring how the
- * render script concatenates them) and returns the pure `diffKeyGeometry` +
- * `buildStructuralBlock`, so the parity test exercises exactly the shipped code.
- */
-export function getGeometryStageInternals() {
-    const factory = new Function(RENDER_SCRIPT_FACTS_STAGE +
-        RENDER_SCRIPT_GEOMETRY_STAGE +
-        '\nreturn { diffKeyGeometry: diffKeyGeometry, buildStructuralBlock: buildStructuralBlock, buildReviewScaffold: buildReviewScaffold, derivePresenceFacts: derivePresenceFacts, deriveCopyFacts: deriveCopyFacts, deriveSpanFacts: deriveSpanFacts, deriveLineFacts: deriveLineFacts, deriveColorFacts: deriveColorFacts, deriveTypefaceFacts: deriveTypefaceFacts, deriveTypeMetricFacts: deriveTypeMetricFacts, buildAppearanceReferenceFromParams: buildAppearanceReferenceFromParams, ciede2000: ciede2000, hexToLab: hexToLab };');
-    return factory();
-}
-//# sourceMappingURL=structural-facts.js.map