@crvouga/atlas 0.0.0-stage → 0.2.0

package/dist/reports/src/read.js

@@ -0,0 +1,214 @@
+/**
+ * Read side of the shared reports store: what a reports API serves. Pure over
+ * an injected {@link ObjectStore}, {@link Clock} and {@link Timers}; nothing
+ * here imports a runtime or an HTTP framework.
+ */
+import { readUtf8 } from './object-io.js';
+import { inCompletionOrder } from './completion-order.js';
+import { COMMITS_INDEX_PREFIX, commitKey, frameCssKey, isFramePath, shaOfIndexKey, sourceOfKey, sourcesPrefix, } from './keys.js';
+import { reportStore } from './publication.js';
+import { readBundledSnapshot, readBundledSnapshots } from './snapshot-bundle.js';
+import { readStoredSource, sourceTestPrefix } from './source-content.js';
+import { sourceReader } from './source-reader.js';
+/** Parallel object reads per stream. */
+const READ_WIDTH = 16;
+const TEXT_MEDIA = new Set(['html', 'json', 'text']);
+async function readJson(store, key) {
+    const text = await readUtf8(store, key);
+    if (text === null)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export async function readCommit(store, sha) {
+    return readJson(await reportStore(store, sha), commitKey(sha));
+}
+export async function readFrameCss(store, sha) {
+    return (await reportStore(store, sha)).get(frameCssKey(sha));
+}
+/**
+ * Newest commits first, `limit` per page. A commit published twice (a rerun)
+ * has two index entries; only the newer one is ever listed, on any page.
+ */
+export async function listCommits(store, options) {
+    const seen = new Set();
+    const newest = [];
+    for (const key of await store.listKeys(COMMITS_INDEX_PREFIX)) {
+        const sha = shaOfIndexKey(key);
+        if (sha === null || seen.has(sha))
+            continue;
+        seen.add(sha);
+        newest.push({ key, sha });
+    }
+    const after = options.cursor === null
+        ? newest
+        : newest.filter((entry) => entry.key > (options.cursor ?? ''));
+    const page = after.slice(0, Math.max(1, options.limit));
+    const records = await Promise.all(page.map((e) => readCommit(store, e.sha)));
+    return {
+        commits: records.filter((r) => r !== null),
+        cursor: after.length > page.length ? (page.at(-1)?.key ?? null) : null,
+    };
+}
+function sleep(timers, ms) {
+    return new Promise((resolve) => {
+        timers.setTimeout(resolve, ms);
+    });
+}
+async function* newSources(store, sha, sent) {
+    store = await reportStore(store, sha);
+    const fresh = (await store.listKeys(sourcesPrefix(sha)))
+        .map((key) => sourceOfKey(sha, key))
+        .filter((s) => s !== null && !sent.has(s));
+    for (const s of fresh)
+        sent.add(s);
+    const reads = fresh.map((s) => async () => (await readStoredSource(store, sha, s))?.record ?? null);
+    for await (const record of inCompletionOrder(reads, READ_WIDTH)) {
+        if (record !== null)
+            yield record;
+    }
+}
+/**
+ * The commit, then every source in the order its read finishes. While the
+ * commit is running, its sources are re-listed every `pollMs` and each new
+ * one is sent as it lands, until the commit completes or `tailMs` passes.
+ * The state is read before each listing, so a listing after `complete` is
+ * the final one.
+ */
+export async function* commitEvents(store, sha, options) {
+    const startedAt = options.clock.now();
+    const sent = new Set(options.have ?? []);
+    let commit = await readCommit(store, sha);
+    yield { type: 'commit', commit };
+    for (;;) {
+        for await (const source of newSources(store, sha, sent)) {
+            yield { type: 'source', source };
+        }
+        if (commit === null && sent.size === 0) {
+            yield { type: 'end', state: 'missing' };
+            return;
+        }
+        if (commit?.state === 'complete') {
+            yield { type: 'end', state: 'complete' };
+            return;
+        }
+        if (options.clock.now() - startedAt >= options.tailMs) {
+            yield { type: 'end', state: 'running' };
+            return;
+        }
+        await sleep(options.timers, options.pollMs);
+        const latest = await readCommit(store, sha);
+        if (latest !== null && latest.state !== commit?.state) {
+            yield { type: 'commit', commit: latest };
+        }
+        commit = latest ?? commit;
+    }
+}
+function collectFrameFiles(steps, out) {
+    for (const step of steps) {
+        for (const frame of step.frames) {
+            for (const blob of frame.snapshots)
+                out.set(blob.file, blob.media);
+        }
+        collectFrameFiles(step.steps, out);
+    }
+}
+function bytesToBase64(bytes) {
+    let binary = '';
+    const CHUNK = 0x8000;
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+    }
+    return btoa(binary);
+}
+function frameBlob(obj, media) {
+    return TEXT_MEDIA.has(media)
+        ? {
+            contentType: obj.contentType,
+            text: new TextDecoder().decode(obj.bytes),
+        }
+        : { contentType: obj.contentType, base64: bytesToBase64(obj.bytes) };
+}
+/** One test's timeline, without its frame files. */
+export async function readTestReport(store, args) {
+    store = await reportStore(store, args.sha);
+    const prefix = await sourceTestPrefix(store, args);
+    if (prefix === null)
+        return null;
+    if (prefix.startsWith('content/'))
+        return readJson(store, `${prefix}report.json`);
+    const read = await sourceReader(store, args);
+    const obj = await read(`${prefix}report.json`);
+    return obj === null
+        ? null
+        : JSON.parse(new TextDecoder().decode(obj.bytes));
+}
+/** One frame file's bytes, or null when the test never wrote it. */
+export async function readFrameBody(store, args) {
+    store = await reportStore(store, args.sha);
+    if (!isFramePath(args.file))
+        throw new Error('Invalid report frame');
+    const prefix = await sourceTestPrefix(store, args);
+    if (prefix === null)
+        return null;
+    const key = `${prefix}${args.file}`;
+    if (prefix.startsWith('content/'))
+        return readBundledSnapshot(store, prefix, args.file);
+    const read = await sourceReader(store, args);
+    const obj = await read(key);
+    return obj === null
+        ? null
+        : { bytes: obj.bytes, contentType: obj.contentType };
+}
+/** Every source record of a commit, in the order each read finishes. */
+export async function listSourceRecords(store, sha) {
+    const out = [];
+    for await (const source of newSources(store, sha, new Set())) {
+        out.push(source);
+    }
+    return out;
+}
+/** A test's report, then each of its frame files as its read finishes. */
+export async function* testEvents(store, args) {
+    store = await reportStore(store, args.sha);
+    const prefix = await sourceTestPrefix(store, args);
+    const report = await readTestReport(store, args);
+    if (report === null) {
+        yield { type: 'end', found: false };
+        return;
+    }
+    yield { type: 'report', report };
+    const files = new Map();
+    collectFrameFiles(report.steps, files);
+    if (prefix?.startsWith('content/')) {
+        for await (const frame of readBundledSnapshots(store, prefix, new Set(files.keys()))) {
+            const blob = TEXT_MEDIA.has(files.get(frame.file) ?? '')
+                ? {
+                    contentType: frame.contentType,
+                    text: new TextDecoder().decode(frame.bytes),
+                }
+                : {
+                    contentType: frame.contentType,
+                    base64: bytesToBase64(frame.bytes),
+                };
+            yield { type: 'blob', file: frame.file, blob };
+        }
+        yield { type: 'end', found: true };
+        return;
+    }
+    const readFile = await sourceReader(store, args);
+    const reads = [...files].map(([file, media]) => async () => {
+        const obj = await readFile(`${prefix}${file}`);
+        return { file, blob: obj === null ? null : frameBlob(obj, media) };
+    });
+    for await (const read of inCompletionOrder(reads, READ_WIDTH)) {
+        if (read.blob !== null) {
+            yield { type: 'blob', file: read.file, blob: read.blob };
+        }
+    }
+    yield { type: 'end', found: true };
+}

package/dist/reports/src/recording-bundle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A report test with its frame files in memory: what a viewer renders. Text
+ * media are inline, binary media base64.
+ */
+import type { ReportTestStatus, RunReport } from './report-types.js';
+/** One embedded frame file: text media inline, binary media as base64. */
+export type HtmlReportBlob = {
+    readonly contentType: string;
+    readonly text?: string;
+    readonly base64?: string;
+};
+export type HtmlReportTest = {
+    readonly report: RunReport;
+    /** Keyed by the blob's `file` (relative to the test dir). */
+    readonly blobs: Readonly<Record<string, HtmlReportBlob>>;
+};
+export type HtmlReportBundle = {
+    readonly runId: string;
+    readonly status: ReportTestStatus;
+    readonly updatedAtMs: number;
+    readonly tests: readonly HtmlReportTest[];
+};

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

@@ -0,0 +1,4 @@
+/**
+ * A report test with its frame files in memory: what a viewer renders. Text
+ * media are inline, binary media base64.
+ */

package/dist/reports/src/recording-keys.d.ts

@@ -0,0 +1,9 @@
+/** Object-store key layout for one report bucket. */
+export declare const RUNS_INDEX_KEY = "runs/index.json";
+export declare function runPrefix(runId: string): string;
+export declare function runManifestKey(runId: string): string;
+export declare function testPrefix(runId: string, testId: string): string;
+export declare function testReportKey(runId: string, testId: string): string;
+export declare function testFrameKey(runId: string, testId: string, frameFile: string): string;
+export declare function mediaExtension(media: string): string;
+export declare function contentTypeForMedia(media: string): string;

package/dist/reports/src/recording-keys.js

@@ -0,0 +1,50 @@
+/** Object-store key layout for one report bucket. */
+export const RUNS_INDEX_KEY = 'runs/index.json';
+export function runPrefix(runId) {
+    return `runs/${runId}`;
+}
+export function runManifestKey(runId) {
+    return `${runPrefix(runId)}/manifest.json`;
+}
+export function testPrefix(runId, testId) {
+    return `${runPrefix(runId)}/tests/${testId}`;
+}
+export function testReportKey(runId, testId) {
+    return `${testPrefix(runId, testId)}/report.json`;
+}
+export function testFrameKey(runId, testId, frameFile) {
+    const rel = frameFile.replace(/^\/+/, '');
+    return `${testPrefix(runId, testId)}/${rel}`;
+}
+export function mediaExtension(media) {
+    switch (media) {
+        case 'html':
+            return 'html';
+        case 'png':
+            return 'png';
+        case 'json':
+            return 'json';
+        case 'text':
+            return 'txt';
+        case 'bytes':
+            return 'bin';
+        default:
+            return 'bin';
+    }
+}
+export function contentTypeForMedia(media) {
+    switch (media) {
+        case 'html':
+            return 'text/html; charset=utf-8';
+        case 'png':
+            return 'image/png';
+        case 'json':
+            return 'application/json; charset=utf-8';
+        case 'text':
+            return 'text/plain; charset=utf-8';
+        case 'bytes':
+            return 'application/octet-stream';
+        default:
+            return 'application/octet-stream';
+    }
+}

package/dist/reports/src/remote-report.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A commit's report, streamed from a reports API into a Solid store the
+ * viewer renders as it grows: the test list fills in source by source, and
+ * a test's steps and frame files stream in the first time it is opened.
+ * Transport and time are injected; nothing here touches a global.
+ */
+import type { Timers } from './clock.js';
+import type { CommitRecord, SourceRecord } from './protocol.js';
+import type { ReportData } from './types.js';
+import type { HttpClient } from './http.js';
+import { type Accessor } from 'solid-js';
+import type { ReportFetcher } from './fetcher.js';
+import type { ReportTestLoader } from './report-loader.js';
+export type RemoteReportArgs = {
+    readonly http: HttpClient;
+    readonly timers: Timers;
+    /** The reports API root (`https://api.example.com/api/reports`). */
+    readonly apiBase: string;
+    readonly sha: string;
+    /** Cached reads (sources, stylesheet, one test, one frame file). */
+    readonly fetcher: ReportFetcher;
+};
+export type RemoteReportPhase = 'connecting' | 'live' | 'complete' | 'missing' | 'error';
+export type RemoteReport = {
+    readonly data: ReportData;
+    readonly commit: Accessor<CommitRecord | null>;
+    readonly phase: Accessor<RemoteReportPhase>;
+    readonly sources: Accessor<readonly SourceRecord[]>;
+    readonly frameCss: Accessor<string | undefined>;
+    readonly loader: ReportTestLoader;
+    readonly dispose: () => void;
+};
+/** Read an SSE response body, handing each message to `onEvent`. */
+export declare function readEventStream<T>(response: Response, onEvent: (event: T) => void): Promise<void>;
+/**
+ * Open a commit's report. The commit stream reconnects on its own (sending
+ * the sources it already holds) until the commit is complete or missing.
+ */
+export declare function createRemoteReport(args: RemoteReportArgs): RemoteReport;

package/dist/reports/src/remote-report.js

@@ -0,0 +1,304 @@
+/**
+ * A commit's report, streamed from a reports API into a Solid store the
+ * viewer renders as it grows: the test list fills in source by source, and
+ * a test's steps and frame files stream in the first time it is opened.
+ * Transport and time are injected; nothing here touches a global.
+ */
+import { splitViewerTestId, viewerTestId, } from './keys.js';
+import { SseDecoder } from './protocol.js';
+import { batch, createSignal } from 'solid-js';
+import { createStore, produce } from 'solid-js/store';
+/** Wait before reconnecting a stream that failed. */
+const RETRY_MS = 3_000;
+/** Read an SSE response body, handing each message to `onEvent`. */
+export async function readEventStream(response, onEvent) {
+    if (!response.ok || response.body === null) {
+        throw new Error(`reports API answered ${String(response.status)}`);
+    }
+    const reader = response.body.getReader();
+    const text = new TextDecoder();
+    const decoder = new SseDecoder();
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            return;
+        for (const event of decoder.push(text.decode(value, { stream: true }))) {
+            onEvent(event);
+        }
+    }
+}
+function worstStatus(tests) {
+    const statuses = tests.map((t) => t.report.meta.status);
+    if (statuses.includes('failed'))
+        return 'failed';
+    if (statuses.length > 0 && statuses.every((s) => s === 'skipped')) {
+        return 'skipped';
+    }
+    return statuses.length === 0 ? 'skipped' : 'passed';
+}
+function stubTest(source, meta) {
+    return {
+        report: {
+            meta: { ...meta, testId: viewerTestId(source, meta.testId) },
+            steps: [],
+        },
+        blobs: {},
+    };
+}
+function reportLabel(sha, commit) {
+    const short = sha.slice(0, 9);
+    return commit === null ? short : `${short} · ${commit.branch}`;
+}
+function loading() {
+    return { kind: 'loading', frames: 0, framesTotal: null };
+}
+function reportUrl(ctx, path) {
+    return `${ctx.args.apiBase}/${ctx.args.sha}${path}`;
+}
+function disposed(ctx) {
+    return ctx.controller.signal.aborted;
+}
+function addSource(ctx, record, authoritative = true) {
+    if (!authoritative && ctx.sources.has(record.source))
+        return;
+    if (authoritative)
+        ctx.sources.add(record.source);
+    if (JSON.stringify(ctx.records.get(record.source)) === JSON.stringify(record))
+        return;
+    ctx.records.set(record.source, record);
+    ctx.addRecord(record);
+    for (const test of ctx.store.data.tests) {
+        if (splitViewerTestId(test.report.meta.testId)?.source === record.source)
+            ctx.setStore('loads', test.report.meta.testId, undefined);
+    }
+    ctx.setStore('data', produce((data) => {
+        data.tests = data.tests.filter((test) => splitViewerTestId(test.report.meta.testId)?.source !== record.source);
+        for (const meta of record.tests) {
+            data.tests.push(stubTest(record.source, meta));
+        }
+        data.status = streamedStatus(ctx, data.tests);
+        data.updatedAtMs = Math.max(data.updatedAtMs, record.updatedAtMs);
+    }));
+}
+function streamedStatus(ctx, tests) {
+    if (ctx.commit()?.status === 'failed' ||
+        [...ctx.records.values()].some((record) => record.status === 'failed'))
+        return 'failed';
+    return worstStatus(tests);
+}
+function onCommitEvent(ctx, event) {
+    if (event.type === 'commit') {
+        ctx.setCommit(event.commit);
+        ctx.setStore('data', 'status', streamedStatus(ctx, ctx.store.data.tests));
+        ctx.setStore('data', 'runId', reportLabel(ctx.args.sha, event.commit));
+        if (event.commit?.endedAtMs != null) {
+            ctx.setStore('data', 'updatedAtMs', event.commit.endedAtMs);
+        }
+        return;
+    }
+    if (event.type === 'source') {
+        ctx.setPhase('live');
+        addSource(ctx, event.source);
+        return;
+    }
+    ctx.setPhase(event.state === 'running' ? 'live' : event.state);
+}
+/** Follow the commit stream, reconnecting until it is complete or missing. */
+async function followCommit(ctx) {
+    while (!disposed(ctx)) {
+        const have = [...ctx.sources].join(',');
+        const query = have === '' ? '' : `?have=${encodeURIComponent(have)}`;
+        let ended = false;
+        try {
+            const response = await ctx.args.http.fetch(reportUrl(ctx, `/events${query}`), { signal: ctx.controller.signal });
+            await readEventStream(response, (event) => {
+                if (event.type === 'end')
+                    ended = true;
+                onCommitEvent(ctx, event);
+            });
+        }
+        catch {
+            ended = false;
+        }
+        if (disposed(ctx))
+            return;
+        if (ctx.phase() === 'complete' || ctx.phase() === 'missing')
+            return;
+        // A stream cut short (no `end`) is a failure: back off, then resume.
+        if (!ended) {
+            ctx.setPhase('error');
+            await waitForReconnect(ctx);
+        }
+    }
+}
+function waitForReconnect(ctx) {
+    return new Promise((resolve) => {
+        const signal = ctx.controller.signal;
+        const finish = () => {
+            ctx.args.timers.clearTimeout(timer);
+            signal.removeEventListener('abort', finish);
+            resolve();
+        };
+        const timer = ctx.args.timers.setTimeout(finish, RETRY_MS);
+        signal.addEventListener('abort', finish, { once: true });
+        if (signal.aborted)
+            finish();
+    });
+}
+function testIndex(ctx, id) {
+    return ctx.store.data.tests.findIndex((t) => t.report.meta.testId === id);
+}
+/** The timeline only. Frame files arrive later, one at a time, as they paint. */
+async function loadTest(ctx, id) {
+    const parts = splitViewerTestId(id);
+    if (parts === null) {
+        ctx.setStore('loads', id, { kind: 'missing' });
+        return;
+    }
+    try {
+        const report = await ctx.args.fetcher.test(ctx.args.sha, parts.source, parts.testId);
+        if (disposed(ctx))
+            return;
+        if (report === null) {
+            ctx.setStore('loads', id, { kind: 'missing' });
+            return;
+        }
+        batch(() => {
+            const index = testIndex(ctx, id);
+            if (index >= 0) {
+                ctx.setStore('data', 'tests', index, 'report', 'steps', report.steps);
+            }
+            ctx.setStore('loads', id, { kind: 'ready' });
+        });
+    }
+    catch (error) {
+        if (disposed(ctx))
+            return;
+        ctx.setStore('loads', id, {
+            kind: 'error',
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function loadBlob(ctx, id, file) {
+    const key = `${id}\n${file}`;
+    if (ctx.inflight.has(key))
+        return;
+    const index = testIndex(ctx, id);
+    if (index < 0 || ctx.store.data.tests[index]?.blobs[file] !== undefined) {
+        return;
+    }
+    const parts = splitViewerTestId(id);
+    if (parts === null)
+        return;
+    ctx.inflight.add(key);
+    try {
+        const blob = await ctx.args.fetcher.blob(ctx.args.sha, parts.source, parts.testId, file);
+        if (!disposed(ctx) && blob !== null) {
+            const at = testIndex(ctx, id);
+            if (at >= 0)
+                ctx.setStore('data', 'tests', at, 'blobs', file, blob);
+        }
+    }
+    catch {
+        // The file can be asked for again. A 404 is not remembered.
+    }
+    finally {
+        ctx.inflight.delete(key);
+    }
+}
+function testLoader(ctx) {
+    return {
+        load(id) {
+            const current = ctx.store.loads[id];
+            if (current !== undefined && current.kind !== 'error')
+                return;
+            ctx.setStore('loads', id, loading());
+            void loadTest(ctx, id);
+        },
+        ensureBlob(id, file) {
+            void loadBlob(ctx, id, file);
+        },
+        state(id) {
+            const known = ctx.store.data.tests.some((t) => t.report.meta.testId === id);
+            if (!known) {
+                const settled = ctx.phase() === 'complete' || ctx.phase() === 'missing';
+                return settled ? { kind: 'missing' } : loading();
+            }
+            return ctx.store.loads[id] ?? loading();
+        },
+    };
+}
+/** Sources and the snapshot stylesheet, from the query cache when it has them. */
+async function loadCached(ctx) {
+    try {
+        const [sources, css] = await Promise.allSettled([
+            ctx.args.fetcher.sources(ctx.args.sha),
+            ctx.args.fetcher.frameCss(ctx.args.sha),
+        ]);
+        if (disposed(ctx))
+            return;
+        if (sources.status === 'fulfilled')
+            for (const source of sources.value)
+                addSource(ctx, source, false);
+        ctx.setFrameCss(css.status === 'fulfilled' ? css.value : '');
+        if (sources.status === 'fulfilled' &&
+            sources.value.length > 0 &&
+            ctx.phase() === 'connecting')
+            ctx.setPhase('live');
+    }
+    catch {
+        if (!disposed(ctx) && ctx.frameCss() === undefined)
+            ctx.setFrameCss('');
+    }
+}
+/**
+ * Open a commit's report. The commit stream reconnects on its own (sending
+ * the sources it already holds) until the commit is complete or missing.
+ */
+export function createRemoteReport(args) {
+    const [store, setStore] = createStore({
+        data: {
+            title: 'Spec report',
+            runId: reportLabel(args.sha, null),
+            status: 'skipped',
+            updatedAtMs: 0,
+            tests: [],
+        },
+        loads: {},
+    });
+    const [commit, setCommit] = createSignal(null);
+    const [records, setRecords] = createSignal([]);
+    const [phase, setPhase] = createSignal('connecting');
+    const [frameCss, setFrameCss] = createSignal();
+    const ctx = {
+        args,
+        store,
+        setStore,
+        setCommit,
+        commit,
+        phase,
+        setPhase,
+        frameCss,
+        setFrameCss,
+        sources: new Set(),
+        records: new Map(),
+        addRecord: (record) => setRecords((previous) => [
+            ...previous.filter((source) => source.source !== record.source),
+            record,
+        ]),
+        inflight: new Set(),
+        controller: new AbortController(),
+    };
+    void followCommit(ctx);
+    void loadCached(ctx);
+    return {
+        data: store.data,
+        commit,
+        phase,
+        sources: records,
+        frameCss,
+        loader: testLoader(ctx),
+        dispose: () => ctx.controller.abort(),
+    };
+}

package/dist/reports/src/report-loader.d.ts

@@ -0,0 +1,22 @@
+export type TestLoad = {
+    readonly kind: 'ready';
+} | {
+    readonly kind: 'loading';
+    readonly frames: number;
+    readonly framesTotal: number | null;
+} | {
+    readonly kind: 'missing';
+} | {
+    readonly kind: 'error';
+    readonly message: string;
+};
+/**
+ * Loads a test's steps on first view, then individual frame files as the
+ * scrubber reaches them. Absent when every test arrives with its frames
+ * (a standalone HTML file).
+ */
+export type ReportTestLoader = {
+    readonly load: (testId: string) => void;
+    readonly ensureBlob?: (testId: string, file: string) => void;
+    readonly state: (testId: string) => TestLoad;
+};

package/dist/reports/src/report-parts.d.ts

@@ -0,0 +1,10 @@
+import type { ObjectStore } from './object-store.js';
+import type { EvidenceStatus, ReportPart } from './explorer-types.js';
+export declare function partStatus(part: ReportPart): EvidenceStatus;
+export declare function validatePart(part: ReportPart): void;
+/** Each producer owns a separate key, independent of the spec-run attempt. */
+export declare function publishPart(store: ObjectStore, part: ReportPart): Promise<void>;
+/** Latest result per producer, sorted stably; corrupt evidence fails visibly. */
+export declare function readParts(store: ObjectStore, sha: string): Promise<readonly ReportPart[]>;
+/** Ties are conservative and independent of write/list order. */
+export declare function latestParts(parts: readonly ReportPart[]): readonly ReportPart[];