@crvouga/atlas 0.0.0-stage → 0.2.0

package/dist/reports/src/snapshot-bundle.js

@@ -0,0 +1,94 @@
+/** Indexed gzip chunks keep snapshot uploads small in count and reads bounded. */
+import { readBytes, readObjectBytes, readUtf8, writeUtf8, } from './object-io.js';
+import { eachLimited, inCompletionOrder } from './completion-order.js';
+const CHUNK_BYTES = 1024 * 1024;
+function base64(bytes) {
+    let text = '';
+    for (let at = 0; at < bytes.length; at += 0x8000)
+        text += String.fromCharCode(...bytes.subarray(at, at + 0x8000));
+    return btoa(text);
+}
+async function gzip(text) {
+    const input = new Blob([text]).stream();
+    return readBytes(input.pipeThrough(new CompressionStream('gzip')));
+}
+export async function publishSnapshotBundle(args) {
+    const index = {};
+    const chunks = [];
+    let entries = {};
+    let size = 0;
+    const flush = async () => {
+        if (size === 0)
+            return;
+        chunks.push(await gzip(JSON.stringify(entries)));
+        entries = {};
+        size = 0;
+    };
+    for (const file of args.files) {
+        const object = await args.local.get(`${args.localPrefix}${file}`);
+        if (object === null)
+            throw new Error(`Missing report snapshot: ${args.localPrefix}${file}`);
+        const snapshot = {
+            contentType: object.contentType,
+            base64: base64(await readBytes(object.body)),
+        };
+        const length = snapshot.base64.length + file.length + snapshot.contentType.length;
+        if (size > 0 && size + length > CHUNK_BYTES)
+            await flush();
+        entries[file] = snapshot;
+        index[file] = `snapshots-${chunks.length}.json.gz`;
+        size += length;
+    }
+    await flush();
+    await eachLimited(chunks.map((bytes, part) => ({ bytes, part })), 4, ({ bytes, part }) => {
+        return args.remote.put(`${args.remotePrefix}snapshots-${part}.json.gz`, bytes, 'application/gzip');
+    });
+    await writeUtf8(args.remote, `${args.remotePrefix}snapshots.json`, JSON.stringify(index), 'application/json');
+}
+export async function readBundledSnapshot(store, prefix, file) {
+    const text = await readUtf8(store, `${prefix}snapshots.json`);
+    if (text === null)
+        return null;
+    const index = JSON.parse(text);
+    const chunk = index[file];
+    if (chunk === undefined)
+        return null;
+    const snapshots = await readSnapshotChunk(store, prefix, chunk);
+    return snapshotBody(snapshots?.[file]);
+}
+async function readSnapshotChunk(store, prefix, chunk) {
+    if (!/^snapshots-\d+\.json\.gz$/.test(chunk))
+        throw new Error('Invalid snapshot chunk');
+    const packed = await readObjectBytes(store, `${prefix}${chunk}`);
+    if (packed === null)
+        return null;
+    const stream = new Blob([packed])
+        .stream()
+        .pipeThrough(new DecompressionStream('gzip'));
+    return JSON.parse(new TextDecoder().decode(await readBytes(stream)));
+}
+function snapshotBody(snapshot) {
+    if (snapshot === undefined)
+        return null;
+    const binary = atob(snapshot.base64);
+    const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    return { bytes, contentType: snapshot.contentType };
+}
+/** A streamed test reads each compressed chunk once even when it contains many frames. */
+export async function* readBundledSnapshots(store, prefix, files) {
+    const text = await readUtf8(store, `${prefix}snapshots.json`);
+    if (text === null)
+        return;
+    const index = JSON.parse(text);
+    const chunks = [...new Set([...files].flatMap((file) => index[file] ?? []))];
+    const reads = chunks.map((chunk) => () => readSnapshotChunk(store, prefix, chunk));
+    for await (const snapshots of inCompletionOrder(reads, 8)) {
+        for (const [file, snapshot] of Object.entries(snapshots ?? {})) {
+            if (!files.has(file))
+                continue;
+            const body = snapshotBody(snapshot);
+            if (body !== null)
+                yield { file, ...body };
+        }
+    }
+}

package/dist/reports/src/snapshot-surface.d.ts

@@ -0,0 +1,29 @@
+import type { ReportStepHit } from './report-types.js';
+export type HitResult = 'none' | 'found' | 'missing';
+/**
+ * Point `html` / `body` / `:root` at the phone viewport, and turn a full
+ * browser viewport unit into a percentage of that box.
+ */
+export declare function scopeSnapshotCss(css: string): string;
+/** Make sure `doc` is our standards-mode shell with `frameCss` installed. */
+export declare function ensureShell(doc: Document, frameCss: string): void;
+/** Chained first match — mirrors how the UI driver resolves `get(a).get(b)`. */
+export declare function resolveHitTarget(scope: ParentNode, path: readonly string[]): Element | null;
+/** Draw the one press overlay on `hit`'s target. */
+export declare function drawHit(doc: Document, hit: ReportStepHit | null): HitResult;
+/**
+ * Paint one snapshot into `doc` (already a shell) and draw `hit`. `key`
+ * identifies the snapshot for parse caching.
+ */
+export declare function paintSnapshot(doc: Document, snap: {
+    readonly key: string;
+    readonly html: string;
+}, hit: ReportStepHit | null): HitResult;
+/** In-page snapshot surface. No iframe. */
+export declare function createSnapshotHost(): HTMLDivElement;
+/** Paint one snapshot into the shadow tree `createSnapshotHost` built. */
+export declare function paintSnapshotHost(host: HTMLElement, snap: {
+    readonly key: string;
+    readonly html: string;
+    readonly css: string;
+}, hit: ReportStepHit | null): HitResult;

package/dist/reports/src/snapshot-surface.js

@@ -0,0 +1,339 @@
+import { cleanSnapshotHtml, PHONE_H, PHONE_W, } from './phone.js';
+/**
+ * One long-lived snapshot surface per client panel. Frames are painted by
+ * swapping the parsed snapshot DOM into that surface synchronously, so
+ * scrubbing never re-parses `frameCss` or refetches fonts. The press target
+ * is resolved against the painted DOM with the driver's chained first-match
+ * semantics and drawn as a single overlay from real layout.
+ *
+ * The phone paints into an open shadow tree, not an iframe: embedded
+ * browsers drop iframe documents, and a shadow tree stays in the page.
+ * Snapshot styles sit on the shadow root, and the host is the 390×844
+ * viewport the app shell fills.
+ */
+const FRAME_CSS_ID = 'sr-frame-css';
+const OVERLAY_ID = 'sr-press';
+const SNAP_ATTR = 'data-sr-snap';
+const PARSE_CACHE_MAX = 256;
+const OVERLAY_CSS = `#${OVERLAY_ID}{position:absolute;display:none;pointer-events:none;z-index:2147483647;box-sizing:border-box;border:2px solid #ff5a8a;border-radius:6px;box-shadow:0 0 0 4px rgba(255,90,138,.35)}#${OVERLAY_ID} i{position:absolute;width:14px;height:14px;margin:-7px 0 0 -7px;border-radius:50%;background:#ff5a8a;box-shadow:0 0 0 4px rgba(255,90,138,.35)}`;
+const parseCache = new Map();
+/**
+ * Point `html` / `body` / `:root` at the phone viewport, and turn a full
+ * browser viewport unit into a percentage of that box.
+ */
+export function scopeSnapshotCss(css) {
+    const scoped = css.replace(/(^|[^\w-])(:root|html|body)(?![\w-])/g, (_match, prefix, token) => `${prefix}${token === 'body' ? '.sr-snap-body' : '.sr-snap-doc'}`);
+    return scoped.replace(/\b100(?:d|s|l)?v[hw]\b/g, '100%');
+}
+/** Changes when the snapshot bytes change, even if the file name does not. */
+function contentStamp(key, html) {
+    let hash = 5381;
+    for (let i = 0; i < html.length; i += 1) {
+        hash = Math.imul(hash, 33) ^ html.charCodeAt(i);
+    }
+    return `${key}:${(hash >>> 0).toString(16)}`;
+}
+function parseSnapshot(key, html) {
+    const cached = parseCache.get(key);
+    if (cached)
+        return cached;
+    const doc = new DOMParser().parseFromString(cleanSnapshotHtml(html), 'text/html');
+    const parsed = {
+        headKey: doc.head.innerHTML,
+        head: Array.from(doc.head.childNodes),
+        body: doc.body,
+        htmlAttrs: Array.from(doc.documentElement.attributes),
+    };
+    if (parseCache.size >= PARSE_CACHE_MAX) {
+        const oldest = parseCache.keys().next().value;
+        if (oldest !== undefined)
+            parseCache.delete(oldest);
+    }
+    parseCache.set(key, parsed);
+    return parsed;
+}
+function shellHtml(frameCss) {
+    const base = `html,body{margin:0}html{position:relative}${OVERLAY_CSS}`;
+    return `<!DOCTYPE html><html><head><meta charset="utf-8"><style id="${FRAME_CSS_ID}">${frameCss}${base}</style></head><body></body></html>`;
+}
+/** Make sure `doc` is our standards-mode shell with `frameCss` installed. */
+export function ensureShell(doc, frameCss) {
+    if (doc.getElementById(FRAME_CSS_ID))
+        return;
+    doc.open();
+    doc.write(shellHtml(frameCss));
+    doc.close();
+}
+function documentRoot(doc) {
+    return {
+        head: doc.head,
+        body: doc.body,
+        documentElement: doc.documentElement,
+        sheets: doc.head,
+        scopeCss: false,
+        docClass: null,
+        bodyClass: null,
+        getElementById: (id) => doc.getElementById(id),
+        importNode: (node, deep) => doc.importNode(node, deep),
+        createElement: (tag) => doc.createElement(tag),
+    };
+}
+/** Keep `token` on `el` after a snapshot overwrites its class. */
+function pinClass(el, token) {
+    if (!token)
+        return;
+    const parts = (el.getAttribute('class') ?? '').split(/\s+/).filter(Boolean);
+    if (parts.includes(token))
+        return;
+    parts.push(token);
+    el.setAttribute('class', parts.join(' '));
+}
+function syncAttributes(target, attrs) {
+    const keep = new Set(attrs.map((attr) => attr.name));
+    for (const attr of Array.from(target.attributes)) {
+        if (!keep.has(attr.name))
+            target.removeAttribute(attr.name);
+    }
+    for (const attr of attrs) {
+        if (target.getAttribute(attr.name) !== attr.value) {
+            target.setAttribute(attr.name, attr.value);
+        }
+    }
+}
+function adoptHead(root, node) {
+    if (node.nodeType !== 1)
+        return null;
+    const copy = root.importNode(node, true);
+    if (root.scopeCss && copy.tagName === 'STYLE') {
+        copy.textContent = scopeSnapshotCss(copy.textContent ?? '');
+    }
+    copy.setAttribute(SNAP_ATTR, '');
+    return copy;
+}
+function isSheetNode(node) {
+    const tag = node.tagName;
+    return tag === 'STYLE' || tag === 'LINK' || tag === 'BASE';
+}
+function clearAdopted(root) {
+    for (const old of Array.from(root.head.querySelectorAll(`[${SNAP_ATTR}]`))) {
+        old.remove();
+    }
+    if (root.sheets === root.head)
+        return;
+    for (const old of Array.from(root.sheets.querySelectorAll(`[${SNAP_ATTR}]`))) {
+        old.remove();
+    }
+}
+/** Styles go on the shadow root. A `display` wrapper drops them in Chromium. */
+function placeAdopted(root, copy) {
+    const parent = isSheetNode(copy) ? root.sheets : root.head;
+    const frame = root.getElementById(FRAME_CSS_ID);
+    if (frame && frame.parentNode === parent)
+        parent.insertBefore(copy, frame);
+    else
+        parent.appendChild(copy);
+}
+function syncHead(root, parsed) {
+    if (root.head.getAttribute(SNAP_ATTR) === parsed.headKey)
+        return;
+    clearAdopted(root);
+    for (const node of parsed.head) {
+        const copy = adoptHead(root, node);
+        if (!copy)
+            continue;
+        placeAdopted(root, copy);
+    }
+    root.head.setAttribute(SNAP_ATTR, parsed.headKey);
+}
+function testIdSelector(id) {
+    return `[data-testid="${id.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"]`;
+}
+/** Chained first match — mirrors how the UI driver resolves `get(a).get(b)`. */
+export function resolveHitTarget(scope, path) {
+    let current = scope;
+    let found = null;
+    for (const id of path) {
+        found = current.querySelector(testIdSelector(id));
+        if (!found)
+            return null;
+        current = found;
+    }
+    return found;
+}
+function overlayEl(root) {
+    const existing = root.getElementById(OVERLAY_ID);
+    if (existing)
+        return existing;
+    const el = root.createElement('div');
+    el.id = OVERLAY_ID;
+    el.appendChild(root.createElement('i'));
+    root.documentElement.appendChild(el);
+    return el;
+}
+function hideOverlay(root) {
+    const el = root.getElementById(OVERLAY_ID);
+    if (el)
+        el.style.display = 'none';
+}
+function localBox(box, target) {
+    const boxRect = box.getBoundingClientRect();
+    const rect = target.getBoundingClientRect();
+    const sx = boxRect.width > 0 && box.clientWidth > 0
+        ? boxRect.width / box.clientWidth
+        : 1;
+    const sy = boxRect.height > 0 && box.clientHeight > 0
+        ? boxRect.height / box.clientHeight
+        : 1;
+    return {
+        left: (rect.left - boxRect.left) / sx,
+        top: (rect.top - boxRect.top) / sy,
+        width: rect.width / sx,
+        height: rect.height / sy,
+    };
+}
+function placeOverlay(root, target, hit) {
+    const view = root.body;
+    let box = localBox(root.documentElement, target);
+    if (box.top + box.height < 0 || box.top > view.clientHeight) {
+        target.scrollIntoView({ block: 'center' });
+        box = localBox(root.documentElement, target);
+    }
+    const point = hit.point ?? { xRatio: 0.5, yRatio: 0.5 };
+    const el = overlayEl(root);
+    el.style.display = 'block';
+    el.style.left = `${box.left - 3}px`;
+    el.style.top = `${box.top - 3}px`;
+    el.style.width = `${box.width + 6}px`;
+    el.style.height = `${box.height + 6}px`;
+    const dot = el.firstElementChild;
+    if (dot) {
+        dot.style.left = `${3 + box.width * point.xRatio}px`;
+        dot.style.top = `${3 + box.height * point.yRatio}px`;
+    }
+}
+function drawOn(root, hit) {
+    if (!hit || hit.path.length === 0) {
+        hideOverlay(root);
+        return 'none';
+    }
+    const target = resolveHitTarget(root.documentElement, hit.path);
+    if (!target) {
+        hideOverlay(root);
+        return 'missing';
+    }
+    placeOverlay(root, target, hit);
+    return 'found';
+}
+/** Draw the one press overlay on `hit`'s target. */
+export function drawHit(doc, hit) {
+    if (!doc.getElementById('sr-overlay-css')) {
+        const style = doc.createElement('style');
+        style.id = 'sr-overlay-css';
+        style.textContent = OVERLAY_CSS;
+        doc.head.appendChild(style);
+    }
+    return drawOn(documentRoot(doc), hit);
+}
+function paintRoot(root, snap, hit) {
+    const parsed = parseSnapshot(snap.key, snap.html);
+    syncHead(root, parsed);
+    syncAttributes(root.documentElement, parsed.htmlAttrs);
+    pinClass(root.documentElement, root.docClass);
+    syncAttributes(root.body, Array.from(parsed.body.attributes));
+    pinClass(root.body, root.bodyClass);
+    root.body.replaceChildren(...Array.from(parsed.body.childNodes, (node) => root.importNode(node, true)));
+    root.body.scrollTop = 0;
+    return drawOn(root, hit);
+}
+/**
+ * Paint one snapshot into `doc` (already a shell) and draw `hit`. `key`
+ * identifies the snapshot for parse caching.
+ */
+export function paintSnapshot(doc, snap, hit) {
+    return paintRoot(documentRoot(doc), snap, hit);
+}
+const PHONE_BOX = `width:${String(PHONE_W)}px;height:${String(PHONE_H)}px`;
+/** Shell fill. Unlayered, so it wins over the layered theme host. */
+const HOST_FILL = [
+    'display:flex;flex-direction:column;flex:1 1 auto;',
+    'min-width:0;min-height:0;width:100%;height:100%;overflow:hidden;',
+    'background-color:var(--ui-color-background,#121418);',
+    'color:var(--ui-color-text,#f4f6f8)',
+].join('');
+const HOST_LAYOUT = [
+    `:host{display:block;${PHONE_BOX};background:#121418;color:#f4f6f8;`,
+    'font:16px/1.45 system-ui,sans-serif}',
+    `.sr-snap-doc{position:relative;${PHONE_BOX};display:flex;`,
+    'flex-direction:column;overflow:hidden}',
+    `.sr-snap-body{position:relative;${PHONE_BOX};display:flex;`,
+    'flex-direction:column;flex:1 1 auto;min-height:0;overflow:hidden}',
+    '.sr-snap-head{display:none}',
+    '.sr-snap-body>#root,.sr-snap-body>.dom-root,.sr-snap-body>.themeHost,',
+    '#root>.themeHost,.dom-root>.themeHost,.dom-root>*>.themeHost',
+    `{${HOST_FILL}}`,
+].join('');
+/** In-page snapshot surface. No iframe. */
+export function createSnapshotHost() {
+    const host = document.createElement('div');
+    host.className = 'sr-snap';
+    const shadow = host.attachShadow({ mode: 'open' });
+    const style = document.createElement('style');
+    style.id = FRAME_CSS_ID;
+    const docEl = document.createElement('div');
+    docEl.className = 'sr-snap-doc';
+    const head = document.createElement('div');
+    head.className = 'sr-snap-head';
+    const body = document.createElement('div');
+    body.className = 'sr-snap-body';
+    docEl.append(head, body);
+    shadow.append(docEl, style);
+    return host;
+}
+function hostRoot(host) {
+    const shadow = host.shadowRoot;
+    const documentElement = shadow?.querySelector('.sr-snap-doc');
+    const head = shadow?.querySelector('.sr-snap-head');
+    const body = shadow?.querySelector('.sr-snap-body');
+    if (!shadow || !documentElement || !head || !body)
+        return null;
+    if (!('style' in documentElement) ||
+        !('style' in head) ||
+        !('style' in body)) {
+        return null;
+    }
+    return {
+        head: head,
+        body: body,
+        documentElement: documentElement,
+        sheets: shadow,
+        scopeCss: true,
+        docClass: 'sr-snap-doc',
+        bodyClass: 'sr-snap-body',
+        getElementById: (id) => shadow.getElementById(id),
+        importNode: (node, deep) => document.importNode(node, deep),
+        createElement: (tag) => document.createElement(tag),
+    };
+}
+function installHostCss(root, frameCss) {
+    const style = root.getElementById(FRAME_CSS_ID);
+    if (!style)
+        return;
+    const next = `${scopeSnapshotCss(frameCss)}${HOST_LAYOUT}${OVERLAY_CSS}`;
+    if (style.textContent !== next)
+        style.textContent = next;
+}
+/** Paint one snapshot into the shadow tree `createSnapshotHost` built. */
+export function paintSnapshotHost(host, snap, hit) {
+    const root = hostRoot(host);
+    if (!root)
+        return 'none';
+    installHostCss(root, snap.css);
+    const stamp = contentStamp(snap.key, snap.html);
+    if (host.dataset['snap'] === stamp && root.body.childNodes.length > 0) {
+        return drawOn(root, hit);
+    }
+    const result = paintRoot(root, { key: stamp, html: snap.html }, hit);
+    host.dataset['snap'] = stamp;
+    void root.body.offsetHeight;
+    return result;
+}

package/dist/reports/src/source-content.d.ts

@@ -0,0 +1,30 @@
+import type { ObjectStore } from './object-store.js';
+import type { SourceRecord } from './protocol.js';
+export type SourceIdentity = {
+    readonly taskHash: string;
+    readonly generation: number;
+};
+type SourceReference = {
+    readonly record: SourceRecord;
+    readonly contentPrefix: string;
+};
+export declare function reportGeneration(nowMs: number, retentionDays: number): number;
+export declare function sourceContentPrefix(identity: SourceIdentity, source: string): string;
+export declare function attachSource(store: ObjectStore, args: {
+    readonly sha: string;
+    readonly record: SourceRecord;
+    readonly contentPrefix: string;
+}): Promise<void>;
+export declare function reuseSource(store: ObjectStore, args: {
+    readonly sha: string;
+    readonly packageDir: string;
+    readonly bucket: string;
+    readonly identity: SourceIdentity;
+}): Promise<SourceRecord | null>;
+export declare function readStoredSource(store: ObjectStore, sha: string, source: string): Promise<SourceReference | null>;
+export declare function sourceTestPrefix(store: ObjectStore, args: {
+    readonly sha: string;
+    readonly source: string;
+    readonly testId: string;
+}): Promise<string | null>;
+export {};

package/dist/reports/src/source-content.js

@@ -0,0 +1,63 @@
+/** A source can own commit-local files or reference a reusable complete source. */
+import { readUtf8, writeUtf8 } from './object-io.js';
+import { commitPrefix, isKeySegment, sourceId, sourceKey } from './keys.js';
+import { reportStore } from './publication.js';
+export function reportGeneration(nowMs, retentionDays) {
+    if (!Number.isFinite(nowMs) || nowMs < 0)
+        throw new Error('Report time must be nonnegative');
+    if (!Number.isInteger(retentionDays) || retentionDays < 1)
+        throw new Error('Report retention must be a positive number of days');
+    return Math.floor(nowMs / (retentionDays * 86_400_000));
+}
+export function sourceContentPrefix(identity, source) {
+    if (!/^[0-9a-f]{16,64}$/.test(identity.taskHash))
+        throw new Error('Report identity needs an exact task hash');
+    if (!Number.isSafeInteger(identity.generation) || identity.generation < 0)
+        throw new Error('Report generation must be a nonnegative integer');
+    if (!isKeySegment(source))
+        throw new Error('Invalid report source');
+    return `content/v2/${identity.generation}/${identity.taskHash}/${source}/`;
+}
+export async function attachSource(store, args) {
+    await writeUtf8(store, sourceKey(args.sha, args.record.source), JSON.stringify({ record: args.record, contentPrefix: args.contentPrefix }), 'application/json; charset=utf-8');
+}
+export async function reuseSource(store, args) {
+    const source = sourceId(args.packageDir, args.bucket);
+    const contentPrefix = sourceContentPrefix(args.identity, source);
+    const text = await readUtf8(store, `${contentPrefix}complete.json`);
+    if (text === null)
+        return null;
+    const record = JSON.parse(text);
+    if (record.source !== source ||
+        record.packageDir !== args.packageDir ||
+        record.bucket !== args.bucket ||
+        record.status !== 'passed')
+        return null;
+    await attachSource(store, { sha: args.sha, record, contentPrefix });
+    return record;
+}
+export async function readStoredSource(store, sha, source) {
+    store = await reportStore(store, sha);
+    const text = await readUtf8(store, sourceKey(sha, source));
+    if (text === null)
+        return null;
+    const stored = JSON.parse(text);
+    if ('record' in stored) {
+        const prefix = stored.contentPrefix;
+        if (!/^content\/v2\/\d+\/[0-9a-f]{16,64}\/[a-zA-Z0-9._-]+\/$/.test(prefix) ||
+            !prefix.endsWith(`/${source}/`) ||
+            stored.record.source !== source)
+            throw new Error('Invalid report content reference');
+        return stored;
+    }
+    return {
+        record: stored,
+        contentPrefix: `${commitPrefix(sha)}tests/${source}/`,
+    };
+}
+export async function sourceTestPrefix(store, args) {
+    if (!isKeySegment(args.testId))
+        throw new Error('Invalid report test');
+    const stored = await readStoredSource(store, args.sha, args.source);
+    return stored === null ? null : `${stored.contentPrefix}${args.testId}/`;
+}

package/dist/reports/src/source-entries.d.ts

@@ -0,0 +1,4 @@
+import type { HtmlReportTest } from './recording-bundle.js';
+import type { BundleEntry } from './bundle.js';
+import type { PublishSourceArgs } from './publish.js';
+export declare function sourceEntries(args: PublishSourceArgs, source: string, tests: readonly HtmlReportTest[], runId: string): AsyncGenerator<BundleEntry>;

package/dist/reports/src/source-entries.js

@@ -0,0 +1,34 @@
+import { testFrameKey } from './recording-keys.js';
+import { remoteTestFileKey, remoteTestReportKey } from './keys.js';
+const JSON_TYPE = 'application/json; charset=utf-8';
+function frameFiles(steps, out) {
+    for (const step of steps) {
+        for (const frame of step.frames) {
+            for (const blob of frame.snapshots)
+                out.add(blob.file);
+        }
+        frameFiles(step.steps, out);
+    }
+}
+export async function* sourceEntries(args, source, tests, runId) {
+    for (const { report } of [...tests].sort((a, b) => a.report.meta.testId < b.report.meta.testId ? -1 : 1)) {
+        const { testId } = report.meta;
+        yield {
+            key: remoteTestReportKey(args.sha, source, testId),
+            bytes: new TextEncoder().encode(JSON.stringify(report)),
+            contentType: JSON_TYPE,
+        };
+        const files = new Set();
+        frameFiles(report.steps, files);
+        for (const file of [...files].sort()) {
+            const obj = await args.local.get(testFrameKey(runId, testId, file));
+            if (obj === null)
+                throw new Error(`Missing report snapshot: ${file}`);
+            yield {
+                key: remoteTestFileKey(args.sha, source, testId, file),
+                bytes: new Uint8Array(await new Response(obj.body).arrayBuffer()),
+                contentType: obj.contentType,
+            };
+        }
+    }
+}

package/dist/reports/src/source-part.d.ts

@@ -0,0 +1,4 @@
+import type { ReportPart } from './explorer-types.js';
+import type { SourceRecord } from './protocol.js';
+export declare function sourcePart(sha: string, source: SourceRecord): ReportPart;
+export declare function sourceParts(sha: string, source: SourceRecord): readonly ReportPart[];

package/dist/reports/src/source-part.js

@@ -0,0 +1,66 @@
+import { viewerTestId } from './keys.js';
+export function sourcePart(sha, source) {
+    const kind = source.bucket === 'ui-quality' ? 'ui-quality' : 'behavior';
+    const primary = source.evidence?.find((part) => part.kind !== 'performance');
+    if (primary)
+        return withProducerFailure({
+            ...primary,
+            sha,
+            id: source.source,
+            recordedAtMs: source.updatedAtMs,
+            checks: primary.checks.map((check) => ({
+                ...check,
+                id: viewerTestId(source.source, check.id),
+            })),
+        }, source);
+    return withProducerFailure({
+        sha,
+        id: source.source,
+        kind,
+        title: `${source.packageDir} / ${source.bucket}`,
+        recordedAtMs: source.updatedAtMs,
+        checks: source.tests.map((test) => ({
+            id: viewerTestId(source.source, test.testId),
+            title: test.title,
+            status: test.status === 'skipped' ? 'not-run' : test.status,
+            detail: test.error ?? '',
+            ...(test.sourceFile === undefined ? {} : { specPath: test.sourceFile }),
+            measurements: [],
+        })),
+    }, source);
+}
+function withProducerFailure(part, source) {
+    if (source.status !== 'failed' ||
+        part.checks.some((check) => check.status === 'failed'))
+        return part;
+    return {
+        ...part,
+        checks: [
+            ...part.checks,
+            {
+                id: `${source.source}:producer-failure`,
+                title: 'Producer failed',
+                status: 'failed',
+                detail: 'The report producer did not complete successfully. Individual recorded outcomes are preserved.',
+                measurements: [],
+            },
+        ],
+    };
+}
+export function sourceParts(sha, source) {
+    return [
+        sourcePart(sha, source),
+        ...(source.evidence ?? [])
+            .filter((part) => part.kind === 'performance')
+            .map((part) => ({
+            ...part,
+            sha,
+            id: `${source.source}--${part.kind}`,
+            recordedAtMs: source.updatedAtMs,
+            checks: part.checks.map((check) => ({
+                ...check,
+                id: viewerTestId(source.source, check.id),
+            })),
+        })),
+    ];
+}

package/dist/reports/src/source-reader.d.ts

@@ -0,0 +1,6 @@
+import type { ObjectStore } from './object-store.js';
+import type { BundleEntry } from './bundle.js';
+export declare function sourceReader(store: ObjectStore, args: {
+    sha: string;
+    source: string;
+}): Promise<(key: string) => Promise<BundleEntry | null>>;