@slicedearth/whoisleuth-cli 1.47.4 → 2.0.1

package/frontend/src/lib/analysis/lookup-investigation-brief.js

@@ -1,153 +0,0 @@
-export const LOOKUP_INVESTIGATION_BRIEF_SCHEMA = 'whoisleuth.investigation-brief';
-export const LOOKUP_INVESTIGATION_BRIEF_VERSION = 1;
-const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/gu;
-const MAX_FACTS = 12;
-const MAX_LIMITATIONS = 20;
-function text(value, maximum = 320) {
-    return String(value ?? '')
-        .replace(CONTROL_CHARACTERS, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim()
-        .slice(0, maximum);
-}
-function timestamp(value) {
-    if (typeof value !== 'string')
-        return null;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
-}
-function uniqueText(values, maximum = MAX_LIMITATIONS) {
-    const output = [];
-    const seen = new Set();
-    for (const value of values) {
-        const normalized = text(value);
-        if (!normalized || seen.has(normalized))
-            continue;
-        output.push(normalized);
-        seen.add(normalized);
-        if (output.length >= maximum)
-            break;
-    }
-    return output;
-}
-function taskQuestion(support) {
-    return support.guidance.questions[0]
-        ?? 'What does the collected evidence establish, and what remains uncertain?';
-}
-export function buildLookupInvestigationBrief(input) {
-    const generatedAt = timestamp(input.generatedAt) ?? new Date().toISOString();
-    const verifiedFacts = input.summary.facts
-        .filter((fact) => fact.value !== '—')
-        .slice(0, MAX_FACTS);
-    const contradictions = input.decisionSupport.entries
-        .filter((entry) => entry.state === 'conflict');
-    const unknowns = input.decisionSupport.entries
-        .filter((entry) => entry.state === 'uncertain');
-    const limitedSources = input.quality.entries
-        .filter((entry) => entry.state !== 'complete')
-        .map((entry) => `${entry.label}: ${entry.statusLabel}`);
-    const graphKinds = uniqueText(input.graph.edges.map((edge) => edge.label), 12);
-    return {
-        schema: LOOKUP_INVESTIGATION_BRIEF_SCHEMA,
-        schemaVersion: LOOKUP_INVESTIGATION_BRIEF_VERSION,
-        generatedAt,
-        target: text(input.target, 253) || 'Unknown target',
-        targetType: text(input.targetType, 40) || 'unknown',
-        task: input.task,
-        taskLabel: input.decisionSupport.guidance.label,
-        question: taskQuestion(input.decisionSupport),
-        summary: input.decisionSupport.guidance.summary,
-        observation: {
-            observedAt: input.quality.observedAt,
-            evidenceAgeDays: input.quality.ageDays,
-            completeSources: input.quality.completeCount,
-            limitedSources: input.quality.limitedCount,
-            freshnessPolicy: input.quality.freshnessPolicy,
-        },
-        verifiedFacts,
-        contradictions,
-        unknowns,
-        nextActions: input.decisionSupport.actions,
-        relationships: {
-            nodes: input.graph.nodes.length,
-            edges: input.graph.edges.length,
-            truncated: input.graph.truncated,
-            kinds: graphKinds,
-        },
-        limitations: uniqueText([
-            ...limitedSources,
-            ...input.graph.limitations,
-            'This brief is a deterministic organisation of collected and derived evidence, not an attribution, ownership, safety, availability, or maliciousness conclusion.',
-            'Analyst assertions, hypotheses, and decisions must remain separate from observed evidence.',
-        ]),
-    };
-}
-function markdown(value) {
-    return text(value, 2_000)
-        .replace(/&/gu, '&')
-        .replace(/</gu, '&lt;')
-        .replace(/>/gu, '&gt;')
-        .replace(/([\\`*_{}[\]()#+\-.!|=~])/gu, '\\$1');
-}
-function factLine(fact) {
-    const sources = fact.provenance.sources.length
-        ? ` Sources: ${fact.provenance.sources.map(markdown).join(', ')}.`
-        : '';
-    return `- **${markdown(fact.label)}:** ${markdown(fact.value)}.${sources}`;
-}
-function decisionLine(entry) {
-    return `- **${markdown(entry.title)}:** ${markdown(entry.detail)} Sources: ${entry.sources.map(markdown).join(', ') || 'not reported'}.`;
-}
-export function formatLookupInvestigationBriefMarkdown(brief) {
-    const lines = [
-        `# Investigation brief: ${markdown(brief.target)}`,
-        '',
-        `Generated ${markdown(brief.generatedAt)} from a ${markdown(brief.targetType)} Lookup.`,
-        '',
-        '## Decision context',
-        '',
-        `- **Task:** ${markdown(brief.taskLabel)}`,
-        `- **Question:** ${markdown(brief.question)}`,
-        `- **Summary:** ${markdown(brief.summary)}`,
-        `- **Evidence observed:** ${markdown(brief.observation.observedAt ?? 'not reported')}`,
-        `- **Source quality:** ${brief.observation.completeSources} complete; ${brief.observation.limitedSources} limited`,
-        `- **Freshness policy:** v${brief.observation.freshnessPolicy.version} ${markdown(brief.observation.freshnessPolicy.id)} for ${markdown(brief.observation.freshnessPolicy.task)}; registration ${brief.observation.freshnessPolicy.thresholdsDays.registration}d, network ${brief.observation.freshnessPolicy.thresholdsDays.network}d, web ${brief.observation.freshnessPolicy.thresholdsDays.web}d`,
-        '',
-        '## Verified normalised facts',
-        '',
-        ...(brief.verifiedFacts.length ? brief.verifiedFacts.map(factLine) : ['- No normalised fact was available for this brief.']),
-        '',
-        '## Contradictory evidence',
-        '',
-        ...(brief.contradictions.length ? brief.contradictions.map(decisionLine) : ['- No explicit contradiction was derived from the supported comparisons.']),
-        '',
-        '## Unknowns and incomplete comparisons',
-        '',
-        ...(brief.unknowns.length ? brief.unknowns.map(decisionLine) : ['- No explicit uncertainty entry was derived. Review source quality before treating this as complete.']),
-        '',
-        '## Recommended next manual steps',
-        '',
-        ...(brief.nextActions.length
-            ? brief.nextActions.map((action) => `- **${markdown(action.label)}:** ${markdown(action.reason)}`)
-            : ['- Review the underlying source evidence and its limitations.']),
-        '',
-        '## Observed relationship map',
-        '',
-        `- ${brief.relationships.nodes} nodes and ${brief.relationships.edges} edges${brief.relationships.truncated ? '; bounded output was truncated' : ''}.`,
-        `- Relationship types: ${brief.relationships.kinds.map(markdown).join(', ') || 'none observed'}.`,
-        '',
-        '## Limitations',
-        '',
-        ...brief.limitations.map((limitation) => `- ${markdown(limitation)}`),
-        '',
-    ];
-    return lines.join('\n');
-}
-export function lookupInvestigationBriefFilename(brief) {
-    const target = brief.target
-        .toLowerCase()
-        .replace(/[^a-z0-9.-]+/gu, '-')
-        .replace(/^-+|-+$/gu, '')
-        .slice(0, 80) || 'lookup';
-    return `whoisleuth-investigation-brief-${target}-${brief.generatedAt.slice(0, 10)}.md`;
-}

package/frontend/src/lib/analysis/lookup-presentation.js

@@ -1,120 +0,0 @@
-export const LOOKUP_PRESENTATION_STORAGE_KEY = 'whoisleuth:lookup-presentation:v1';
-export const MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES = 1_024;
-export const MAX_LOOKUP_URL_QUERY_LENGTH = 4_096;
-export const LOOKUP_TASK_VIEWS = Object.freeze([
-    Object.freeze({ id: 'general', label: 'General investigation' }),
-    Object.freeze({ id: 'acquisition', label: 'Acquisition review' }),
-    Object.freeze({ id: 'brand', label: 'Brand review' }),
-    Object.freeze({ id: 'incident', label: 'Incident response' }),
-    Object.freeze({ id: 'owned', label: 'Owned-domain posture' }),
-]);
-const TASKS = new Set(LOOKUP_TASK_VIEWS.map((option) => option.id));
-const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/u;
-export function parseLookupTaskContext(value) {
-    if (typeof value !== 'string' || value.length > 16)
-        return null;
-    return TASKS.has(value) ? value : null;
-}
-export function normalizeLookupTaskView(value) {
-    return typeof value === 'string' && TASKS.has(value)
-        ? value
-        : 'general';
-}
-function lookupUrlQuery(value) {
-    if (value === null || value.length > MAX_LOOKUP_URL_QUERY_LENGTH || CONTROL_CHARACTERS.test(value))
-        return null;
-    const normalized = value.trim();
-    return normalized ? normalized : null;
-}
-function lookupUrlDepth(value) {
-    return value === 'fast' || value === 'deep' ? value : null;
-}
-function record(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
-}
-export function lookupResultDepth(value, fallback = null) {
-    const result = record(value);
-    if (!result)
-        return fallback;
-    const availability = record(result.availability);
-    if (availability?.deepScanComplete === false)
-        return 'fast';
-    if (availability?.deepScanComplete === true)
-        return 'deep';
-    const whois = record(result.whois);
-    if (whois?.skipped === true
-        && typeof whois.detail === 'string'
-        && /fast rdap-only mode/iu.test(whois.detail))
-        return 'fast';
-    const scanModes = [
-        record(result.reverseDns)?.scanMode,
-        record(availability?.dns)?.scanMode,
-        record(availability?.http)?.scanMode,
-    ];
-    if (scanModes.includes('deep'))
-        return 'deep';
-    if (scanModes.includes('fast'))
-        return 'fast';
-    return fallback;
-}
-export function reconcileLookupUrlState(current, searchParams, preferredTask) {
-    const explicitQuery = lookupUrlQuery(searchParams.get('q'));
-    const explicitDepth = lookupUrlDepth(searchParams.get('depth'));
-    const queryChanged = explicitQuery !== null && explicitQuery !== current.query;
-    const depthChanged = explicitDepth !== null && explicitDepth !== current.depth;
-    const conflictsWithResult = current.result !== null && ((explicitQuery !== null && explicitQuery !== current.completedTarget)
-        || (explicitDepth !== null && explicitDepth !== current.retainedResultDepth));
-    return {
-        query: explicitQuery ?? current.query,
-        depth: explicitDepth ?? current.depth,
-        task: parseLookupTaskContext(searchParams.get('task')) ?? normalizeLookupTaskView(preferredTask),
-        result: conflictsWithResult ? null : current.result,
-        completedTarget: conflictsWithResult ? '' : current.completedTarget,
-        error: conflictsWithResult || queryChanged || depthChanged ? '' : current.error,
-    };
-}
-export function readLookupPresentation(storage) {
-    try {
-        const serialized = storage.getItem(LOOKUP_PRESENTATION_STORAGE_KEY);
-        if (serialized === null
-            || serialized.length > MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES
-            || new TextEncoder().encode(serialized).byteLength > MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES) {
-            return { task: 'general' };
-        }
-        const stored = JSON.parse(serialized);
-        if (stored?.version === 1) {
-            return {
-                task: normalizeLookupTaskView(stored.task),
-            };
-        }
-    }
-    catch {
-        // Invalid or unavailable browser storage falls back to the stable defaults.
-    }
-    return { task: 'general' };
-}
-export function writeLookupPresentation(storage, state) {
-    try {
-        storage.setItem(LOOKUP_PRESENTATION_STORAGE_KEY, JSON.stringify({
-            version: 1,
-            task: normalizeLookupTaskView(state.task),
-        }));
-    }
-    catch {
-        // The caller's in-memory selection remains valid when storage is unavailable.
-    }
-}
-const PRIORITY = Object.freeze({
-    general: Object.freeze(['overview', 'registry', 'web-evidence', 'relationships-history', 'source-quality', 'case-response', 'advanced-evidence']),
-    acquisition: Object.freeze(['overview', 'registry', 'relationships-history', 'web-evidence', 'source-quality', 'case-response', 'advanced-evidence']),
-    brand: Object.freeze(['overview', 'web-evidence', 'relationships-history', 'registry', 'source-quality', 'case-response', 'advanced-evidence']),
-    incident: Object.freeze(['overview', 'web-evidence', 'relationships-history', 'advanced-evidence', 'registry', 'source-quality', 'case-response']),
-    owned: Object.freeze(['overview', 'registry', 'web-evidence', 'relationships-history', 'source-quality', 'case-response', 'advanced-evidence']),
-});
-export function prioritizeLookupSectionLinks(links, task) {
-    const order = PRIORITY[normalizeLookupTaskView(task)];
-    const rank = new Map(order.map((id, index) => [`#${id}`, index]));
-    return [...links].sort((left, right) => ((rank.get(left.href) ?? order.length) - (rank.get(right.href) ?? order.length)));
-}

package/frontend/src/lib/analysis/lookup-response.js

@@ -1,2 +0,0 @@
-// Environment-neutral Lookup response contract shared with the backend.
-export * from "../../../../lib/lookup-response-contract.mjs";

package/frontend/src/lib/analysis/lookup-source-refresh.js

@@ -1,277 +0,0 @@
-import { BoundedJsonResponseError, requestJsonCapped, } from "../bounded-json-response.js";
-export const LOOKUP_SOURCE_REFRESH_VERSION = 1;
-export const LOOKUP_SOURCE_STALE_AFTER_DAYS = 7;
-export const LOOKUP_FRESHNESS_POLICY_VERSION = 1;
-export const LOOKUP_SOURCE_REFRESH_TIMEOUT_MS = 40_000;
-export const MAX_LOOKUP_SOURCE_REFRESH_KEYS = 512;
-export const MAX_LOOKUP_SOURCE_REFRESH_BYTES = 2 * 1024 * 1024;
-export const MAX_LOOKUP_SOURCE_REFRESH_HISTORY = 12;
-const DOMAIN_EVIDENCE_IDS = new Set([
-    'availability',
-    'client-behavior',
-    'dns',
-    'http',
-    'page-identity',
-    'page-role',
-    'security-posture',
-    'technology',
-    'tls',
-]);
-const NETWORK_EVIDENCE_IDS = new Set(['availability', 'dns', 'reverse-dns', 'network-context']);
-const WEB_EVIDENCE_IDS = new Set(['http', 'tls', 'page-identity', 'page-role', 'client-behavior', 'security-posture', 'technology']);
-const TASK_FRESHNESS_THRESHOLDS = Object.freeze({
-    general: Object.freeze({ registration: 30, network: 7, web: 3 }),
-    acquisition: Object.freeze({ registration: 7, network: 3, web: 3 }),
-    brand: Object.freeze({ registration: 30, network: 3, web: 1 }),
-    incident: Object.freeze({ registration: 14, network: 1, web: 1 }),
-    owned: Object.freeze({ registration: 30, network: 7, web: 3 }),
-});
-function freshnessDays(value, fallback) {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? Math.max(1, Math.min(365, Math.round(parsed))) : fallback;
-}
-export function buildLookupFreshnessPolicy(task, input) {
-    const defaults = TASK_FRESHNESS_THRESHOLDS[task];
-    const custom = input?.id === 'analyst-custom';
-    return {
-        version: LOOKUP_FRESHNESS_POLICY_VERSION,
-        id: custom ? 'analyst-custom' : 'task-default',
-        task,
-        thresholdsDays: custom ? {
-            registration: freshnessDays(input?.thresholdsDays?.registration, defaults.registration),
-            network: freshnessDays(input?.thresholdsDays?.network, defaults.network),
-            web: freshnessDays(input?.thresholdsDays?.web, defaults.web),
-        } : { ...defaults },
-    };
-}
-function observedAgeDays(observedAt, now) {
-    if (typeof observedAt !== 'string' || typeof now !== 'string')
-        return null;
-    const observedMs = Date.parse(observedAt);
-    const nowMs = Date.parse(now);
-    if (!Number.isFinite(observedMs) || !Number.isFinite(nowMs))
-        return null;
-    return Math.max(0, Math.floor((nowMs - observedMs) / 86_400_000));
-}
-function limited(entries, ids) {
-    return entries.some((entry) => ids.has(entry.id) && entry.manualReviewSuggested);
-}
-function availableIds(entries, ids) {
-    return entries.filter((entry) => ids.has(entry.id)).map((entry) => entry.id).slice(0, 12);
-}
-export function buildLookupSourceRefreshPlan(ledger, observedAt, now = new Date().toISOString(), options = {}) {
-    const ageDays = observedAgeDays(observedAt, now);
-    const freshnessPolicy = buildLookupFreshnessPolicy(options.task ?? 'general', options.freshnessPolicy);
-    const entries = ledger.entries.slice(0, 24);
-    const plans = [];
-    const groups = [
-        {
-            id: 'rdap',
-            label: 'Registry RDAP',
-            endpoint: '/api/rdap',
-            ids: new Set(['rdap']),
-            disclosure: 'Starts one bounded registry RDAP operation for this target.',
-            threshold: 'registration',
-        },
-        {
-            id: 'whois',
-            label: 'WHOIS',
-            endpoint: '/api/whois',
-            ids: new Set(['whois']),
-            disclosure: 'Starts one bounded referral-aware WHOIS operation for this target.',
-            threshold: 'registration',
-        },
-        {
-            id: 'availability',
-            label: 'Domain evidence',
-            endpoint: '/api/availability',
-            ids: DOMAIN_EVIDENCE_IDS,
-            disclosure: 'Repeats the bounded domain-evidence branch, including eligible DNS, HTTP, page, and TLS work for the selected depth.',
-            threshold: 'network',
-        },
-    ];
-    for (const group of groups) {
-        const evidenceIds = availableIds(entries, group.ids);
-        if (!evidenceIds.length)
-            continue;
-        const isLimited = limited(entries, group.ids);
-        const thresholds = evidenceIds.map((id) => WEB_EVIDENCE_IDS.has(id)
-            ? freshnessPolicy.thresholdsDays.web
-            : NETWORK_EVIDENCE_IDS.has(id)
-                ? freshnessPolicy.thresholdsDays.network
-                : freshnessPolicy.thresholdsDays[group.threshold]);
-        const staleAfterDays = Math.min(...thresholds);
-        const evidenceAges = evidenceIds
-            .map((id) => observedAgeDays(options.observedAtByEvidence?.[id] ?? observedAt, now))
-            .filter((value) => value !== null);
-        const groupAgeDays = evidenceAges.length ? Math.max(...evidenceAges) : ageDays;
-        const groupStale = groupAgeDays !== null && groupAgeDays >= staleAfterDays;
-        if (!isLimited && !groupStale)
-            continue;
-        plans.push({
-            id: group.id,
-            label: group.label,
-            endpoint: group.endpoint,
-            evidenceIds,
-            reason: isLimited ? 'limited' : 'stale',
-            requestDisclosure: group.disclosure,
-            supersedesObservedAt: typeof observedAt === 'string' && Number.isFinite(Date.parse(observedAt))
-                ? new Date(observedAt).toISOString()
-                : null,
-            ageDays: groupAgeDays,
-            staleAfterDays,
-        });
-    }
-    const stale = plans.some((item) => item.reason === 'stale');
-    return {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        stale,
-        ageDays,
-        freshnessPolicy,
-        items: plans,
-        limitations: [
-            'A source refresh is displayed separately and never merged into the original unified Lookup envelope.',
-            'Run a complete Lookup before saving, comparing, or exporting replacement evidence collected at one review time.',
-            'A retry can remain partial or unavailable and never proves that missing evidence is absent.',
-            'Freshness thresholds organise review only. They do not make an older observation false or a newer observation complete.',
-        ],
-    };
-}
-function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
-function text(value, maximum = 180) {
-    return String(value ?? '')
-        .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim()
-        .slice(0, maximum);
-}
-function summarizeSource(plan, body, observedAt, depth, supersedesObservedAt) {
-    const base = {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        id: plan.id,
-        observedAt,
-        attemptedAt: observedAt,
-        reason: plan.reason,
-        evidenceIds: plan.evidenceIds.slice(0, 12),
-        supersedesObservedAt,
-    };
-    if (plan.id === 'rdap') {
-        const upstreamStatus = Number(body.upstreamStatus);
-        const parsed = record(body.parsed);
-        const complete = upstreamStatus === 200 && Object.keys(parsed).length > 0;
-        return {
-            ...base,
-            state: complete ? 'complete' : 'limited',
-            detail: complete
-                ? `Registry RDAP returned a validated ${upstreamStatus} response.`
-                : `Registry RDAP returned ${Number.isFinite(upstreamStatus) ? `HTTP ${upstreamStatus}` : 'no complete structured record'}.`,
-        };
-    }
-    if (plan.id === 'whois') {
-        const chain = Array.isArray(body.chain) ? body.chain : [];
-        const chainStatus = text(record(body.parsed).chainStatus, 40);
-        const complete = chain.length > 0 && chainStatus === 'complete';
-        return {
-            ...base,
-            state: complete ? 'complete' : 'limited',
-            detail: complete
-                ? `WHOIS returned a complete ${chain.length}-hop referral chain.`
-                : `WHOIS returned ${chain.length} hop${chain.length === 1 ? '' : 's'} with ${chainStatus || 'unknown'} chain status.`,
-        };
-    }
-    const state = text(body.state, 40) || 'unknown';
-    const complete = body.deepScanComplete === true
-        || (depth === 'fast' && state !== 'unknown');
-    const sourceStates = ['dns', 'http', 'tls']
-        .map((key) => text(record(body[key]).status, 40))
-        .filter(Boolean);
-    return {
-        ...base,
-        state: complete ? 'complete' : 'limited',
-        detail: `Domain evidence returned ${state}${sourceStates.length ? `; DNS, HTTP, and TLS states: ${sourceStates.join(', ')}` : ''}.`,
-    };
-}
-function unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, detail) {
-    return {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        id: plan.id,
-        state: 'unavailable',
-        detail,
-        observedAt: null,
-        attemptedAt,
-        reason: plan.reason,
-        evidenceIds: plan.evidenceIds.slice(0, 12),
-        supersedesObservedAt,
-    };
-}
-export async function requestLookupSourceRefresh(plan, query, depth, options = {}) {
-    const normalizedQuery = text(query, 4096);
-    if (!normalizedQuery)
-        return { ok: false, message: 'A valid Lookup target is required.' };
-    const timeoutMs = Number.isFinite(options.timeoutMs)
-        ? Math.max(1, Math.min(LOOKUP_SOURCE_REFRESH_TIMEOUT_MS, Math.round(Number(options.timeoutMs))))
-        : LOOKUP_SOURCE_REFRESH_TIMEOUT_MS;
-    const attemptedAt = options.now?.() ?? new Date().toISOString();
-    const supersedesObservedAt = options.supersedesObservedAt === undefined
-        ? plan.supersedesObservedAt
-        : options.supersedesObservedAt;
-    try {
-        const url = `${plan.endpoint}?q=${encodeURIComponent(normalizedQuery)}${plan.id === 'availability' && depth === 'fast' ? '&fast=true' : ''}`;
-        const { response, body: rawBody } = await requestJsonCapped(url, {
-            credentials: 'same-origin',
-        }, {
-            ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
-            maximumBytes: MAX_LOOKUP_SOURCE_REFRESH_BYTES,
-            timeoutMs,
-        });
-        const body = record(rawBody);
-        if (!response.ok) {
-            return {
-                ok: true,
-                value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, text(body.error, 240) || `The source returned HTTP ${response.status}; no new observation was recorded.`),
-            };
-        }
-        if (Object.keys(body).length > MAX_LOOKUP_SOURCE_REFRESH_KEYS) {
-            return { ok: false, message: 'Source refresh returned an oversized record.' };
-        }
-        return {
-            ok: true,
-            value: summarizeSource(plan, body, attemptedAt, depth, supersedesObservedAt),
-        };
-    }
-    catch (cause) {
-        if (cause instanceof BoundedJsonResponseError && cause.code === 'response_too_large') {
-            return { ok: true, value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, 'The source response exceeded the local limit; no new observation was recorded.') };
-        }
-        return {
-            ok: true,
-            value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, cause instanceof BoundedJsonResponseError && cause.code === 'timeout'
-                ? 'The source refresh timed out; no new observation was recorded.'
-                : 'The source refresh could not be completed; no new observation was recorded.'),
-        };
-    }
-}
-export function mergeLookupSourceRefreshLedger(current, result) {
-    const candidates = [
-        ...(current?.version === LOOKUP_SOURCE_REFRESH_VERSION ? current.entries : []),
-        result,
-    ];
-    const byObservation = new Map();
-    for (const entry of candidates.slice(-MAX_LOOKUP_SOURCE_REFRESH_HISTORY * 4)) {
-        byObservation.set(`${entry.id}:${entry.attemptedAt}`, entry);
-    }
-    const ordered = [...byObservation.values()]
-        .sort((left, right) => Date.parse(left.attemptedAt) - Date.parse(right.attemptedAt));
-    const truncated = Boolean(current?.truncated)
-        || ordered.length > MAX_LOOKUP_SOURCE_REFRESH_HISTORY
-        || candidates.length > MAX_LOOKUP_SOURCE_REFRESH_HISTORY;
-    return {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        entries: ordered.slice(-MAX_LOOKUP_SOURCE_REFRESH_HISTORY),
-        truncated,
-    };
-}