@crvouga/atlas 0.0.0-stage → 0.2.0

package/dist/reports/src/catalog.js

@@ -0,0 +1,127 @@
+/** Shared search, filter, group and sort for reports and the tests inside one. */
+const STATUS_RANK = {
+    failed: 0,
+    running: 1,
+    skipped: 2,
+    passed: 3,
+};
+export function catalogCounts(entities) {
+    const counts = {
+        all: entities.length,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        running: 0,
+    };
+    for (const entity of entities) {
+        if (entity.status === 'passed' ||
+            entity.status === 'failed' ||
+            entity.status === 'skipped' ||
+            entity.status === 'running') {
+            counts[entity.status] += 1;
+        }
+    }
+    return counts;
+}
+function matches(entity, query) {
+    if (query.status !== 'all' && entity.status !== query.status)
+        return false;
+    const q = query.q.trim().toLowerCase();
+    return q.length === 0 || entity.search.toLowerCase().includes(q);
+}
+function compare(a, b, sort) {
+    if (sort === 'duration')
+        return (b.durationMs ?? -1) - (a.durationMs ?? -1);
+    if (sort === 'status') {
+        const rank = (STATUS_RANK[a.status] ?? 9) - (STATUS_RANK[b.status] ?? 9);
+        if (rank !== 0)
+            return rank;
+    }
+    if (a.title < b.title)
+        return -1;
+    if (a.title > b.title)
+        return 1;
+    return 0;
+}
+function groupKey(entity, group) {
+    if (group === 'file')
+        return entity.file || 'Other';
+    if (group === 'status')
+        return entity.status;
+    if (group === 'package')
+        return entity.packageName || 'Other';
+    if (group === 'runtime')
+        return entity.runtime || 'Other';
+    return 'All';
+}
+function groupRank(name, group) {
+    if (group === 'status')
+        return STATUS_RANK[name] ?? 9;
+    return 0;
+}
+function compareGroups(a, b, group) {
+    const rank = groupRank(a.name, group) - groupRank(b.name, group);
+    if (rank !== 0)
+        return rank;
+    if (a.name === 'Other')
+        return 1;
+    if (b.name === 'Other')
+        return -1;
+    if (a.name < b.name)
+        return -1;
+    if (a.name > b.name)
+        return 1;
+    return 0;
+}
+const LIST_KEYS = [
+    'q',
+    'status',
+    'group',
+    'sort',
+    'layout',
+    'spec',
+    'tab',
+    'partq',
+];
+/** The list's search params, dropped when a test route carries frame and zoom. */
+export function catalogParams(params) {
+    const out = {};
+    for (const key of LIST_KEYS) {
+        const value = params[key];
+        if (value)
+            out[key] = value;
+    }
+    return out;
+}
+/** Filter, sort, then one group per chosen key. `recent` keeps input order. */
+export function arrangeCatalog(entities, query) {
+    const shown = entities.filter((entity) => matches(entity, query));
+    const sorted = query.sort === 'recent'
+        ? shown
+        : [...shown].sort((a, b) => compare(a, b, query.sort));
+    const order = [];
+    const map = new Map();
+    for (const entity of sorted) {
+        const key = groupKey(entity, query.group);
+        const list = map.get(key);
+        if (list === undefined) {
+            map.set(key, [entity]);
+            order.push(key);
+        }
+        else {
+            list.push(entity);
+        }
+    }
+    const groups = order.map((name) => {
+        const list = map.get(name) ?? [];
+        return {
+            name,
+            durationMs: list.reduce((sum, entity) => sum + (entity.durationMs ?? 0), 0),
+            failed: list.filter((entity) => entity.status === 'failed').length,
+            entities: list,
+        };
+    });
+    if (query.group === 'none')
+        return groups;
+    return [...groups].sort((a, b) => compareGroups(a, b, query.group));
+}

package/dist/reports/src/clock.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Injectable wall / virtual time for deterministic simulation.
+ * Production uses {@link wallClock} / {@link wallTimers}.
+ */
+export type Clock = {
+    /** Epoch milliseconds (virtual or wall). */
+    readonly now: () => number;
+};
+export type Timers = {
+    readonly setTimeout: (fn: () => void, ms: number) => unknown;
+    readonly clearTimeout: (handle: unknown) => void;
+    readonly setInterval: (fn: () => void, ms: number) => unknown;
+    readonly clearInterval: (handle: unknown) => void;
+};

package/dist/reports/src/clock.js

@@ -0,0 +1,4 @@
+/**
+ * Injectable wall / virtual time for deterministic simulation.
+ * Production uses {@link wallClock} / {@link wallTimers}.
+ */

package/dist/reports/src/completion-order.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Run `tasks` at most `limit` at a time and yield each result the moment it
+ * settles, so one slow read never holds back faster siblings. A rejection
+ * is rethrown to the consumer once every started task has settled.
+ */
+export declare function inCompletionOrder<T>(tasks: readonly (() => Promise<T>)[], limit: number): AsyncGenerator<T>;
+/** Apply `work` to every item, at most `limit` at a time. */
+export declare function eachLimited<T>(items: readonly T[], limit: number, work: (item: T) => Promise<void>): Promise<void>;
+/** Consume a lazy input with backpressure, draining started work before failure. */
+export declare function eachLimitedStream<T>(items: AsyncIterable<T>, limit: number, work: (item: T) => Promise<void>): Promise<void>;

package/dist/reports/src/completion-order.js

@@ -0,0 +1,76 @@
+/**
+ * Run `tasks` at most `limit` at a time and yield each result the moment it
+ * settles, so one slow read never holds back faster siblings. A rejection
+ * is rethrown to the consumer once every started task has settled.
+ */
+export async function* inCompletionOrder(tasks, limit) {
+    const width = Math.max(1, Math.floor(limit));
+    const running = new Map();
+    let next = 0;
+    const outcome = { failure: null };
+    const start = () => {
+        while (running.size < width &&
+            next < tasks.length &&
+            outcome.failure === null) {
+            const id = next;
+            const task = tasks[id];
+            next += 1;
+            if (task === undefined)
+                continue;
+            running.set(id, task().then((value) => ({ id, value }), (error) => {
+                running.delete(id);
+                outcome.failure ??= { error };
+                throw error;
+            }));
+        }
+    };
+    start();
+    while (running.size > 0) {
+        let settled = null;
+        try {
+            settled = await Promise.race(running.values());
+        }
+        catch {
+            // Recorded in `failure`; drain the rest, then rethrow.
+            continue;
+        }
+        running.delete(settled.id);
+        if (outcome.failure === null)
+            yield settled.value;
+        start();
+    }
+    if (outcome.failure !== null)
+        throw outcome.failure.error;
+}
+/** Apply `work` to every item, at most `limit` at a time. */
+export async function eachLimited(items, limit, work) {
+    const tasks = items.map((item) => () => work(item));
+    for await (const _ of inCompletionOrder(tasks, limit)) {
+        // Results are void; draining is the point.
+    }
+}
+/** Consume a lazy input with backpressure, draining started work before failure. */
+export async function eachLimitedStream(items, limit, work) {
+    const width = Math.max(1, Math.floor(limit));
+    const running = new Set();
+    const outcome = { failure: null };
+    try {
+        for await (const item of items) {
+            if (outcome.failure !== null)
+                break;
+            const task = work(item)
+                .catch((error) => {
+                outcome.failure ??= { error };
+            })
+                .finally(() => running.delete(task));
+            running.add(task);
+            if (running.size >= width)
+                await Promise.race(running);
+        }
+    }
+    finally {
+        await Promise.all(running);
+    }
+    if (outcome.failure !== null)
+        throw outcome.failure.error;
+}

package/dist/reports/src/evidence-live.d.ts

@@ -0,0 +1,40 @@
+import type { Clock } from './clock.js';
+import type { ActiveRun, LayerEvidence, LayerHeader } from './evidence-types.js';
+import type { ObjectStore } from './object-store.js';
+/** What a running spec suite announces under `active/` in the local store. */
+export type LiveRunRecord = {
+    readonly packageDir: string;
+    readonly bucket: string;
+    readonly startedAtMs: number;
+    readonly plannedChecks?: number;
+};
+/** How the host reaches the results a spec run has written so far. */
+export type LiveSource = {
+    /** The bucket the run writes each finished test into, or null when it cannot be read. */
+    readonly bucket: (run: LiveRunRecord) => ObjectStore | null;
+    /** The checkout the runs execute. */
+    readonly origin?: () => Promise<{
+        readonly sha: string | null;
+        readonly branch: string | null;
+    }>;
+    /** The stylesheet the runs' snapshots render with. */
+    readonly frameCss?: () => Promise<string | null>;
+};
+export declare function liveLayerId(source: string): string;
+/**
+ * Finished tests of runs that have not been collected into a layer yet, so a
+ * result appears the moment its test ends instead of when its package does.
+ */
+export declare function createLiveEvidence(args: {
+    readonly live: LiveSource | undefined;
+    readonly clock: Clock;
+    readonly backend: string;
+}): {
+    /** Read what each running suite has finished. `collected` are the newest archived layers. */
+    refresh(runs: readonly LiveRunRecord[], collected: readonly LayerHeader[]): Promise<{
+        layers: LayerEvidence[];
+        active: ActiveRun[];
+    }>;
+    find(id: string): LayerEvidence | null;
+    store(source: string): ObjectStore | null;
+};

package/dist/reports/src/evidence-live.js

@@ -0,0 +1,118 @@
+import { eachLimited } from './completion-order.js';
+import { sourceId } from './keys.js';
+import { layerEvidence } from './layer-merge.js';
+import { readUtf8 } from './object-io.js';
+import { SPEC_RUN_ID } from './publish.js';
+import { testPrefix } from './recording-keys.js';
+import { sourcePart } from './source-part.js';
+import { suiteStatus } from './status.js';
+/** A finished run stays visible this long while its layer is being collected. */
+const LINGER_MS = 30_000;
+const REPORT = '/report.json';
+export function liveLayerId(source) {
+    return `live-${source}`;
+}
+function sourceOf(run) {
+    try {
+        return sourceId(run.packageDir, run.bucket);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Finished tests of runs that have not been collected into a layer yet, so a
+ * result appears the moment its test ends instead of when its package does.
+ */
+export function createLiveEvidence(args) {
+    const tracked = new Map();
+    async function load(source, state, origin) {
+        const head = testPrefix(SPEC_RUN_ID, '');
+        const keys = await state.store.listKeys(head);
+        const fresh = keys.flatMap(key => {
+            const id = key.endsWith(REPORT) ? key.slice(head.length, -REPORT.length) : '';
+            return id && !id.includes('/') && !state.metas.has(id) ? [{ key, id }] : [];
+        });
+        await eachLimited(fresh, 16, async ({ key, id }) => {
+            const text = await readUtf8(state.store, key);
+            if (text === null)
+                return;
+            // A report still being written parses on a later pass.
+            try {
+                state.metas.set(id, JSON.parse(text).meta);
+            }
+            catch {
+                /* not complete yet */
+            }
+        });
+        const tests = [...state.metas.values()].sort((a, b) => (a.testId < b.testId ? -1 : a.testId > b.testId ? 1 : 0));
+        const record = { source, packageDir: state.run.packageDir, bucket: state.run.bucket, status: suiteStatus(tests), updatedAtMs: args.clock.now(), tests };
+        const summary = { id: liveLayerId(source), producer: source, recordedAtMs: record.updatedAtMs, sha: origin.sha, branch: origin.branch, runUrl: null, parameters: {}, specs: [], parts: [sourcePart(origin.sha ?? '', record)], source: record, recording: null };
+        const evidence = layerEvidence(summary, args.backend);
+        const layer = { ...evidence.layer, live: true, recording: { type: 'live', source }, execution: `live:${state.run.startedAtMs}:${tests.length}` };
+        state.evidence = { ...evidence, layer };
+    }
+    return {
+        /** Read what each running suite has finished. `collected` are the newest archived layers. */
+        async refresh(runs, collected) {
+            const now = args.clock.now();
+            // One checkout runs every suite, so its revision is asked for once per pass.
+            const origin = runs.length || tracked.size ? ((await args.live?.origin?.()) ?? { sha: null, branch: null }) : { sha: null, branch: null };
+            const active = [];
+            const running = new Set();
+            for (const run of runs) {
+                const source = sourceOf(run);
+                if (source === null)
+                    continue;
+                running.add(source);
+                let state = tracked.get(source);
+                if (!state || state.run.startedAtMs !== run.startedAtMs) {
+                    const store = args.live?.bucket(run) ?? null;
+                    state = store ? { run, store, metas: new Map(), evidence: null, goneAt: null } : undefined;
+                    if (state)
+                        tracked.set(source, state);
+                    else
+                        tracked.delete(source);
+                }
+                if (state) {
+                    state.goneAt = null;
+                    try {
+                        await load(source, state, origin);
+                    }
+                    catch {
+                        /* the bucket is being replaced; the next pass reads it */
+                    }
+                }
+                const counts = state?.evidence?.layer.counts;
+                active.push({ source, ...run, completed: counts ? counts.passed + counts.failed + counts['not-run'] : 0, failed: counts?.failed ?? 0 });
+            }
+            for (const [source, state] of tracked) {
+                if (running.has(source))
+                    continue;
+                if (state.goneAt === null) {
+                    state.goneAt = now;
+                    try {
+                        await load(source, state, origin);
+                    }
+                    catch {
+                        /* keep what was read while it ran */
+                    }
+                }
+                const archived = collected.some(layer => layer.producer === source && !layer.live && layer.recordedAtMs >= state.run.startedAtMs);
+                if (archived || now - state.goneAt > LINGER_MS)
+                    tracked.delete(source);
+            }
+            const layers = [...tracked.values()].flatMap(state => (state.evidence?.rows.length ? [state.evidence] : []));
+            return { layers, active };
+        },
+        find(id) {
+            for (const state of tracked.values())
+                if (state.evidence?.id === id)
+                    return state.evidence;
+            return null;
+        },
+        store(source) {
+            return tracked.get(source)?.store ?? null;
+        },
+    };
+}

package/dist/reports/src/evidence-types.d.ts

@@ -0,0 +1,90 @@
+import type { EvidenceMeasurement, EvidenceStatus } from './explorer-types.js';
+import type { LayerParameters } from './layer-types.js';
+/** Where a recorded test's timeline and captured files are read from. */
+export type RecordingAddress = {
+    readonly type: 'layer';
+    readonly layer: string;
+} | {
+    readonly type: 'commit';
+    readonly sha: string;
+    readonly source: string;
+} | {
+    readonly type: 'live';
+    readonly source: string;
+};
+/** One store that contributes report layers. */
+export type BackendInfo = {
+    readonly id: string;
+    readonly label: string;
+    /** Spec runs on this machine write here while they are still running. */
+    readonly live: boolean;
+    readonly available: boolean;
+};
+export type StatusCounts = Readonly<Record<EvidenceStatus, number>>;
+/** A report layer's origin and totals. Its checks are read separately, once. */
+export type LayerHeader = {
+    readonly id: string;
+    readonly backend: string;
+    readonly producer: string;
+    readonly packageDir: string | null;
+    readonly recordedAtMs: number;
+    readonly sha: string | null;
+    readonly branch: string | null;
+    readonly runUrl: string | null;
+    readonly parameters: LayerParameters;
+    readonly freshness?: 'unknown' | 'modified';
+    readonly recording: RecordingAddress | null;
+    /** From a spec run that has not been collected into a layer yet. */
+    readonly live: boolean;
+    readonly counts: StatusCounts;
+    /** Equal for the mutable and the archived address of one execution. */
+    readonly execution: string;
+};
+/** One check of one report part. */
+export type LayerRow = {
+    readonly kind: string;
+    readonly id: string;
+    readonly title: string;
+    readonly status: EvidenceStatus;
+    readonly specPath: string | null;
+    readonly detail: string;
+    readonly measurements: readonly EvidenceMeasurement[];
+    /** The recorded test behind this check, when it has a timeline to open. */
+    readonly testId: string | null;
+    /** What distinguishes this recorded test from another run of the same check. */
+    readonly variant: LayerParameters;
+    readonly durationMs: number | null;
+};
+export type LayerRows = {
+    readonly id: string;
+    readonly rows: readonly LayerRow[];
+    /** Spec path to the fingerprint the layer recorded for it. */
+    readonly fingerprints: Readonly<Record<string, string>>;
+};
+export type LayerEvidence = LayerRows & {
+    readonly layer: LayerHeader;
+};
+/** A spec run that is writing results right now. */
+export type ActiveRun = {
+    readonly source: string;
+    readonly packageDir: string;
+    readonly bucket: string;
+    readonly startedAtMs: number;
+    /** Spec files the run planned, when the producer recorded it. */
+    readonly plannedChecks?: number;
+    readonly completed: number;
+    readonly failed: number;
+};
+export type EvidencePage = {
+    readonly layers: readonly LayerHeader[];
+    readonly cursor: string | null;
+    readonly notices: readonly string[];
+    readonly backends: readonly BackendInfo[];
+    readonly active: readonly ActiveRun[];
+};
+/** The report API paths of one recorded test. */
+export declare function recordingPaths(address: RecordingAddress, testId: string): {
+    report: string;
+    file: (path: string) => string;
+    css: string;
+};

package/dist/reports/src/evidence-types.js

@@ -0,0 +1,15 @@
+/** The report API paths of one recorded test. */
+export function recordingPaths(address, testId) {
+    const test = encodeURIComponent(testId);
+    const file = (base) => (path) => `${base}/files/${path.split('/').map(encodeURIComponent).join('/')}`;
+    if (address.type === 'layer') {
+        const base = `/layers/${address.layer}/tests/${test}`;
+        return { report: `${base}/report.json`, file: file(base), css: `/layers/${address.layer}/frame.css` };
+    }
+    if (address.type === 'live') {
+        const base = `/live/${encodeURIComponent(address.source)}/tests/${test}`;
+        return { report: `${base}/report.json`, file: file(base), css: `/live/${encodeURIComponent(address.source)}/frame.css` };
+    }
+    const base = `/${address.sha}/tests/${encodeURIComponent(address.source)}/${test}`;
+    return { report: base, file: file(base), css: `/${address.sha}/frame.css` };
+}

package/dist/reports/src/evidence-view.d.ts

@@ -0,0 +1,68 @@
+import type { EvidenceStatus } from './explorer-types.js';
+import type { LayerEvidence, LayerHeader, LayerRow, StatusCounts } from './evidence-types.js';
+import { type CombinedEvidence, type EvidenceResult } from './layer-merge.js';
+/** Everything the combined report holds for one check. */
+export type CheckSlot = {
+    readonly key: string;
+    readonly id: string;
+    readonly title: string;
+    readonly specPath: string | null;
+    /** The worst outcome across the check's parameter sets. */
+    readonly status: EvidenceStatus;
+    /** What happened, newest first. One entry per producer and parameter set. */
+    readonly outcomes: readonly EvidenceResult[];
+    /** Recorded timings of the same check. They never change its outcome. */
+    readonly diagnostics: readonly EvidenceResult[];
+    readonly latestAtMs: number;
+    readonly live: boolean;
+};
+/** Group the combined results by check, in the order the checks were first seen. */
+export declare function checkSlots(results: readonly EvidenceResult[]): CheckSlot[];
+export type SpecStatus = EvidenceStatus | 'none';
+export type SpecSummary = {
+    readonly status: SpecStatus;
+    readonly counts: StatusCounts;
+    readonly total: number;
+    readonly latestAtMs: number | null;
+    readonly live: boolean;
+};
+export declare const NO_EVIDENCE: SpecSummary;
+/** No recorded check is `none`, never a pass. */
+export declare function summarizeSlots(slots: readonly CheckSlot[]): SpecSummary;
+export declare function addSummaries(summaries: readonly SpecSummary[]): SpecSummary;
+export type SpecEvidence = {
+    readonly slots: readonly CheckSlot[];
+    readonly summary: SpecSummary;
+};
+export type EvidenceView = {
+    /** Keyed by the spec path the outline uses (`specs/...`). */
+    readonly specs: ReadonlyMap<string, SpecEvidence>;
+    /** Results whose spec is no longer in the outline, or that name no spec. */
+    readonly unassigned: readonly CheckSlot[];
+    readonly total: SpecSummary;
+};
+export declare function evidenceView(combined: CombinedEvidence): EvidenceView;
+/** Sources left out of the combined report. Everything else, including layers that arrive later, contributes. */
+export type SourceSelection = {
+    readonly backends: readonly string[];
+    readonly branches: readonly string[];
+    readonly layers: readonly string[];
+};
+export declare const ALL_SOURCES: SourceSelection;
+export declare function branchOf(layer: LayerHeader): string;
+export declare function contributes(layer: LayerHeader, excluded: SourceSelection): boolean;
+export type SourceFacet = {
+    readonly id: string;
+    readonly layers: number;
+    readonly latestAtMs: number;
+};
+export declare function sourceFacets(layers: readonly LayerHeader[]): {
+    backends: SourceFacet[];
+    branches: SourceFacet[];
+};
+export type HistoryEntry = {
+    readonly layer: LayerHeader;
+    readonly row: LayerRow;
+};
+/** Every layer's own record of one check, newest first. A superseded result stays readable here. */
+export declare function checkHistory(layers: readonly LayerEvidence[], path: string | null, id: string): HistoryEntry[];

package/dist/reports/src/evidence-view.js

@@ -0,0 +1,113 @@
+import { emptyCounts, isDiagnosticKind, slotKey } from './layer-merge.js';
+const WORST = { passed: 0, 'not-run': 1, running: 2, failed: 3 };
+function worst(statuses) {
+    let status = 'passed';
+    for (const next of statuses)
+        if (WORST[next] > WORST[status])
+            status = next;
+    return status;
+}
+function newestFirst(a, b) {
+    return b.layer.recordedAtMs - a.layer.recordedAtMs || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+}
+/** Group the combined results by check, in the order the checks were first seen. */
+export function checkSlots(results) {
+    const groups = new Map();
+    for (const result of results) {
+        const group = groups.get(result.slot);
+        if (group)
+            group.push(result);
+        else
+            groups.set(result.slot, [result]);
+    }
+    return [...groups].map(([key, group]) => {
+        const checked = group.filter(result => !isDiagnosticKind(result.row.kind));
+        const outcomes = (checked.length ? checked : group).slice().sort(newestFirst);
+        const diagnostics = checked.length ? group.filter(result => isDiagnosticKind(result.row.kind)).sort(newestFirst) : [];
+        const first = outcomes[0];
+        return {
+            key,
+            id: first.row.id,
+            title: first.row.title,
+            specPath: first.row.specPath,
+            status: worst(outcomes.map(result => result.row.status)),
+            outcomes,
+            diagnostics,
+            latestAtMs: Math.max(...group.map(result => result.layer.recordedAtMs)),
+            live: group.some(result => result.layer.live),
+        };
+    });
+}
+export const NO_EVIDENCE = { status: 'none', counts: emptyCounts(), total: 0, latestAtMs: null, live: false };
+/** No recorded check is `none`, never a pass. */
+export function summarizeSlots(slots) {
+    if (!slots.length)
+        return NO_EVIDENCE;
+    const counts = emptyCounts();
+    for (const slot of slots)
+        counts[slot.status] += 1;
+    const status = counts.failed ? 'failed' : counts.running ? 'running' : counts.passed ? 'passed' : 'not-run';
+    return {
+        status,
+        counts,
+        total: slots.length,
+        latestAtMs: Math.max(...slots.map(slot => slot.latestAtMs)),
+        live: slots.some(slot => slot.live),
+    };
+}
+export function addSummaries(summaries) {
+    const counts = emptyCounts();
+    let total = 0, latestAtMs = null, live = false;
+    for (const summary of summaries) {
+        for (const status of Object.keys(counts))
+            counts[status] += summary.counts[status];
+        total += summary.total;
+        live ||= summary.live;
+        if (summary.latestAtMs !== null)
+            latestAtMs = Math.max(latestAtMs ?? 0, summary.latestAtMs);
+    }
+    if (!total)
+        return NO_EVIDENCE;
+    const status = counts.failed ? 'failed' : counts.running ? 'running' : counts.passed ? 'passed' : 'not-run';
+    return { status, counts, total, latestAtMs, live };
+}
+export function evidenceView(combined) {
+    const specs = new Map();
+    for (const { spec, results } of combined.specs) {
+        const slots = checkSlots(results);
+        specs.set(spec.path, { slots, summary: summarizeSlots(slots) });
+    }
+    return { specs, unassigned: checkSlots(combined.unassigned), total: addSummaries([...specs.values()].map(entry => entry.summary)) };
+}
+export const ALL_SOURCES = { backends: [], branches: [], layers: [] };
+export function branchOf(layer) {
+    return layer.branch ?? 'Unknown branch';
+}
+export function contributes(layer, excluded) {
+    return !excluded.backends.includes(layer.backend) && !excluded.branches.includes(branchOf(layer)) && !excluded.layers.includes(layer.id);
+}
+function facets(layers, id) {
+    const found = new Map();
+    for (const layer of layers) {
+        const facet = found.get(id(layer)) ?? { layers: 0, latestAtMs: 0 };
+        facet.layers += 1;
+        facet.latestAtMs = Math.max(facet.latestAtMs, layer.recordedAtMs);
+        found.set(id(layer), facet);
+    }
+    return [...found].map(([key, facet]) => ({ id: key, ...facet })).sort((a, b) => b.latestAtMs - a.latestAtMs || (a.id < b.id ? -1 : 1));
+}
+export function sourceFacets(layers) {
+    return { backends: facets(layers, layer => layer.backend), branches: facets(layers, branchOf) };
+}
+/** Every layer's own record of one check, newest first. A superseded result stays readable here. */
+export function checkHistory(layers, path, id) {
+    const slot = slotKey(path ?? '', id);
+    const entries = [];
+    for (const { layer, rows } of layers) {
+        const own = rows.filter(row => slotKey(row.specPath ?? '', row.id) === slot);
+        const checked = own.filter(row => !isDiagnosticKind(row.kind));
+        for (const row of checked.length ? checked : own)
+            entries.push({ layer, row });
+    }
+    return entries.sort((a, b) => b.layer.recordedAtMs - a.layer.recordedAtMs || (a.layer.id < b.layer.id ? -1 : 1));
+}