@slicedearth/whoisleuth-cli 2.0.1 → 2.2.0

package/cli/lookup-browser.mjs

@@ -1,299 +1,14 @@
 import { StringDecoder } from 'node:string_decoder';
-import { formatTerminalLookup, safeTerminalValue } from "./formatters/terminal.mjs";
-import { presentTerminalOutput, terminalPresentation, wrapTerminalOutput, } from "./terminal-presentation.mjs";
-const MIN_LOOKUP_BROWSER_HEIGHT = 12;
-const MAX_LOOKUP_BROWSER_HEIGHT = 80;
-const MAX_LOOKUP_BROWSER_PANELS = 9;
+import { safeTerminalValue } from "./formatters/terminal.mjs";
+import { terminalPresentation, } from "./terminal-presentation.mjs";
+import { MIN_LOOKUP_BROWSER_HEIGHT, MAX_LOOKUP_BROWSER_PANELS, MAX_LOOKUP_BROWSER_SEARCH_BYTES, MAX_LOOKUP_BROWSER_SEARCH_MATCHES, MAX_LOOKUP_BROWSER_SEARCH_SCALARS, boundedBrowserDimensions, boundedSearchText, buildLookupBrowserHelpFrame, buildLookupBrowserFrame, buildLookupBrowserPanels, buildLookupBrowserSearchFrame, buildLookupCollectionFrame, findLookupBrowserMatches, renderedPanelLineOffset, renderLookupBrowser, terminalDisplayWidth, } from "./lookup-browser-view.mjs";
 const ENTER_ALTERNATE_SCREEN = '\u001b[?1049h\u001b[?25l';
 const LEAVE_ALTERNATE_SCREEN = '\u001b[?25h\u001b[?1049l';
 const CLEAR_SCREEN = '\u001b[2J\u001b[H';
 const ESCAPE_SEQUENCE_WAIT_MS = 40;
 const MAX_PENDING_INPUT_LENGTH = 512;
 const MAX_LOOKUP_BROWSER_INPUT_CHUNK_BYTES = 2_048;
-const MAX_LOOKUP_BROWSER_SEARCH_BYTES = 256;
-const MAX_LOOKUP_BROWSER_SEARCH_SCALARS = 80;
-const MAX_LOOKUP_BROWSER_SEARCH_MATCHES = 256;
-const ANSI_SEQUENCE_RE = /\u001b\[[0-?]*[ -/]*[@-~]/gu;
 const COMPLETE_CSI_RE = /^\u001b\[[0-?]*[ -/]*[@-~]/u;
-function boundedHeight(value) {
-    const height = Number(value);
-    if (!Number.isSafeInteger(height))
-        return 24;
-    return Math.max(MIN_LOOKUP_BROWSER_HEIGHT, Math.min(MAX_LOOKUP_BROWSER_HEIGHT, height));
-}
-function panelId(value, index) {
-    const normalized = value.toLowerCase().replace(/[^a-z0-9]+/gu, '-').replace(/^-|-$/gu, '');
-    return normalized || `panel-${index + 1}`;
-}
-function terminalCharacterWidth(character) {
-    const codePoint = character.codePointAt(0) || 0;
-    if (/\p{Mark}/u.test(character)
-        || codePoint === 0x200d
-        || codePoint >= 0xfe00 && codePoint <= 0xfe0f
-        || codePoint >= 0xe0100 && codePoint <= 0xe01ef)
-        return 0;
-    return codePoint >= 0x1100 && (codePoint <= 0x115f
-        || codePoint === 0x2329
-        || codePoint === 0x232a
-        || codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f
-        || codePoint >= 0xac00 && codePoint <= 0xd7a3
-        || codePoint >= 0xf900 && codePoint <= 0xfaff
-        || codePoint >= 0xfe10 && codePoint <= 0xfe19
-        || codePoint >= 0xfe30 && codePoint <= 0xfe6f
-        || codePoint >= 0xff00 && codePoint <= 0xff60
-        || codePoint >= 0xffe0 && codePoint <= 0xffe6
-        || codePoint >= 0x1f300 && codePoint <= 0x1faff
-        || codePoint >= 0x20000 && codePoint <= 0x3fffd) ? 2 : 1;
-}
-function terminalDisplayWidth(value) {
-    return Array.from(value.replace(ANSI_SEQUENCE_RE, ''))
-        .reduce((total, character) => total + terminalCharacterWidth(character), 0);
-}
-function hardWrapTerminalLine(line, width) {
-    if (!line || terminalDisplayWidth(line) <= width)
-        return [line];
-    const lines = [];
-    let current = '';
-    let currentWidth = 0;
-    for (const character of line) {
-        const characterWidth = terminalCharacterWidth(character);
-        if (current && currentWidth + characterWidth > width) {
-            lines.push(current);
-            current = '';
-            currentWidth = 0;
-        }
-        current += character;
-        currentWidth += characterWidth;
-    }
-    if (current || !lines.length)
-        lines.push(current);
-    return lines;
-}
-function clipTerminalLine(line, width) {
-    if (terminalDisplayWidth(line) <= width)
-        return line;
-    const maximumContentWidth = Math.max(1, width - 1);
-    let clipped = '';
-    let clippedWidth = 0;
-    for (const character of line) {
-        const characterWidth = terminalCharacterWidth(character);
-        if (clippedWidth + characterWidth > maximumContentWidth)
-            break;
-        clipped += character;
-        clippedWidth += characterWidth;
-    }
-    return `${clipped}…`;
-}
-function wrapLookupBrowserLines(value, width) {
-    const softlyWrapped = wrapTerminalOutput(`${value}\n`, width).replace(/\n$/u, '').split('\n');
-    return softlyWrapped.flatMap((line) => hardWrapTerminalLine(line, width));
-}
-function buildLookupBrowserPanels(document) {
-    const blocks = formatTerminalLookup(document, { detail: 'verbose' })
-        .trimEnd()
-        .split(/\n\n/gu)
-        .slice(0, MAX_LOOKUP_BROWSER_PANELS);
-    return blocks.flatMap((block, index) => {
-        const [heading, ...lines] = block.split('\n');
-        if (!heading?.endsWith(':') || lines.length === 0)
-            return [];
-        const label = heading.slice(0, -1);
-        return [Object.freeze({
-                id: panelId(label, index),
-                label,
-                lines: Object.freeze(lines),
-            })];
-    });
-}
-function browserTabLine(panels, activeIndex, width) {
-    const labels = panels.map((panel, index) => index === activeIndex
-        ? `[${index + 1} ${panel.label}]`
-        : `${index + 1} ${panel.label}`);
-    const complete = labels.join('  ');
-    if (terminalDisplayWidth(complete) <= width)
-        return complete;
-    const visible = [activeIndex - 1, activeIndex, activeIndex + 1]
-        .filter((index) => index >= 0 && index < panels.length)
-        .map((index) => labels[index]);
-    const windowed = `${activeIndex > 1 ? '‹  ' : ''}${visible.join('  ')}${activeIndex + 2 < panels.length ? '  ›' : ''}`;
-    return clipTerminalLine(windowed, width);
-}
-function boundedTargetLine(query, width) {
-    return clipTerminalLine(`Target  ${query}`, width);
-}
-function boundedBrowserDimensions(options) {
-    return {
-        width: Math.max(40, Math.min(160, Number.isSafeInteger(options.width) ? Number(options.width) : 100)),
-        height: boundedHeight(options.height),
-    };
-}
-function boundedSearchText(value) {
-    const text = typeof value === 'string' ? value : '';
-    if (Buffer.byteLength(text, 'utf8') > MAX_LOOKUP_BROWSER_SEARCH_BYTES
-        || Array.from(text).length > MAX_LOOKUP_BROWSER_SEARCH_SCALARS
-        || /[\u0000-\u001f\u007f-\u009f\u061c\u200b-\u200f\u202a-\u202e\u2060-\u2069\ufeff]/u.test(text)) {
-        throw new RangeError(`Lookup browser search is limited to ${MAX_LOOKUP_BROWSER_SEARCH_SCALARS} characters and ${MAX_LOOKUP_BROWSER_SEARCH_BYTES} UTF-8 bytes.`);
-    }
-    return text;
-}
-function findLookupBrowserMatches(panels, query) {
-    const normalized = boundedSearchText(query).trim().toLocaleLowerCase('en-US');
-    if (!normalized)
-        return { matches: [], truncated: false };
-    const matches = [];
-    let truncated = false;
-    outer: for (let panelIndex = 0; panelIndex < panels.length; panelIndex += 1) {
-        const panel = panels[panelIndex];
-        const lines = [panel.label, ...panel.lines];
-        for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
-            if (!String(lines[lineIndex] || '').toLocaleLowerCase('en-US').includes(normalized))
-                continue;
-            if (matches.length >= MAX_LOOKUP_BROWSER_SEARCH_MATCHES) {
-                truncated = true;
-                break outer;
-            }
-            matches.push(Object.freeze({ panelIndex, lineIndex: Math.max(0, lineIndex - 1) }));
-        }
-    }
-    return { matches, truncated };
-}
-function renderedPanelLineOffset(panel, lineIndex, width) {
-    if (lineIndex <= 0)
-        return 0;
-    return panel.lines
-        .slice(0, Math.min(lineIndex, panel.lines.length))
-        .reduce((total, line) => total + wrapLookupBrowserLines(line, width).length, 0);
-}
-function renderStandaloneBrowserFrame(lines, options) {
-    const { width, height } = boundedBrowserDimensions(options);
-    const clipped = lines.slice(0, height).map((line) => clipTerminalLine(line, width));
-    return presentTerminalOutput(`${clipped.join('\n')}\n`, {
-        color: options.color === true,
-        interactive: true,
-        palette: options.palette || 'auto',
-        width: null,
-    });
-}
-function buildLookupBrowserHelpFrame(document, options = {}) {
-    const query = safeTerminalValue(document?.query ?? options.query, 'unknown target');
-    const mode = safeTerminalValue(document?.mode ?? options.mode, 'unknown mode');
-    return renderStandaloneBrowserFrame([
-        'WHOISleuth evidence browser help',
-        boundedTargetLine(query, boundedBrowserDimensions(options).width),
-        `Mode    ${mode}`,
-        '',
-        options.collecting ? 'Collection' : 'Panels',
-        options.collecting
-            ? '  q / Ctrl-C  cancel the active collection'
-            : '  ←/→ h/l Tab  move panels · 1-9 select',
-        options.collecting
-            ? '  progress is transient and is never retained'
-            : '  ↑/↓ j/k PgUp/PgDn Home/End  scroll',
-        options.collecting ? '  ? / Esc  return to collection progress' : '  /  search rendered panels · n/N matches',
-        '  ? / Esc  return · q  close',
-    ], options);
-}
-function buildLookupBrowserSearchFrame(document, query, notice, options = {}) {
-    return renderStandaloneBrowserFrame([
-        'WHOISleuth evidence browser search',
-        boundedTargetLine(safeTerminalValue(document.query, 'unknown target'), boundedBrowserDimensions(options).width),
-        `Mode    ${safeTerminalValue(document.mode, 'unknown mode')}`,
-        '',
-        `Search  ${query || 'type a bounded term'}`,
-        notice || 'Search covers only the bounded text rendered in the evidence panels.',
-        '',
-        'Enter apply · Backspace edit · Esc cancel',
-    ], options);
-}
-function buildLookupCollectionFrame(queryValue, modeValue, sources, options = {}) {
-    const { width, height } = boundedBrowserDimensions(options);
-    const query = safeTerminalValue(queryValue, 'unknown target');
-    const mode = modeValue === 'deep' ? 'deep' : 'fast';
-    const header = [
-        'WHOISleuth evidence browser',
-        boundedTargetLine(query, width),
-        `Mode    ${mode}`,
-        'Collection in progress:',
-    ];
-    const footer = ['? help · progress is transient', 'q/Esc/Ctrl-C cancel'];
-    const bodyCapacity = Math.max(1, height - header.length - footer.length);
-    const body = mode === 'fast'
-        ? [
-            'Registration evidence  collecting',
-            'Fast mode waits for the final bounded result.',
-            'Per-source states are not fabricated.',
-        ]
-        : sources.flatMap((source) => {
-            const state = source.state === 'pending'
-                ? 'pending'
-                : `${source.state}${source.complete ? ' · complete' : ' · incomplete'}${source.truncated ? ' · truncated' : ''}`;
-            const limitation = source.state !== 'pending' && source.limitation
-                ? ` · ${source.limitation}`
-                : '';
-            return [clipTerminalLine(`${source.source.replaceAll('_', ' ')}  ${state}${limitation}`, width)];
-        });
-    const visible = body.slice(0, bodyCapacity);
-    if (body.length > visible.length && visible.length) {
-        visible[visible.length - 1] = `+${body.length - visible.length + 1} source states not visible at this height`;
-    }
-    return renderStandaloneBrowserFrame([...header, ...visible, ...footer], {
-        ...options,
-        width,
-        height,
-    });
-}
-function buildLookupBrowserFrame(document, options = {}) {
-    const panels = buildLookupBrowserPanels(document);
-    const { width, height } = boundedBrowserDimensions(options);
-    if (!panels.length)
-        return Object.freeze({
-            value: `${clipTerminalLine('WHOISleuth evidence browser', width)}\n${clipTerminalLine('No bounded terminal panels were available.', width)}\n`,
-            scrollOffset: 0,
-            maximumScrollOffset: 0,
-            pageSize: 0,
-            totalBodyLines: 0,
-        });
-    const activeIndex = Math.max(0, Math.min(panels.length - 1, Number.isSafeInteger(options.activeIndex) ? Number(options.activeIndex) : 0));
-    const panel = panels[activeIndex];
-    const query = safeTerminalValue(document.query, 'unknown target');
-    const mode = safeTerminalValue(document.mode, 'unknown mode');
-    const header = [
-        'WHOISleuth evidence browser',
-        boundedTargetLine(query, width),
-        `Mode    ${clipTerminalLine(mode, Math.max(1, width - 8))}`,
-        browserTabLine(panels, activeIndex, width),
-        `${panel.label}:`,
-    ];
-    const footerLineCount = 2;
-    const body = wrapLookupBrowserLines(panel.lines.join('\n'), width);
-    const bodyCapacity = Math.max(1, height - header.length - footerLineCount);
-    const maximumScrollOffset = Math.max(0, body.length - bodyCapacity);
-    const requestedScrollOffset = Number.isSafeInteger(options.scrollOffset) ? Number(options.scrollOffset) : 0;
-    const scrollOffset = Math.max(0, Math.min(maximumScrollOffset, requestedScrollOffset));
-    const visibleBody = body.slice(scrollOffset, scrollOffset + bodyCapacity);
-    const firstVisibleLine = body.length ? scrollOffset + 1 : 0;
-    const lastVisibleLine = body.length ? scrollOffset + visibleBody.length : 0;
-    const footer = [
-        options.searchStatus || `View ${activeIndex + 1}/${panels.length} · lines ${firstVisibleLine}-${lastVisibleLine}/${body.length}`,
-        '←/→ panels · ↑/↓ scroll · / search · ? help · q close',
-    ].map((line) => clipTerminalLine(line, width));
-    const value = [...header, ...visibleBody, ...footer].slice(0, height).join('\n');
-    return Object.freeze({
-        value: presentTerminalOutput(`${value}\n`, {
-            color: options.color === true,
-            interactive: true,
-            palette: options.palette || 'auto',
-            width: null,
-        }),
-        scrollOffset,
-        maximumScrollOffset,
-        pageSize: bodyCapacity,
-        totalBodyLines: body.length,
-    });
-}
-function renderLookupBrowser(document, options = {}) {
-    return buildLookupBrowserFrame(document, options).value;
-}
 function canBrowseLookup(input, output, environment = process.env) {
     return input?.isTTY === true
         && output?.isTTY === true

package/cli/mail-review.mjs

@@ -2,6 +2,7 @@ import { Buffer } from 'node:buffer';
 import { getDomain } from 'tldts';
 import { scanBoundedJson } from "../lib/bounded-json.mjs";
 import { isValidAsciiDomainName } from "../lib/hostname.mjs";
+import { isRecord, recordOrEmpty } from "../lib/json-record.mjs";
 import { CliUsageError } from "./errors.mjs";
 export const CLI_MAIL_REVIEW_SCHEMA = 'whoisleuth.cli.mail-review';
 export const CLI_MAIL_REVIEW_VERSION = 3;
@@ -9,12 +10,7 @@ export const MAX_MAIL_REVIEW_INPUT_BYTES = 16 * 1024 * 1024;
 export const MAX_MAIL_REVIEW_ROWS = 500;
 const UNSAFE_TEXT_RE = /[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2060-\u206f]/u;
 const UNSAFE_TEXT_GLOBAL_RE = /[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2060-\u206f]+/gu;
-function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
+const record = recordOrEmpty;
 function text(value, maximum = 500) {
     return typeof value === 'string'
         ? value.replace(UNSAFE_TEXT_GLOBAL_RE, ' ').replace(/\s+/gu, ' ').trim().slice(0, maximum)

package/cli/offline-artifact-validation.mjs

@@ -0,0 +1,19 @@
+import { CASE_RESPONSE_PACKET_SCHEMA } from "../packages/cases/case-response-packet.mjs";
+import { INVESTIGATION_CAPSULE_SCHEMA } from "../packages/investigation/investigation-capsule.mjs";
+import { LOOKUP_EVIDENCE_SCHEMA } from "../lib/evidence-export.mjs";
+import { validateCaseResponsePacket } from "./artifact-validation/case-response.mjs";
+import { validateInvestigationCapsuleStructure } from "./artifact-validation/investigation-capsule.mjs";
+import { validateLookupEvidenceArtifactStructure } from "./artifact-validation/lookup-evidence.mjs";
+import { validateSignedDigestArtifactStructure } from "./artifact-validation/signed-review.mjs";
+import {} from "./artifact-validation/structure-primitives.mjs";
+export { validateInvestigationCapsuleStructure, validateLookupEvidenceArtifactStructure, validateSignedDigestArtifactStructure };
+export function validateOfflineArtifactStructure(schema, value) {
+    if (schema === CASE_RESPONSE_PACKET_SCHEMA)
+        validateCaseResponsePacket(value);
+    else if (schema === INVESTIGATION_CAPSULE_SCHEMA)
+        validateInvestigationCapsuleStructure(value);
+    else if (schema === LOOKUP_EVIDENCE_SCHEMA)
+        validateLookupEvidenceArtifactStructure(value);
+    else
+        validateSignedDigestArtifactStructure(schema, value);
+}

package/cli/review-command-runner.mjs

@@ -0,0 +1,269 @@
+import { MAX_OFFLINE_ARTIFACT_BYTES, formatOfflineArtifactVerification, isCompleteOfflineArtifactVerification, verifyOfflineArtifact, } from "./artifact-verify.mjs";
+import { MAX_CASE_PACK_INPUT_BYTES, buildCliCasePack, formatCliCasePack } from "./case-pack.mjs";
+import { MAX_COMPARE_INPUT_BYTES, compareLookupDocument, parseCliLookupDocument, } from "./compare.mjs";
+import { boundedCliErrorMessage, CliUsageError } from "./errors.mjs";
+import EXIT_CODES from "./exit-codes.mjs";
+import { MAX_OFFLINE_EVIDENCE_INPUT_BYTES, buildOfflineEvidenceReview, buildOfflineEvidenceReviewWithLocalResources, formatOfflineEvidenceReview, } from "./offline-evidence-review.mjs";
+import { buildCliLookupBrief, formatCliLookupBrief } from "./lookup-brief.mjs";
+import { MAX_MAIL_REVIEW_INPUT_BYTES, buildCliMailReview, formatCliMailReview, } from "./mail-review.mjs";
+import { buildCliPageComparison, formatCliPageComparison } from "./page-compare.mjs";
+import { MAX_SOURCE_RELIABILITY_INPUT_BYTES, buildSourceReliabilityReport, formatSourceReliabilityReport, } from "./source-reliability.mjs";
+import { buildInterchangeFidelityReport, formatInterchangeFidelityReport, } from "./interchange-report.mjs";
+import { buildCliCompareDocument, formatJsonDocument, } from "./formatters/json.mjs";
+import { formatTerminalCompare } from "./formatters/terminal.mjs";
+import { MAX_SAVED_LOOKUP_INPUT_BYTES } from "./saved-lookup.mjs";
+import { REVIEW_INLINE_COMMANDS } from "./inline-command-families.mjs";
+import { runDiscriminatedCommandHandler } from "./discriminated-command-handlers.mjs";
+async function runVerifyArtifactCommand(args, dependencies, context) {
+    context.setFailureLabel('Artefact verification');
+    let input;
+    try {
+        input = dependencies.readArtifactInput
+            ? await dependencies.readArtifactInput(args.source)
+            : await context.readInput(args.source, MAX_OFFLINE_ARTIFACT_BYTES, 'Artefact input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read artifact input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    if (!input.trim())
+        throw new CliUsageError('verify-artifact requires one JSON file or an artefact on stdin.');
+    const passphrase = args.passphraseSource ? await context.readPassphraseSource(args.passphraseSource) : null;
+    let manifest = null;
+    if (args.manifestSource && args.manifestEntryId) {
+        let raw;
+        try {
+            raw = dependencies.readArtifactInput
+                ? await dependencies.readArtifactInput(args.manifestSource)
+                : await context.readInput(args.manifestSource, MAX_OFFLINE_ARTIFACT_BYTES, 'Investigation manifest input');
+        }
+        catch (error) {
+            if (error instanceof CliUsageError)
+                throw error;
+            throw new CliUsageError(`Could not read investigation manifest input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+        }
+        if (!raw.trim())
+            throw new CliUsageError('The investigation manifest input is empty.');
+        manifest = Object.freeze({ raw, entryId: args.manifestEntryId });
+    }
+    const report = await verifyOfflineArtifact(input, { passphrase, manifest });
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(report)
+            : context.terminal(formatOfflineArtifactVerification(report), args.color));
+    }
+    return args.strictExit && !isCompleteOfflineArtifactVerification(report)
+        ? EXIT_CODES.PARTIAL_FAILURE
+        : EXIT_CODES.SUCCESS;
+}
+async function runInterchangeReportCommand(args, dependencies, context) {
+    context.setFailureLabel('Interchange fidelity report');
+    let input;
+    try {
+        input = dependencies.readArtifactInput
+            ? await dependencies.readArtifactInput(args.source)
+            : await context.readInput(args.source, MAX_OFFLINE_ARTIFACT_BYTES, 'Interchange input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read interchange input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    if (!input.trim())
+        throw new CliUsageError('interchange-report requires one JSON file or an artefact on stdin.');
+    const passphrase = args.passphraseSource ? await context.readPassphraseSource(args.passphraseSource) : null;
+    const report = await buildInterchangeFidelityReport(input, {
+        generatedAt: context.now(),
+        passphrase,
+    });
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(report)
+            : context.terminal(formatInterchangeFidelityReport(report), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runSourceReportCommand(args, dependencies, context) {
+    context.setFailureLabel('Source reliability report');
+    let input;
+    try {
+        input = dependencies.readSourceReliabilityInput
+            ? await dependencies.readSourceReliabilityInput(args.source)
+            : await context.readInput(args.source, MAX_SOURCE_RELIABILITY_INPUT_BYTES, 'Source reliability input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read source reliability input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    if (!input.trim())
+        throw new CliUsageError('source-report requires one JSON file or lookup documents on stdin.');
+    const report = buildSourceReliabilityReport(input, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(report)
+            : context.terminal(formatSourceReliabilityReport(report), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runCompareCommand(args, dependencies, context) {
+    context.setFailureLabel('Registry comparison');
+    let input;
+    try {
+        input = dependencies.readCompareInput
+            ? await dependencies.readCompareInput(args.source)
+            : await context.readInput(args.source, MAX_COMPARE_INPUT_BYTES, 'Comparison input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read comparison input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    if (!input.trim())
+        throw new CliUsageError('compare requires one lookup JSON file or a lookup document on stdin.');
+    const parsed = parseCliLookupDocument(input);
+    const loadComparison = dependencies.loadRegistryComparison || (() => import("../lib/registry-comparison.mjs"));
+    const comparisonModule = await loadComparison();
+    const result = compareLookupDocument(parsed, comparisonModule.compareRegistrySources, comparisonModule.compareRdapPublications);
+    const document = buildCliCompareDocument(result, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(document)
+            : context.terminal(formatTerminalCompare(document), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runPageCompareCommand(args, dependencies, context) {
+    context.setFailureLabel('Static page comparison');
+    const readDiffInput = dependencies.readDiffInput
+        || ((source) => context.readInput(source, MAX_SAVED_LOOKUP_INPUT_BYTES, 'Page comparison input'));
+    let leftInput;
+    let rightInput;
+    try {
+        [leftInput, rightInput] = await Promise.all([
+            readDiffInput(args.leftSource),
+            readDiffInput(args.rightSource),
+        ]);
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read page comparison input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    const document = buildCliPageComparison(leftInput, rightInput, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(document)
+            : context.terminal(formatCliPageComparison(document), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runMailReviewCommand(args, dependencies, context) {
+    context.setFailureLabel('Passive mail review');
+    let input;
+    try {
+        input = dependencies.readMailReviewInput
+            ? await dependencies.readMailReviewInput(args.source)
+            : await context.readInput(args.source, MAX_MAIL_REVIEW_INPUT_BYTES, 'Mail review input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read mail review input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    const document = buildCliMailReview(input, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(document)
+            : context.terminal(formatCliMailReview(document), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runOfflineEvidenceReviewCommand(args, dependencies, context) {
+    context.setFailureLabel('Offline evidence review');
+    let input;
+    try {
+        input = dependencies.readArtifactInput
+            ? await dependencies.readArtifactInput(args.source)
+            : await context.readInput(args.source, MAX_OFFLINE_EVIDENCE_INPUT_BYTES, 'Offline evidence input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read offline evidence input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    if (!input.trim())
+        throw new CliUsageError('review-evidence requires one JSON file or a document on stdin.');
+    const document = args.mmdbSource
+        ? await buildOfflineEvidenceReviewWithLocalResources(input, context.now(), { mmdbPath: args.mmdbSource })
+        : buildOfflineEvidenceReview(input, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(document)
+            : context.terminal(formatOfflineEvidenceReview(document), args.color));
+    }
+    if (args.strictExit) {
+        const result = document.result && typeof document.result === 'object' && !Array.isArray(document.result)
+            ? document.result
+            : {};
+        const gate = result.gate && typeof result.gate === 'object' && !Array.isArray(result.gate)
+            ? result.gate
+            : null;
+        const zoneMismatch = document.kind === 'zone_intent' && (result.complete !== true
+            || (result.counts && typeof result.counts === 'object' && !Array.isArray(result.counts)
+                && ['different', 'missing', 'unexpected', 'incomplete'].some((key) => Number(result.counts[key]) > 0)));
+        if (gate?.pass === false || zoneMismatch)
+            return EXIT_CODES.PARTIAL_FAILURE;
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runBriefOrCasePackCommand(args, dependencies, context) {
+    const isBrief = args.action === 'brief';
+    context.setFailureLabel(isBrief ? 'Lookup brief' : 'Case pack');
+    let input;
+    try {
+        input = dependencies.readArtifactInput
+            ? await dependencies.readArtifactInput(args.source)
+            : await context.readInput(args.source, isBrief ? MAX_SAVED_LOOKUP_INPUT_BYTES : MAX_CASE_PACK_INPUT_BYTES, isBrief ? 'Lookup brief input' : 'Case-pack input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read ${isBrief ? 'Lookup brief' : 'case-pack'} input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    if (!input.trim())
+        throw new CliUsageError(`${args.action} requires one JSON file or a document on stdin.`);
+    if (args.action === 'brief') {
+        const document = buildCliLookupBrief(input, context.now());
+        if (!args.quiet) {
+            context.writeStdout(args.output === 'json'
+                ? formatJsonDocument(document)
+                : context.terminal(formatCliLookupBrief(document), args.color));
+        }
+    }
+    else {
+        const document = buildCliCasePack(input, { audience: args.audience, reviewed: args.reviewed }, context.now());
+        if (!args.quiet) {
+            context.writeStdout(args.output === 'json'
+                ? formatJsonDocument(document)
+                : context.terminal(formatCliCasePack(document), args.color));
+        }
+    }
+    return EXIT_CODES.SUCCESS;
+}
+const REVIEW_COMMAND_HANDLERS = Object.freeze({
+    'verify-artifact': runVerifyArtifactCommand,
+    'interchange-report': runInterchangeReportCommand,
+    'source-report': runSourceReportCommand,
+    'compare': runCompareCommand,
+    'page-compare': runPageCompareCommand,
+    'mail-review': runMailReviewCommand,
+    'review-evidence': runOfflineEvidenceReviewCommand,
+    'brief': runBriefOrCasePackCommand,
+    'case-pack': runBriefOrCasePackCommand,
+});
+function runReviewCommand(args, dependencies, context) {
+    return runDiscriminatedCommandHandler(REVIEW_COMMAND_HANDLERS, args, dependencies, context);
+}
+export { REVIEW_COMMAND_HANDLERS, runReviewCommand };