@event4u/agent-config 16.3.0 → 16.5.0

package/dist/cli/commands/uiRenderAssetGrid.js

@@ -0,0 +1,265 @@
+/**
+ * uiRenderAssetGrid — the incumbent icon grid, read from the set's own SVGs.
+ *
+ * Step E6 of `road-to-svg-with-a-witness`, carrying findings 2.1 and 2.2 of
+ * `road-to-svg-rules-in-the-dispatch-path`. Its own module because
+ * `uiRenderAsset.ts` is over the source-size budget and this is the most
+ * self-contained reading in it: no browser, no page, no shared state — bytes
+ * in, one grading out, which is also why its two findings are exercisable
+ * without a render.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { elementExtent, parseElements, readViewBox } from '../../scripts/lint_svg_asset.js';
+/**
+ * Elements whose contents DEFINE something rather than paint it.
+ *
+ * A shape inside one of these never appears on the canvas on its own, so it
+ * must not contribute to the graphic's extent. `<pattern>` and `<symbol>` join
+ * the three obvious ones for the same reason.
+ */
+const NON_RENDERING = new Set(['defs', 'clippath', 'mask', 'symbol', 'marker', 'pattern']);
+/**
+ * The elements that actually paint: everything outside a transformed subtree
+ * and outside a non-rendering container.
+ *
+ * Extracted by finding 9 of this change's second completion review. The extent
+ * reading did this walk and the stroke-width reading did not, so an icon whose
+ * clip path carried `stroke-width="8"` reported 8 as its stroke while its
+ * padding was measured from the 1.5 the viewer sees. Two readings of the same
+ * file disagreeing about which elements are in it is the shape a shared walk
+ * removes by construction — the previous fix widened the extent half and left
+ * the other, which is exactly how the pair came to disagree.
+ */
+function renderingElements(elements) {
+    const out = [];
+    const openSkips = [];
+    let skipDepth = 0;
+    for (const el of elements) {
+        if (el.closing) {
+            const was = openSkips.pop();
+            if (was === true)
+                skipDepth -= 1;
+            continue;
+        }
+        const carries = Boolean(el.attrs['transform'] || el.attrs['style']?.includes('transform')) ||
+            NON_RENDERING.has(el.name);
+        if (!el.selfClosing) {
+            openSkips.push(carries);
+            if (carries)
+                skipDepth += 1;
+        }
+        if (skipDepth > 0 || (el.selfClosing && carries))
+            continue;
+        out.push(el);
+    }
+    return out;
+}
+/**
+ * The centreline extent of one graphic's own geometry, in user units.
+ *
+ * Shared by the references and by the candidate — finding 2.2 is precisely
+ * that the two used to be measured by different methods, so the one thing this
+ * function must never grow is a second caller-specific branch.
+ *
+ * A TRANSFORM ANYWHERE ABOVE A SHAPE DISQUALIFIES IT, not only one on the
+ * shape. `elementExtent` refuses an element that carries its own `transform`,
+ * and a flat element list makes it easy to miss that a `<g transform="…">`
+ * moves everything inside it — measured here: a rect inside a rotated group
+ * read as if the group were not there, and the file reported a padding it does
+ * not have. The depth stack below is what carries the inheritance; without it
+ * the refusal is a half-refusal, which is worse than none because it looks
+ * like a reading.
+ */
+export function centrelineExtent(elements) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    // Two reasons to skip a subtree, tracked on one stack: an ancestor carries
+    // a transform, or an ancestor DOES NOT RENDER.
+    //
+    // The second is finding 3 of this change's completion review. Geometry
+    // inside `<defs>`, `<clipPath>`, `<mask>`, `<symbol>`, `<marker>` or
+    // `<pattern>` is a definition, not paint — and a clip path is usually a
+    // full-bleed rect, so an exported icon reported padding 0 on BOTH sides
+    // and the comparison finding 2.2 exists to make meaningful compared two
+    // zeroes. The old `d`-scraping reader had the same blind spot; reading
+    // primitives widened it, because clip and mask shapes are rects and
+    // circles.
+    for (const el of renderingElements(elements)) {
+        const box = elementExtent(el);
+        if (!box)
+            continue;
+        minX = Math.min(minX, box.minX);
+        maxX = Math.max(maxX, box.maxX);
+        minY = Math.min(minY, box.minY);
+        maxY = Math.max(maxY, box.maxY);
+    }
+    return Number.isFinite(minX) ? { minX, minY, maxX, maxY } : null;
+}
+/** Smallest distance from a viewBox edge to an extent. Negative when it overflows. */
+export function paddingFromExtent(vb, ext) {
+    return Math.min(ext.minX - vb.x, ext.minY - vb.y, vb.x + vb.w - ext.maxX, vb.y + vb.h - ext.maxY);
+}
+/**
+ * Stroke width and padding of each reference icon, read from its own bytes.
+ * Padding is the smallest distance from a viewBox edge to the drawn geometry.
+ * Nothing is declared here and no grid table is vendored (E6, Non-goals).
+ *
+ * Finding 2.1 of `road-to-svg-rules-in-the-dispatch-path`, both halves. This
+ * used to scrape `d` with a loose number-pair regex, so:
+ *
+ *   · a reference drawn with `<rect>` / `<circle>` / `<line>` yielded no
+ *     extent, was dropped, and — when every reference was drawn that way —
+ *     the reading then said "no icon reference set was supplied" although one
+ *     was. It now reads every primitive, and a file it still cannot read is
+ *     returned in `skipped` with the reason rather than vanishing.
+ *   · relative commands were read as absolute, so a path drawn with `m`/`l`
+ *     reported an extent anchored near the origin. `pathExtent` walks the
+ *     current point.
+ *
+ * The reading degrades to `unverified` rather than to a pass, so no verdict
+ * was wrong before this — but the reason given for the degradation was.
+ */
+export function readIconReferencesDetailed(files) {
+    const refs = [];
+    const skipped = [];
+    for (const file of files) {
+        if (!fs.existsSync(file)) {
+            skipped.push({ file, reason: 'file does not exist' });
+            continue;
+        }
+        const content = fs.readFileSync(file, 'utf8');
+        const elements = parseElements(content);
+        const root = elements.find((el) => el.name === 'svg' && !el.closing);
+        const vb = readViewBox(root);
+        if (!vb) {
+            skipped.push({ file, reason: 'no readable viewBox' });
+            continue;
+        }
+        // The SAME walk the candidate's stroke reading uses. Finding 5 of the
+        // third completion review: the candidate side was moved onto
+        // `renderingElements` and the reference side was not, so a reference
+        // icon's clip path contributed a stroke the viewer never sees.
+        // Reproduced: two byte-identical files reported 1.5 against [1.5, 8].
+        // The same defect as finding 9 of the previous round, in the other
+        // half of the same pair — which is what a defect-pattern sweep over
+        // the construct, rather than over the one reported site, is for.
+        const strokes = new Set();
+        for (const el of renderingElements(elements)) {
+            const sw = Number(el.attrs['stroke-width']);
+            if (Number.isFinite(sw) && sw > 0)
+                strokes.add(sw);
+        }
+        const ext = centrelineExtent(elements.filter((el) => el.name !== 'svg'));
+        if (!ext) {
+            skipped.push({ file, reason: 'no element in it carries readable geometry (every shape transformed, or none drawn)' });
+            continue;
+        }
+        refs.push({
+            file,
+            viewBox: vb,
+            strokeWidths: [...strokes].sort((a, b) => a - b),
+            padding: paddingFromExtent(vb, ext),
+        });
+    }
+    return { refs, skipped };
+}
+/** The list-only form, kept because every existing caller wants exactly that. */
+export function readIconReferences(files) {
+    return readIconReferencesDetailed(files).refs;
+}
+/**
+ * Graded against the incumbent set, both sides measured the same way (2.2).
+ *
+ * Exported so the grading can be exercised without launching a browser: the
+ * two findings it carries are a padding-method mismatch and a reference set
+ * dropped silently, and neither needs a render to reproduce.
+ */
+export function gradeIconGrid(file, vb, elements, iconSet, 
+/**
+ * The RENDERED painted box. Kept in the signature and deliberately unread:
+ * it is what the candidate's padding used to come from (finding 2.2), and
+ * dropping the parameter would make a caller that still passes it look
+ * correct while silently changing which argument lands where. Named with a
+ * leading underscore so the linter agrees it is not used.
+ */
+_paintedBox) {
+    const self = path.resolve(file);
+    const { refs, skipped } = readIconReferencesDetailed(iconSet.map((f) => path.resolve(f)).filter((f) => f !== self));
+    const comparable = vb ? refs.filter((r) => r.viewBox.w === vb.w && r.viewBox.h === vb.h) : [];
+    const strokes = new Set();
+    for (const el of renderingElements(elements)) {
+        const sw = Number(el.attrs['stroke-width']);
+        if (Number.isFinite(sw) && sw > 0)
+            strokes.add(sw);
+    }
+    const strokeWidth = strokes.size > 0 ? Math.max(...strokes) : null;
+    /**
+     * Finding 2.2: BOTH sides are centreline extents now.
+     *
+     * The candidate's padding used to come from `painted_box`, a RENDERED box
+     * that includes half the stroke and the caps, while the references came
+     * from raw coordinates. A candidate matching a reference exactly therefore
+     * measured one half-stroke less padding than it — latent rather than live
+     * only because the shipped icon pair happens to sit outside the band, so a
+     * new fixture at a different stroke width would have made it fire on a
+     * clean twin (Risk 7).
+     *
+     * Fixed by measuring, not by widening a threshold: `centrelineExtent` is
+     * the same function the references go through. `painted_box` keeps its own
+     * meaning everywhere else in the reading — it is simply not the thing to
+     * compare against a centreline.
+     */
+    const selfExt = centrelineExtent(elements.filter((el) => el.name !== 'svg'));
+    const padding = vb && selfExt ? paddingFromExtent(vb, selfExt) : null;
+    if (comparable.length === 0) {
+        const unreadable = skipped.length
+            ? ` ${String(skipped.length)} supplied file(s) could not be read: ${skipped
+                .map((s) => `${path.basename(s.file)} (${s.reason})`)
+                .join('; ')}.`
+            : '';
+        return {
+            status: 'unverified',
+            reference_files: refs.map((r) => path.basename(r.file)),
+            reference_stroke_widths: [],
+            reference_padding: [],
+            stroke_width: strokeWidth,
+            padding,
+            reason: refs.length === 0
+                ? (refs.length === 0 && skipped.length === 0 && iconSet.length > 0
+                    ? 'every file in the supplied icon reference set is the file under test, so there is ' +
+                        'nothing to compare against'
+                    : iconSet.length === 0
+                        ? 'no icon reference set was supplied, so the incumbent grid was never read (E6)'
+                        : 'an icon reference set was supplied but no file in it yielded a reading, so there ' +
+                            'is no grid to compare against') + unreadable
+                : vb === null
+                    ? // Finding 8 of the fifth completion review: a CANDIDATE
+                        // with no readable viewBox reached the same branch as a
+                        // reference set that shares no size, and was told that
+                        // no reference shares its viewBox — a statement about
+                        // the references, when the unreadable thing is the file
+                        // in front of the author. The reason has to name what
+                        // is actually missing or the author fixes the wrong
+                        // file.
+                        'this file has no readable viewBox, so its grid cannot be compared against any ' +
+                            'reference' + unreadable
+                    : 'no reference icon shares this viewBox size, so there is no grid to compare against' +
+                        unreadable,
+        };
+    }
+    const refStrokes = [...new Set(comparable.flatMap((r) => r.strokeWidths))].sort((a, b) => a - b);
+    const refPadding = [...new Set(comparable.map((r) => r.padding))].sort((a, b) => a - b);
+    return {
+        status: 'read',
+        reference_files: comparable.map((r) => path.basename(r.file)),
+        reference_stroke_widths: refStrokes,
+        reference_padding: refPadding,
+        stroke_width: strokeWidth,
+        padding,
+        reason: `read from ${comparable.length} incumbent SVG(s)`,
+    };
+}
+//# sourceMappingURL=uiRenderAssetGrid.js.map

package/dist/cli/commands/uiRenderAssetGrounds.js

@@ -0,0 +1,323 @@
+import { HOST_BASENAME, MIN_CONTRAST_RATIO, } from './uiRenderAssetTypes.js';
+/**
+ * The per-ground readings — steps 4.1 and 4.2 of
+ * `road-to-svg-from-a-live-session`.
+ *
+ * Three images, read in one scratch page so nothing is decoded twice:
+ *
+ *   transparent  the file on no ground at all, which is where its own
+ *                silhouette comes from. A silhouette taken from the light
+ *                capture would lose every white part of the graphic, which is
+ *                precisely the paint these two readings are about.
+ *   light / dark the two captures the profile already wrote.
+ *
+ * Inside that silhouette, two counts per ground. A pixel whose contrast ratio
+ * against the ground is below 3:1 is hard to see there (4.2) — a wordmark in
+ * dark violet shipped unreadable on a dark ground and the variant was never
+ * built. A pixel whose colour sits within the anti-alias band of the ground is
+ * the ground showing THROUGH the graphic (4.1) — the hairline seams between
+ * abutting traced segments, invisible on white and obvious on black.
+ *
+ * Holes are excluded by declaration, never by geometry: a ring's middle is
+ * ground on purpose, and only the author can say which gaps are intended.
+ */
+/**
+ * What FRACTION of the capture the graphic covers, width and height.
+ *
+ * Finding 4 of this change's second completion review. The capture is the
+ * VIEWPORT, floored at 64 px, while the page is `margin:0` with
+ * `body>svg{width:cssWidth}` — so the graphic sits in the top-left corner and
+ * covers only part of the image whenever `cssWidth` is smaller. Every icon is
+ * such a case: the sizes are 16/24/48 against a floor of 64. Mapping a
+ * user-unit box across the whole capture therefore put every declared hole and
+ * every declared-translucent shape 4/3 too far out, and the exclusions the
+ * author declared were applied to the wrong part of their own file.
+ *
+ * A FRACTION rather than a pixel count, because the image's size is known only
+ * inside the page while everything this needs is known outside it — which is
+ * also what makes the arithmetic testable without a renderer. Clamped to 1:
+ * `cssWidth` above the viewport is the graphic filling the capture, not
+ * overflowing the coordinate space.
+ */
+export function graphicFraction(spec) {
+    if (spec.width <= 0 || spec.height <= 0 || spec.cssWidth <= 0)
+        return { w: 1, h: 1 };
+    const w = Math.min(1, spec.cssWidth / spec.width);
+    const vb = spec.viewBox;
+    if (!vb || vb.w <= 0)
+        return { w, h: 1 };
+    // The rendered height follows the viewBox aspect from the rendered width.
+    const cssHeight = spec.cssWidth * (vb.h / vb.w);
+    return { w, h: Math.min(1, cssHeight / spec.height) };
+}
+export async function readGrounds(context, openPage, spec) {
+    // The transparent render: `omitBackground` leaves alpha 0 where the file
+    // paints nothing, which is the only honest source for a silhouette.
+    const clear = await openPage(context, {
+        url: spec.url,
+        hostHtml: spec.hostHtml,
+        hostBasename: HOST_BASENAME,
+        width: spec.width,
+        height: spec.height,
+        background: 'transparent',
+        cssWidth: spec.cssWidth,
+        blocked: spec.blocked,
+    });
+    let silhouette;
+    try {
+        silhouette = await clear.screenshot({ omitBackground: true });
+    }
+    finally {
+        await clear.close();
+    }
+    const out = [];
+    for (const mode of ['light', 'dark']) {
+        const colour = spec.backgrounds[mode];
+        const page = await openPage(context, {
+            url: spec.url,
+            hostHtml: spec.hostHtml,
+            hostBasename: HOST_BASENAME,
+            width: spec.width,
+            height: spec.height,
+            background: colour,
+            cssWidth: spec.cssWidth,
+            blocked: spec.blocked,
+        });
+        let shot;
+        try {
+            shot = await page.screenshot();
+        }
+        finally {
+            await page.close();
+        }
+        const scratch = await context.newPage();
+        try {
+            await scratch.setContent('<!doctype html><body></body>');
+            const counts = await scratch.evaluate(async (args) => {
+                const load = async (b64) => {
+                    const img = new Image();
+                    img.src = `data:image/png;base64,${b64}`;
+                    try {
+                        await img.decode();
+                    }
+                    catch {
+                        return null;
+                    }
+                    return img;
+                };
+                const a = await load(args.silhouette);
+                const b = await load(args.ground);
+                if (!a || !b)
+                    return null;
+                const w = Math.min(a.naturalWidth, b.naturalWidth);
+                const h = Math.min(a.naturalHeight, b.naturalHeight);
+                if (w === 0 || h === 0)
+                    return null;
+                const read = (img) => {
+                    const c = document.createElement('canvas');
+                    c.width = w;
+                    c.height = h;
+                    const cx = c.getContext('2d', { willReadFrequently: true });
+                    if (!cx)
+                        return null;
+                    cx.clearRect(0, 0, w, h);
+                    cx.drawImage(img, 0, 0);
+                    return cx.getImageData(0, 0, w, h).data;
+                };
+                const alpha = read(a);
+                const px = read(b);
+                if (!alpha || !px)
+                    return null;
+                const hex = args.colour.trim();
+                const parse = (v) => {
+                    const m3 = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(v);
+                    if (m3) {
+                        return [
+                            parseInt(m3[1].repeat(2), 16),
+                            parseInt(m3[2].repeat(2), 16),
+                            parseInt(m3[3].repeat(2), 16),
+                        ];
+                    }
+                    // 4 and 8 digits carry an ALPHA the ground does not
+                    // need; 6 is the plain case. Finding 5 of the fifth
+                    // completion review: this handled 3 and 6 while the
+                    // token reader that produces the value accepts 3 to 8,
+                    // so a `#rrggbbaa` background fell through to the
+                    // white fallback and every contrast ratio on that
+                    // ground was computed against a colour nobody chose —
+                    // silently, because white is a plausible answer.
+                    const m68 = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})(?:[0-9a-f]{2})?$/i.exec(v);
+                    if (m68) {
+                        return [
+                            parseInt(m68[1], 16),
+                            parseInt(m68[2], 16),
+                            parseInt(m68[3], 16),
+                        ];
+                    }
+                    const m4 = /^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/i.exec(v);
+                    if (m4) {
+                        return [
+                            parseInt(m4[1].repeat(2), 16),
+                            parseInt(m4[2].repeat(2), 16),
+                            parseInt(m4[3].repeat(2), 16),
+                        ];
+                    }
+                    const rgb = /rgba?\(\s*(\d+)[,\s]+(\d+)[,\s]+(\d+)/.exec(v);
+                    if (rgb) {
+                        return [Number(rgb[1]), Number(rgb[2]), Number(rgb[3])];
+                    }
+                    return [255, 255, 255];
+                };
+                const ground = parse(hex);
+                const lum = (c) => {
+                    const f = (v) => {
+                        const x = v / 255;
+                        return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+                    };
+                    return 0.2126 * f(c[0]) + 0.7152 * f(c[1]) + 0.0722 * f(c[2]);
+                };
+                const groundLum = lum(ground);
+                const ratio = (c) => {
+                    const l = lum(c);
+                    const hi = Math.max(l, groundLum);
+                    const lo = Math.min(l, groundLum);
+                    return (hi + 0.05) / (lo + 0.05);
+                };
+                // Declared holes and translucent shapes, mapped from user
+                // units into this image.
+                //
+                // The graphic's own extent in IMAGE pixels, which is what a
+                // user-unit coordinate maps into — not the capture's. The
+                // page is `margin:0` with `body>svg{width:cssWidth}`, so it
+                // sits at the top-left corner and the height follows the
+                // viewBox aspect. A file with no viewBox is not mapped at
+                // all (the guard below), so there is no aspect to miss.
+                const gW = w * args.graphic.w;
+                const gH = h * args.graphic.h;
+                const within = (boxes, x, y) => {
+                    if (!args.vb || boxes.length === 0)
+                        return false;
+                    if (gW <= 0 || gH <= 0 || x >= gW || y >= gH)
+                        return false;
+                    const ux = args.vb.x + (x / gW) * args.vb.w;
+                    const uy = args.vb.y + (y / gH) * args.vb.h;
+                    return boxes.some((box) => ux >= box.x && ux <= box.x + box.w && uy >= box.y && uy <= box.y + box.h);
+                };
+                const inHole = (x, y) => within(args.holes, x, y);
+                const inSoft = (x, y) => within(args.soft, x, y);
+                // The OUTER silhouette: flood the transparent region
+                // inwards from the border. What the flood cannot reach is
+                // inside the graphic — including the hairline gaps between
+                // abutting shapes, which is the thing step 4.1 counts and
+                // which an `alpha >= 200` definition excludes by
+                // construction (measured: 0 bleed pixels on the planted
+                // fixture before this).
+                const opaque = (i) => alpha[i * 4 + 3] >= 200;
+                const outside = new Uint8Array(w * h);
+                const stack = [];
+                const push = (i) => {
+                    if (outside[i] === 1 || opaque(i))
+                        return;
+                    outside[i] = 1;
+                    stack.push(i);
+                };
+                for (let x = 0; x < w; x += 1) {
+                    push(x);
+                    push((h - 1) * w + x);
+                }
+                for (let y = 0; y < h; y += 1) {
+                    push(y * w);
+                    push(y * w + (w - 1));
+                }
+                while (stack.length > 0) {
+                    const i = stack.pop();
+                    const x = i % w;
+                    const y = (i - x) / w;
+                    if (x > 0)
+                        push(i - 1);
+                    if (x + 1 < w)
+                        push(i + 1);
+                    if (y > 0)
+                        push(i - w);
+                    if (y + 1 < h)
+                        push(i + w);
+                }
+                let sil = 0;
+                let painted = 0;
+                let low = 0;
+                let bleed = 0;
+                for (let i = 0; i < w * h; i += 1) {
+                    if (outside[i] === 1)
+                        continue;
+                    sil += 1;
+                    const c = [
+                        px[i * 4],
+                        px[i * 4 + 1],
+                        px[i * 4 + 2],
+                    ];
+                    // Contrast is asked of PAINTED pixels only: the ratio
+                    // of a gap against the ground showing through it is the
+                    // ratio of the ground against itself.
+                    if (opaque(i)) {
+                        painted += 1;
+                        if (ratio(c) < args.minContrast)
+                            low += 1;
+                    }
+                    // Bleed is an INTERIOR pixel the graphic does not fully
+                    // cover, so the ground shows through it.
+                    //
+                    // Measured, and this is the second definition: comparing
+                    // the pixel's colour against the ground within a
+                    // tolerance read 0 on the planted fixture, because a
+                    // half-covered seam composites to a BLEND of the two
+                    // greys and the ground — nowhere near the ground itself.
+                    // Alpha is the thing that is actually wrong, and it is
+                    // the same number whatever colour the ground is, which
+                    // is why the finding fires on the dark row: that is the
+                    // capture where the consequence is visible.
+                    // Finding 7: a legitimately TRANSLUCENT interior is
+                    // not a seam. A `fill-opacity="0.5"` shape is excluded
+                    // from `painted` and would otherwise be counted as
+                    // near-total bleed against a 0.002 threshold — a
+                    // warning on a correct file, which is the Risk 1
+                    // failure this whole concern is shaped around. The
+                    // caller passes those shapes' extents the same way it
+                    // passes declared holes, because "is this coverage
+                    // intended" is again a question only the author
+                    // answers.
+                    const x = i % w;
+                    const y = Math.floor(i / w);
+                    if (!opaque(i) && !inHole(x, y) && !inSoft(x, y))
+                        bleed += 1;
+                }
+                return { silhouette: sil, painted, low, bleed };
+            }, {
+                silhouette: silhouette.toString('base64'),
+                ground: shot.toString('base64'),
+                colour,
+                holes: spec.holeBoxes,
+                soft: spec.softBoxes,
+                vb: spec.viewBox,
+                minContrast: MIN_CONTRAST_RATIO,
+                graphic: graphicFraction(spec),
+            });
+            if (counts === null)
+                continue;
+            out.push({
+                background: mode,
+                background_color: colour,
+                silhouette_px: counts.silhouette,
+                painted_px: counts.painted,
+                low_contrast_px: counts.low,
+                low_contrast_share: counts.painted === 0 ? 0 : counts.low / counts.painted,
+                bleed_px: counts.bleed,
+                bleed_share: counts.silhouette === 0 ? 0 : counts.bleed / counts.silhouette,
+            });
+        }
+        finally {
+            await scratch.close();
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=uiRenderAssetGrounds.js.map

package/dist/cli/commands/uiRenderAssetIsolation.js

@@ -0,0 +1,85 @@
+/**
+ * Isolation of the asset under test — which is untrusted input — during its
+ * own witness (16.5.0 release review).
+ *
+ * Scripts are disabled for the whole browser context, so a `<script>` or `on*`
+ * handler in the asset never runs; that is also what keeps WebSocket and
+ * WebRTC closed, since `page.route` intercepts neither. A request is allowed
+ * only on the `file:`, `data:`, `blob:` and `about:` schemes, and a `file:`
+ * request only when it resolves inside the project root or the asset's own
+ * directory, so an asset cannot pull an arbitrary local file into a capture.
+ * The comparison pages inline everything they read, so they allow no `file:`.
+ *
+ * The cost, accepted: a host document that builds its visual state with
+ * JavaScript is witnessed as its static markup, not as it would run.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ALLOWED_SCHEMES } from './uiRenderAssetTypes.js';
+/** The directories a `file:` request may resolve into for this asset. */
+export function fileRootsFor(projectRoot, file) {
+    return [projectRoot, path.dirname(path.resolve(file))];
+}
+/** True unless `url` is a `file:` URL resolving outside `root` (symlinks followed). */
+export function fileInside(url, root) {
+    if (!url.startsWith('file:'))
+        return true;
+    const real = (p) => {
+        try {
+            return fs.realpathSync(p);
+        }
+        catch {
+            return path.resolve(p);
+        }
+    };
+    let target;
+    try {
+        target = real(fileURLToPath(url));
+    }
+    catch {
+        return false;
+    }
+    const base = real(root);
+    return target === base || target.startsWith(base + path.sep);
+}
+/**
+ * May the witness page load `url`? A `file:` URL needs a root it resolves
+ * inside; with no roots — a page that inlines everything it reads — none does.
+ */
+export function requestAllowed(url, fileRoots) {
+    if (!ALLOWED_SCHEMES.some((s) => url.startsWith(s)))
+        return false;
+    return !url.startsWith('file:') || fileRoots.some((root) => fileInside(url, root));
+}
+/**
+ * Route every request of `page` through `requestAllowed`, recording what was
+ * refused. One opener for every witness page, so no page confines less than
+ * another (16.5.0 review: the comparison pages checked the scheme only).
+ */
+export async function confinePage(page, blocked, fileRoots, fulfil) {
+    await page.route('**/*', async (route) => {
+        if (fulfil && (await fulfil(route)))
+            return;
+        const url = route.request().url();
+        if (!requestAllowed(url, fileRoots)) {
+            blocked.push(url);
+            await route.abort();
+            return;
+        }
+        await route.continue();
+    });
+}
+/**
+ * Add a stylesheet to the page. Not `page.addStyleTag`: it waits on a
+ * page-script `onload`, which never fires with scripts disabled, while
+ * `evaluate` runs outside the page's own scripts.
+ */
+export async function injectStyle(page, css) {
+    await page.evaluate((text) => {
+        const style = document.createElement('style');
+        style.textContent = text;
+        (document.head ?? document.documentElement).appendChild(style);
+    }, css);
+}
+//# sourceMappingURL=uiRenderAssetIsolation.js.map