@slicedearth/whoisleuth-cli 1.47.4 → 2.0.1

package/frontend/src/lib/analysis/visualization-matrix.js

@@ -1,131 +0,0 @@
-import { scaleBand } from 'd3-scale';
-import { boundedVisualizationId as boundedId, boundedVisualizationText as boundedText, } from "./visualization-bounds.js";
-export const MAX_VISUAL_MATRIX_ROWS = 24;
-export const MAX_VISUAL_MATRIX_COLUMNS = 6;
-// A row is one source-pair lane, so it can publish at most one cell for each
-// allowed column. This keeps output at 24 × 6 = 144 cells and prevents hostile
-// duplicate inputs from creating sub-pixel marks or unbounded cell arrays.
-export const MAX_VISUAL_MATRIX_CELLS = MAX_VISUAL_MATRIX_ROWS * MAX_VISUAL_MATRIX_COLUMNS;
-const MAX_VISUAL_MATRIX_COLUMN_INPUTS = MAX_VISUAL_MATRIX_COLUMNS * 4;
-const MAX_VISUAL_MATRIX_ROW_INPUTS = MAX_VISUAL_MATRIX_ROWS * 4;
-const MAX_VISUAL_MATRIX_CELL_INPUTS_PER_ROW = MAX_VISUAL_MATRIX_COLUMNS * 4;
-function normalizedMatrixTone(value) {
-    const state = boundedText(value, 30).toLowerCase();
-    if (state === 'equal' || state === 'equivalent' || state === 'same')
-        return 'equal';
-    if (state === 'different')
-        return 'different';
-    if (state === 'conflict' || state === 'conflicting')
-        return 'conflict';
-    if (state === 'observed' || state === 'complete' || state === 'success')
-        return 'observed';
-    if (state === 'partial' || state === 'inconclusive' || state === 'rate_limited' || state === 'missing')
-        return 'partial';
-    if (state === 'unavailable' || state === 'error' || state === 'failed')
-        return 'unavailable';
-    if (state === 'not_collected' || state === 'skipped' || state === 'disabled' || state === 'not_recorded') {
-        return 'not_collected';
-    }
-    return 'unknown';
-}
-export function projectEvidenceMatrix(rawColumns, rawRows) {
-    const columnInputs = Array.isArray(rawColumns) ? rawColumns : [];
-    const columns = [];
-    const seenColumns = new Set();
-    for (const rawColumn of columnInputs.slice(0, MAX_VISUAL_MATRIX_COLUMN_INPUTS)) {
-        const column = boundedText(rawColumn, 40);
-        if (!column || seenColumns.has(column) || columns.length >= MAX_VISUAL_MATRIX_COLUMNS)
-            continue;
-        seenColumns.add(column);
-        columns.push(column);
-    }
-    const columnSet = new Set(columns);
-    const seenRows = new Set();
-    const rowInputs = Array.isArray(rawRows) ? rawRows : [];
-    const rows = [];
-    let discardedCellInputs = 0;
-    const scannedRows = rowInputs.slice(0, MAX_VISUAL_MATRIX_ROW_INPUTS);
-    for (const [index, row] of scannedRows.entries()) {
-        if (rows.length >= MAX_VISUAL_MATRIX_ROWS)
-            break;
-        const id = boundedId(row?.id) || `row-${index}`;
-        const label = boundedText(row?.label, 56);
-        if (!label || seenRows.has(id))
-            continue;
-        seenRows.add(id);
-        const rowCells = (Array.isArray(row.cells) ? row.cells : []);
-        const scannedCells = rowCells.slice(0, MAX_VISUAL_MATRIX_CELL_INPUTS_PER_ROW);
-        discardedCellInputs += Math.max(0, rowCells.length - scannedCells.length);
-        const byColumn = new Map();
-        for (const cell of scannedCells) {
-            const column = boundedText(cell?.column, 40);
-            if (!columnSet.has(column) || byColumn.has(column)) {
-                discardedCellInputs += 1;
-                continue;
-            }
-            const exactState = boundedText(cell?.state, 40).toLowerCase() || 'unknown';
-            byColumn.set(column, {
-                column,
-                state: exactState,
-                tone: normalizedMatrixTone(cell?.tone ?? exactState),
-                detail: boundedText(cell?.detail, 320),
-            });
-        }
-        const cells = columns.flatMap((column) => {
-            const value = byColumn.get(column);
-            if (value)
-                return [value];
-            if (row.sparse === true)
-                return [];
-            return [{
-                    column,
-                    state: 'not_collected',
-                    tone: 'not_collected',
-                    detail: '',
-                }];
-        });
-        rows.push({
-            id,
-            label,
-            context: boundedText(row.context, 90),
-            status: boundedText(row.status, 40).toLowerCase() || 'unknown',
-            assessment: boundedText(row.assessment, 80),
-            cells,
-        });
-    }
-    const discarded = {
-        columnInputs: Math.max(0, columnInputs.length - columns.length),
-        rowInputs: Math.max(0, rowInputs.length - rows.length),
-        cellInputs: discardedCellInputs,
-    };
-    const width = 900;
-    const top = 54;
-    const left = 250;
-    const rowHeight = 40;
-    const x = scaleBand().domain(columns).range([left, 870]).padding(0.12);
-    const y = scaleBand().domain(rows.map((row) => row.id))
-        .range([top, top + Math.max(1, rows.length) * rowHeight])
-        .padding(0.12);
-    return {
-        width,
-        height: Math.max(104, top + rows.length * rowHeight + 22),
-        columns: columns.map((column) => ({
-            label: column,
-            x: x(column) ?? left,
-            width: x.bandwidth(),
-        })),
-        rows: rows.map((row) => ({
-            ...row,
-            y: y(row.id) ?? top,
-            height: y.bandwidth(),
-            cells: row.cells.map((cell) => ({
-                ...cell,
-                x: x(cell.column) ?? left,
-                width: x.bandwidth(),
-            })),
-        })),
-        discarded,
-        projectedCellCount: rows.reduce((sum, row) => sum + row.cells.length, 0),
-        truncated: discarded.columnInputs > 0 || discarded.rowInputs > 0 || discarded.cellInputs > 0,
-    };
-}

package/frontend/src/lib/analysis/visualization-models.js

@@ -1,338 +0,0 @@
-import { scaleBand, scaleLinear, scalePoint } from 'd3-scale';
-import { boundedVisualizationId as boundedId, boundedVisualizationNumber as boundedNumber, boundedVisualizationText as boundedText, validVisualizationDate as validDate, } from "./visualization-bounds.js";
-export { FORCE_GRAPH_LINK_KINDS, MAX_FORCE_GRAPH_LINKS, MAX_FORCE_GRAPH_NODES, projectBoundedForceGraph, } from "./visualization-force-graph.js";
-export { MAX_VISUAL_MATRIX_CELLS, MAX_VISUAL_MATRIX_COLUMNS, MAX_VISUAL_MATRIX_ROWS, projectEvidenceMatrix, } from "./visualization-matrix.js";
-export { MAX_COLLECTION_TIMING_SOURCES, MAX_LIFECYCLE_EVENTS, MAX_TREND_POINTS, projectCollectionTiming, projectLifecycleEvents, projectTrendPoints, } from "./visualization-time-series.js";
-export const MAX_REDIRECT_NODES = 9;
-export const WATCHLIST_ACTIVITY_DAYS = 28;
-export const MAX_SCORE_FACTORS = 16;
-export const MAX_SCORE_FACTOR_LABEL_LENGTH = 160;
-export const MAX_PROFILE_LISTING_BAR_GROUPS = 18;
-export const MAX_MONITOR_TIMELINE_EVENTS = 12;
-export const MAX_MONITOR_TIMELINE_LANES = 6;
-function redirectLabel(value) {
-    const text = boundedText(value, 320);
-    try {
-        const parsed = new URL(text);
-        const path = parsed.pathname === '/' ? '' : parsed.pathname;
-        return `${parsed.hostname}${path}`.slice(0, 72);
-    }
-    catch {
-        return text.slice(0, 72);
-    }
-}
-export function projectRedirectPath(rawRedirects) {
-    const redirects = (Array.isArray(rawRedirects) ? rawRedirects : [])
-        .slice(0, MAX_REDIRECT_NODES - 1)
-        .map((redirect) => ({
-        status: boundedText(redirect?.status, 12) || '—',
-        from: redirectLabel(redirect?.from),
-        to: redirectLabel(redirect?.to),
-        queryOmitted: Boolean(redirect?.queryOmitted),
-    }))
-        .filter((redirect) => redirect.from && redirect.to);
-    const rawCount = Array.isArray(rawRedirects) ? rawRedirects.length : 0;
-    if (!redirects.length) {
-        return { width: 900, height: 150, nodes: [], edges: [], truncated: rawCount > 0 };
-    }
-    const firstRedirect = redirects[0];
-    if (!firstRedirect) {
-        return { width: 900, height: 150, nodes: [], edges: [], truncated: rawCount > 0 };
-    }
-    const nodes = [
-        { id: 'redirect-start', label: firstRedirect.from, status: 'start', queryOmitted: false },
-        ...redirects.map((redirect, index) => ({
-            id: `redirect-${index + 1}`,
-            label: redirect.to,
-            status: redirect.status,
-            queryOmitted: redirect.queryOmitted,
-        })),
-    ];
-    const x = scalePoint().domain(nodes.map((node) => node.id)).range([62, 838]).padding(0.35);
-    const projected = nodes.map((node) => ({ ...node, x: x(node.id) ?? 450, y: 70 }));
-    const edges = redirects.flatMap((redirect, index) => {
-        const from = projected[index];
-        const to = projected[index + 1];
-        return from && to ? [{
-                id: `redirect-edge-${index}`,
-                fromX: from.x,
-                toX: to.x,
-                y: 70,
-                status: redirect.status,
-            }] : [];
-    });
-    return {
-        width: 900,
-        height: 150,
-        nodes: projected,
-        edges,
-        truncated: rawCount > redirects.length,
-    };
-}
-function utcDayKey(milliseconds) {
-    return new Date(milliseconds).toISOString().slice(0, 10);
-}
-function utcWeekLabel(startMilliseconds, endMilliseconds) {
-    const start = new Date(startMilliseconds);
-    const end = new Date(endMilliseconds);
-    const startDay = start.getUTCDate();
-    const endDay = end.getUTCDate();
-    const startMonth = start.toLocaleDateString('en-AU', { month: 'short', timeZone: 'UTC' });
-    const endMonth = end.toLocaleDateString('en-AU', { month: 'short', timeZone: 'UTC' });
-    const endYear = end.getUTCFullYear();
-    return startMonth === endMonth
-        ? `${startDay}–${endDay} ${endMonth} ${endYear}`
-        : `${startDay} ${startMonth}–${endDay} ${endMonth} ${endYear}`;
-}
-export function projectWatchlistActivity(rawEvents) {
-    const valid = (Array.isArray(rawEvents) ? rawEvents : [])
-        .map((event) => {
-        const date = validDate(event?.checkedAt);
-        if (!date)
-            return null;
-        const changeCount = Math.max(0, Math.min(10_000, Math.trunc(Number(event.changeCount) || 0)));
-        const resultCount = Math.max(0, Math.min(10_000, Math.trunc(Number(event.resultCount) || 0)));
-        const conclusiveCount = Math.max(0, Math.min(resultCount, Math.trunc(Number(event.conclusiveCount) || 0)));
-        return { ...date, changeCount, resultCount, conclusiveCount };
-    })
-        .filter((event) => Boolean(event));
-    if (!valid.length) {
-        return {
-            width: 660,
-            height: 235,
-            days: [],
-            weekdayLabels: [],
-            weekLabels: [],
-            timeBasis: 'UTC calendar days',
-            windowStart: null,
-            windowEnd: null,
-            maxChanges: 0,
-            totalChecks: 0,
-            totalChanges: 0,
-        };
-    }
-    const latest = Math.max(...valid.map((event) => event.milliseconds));
-    const latestDay = Date.UTC(new Date(latest).getUTCFullYear(), new Date(latest).getUTCMonth(), new Date(latest).getUTCDate());
-    const start = latestDay - (WATCHLIST_ACTIVITY_DAYS - 1) * 86_400_000;
-    const windowEnd = latestDay + 86_400_000;
-    const windowEvents = valid.filter((event) => event.milliseconds >= start && event.milliseconds < windowEnd);
-    const byDay = new Map();
-    for (const event of windowEvents) {
-        const key = utcDayKey(event.milliseconds);
-        const current = byDay.get(key) ?? { checks: 0, changes: 0, results: 0, conclusive: 0 };
-        current.checks += 1;
-        current.changes += event.changeCount;
-        current.results += event.resultCount;
-        current.conclusive += event.conclusiveCount;
-        byDay.set(key, current);
-    }
-    const weekScale = scaleBand().domain([0, 1, 2, 3]).range([92, 638]).padding(0.12);
-    const dayScale = scaleBand().domain([0, 1, 2, 3, 4, 5, 6]).range([42, 190]).padding(0.12);
-    const dayWidth = weekScale.bandwidth();
-    const dayHeight = dayScale.bandwidth();
-    const days = Array.from({ length: WATCHLIST_ACTIVITY_DAYS }, (_, index) => {
-        const milliseconds = start + index * 86_400_000;
-        const key = utcDayKey(milliseconds);
-        const activity = byDay.get(key) ?? { checks: 0, changes: 0, results: 0, conclusive: 0 };
-        return {
-            date: key,
-            label: new Date(milliseconds).toLocaleDateString('en-AU', { day: 'numeric', month: 'short', timeZone: 'UTC' }),
-            week: Math.floor(index / 7),
-            weekday: index % 7,
-            x: weekScale(Math.floor(index / 7)) ?? 0,
-            y: dayScale(index % 7) ?? 0,
-            width: dayWidth,
-            height: dayHeight,
-            ...activity,
-        };
-    });
-    const weekdayLabels = Array.from({ length: 7 }, (_, index) => ({
-        index,
-        label: new Date(start + index * 86_400_000).toLocaleDateString('en-AU', { weekday: 'short', timeZone: 'UTC' }),
-        y: (dayScale(index) ?? 0) + dayHeight / 2 + 3,
-    }));
-    const weekLabels = Array.from({ length: 4 }, (_, index) => {
-        const weekStart = start + index * 7 * 86_400_000;
-        const weekEnd = weekStart + 6 * 86_400_000;
-        return {
-            index,
-            label: utcWeekLabel(weekStart, weekEnd),
-            startDate: utcDayKey(weekStart),
-            endDate: utcDayKey(weekEnd),
-            x: (weekScale(index) ?? 0) + dayWidth / 2,
-        };
-    });
-    return {
-        width: 660,
-        height: 235,
-        days,
-        weekdayLabels,
-        weekLabels,
-        timeBasis: 'UTC calendar days',
-        windowStart: utcDayKey(start),
-        windowEnd: utcDayKey(latestDay),
-        maxChanges: Math.max(0, ...days.map((day) => day.changes)),
-        totalChecks: windowEvents.length,
-        totalChanges: windowEvents.reduce((sum, event) => sum + event.changeCount, 0),
-    };
-}
-export function projectScoreFactors(rawFactors) {
-    const candidates = (Array.isArray(rawFactors) ? rawFactors : [])
-        .map((factor, index) => ({
-        id: `${boundedId(factor?.label) || 'factor'}-${index}`,
-        label: boundedText(factor?.label, MAX_SCORE_FACTOR_LABEL_LENGTH) || `Factor ${index + 1}`,
-        delta: boundedNumber(factor?.delta, -100, 100),
-    }));
-    const factors = candidates.slice(0, MAX_SCORE_FACTORS);
-    const maximum = Math.max(1, ...factors.map((factor) => Math.abs(factor.delta)));
-    const x = scaleLinear().domain([-maximum, maximum]).range([220, 860]).clamp(true);
-    const zeroX = x(0);
-    const rowHeight = 28;
-    return {
-        width: 900,
-        height: Math.max(74, 42 + factors.length * rowHeight),
-        zeroX,
-        maximum,
-        factors: factors.map((factor, index) => {
-            const valueX = x(factor.delta);
-            return {
-                ...factor,
-                x: Math.min(zeroX, valueX),
-                width: factor.delta === 0 ? 0 : Math.max(2, Math.abs(valueX - zeroX)),
-                y: 24 + index * rowHeight,
-            };
-        }),
-        truncated: candidates.length > factors.length,
-    };
-}
-export function projectProfileListingBars(rawGroups) {
-    const candidates = (Array.isArray(rawGroups) ? rawGroups : [])
-        .map((group, index) => {
-        const outcomes = {
-            registered: Math.trunc(boundedNumber(group?.registered, 0, 100_000)),
-            available: Math.trunc(boundedNumber(group?.available, 0, 100_000)),
-            unknown: Math.trunc(boundedNumber(group?.unknown, 0, 100_000)),
-        };
-        const total = Object.values(outcomes).reduce((sum, value) => sum + value, 0);
-        return {
-            id: boundedId(group?.id) || `group-${index}`,
-            label: boundedText(group?.label, 56) || `Group ${index + 1}`,
-            ...outcomes,
-            total,
-            profileListed: Math.min(total, Math.trunc(boundedNumber(group?.profileListed, 0, 100_000))),
-        };
-    })
-        .filter((group) => group.total > 0)
-        .sort((a, b) => b.total - a.total || a.label.localeCompare(b.label));
-    const groups = candidates.slice(0, MAX_PROFILE_LISTING_BAR_GROUPS);
-    const maximum = Math.max(1, ...groups.map((group) => group.total));
-    const x = scaleLinear().domain([0, maximum]).range([210, 860]).clamp(true);
-    const rowHeight = 40;
-    return {
-        width: 900,
-        height: Math.max(76, 40 + groups.length * rowHeight),
-        groups: groups.map((group, index) => {
-            let offset = 0;
-            const segments = ['registered', 'available', 'unknown'].map((state) => {
-                const value = group[state];
-                const start = offset;
-                offset += value;
-                return {
-                    state,
-                    value,
-                    x: x(start),
-                    width: Math.max(value ? 1 : 0, x(offset) - x(start)),
-                };
-            });
-            return { ...group, y: 20 + index * rowHeight, segments };
-        }),
-        truncated: candidates.length > groups.length,
-    };
-}
-export function projectMonitorTimeline(rawEvents) {
-    const candidates = (Array.isArray(rawEvents) ? rawEvents : [])
-        .map((event, index) => {
-        const date = validDate(event?.checkedAt);
-        const id = boundedId(event?.id) || `event-${index}`;
-        if (!date)
-            return null;
-        return {
-            id,
-            checkedAt: date.text,
-            milliseconds: date.milliseconds,
-            mode: boundedText(event?.mode, 20).toLowerCase() || 'saved',
-            groups: (Array.isArray(event.groups) ? event.groups : [])
-                .map((group) => ({
-                key: boundedId(group?.key),
-                label: boundedText(group?.label, 40),
-                changeCount: Math.trunc(boundedNumber(group?.changeCount, 0, 10_000)),
-            }))
-                .filter((group) => group.key && group.label),
-        };
-    })
-        .filter((event) => Boolean(event))
-        .sort((a, b) => a.milliseconds - b.milliseconds || a.id.localeCompare(b.id));
-    const events = candidates.slice(-MAX_MONITOR_TIMELINE_EVENTS);
-    const laneMap = new Map();
-    for (const event of events) {
-        for (const group of event.groups) {
-            if (!laneMap.has(group.key) && laneMap.size < MAX_MONITOR_TIMELINE_LANES) {
-                laneMap.set(group.key, group.label);
-            }
-        }
-    }
-    const lanes = [...laneMap].map(([key, label]) => ({ key, label }));
-    const x = scaleBand().domain(events.map((event) => event.id)).range([170, 865]).padding(0.18);
-    const y = scaleBand().domain(lanes.map((lane) => lane.key)).range([42, 42 + lanes.length * 40]).padding(0.18);
-    const maxChanges = Math.max(1, ...events.flatMap((event) => event.groups.map((group) => group.changeCount)));
-    return {
-        width: 900,
-        height: Math.max(110, 64 + lanes.length * 40),
-        maxChanges,
-        events: events.map((event) => ({
-            ...event,
-            x: x(event.id) ?? 170,
-            width: x.bandwidth(),
-            cells: lanes.map((lane) => ({
-                key: lane.key,
-                label: lane.label,
-                count: event.groups.find((group) => group.key === lane.key)?.changeCount ?? 0,
-                y: y(lane.key) ?? 42,
-                height: y.bandwidth(),
-            })),
-        })),
-        lanes: lanes.map((lane) => ({ ...lane, y: y(lane.key) ?? 42, height: y.bandwidth() })),
-        truncated: candidates.length > events.length
-            || events.some((event) => event.groups.some((group) => !laneMap.has(group.key))),
-    };
-}
-export function projectCertificateValidity(input) {
-    const validFrom = validDate(input.validFrom);
-    const validTo = validDate(input.validTo);
-    const observed = validDate(input.observedAt);
-    if (!validFrom || !validTo || validTo.milliseconds <= validFrom.milliseconds) {
-        return { available: false, width: 900, height: 110 };
-    }
-    const observedMilliseconds = observed?.milliseconds ?? validFrom.milliseconds;
-    const span = validTo.milliseconds - validFrom.milliseconds;
-    const padding = Math.max(86_400_000, span * 0.08);
-    const x = scaleLinear()
-        .domain([validFrom.milliseconds - padding, validTo.milliseconds + padding])
-        .range([72, 828])
-        .clamp(true);
-    return {
-        available: true,
-        width: 900,
-        height: 110,
-        validFrom: validFrom.text,
-        validTo: validTo.text,
-        observedAt: observed?.text ?? '',
-        hasObservation: Boolean(observed),
-        fromX: x(validFrom.milliseconds),
-        toX: x(validTo.milliseconds),
-        observedX: x(observedMilliseconds),
-        observedWithinValidity: observedMilliseconds >= validFrom.milliseconds
-            && observedMilliseconds <= validTo.milliseconds,
-        elapsedPercent: Math.max(0, Math.min(100, ((observedMilliseconds - validFrom.milliseconds) / span) * 100)),
-    };
-}

package/frontend/src/lib/analysis/visualization-time-series.js

@@ -1,185 +0,0 @@
-import { scaleLinear, scalePoint } from 'd3-scale';
-import { boundedVisualizationId as boundedId, boundedVisualizationNumber as boundedNumber, boundedVisualizationText as boundedText, validVisualizationDate as validDate, } from "./visualization-bounds.js";
-export const MAX_LIFECYCLE_EVENTS = 8;
-export const MAX_COLLECTION_TIMING_SOURCES = 16;
-export const MAX_TREND_POINTS = 24;
-export function projectLifecycleEvents(rawEvents) {
-    const seen = new Set();
-    const candidates = (Array.isArray(rawEvents) ? rawEvents : [])
-        .map((event) => {
-        const id = boundedId(event?.id);
-        const label = boundedText(event?.label, 40);
-        const date = validDate(event?.date);
-        if (!id || !label || !date)
-            return null;
-        const kind = event.kind === 'certificate' || event.kind === 'observation'
-            ? event.kind
-            : 'registry';
-        return {
-            id,
-            label,
-            date: date.text,
-            milliseconds: date.milliseconds,
-            detail: boundedText(event.detail, 100),
-            kind,
-        };
-    })
-        .filter((event) => Boolean(event))
-        .sort((a, b) => a.milliseconds - b.milliseconds || a.id.localeCompare(b.id))
-        .filter((event) => {
-        if (seen.has(event.id))
-            return false;
-        seen.add(event.id);
-        return true;
-    });
-    const accepted = candidates.slice(0, MAX_LIFECYCLE_EVENTS);
-    const x = scalePoint()
-        .domain(accepted.map((event) => event.id))
-        .range([70, 830])
-        .padding(accepted.length > 1 ? 0.35 : 0.5);
-    const laneY = [48, 158, 27];
-    const events = accepted.map((event, index) => ({
-        ...event,
-        x: x(event.id) ?? 450,
-        labelY: laneY[index % laneY.length] ?? 102,
-        anchor: index === 0 ? 'start' : index === accepted.length - 1 ? 'end' : 'middle',
-    }));
-    return {
-        width: 900,
-        height: 205,
-        axisY: 102,
-        events,
-        truncated: candidates.length > accepted.length,
-    };
-}
-export function projectCollectionTiming(rawSources, rawTotalMs) {
-    const candidates = (Array.isArray(rawSources) ? rawSources : [])
-        .map((source, index) => {
-        const id = boundedId(source?.source) || `source-${index}`;
-        const durationMs = boundedNumber(source?.durationMs, 0, 300_000);
-        const completedAfterMs = boundedNumber(source?.completedAfterMs, 0, 300_000);
-        return {
-            id,
-            label: boundedText(source?.source, 48) || `Source ${index + 1}`,
-            outcome: boundedText(source?.outcome, 24).toLowerCase() || 'unknown',
-            durationMs,
-            completedAfterMs,
-            startedAfterMs: Math.max(0, completedAfterMs - durationMs),
-        };
-    })
-        .sort((a, b) => a.completedAfterMs - b.completedAfterMs || a.id.localeCompare(b.id));
-    const sources = candidates.slice(0, MAX_COLLECTION_TIMING_SOURCES);
-    const longestSource = [...sources]
-        .sort((a, b) => b.durationMs - a.durationMs
-        || b.completedAfterMs - a.completedAfterMs
-        || a.id.localeCompare(b.id))[0] ?? null;
-    const lastSettledSource = sources.at(-1) ?? null;
-    const requestErrorCount = sources.filter((source) => source.outcome === 'rejected').length;
-    const totalMs = Math.max(1, boundedNumber(rawTotalMs, 0, 300_000), ...sources.map((source) => source.completedAfterMs));
-    const x = scaleLinear().domain([0, totalMs]).range([190, 860]).clamp(true);
-    const rowHeight = 30;
-    return {
-        width: 900,
-        height: Math.max(92, 50 + sources.length * rowHeight),
-        totalMs,
-        longestSource,
-        lastSettledSource,
-        requestErrorCount,
-        ticks: x.ticks(5).map((value) => ({ value, x: x(value) })),
-        sources: sources.map((source, index) => ({
-            ...source,
-            x: x(source.startedAfterMs),
-            width: Math.max(3, x(source.completedAfterMs) - x(source.startedAfterMs)),
-            y: 30 + index * rowHeight,
-        })),
-        truncated: candidates.length > sources.length,
-    };
-}
-export function projectTrendPoints(rawPoints) {
-    const seen = new Set();
-    const candidates = (Array.isArray(rawPoints) ? rawPoints : [])
-        .map((point, index) => {
-        const date = validDate(point?.date);
-        const id = boundedId(point?.id) || `point-${index}`;
-        if (!date || seen.has(id))
-            return null;
-        seen.add(id);
-        return {
-            id,
-            date: date.text,
-            milliseconds: date.milliseconds,
-            total: Math.trunc(boundedNumber(point?.total, 0, 100_000)),
-            added: Math.trunc(boundedNumber(point?.added, 0, 100_000)),
-            partial: Boolean(point?.partial),
-        };
-    })
-        .filter((point) => Boolean(point))
-        .sort((a, b) => a.milliseconds - b.milliseconds || a.id.localeCompare(b.id));
-    const points = candidates.slice(-MAX_TREND_POINTS);
-    const firstMilliseconds = points[0]?.milliseconds ?? 0;
-    const latestMilliseconds = points.at(-1)?.milliseconds ?? firstMilliseconds;
-    const x = scaleLinear()
-        .domain(firstMilliseconds === latestMilliseconds
-        ? [firstMilliseconds - 1, latestMilliseconds + 1]
-        : [firstMilliseconds, latestMilliseconds])
-        .range([64, 850])
-        .clamp(true);
-    const maximum = Math.max(1, ...points.map((point) => point.total));
-    const y = scaleLinear().domain([0, maximum]).range([190, 24]).nice().clamp(true);
-    const first = points[0] ?? null;
-    const latest = points.at(-1) ?? null;
-    const projectedPoints = points.map((point, sequenceIndex) => ({
-        ...point,
-        sequenceIndex,
-        x: points.length > 1 ? x(point.milliseconds) : 450,
-        y: y(point.total),
-        addedY: y(point.added),
-    }));
-    // A capped point is a lower bound, so neither adjacent slope is measured.
-    // Retain only directly adjacent complete-to-complete segments and leave a
-    // visible gap around every capped point.
-    const segments = projectedPoints.slice(1).flatMap((to, index) => {
-        const from = projectedPoints[index];
-        return from && !from.partial && !to.partial ? [{
-                fromId: from.id,
-                toId: to.id,
-                x1: from.x,
-                y1: from.y,
-                x2: to.x,
-                y2: to.y,
-            }] : [];
-    });
-    const partialChecks = points.filter((point) => point.partial).length;
-    const hasPartialChecks = partialChecks > 0;
-    const summaryMetric = (value, lowerBound) => ({
-        value,
-        lowerBound,
-        label: lowerBound ? `At least ${value}` : String(value),
-    });
-    const peakTotal = points.reduce((peak, point) => Math.max(peak, point.total), 0);
-    const newlyObserved = points.reduce((total, point) => total + point.added, 0);
-    return {
-        width: 900,
-        height: 225,
-        maximum,
-        spacing: 'elapsed_time',
-        elapsed: {
-            firstAt: points[0]?.date ?? null,
-            latestAt: points.at(-1)?.date ?? null,
-            milliseconds: Math.max(0, latestMilliseconds - firstMilliseconds),
-        },
-        ticks: y.ticks(4).map((value) => ({ value, y: y(value) })),
-        points: projectedPoints,
-        segments,
-        summary: {
-            first: summaryMetric(first?.total ?? 0, Boolean(first?.partial)),
-            latest: summaryMetric(latest?.total ?? 0, Boolean(latest?.partial)),
-            // Any capped total can exceed the displayed observed maximum.
-            peak: summaryMetric(peakTotal, hasPartialChecks),
-            // Every capped new-count is itself a lower bound, including observed 0.
-            newlyObserved: summaryMetric(newlyObserved, hasPartialChecks),
-            partialChecks,
-        },
-        truncated: candidates.length > points.length,
-    };
-}