@slicedearth/whoisleuth-cli 1.47.4 → 2.0.1

package/cli/offline-evidence-review.mjs

@@ -1,4 +1,5 @@
 import { Buffer } from 'node:buffer';
+import { scanBoundedJson } from "../lib/bounded-json.mjs";
 import { normalizeEncryptedDnsAdapter, planEncryptedDnsQuery, } from "../lib/encrypted-dns-contract.mjs";
 import { validateDnssecEvidence } from "../lib/dnssec-evidence-validation.mjs";
 import { reviewDomainChange } from "../lib/domain-change-review.mjs";
@@ -13,6 +14,7 @@ import { reviewZoneIntent } from "../lib/zone-intent-review.mjs";
 import { reviewDnsConvergence } from "../lib/dns-convergence-review.mjs";
 import { compareTrustStoreEvidence } from "../lib/trust-store-comparison.mjs";
 import { CliUsageError } from "./errors.mjs";
+import { safeTerminalValue } from "./formatters/terminal.mjs";
 import { LOCAL_MMDB_QUERY_SCHEMA, reviewLocalMmdb } from "./local-mmdb-review.mjs";
 const OFFLINE_EVIDENCE_REVIEW_SCHEMA = 'whoisleuth.cli.offline-evidence-review';
 const OFFLINE_EVIDENCE_REVIEW_VERSION = 1;
@@ -31,12 +33,14 @@ function parseInput(value) {
     if (typeof value !== 'string' || Buffer.byteLength(value, 'utf8') > MAX_OFFLINE_EVIDENCE_INPUT_BYTES) {
         throw new CliUsageError(`Offline evidence input is limited to ${MAX_OFFLINE_EVIDENCE_INPUT_BYTES} bytes.`);
     }
+    const normalized = value.replace(/^\uFEFF/u, '');
     let parsed;
     try {
-        parsed = JSON.parse(value.replace(/^\uFEFF/u, ''));
+        scanBoundedJson(normalized);
+        parsed = JSON.parse(normalized);
     }
     catch {
-        throw new CliUsageError('Offline evidence review requires one valid JSON document.');
+        throw new CliUsageError('Offline evidence review requires one valid bounded JSON document without duplicate keys.');
     }
     const document = record(parsed);
     if (document.version !== 1 || typeof document.schema !== 'string') {
@@ -81,8 +85,8 @@ function buildOfflineEvidenceReview(value, generatedAt = new Date().toISOString(
         kind = 'tlsa';
         result = analyzeTlsaEvidence({
             serviceName: input.serviceName,
-            dnssecState: input.dnssecState,
-            pkixValidationState: input.pkixValidationState,
+            dnssecState: 'unavailable',
+            pkixValidationState: 'unavailable',
             records: input.records,
             certificateDerBase64: input.certificateDerBase64,
             spkiDerBase64: input.spkiDerBase64,
@@ -237,7 +241,14 @@ function formatOfflineEvidenceReview(document) {
         const cards = Array.isArray(result.cards) ? result.cards : [];
         for (const value of cards) {
             const card = record(value);
-            lines.push(`${String(card.label ?? card.family ?? 'Evidence')}  ${String(card.state ?? 'unavailable').replaceAll('_', ' ')} (${String(card.completeness ?? 'unavailable')})`);
+            lines.push(`${safeTerminalValue(card.label ?? card.family, 'Evidence')}  ${safeTerminalValue(card.state, 'unavailable').replaceAll('_', ' ')} (${safeTerminalValue(card.completeness, 'unavailable')})`);
+            lines.push(`  Source ${safeTerminalValue(card.source, 'not supplied')}`);
+            lines.push(`  Authority ${safeTerminalValue(card.authority, 'not supplied')}`);
+            const cardLimitations = Array.isArray(card.limitations) ? card.limitations : [];
+            for (const limitation of cardLimitations) {
+                if (typeof limitation === 'string')
+                    lines.push(`  Limitation: ${safeTerminalValue(limitation)}`);
+            }
         }
     }
     else {
@@ -258,7 +269,7 @@ function formatOfflineEvidenceReview(document) {
         lines.push('', 'Review reasons:');
         for (const reason of reasons.slice(0, 8)) {
             if (typeof reason === 'string')
-                lines.push(`  - ${reason.replace(/[\u0000-\u001f\u007f]+/gu, ' ').trim().slice(0, 240)}`);
+                lines.push(`  - ${safeTerminalValue(reason)}`);
         }
         if (reasons.length > 8)
             lines.push(`  - ${reasons.length - 8} more reason(s) omitted.`);
@@ -269,7 +280,7 @@ function formatOfflineEvidenceReview(document) {
     const nestedLimitations = Array.isArray(result.limitations) ? result.limitations : [];
     for (const limitation of nestedLimitations) {
         if (typeof limitation === 'string')
-            lines.push(`  - ${limitation}`);
+            lines.push(`  - ${safeTerminalValue(limitation)}`);
     }
     return `${lines.join('\n')}\n`;
 }

package/cli/open-asset-model-bridge.mjs

@@ -1,5 +1,5 @@
 import { isIP } from 'node:net';
-import { parseExternalFindingsDocument, } from "../frontend/src/lib/analysis/external-findings-import.js";
+import { parseExternalFindingsDocument, } from "../packages/interchange/external-findings-import.mjs";
 import { requireIsoTimestamp } from "../lib/bounded-contract-normalizers.mjs";
 export const OPEN_ASSET_MODEL_BRIDGE_SCHEMA = 'whoisleuth.open-asset-model-bridge';
 export const OPEN_ASSET_MODEL_BRIDGE_VERSION = 1;

package/cli/output-file.mjs

@@ -5,7 +5,14 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { CliUsageError } from "./errors.mjs";
 export const MAX_CLI_OUTPUT_BYTES = 32 * 1024 * 1024;
 const MAX_CLI_OUTPUT_PATH_LENGTH = 4096;
-const pendingOutputFiles = new Set();
+const pendingOutputFiles = new Map();
+const OUTPUT_FILE_OPERATIONS = Object.freeze({
+    randomUUID,
+    open,
+    link,
+    rename,
+    unlink,
+});
 function safeOutputPath(value) {
     if (typeof value !== 'string' || !value || value.length > MAX_CLI_OUTPUT_PATH_LENGTH) {
         throw new CliUsageError(`Output paths are limited to ${MAX_CLI_OUTPUT_PATH_LENGTH} characters.`);
@@ -35,18 +42,22 @@ function createBufferedOutput() {
         value: () => chunks.join(''),
     });
 }
-async function writePrivateFile(pathValue, content, options = {}) {
+async function writePrivateFile(pathValue, content, options = {}, operations = OUTPUT_FILE_OPERATIONS) {
     const target = safeOutputPath(pathValue);
     if (Buffer.byteLength(content, 'utf8') > MAX_CLI_OUTPUT_BYTES) {
         throw new CliUsageError(`Generated output is limited to ${MAX_CLI_OUTPUT_BYTES} bytes.`);
     }
     const directory = dirname(target);
-    const temporary = join(directory, `.${basename(target)}.${process.pid}.${randomUUID()}.tmp`);
+    const temporary = join(directory, `.${basename(target)}.${process.pid}.${operations.randomUUID()}.tmp`);
     let temporaryCreated = false;
     try {
-        const handle = await open(temporary, 'wx', 0o600);
+        const handle = await operations.open(temporary, 'wx', 0o600);
         temporaryCreated = true;
-        pendingOutputFiles.add(temporary);
+        pendingOutputFiles.set(temporary, {
+            remove: () => operations.unlink(temporary),
+            published: false,
+            settled: false,
+        });
         try {
             await handle.writeFile(content, { encoding: 'utf8' });
             await handle.sync();
@@ -55,12 +66,12 @@ async function writePrivateFile(pathValue, content, options = {}) {
             await handle.close();
         }
         if (options.force) {
-            await rename(temporary, target);
+            await operations.rename(temporary, target);
             temporaryCreated = false;
         }
         else {
             try {
-                await link(temporary, target);
+                await operations.link(temporary, target);
             }
             catch (error) {
                 const code = error && typeof error === 'object' && 'code' in error ? error.code : null;
@@ -69,19 +80,64 @@ async function writePrivateFile(pathValue, content, options = {}) {
                 }
                 throw error;
             }
-            await unlink(temporary);
-            temporaryCreated = false;
+            const pending = pendingOutputFiles.get(temporary);
+            if (pending)
+                pending.published = true;
+            try {
+                await operations.unlink(temporary);
+                temporaryCreated = false;
+            }
+            catch {
+                // The target is already published. A second best-effort cleanup runs
+                // below, and signal cleanup retains ownership if it still cannot run.
+            }
         }
         return target;
     }
     finally {
-        if (temporaryCreated)
-            await unlink(temporary).catch(() => { });
-        pendingOutputFiles.delete(temporary);
+        if (temporaryCreated) {
+            try {
+                await operations.unlink(temporary);
+                temporaryCreated = false;
+            }
+            catch {
+                // Keep the path registered for best-effort signal cleanup.
+            }
+        }
+        if (temporaryCreated) {
+            const pending = pendingOutputFiles.get(temporary);
+            if (pending)
+                pending.settled = true;
+        }
+        if (!temporaryCreated)
+            pendingOutputFiles.delete(temporary);
     }
 }
+async function cleanupPendingOutputFiles() {
+    const entries = [...pendingOutputFiles].filter(([, pending]) => pending.settled);
+    let removed = 0;
+    for (const [path, pending] of entries) {
+        try {
+            await pending.remove();
+            pendingOutputFiles.delete(path);
+            removed += 1;
+        }
+        catch {
+            // The caller receives an explicit retained count and can disclose that
+            // the published output is intact while temporary cleanup remains due.
+        }
+    }
+    const retainedFiles = [...pendingOutputFiles.values()].filter((item) => item.settled);
+    return Object.freeze({
+        attempted: entries.length,
+        removed,
+        retained: retainedFiles.length,
+        retainedPublished: retainedFiles.filter((item) => item.published).length,
+        retainedUnpublished: retainedFiles.filter((item) => !item.published).length,
+    });
+}
 function cleanupPendingOutputFilesSync() {
-    for (const path of pendingOutputFiles) {
+    for (const path of pendingOutputFiles.keys()) {
         try {
             unlinkSync(path);
         }
@@ -94,4 +150,4 @@ function cleanupPendingOutputFilesSync() {
         }
     }
 }
-export { cleanupPendingOutputFilesSync, createBufferedOutput, writePrivateFile };
+export { cleanupPendingOutputFiles, cleanupPendingOutputFilesSync, createBufferedOutput, writePrivateFile };

package/cli/page-compare.mjs

@@ -1,10 +1,10 @@
 import { buildBulkComparisonEvidence } from "../lib/bulk-comparison-evidence.mjs";
-import { createPageBaseline } from "../frontend/src/lib/analysis/page-baseline.js";
-import { comparePageBaselines } from "../frontend/src/lib/analysis/page-similarity.js";
+import { createPageBaseline } from "../packages/workspace/page-baseline.mjs";
+import { comparePageBaselines } from "../packages/comparison/page-similarity.mjs";
 import { CliUsageError } from "./errors.mjs";
 import { parseSavedLookupDocument } from "./saved-lookup.mjs";
-export const CLI_PAGE_COMPARE_SCHEMA = 'whoisleuth.cli.page-compare';
-export const CLI_PAGE_COMPARE_VERSION = 3;
+import { CLI_PAGE_COMPARE_SCHEMA, CLI_PAGE_COMPARE_VERSION, } from "../packages/contracts/offline-comparison.mjs";
+export { CLI_PAGE_COMPARE_SCHEMA, CLI_PAGE_COMPARE_VERSION };
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -56,6 +56,7 @@ function buildCliPageComparison(leftText, rightText, generatedAt = new Date().to
         && ['success', 'partial'].includes(right.compact.technology.state);
     const tlsUsable = ['success', 'partial'].includes(left.compact.tls.state)
         && ['success', 'partial'].includes(right.compact.tls.state);
+    const tlsPartial = left.compact.tls.state === 'partial' || right.compact.tls.state === 'partial';
     const technologyPartial = left.compact.technology.truncated || right.compact.technology.truncated
         || left.compact.technology.state === 'partial' || right.compact.technology.state === 'partial';
     return {
@@ -88,12 +89,16 @@ function buildCliPageComparison(leftText, rightText, generatedAt = new Date().to
             leftSourceState: left.compact.tls.state,
             rightSourceState: right.compact.tls.state,
             issuer: {
-                state: tlsUsable ? scalarComparison(left.compact.tls.issuerLabel, right.compact.tls.issuerLabel) : 'unavailable',
+                state: tlsUsable
+                    ? tlsPartial ? 'partial' : scalarComparison(left.compact.tls.issuerLabel, right.compact.tls.issuerLabel)
+                    : 'unavailable',
                 left: left.compact.tls.issuerLabel,
                 right: right.compact.tls.issuerLabel,
             },
             publicKey: {
-                state: tlsUsable ? scalarComparison(left.compact.tls.spkiSha256, right.compact.tls.spkiSha256) : 'unavailable',
+                state: tlsUsable
+                    ? tlsPartial ? 'partial' : scalarComparison(left.compact.tls.spkiSha256, right.compact.tls.spkiSha256)
+                    : 'unavailable',
                 leftSha256: left.compact.tls.spkiSha256,
                 rightSha256: right.compact.tls.spkiSha256,
             },

package/cli/progress-events.mjs

@@ -1,3 +1,4 @@
+import { terminalSafeJson } from "./formatters/json.mjs";
 export const CLI_PROGRESS_EVENT_SCHEMA = 'whoisleuth.cli.progress';
 export const CLI_PROGRESS_EVENT_VERSION = 1;
 const MAX_CLI_PROGRESS_EVENTS = 2_100;
@@ -45,7 +46,7 @@ function createCliProgressEvents(stream, options) {
                 ...(typeof fields.ok === 'boolean' ? { ok: fields.ok } : {}),
                 ...(exitCode !== null ? { exitCode } : {}),
             };
-            stream.write(`${JSON.stringify(document)}\n`);
+            stream.write(`${terminalSafeJson(document)}\n`);
             sequence += 1;
         },
     });

package/cli/progress.mjs

@@ -10,7 +10,7 @@ function safeProgressMessage(value) {
 }
 function createTerminalProgress(stream, options) {
     const environment = options.environment || process.env;
-    const presentation = terminalPresentation(stream, options.color, environment);
+    const presentation = terminalPresentation(stream, options.color, environment, options.palette);
     const enabled = options.enabled
         && presentation.interactive
         && environment.WHOISLEUTH_NO_PROGRESS !== '1';
@@ -23,8 +23,8 @@ function createTerminalProgress(stream, options) {
         if (!enabled || !stream)
             return;
         const elapsedSeconds = Math.max(0, Math.floor((now() - startedAt) / 1000));
-        const marker = tone(PROGRESS_FRAMES[frame % PROGRESS_FRAMES.length] || '·', 'accent', presentation.color);
-        const elapsed = tone(`${elapsedSeconds}s`, 'dim', presentation.color);
+        const marker = tone(PROGRESS_FRAMES[frame % PROGRESS_FRAMES.length] || '·', 'accent', presentation.color ? presentation.palette : false);
+        const elapsed = tone(`${elapsedSeconds}s`, 'dim', presentation.color ? presentation.palette : false);
         stream.write(`\r\u001b[2K${marker} ${message} · ${elapsed}`);
         frame += 1;
     }

package/cli/registry-cohort.mjs

@@ -1,11 +1,11 @@
 import { Buffer } from 'node:buffer';
-import { canonicalArtifactJsonV2 } from "../frontend/src/lib/analysis/artifact-integrity.js";
+import { canonicalArtifactJsonV2 } from "../packages/evidence/artifact-integrity.mjs";
+import { normalizeExplicitIsoTimestamp } from "../packages/evidence/observation.mjs";
 import { scanBoundedJson } from "./bounded-json.mjs";
 import { CliUsageError } from "./errors.mjs";
 import { buildRegistryDoctorReport } from "./registry-doctor.mjs";
 import { SAVED_LOOKUP_SCHEMA, parseSavedLookupDocument, } from "./saved-lookup.mjs";
 export const REGISTRY_COHORT_SCHEMA = 'whoisleuth.cli.registry-cohort';
-export const LEGACY_REGISTRY_COHORT_VERSION = 1;
 export const REGISTRY_COHORT_VERSION = 2;
 export const MAX_REGISTRY_COHORT_INPUT_BYTES = 16 * 1024 * 1024;
 export const MAX_REGISTRY_COHORT_SAMPLES = 500;
@@ -14,8 +14,6 @@ export const MAX_REGISTRY_COHORT_INPUT_POINTS = 2_000;
 export const MAX_REGISTRY_COHORT_TIMELINE_POINTS = 50;
 export const MAX_REGISTRY_COHORT_OMISSIONS = 1_000_000;
 export const MIN_REGISTRY_COHORT_SAMPLE = 5;
-const LEGACY_ROOT_KEYS = new Set(['schema', 'version', 'generatedAt', 'sampleCount', 'minimumCohortSample', 'cohorts', 'limitations']);
-const LEGACY_COHORT_KEYS = new Set(['suffix', 'profileId', 'sampleCount', 'state', 'sourceAlignment', 'publication']);
 const ROOT_KEYS = new Set(['schema', 'version', 'generatedAt', 'inputFamily', 'sampleCount', 'reportsMerged', 'minimumCohortSample', 'sampleWindow', 'cohorts', 'omissions', 'truncated', 'limitations']);
 const COHORT_KEYS = new Set(['suffix', 'profileId', 'sampleCount', 'state', 'latestState', 'sampleWindow', 'sourceAlignment', 'publication', 'timeline', 'timelineOmitted']);
 const POINT_KEYS = new Set(['reportGeneratedAt', 'sampleWindow', 'sampleCount', 'state', 'sourceAlignment', 'publication']);
@@ -29,11 +27,6 @@ const LIMITATIONS = Object.freeze([
     'A merged cohort keeps the most conservative retained state and separately reports the latest point. Duplicate points are suppressed and inherited omission counts are not summed across overlapping retained reports.',
     'Review fixture provenance and source health before changing a parser or registry access profile.',
 ]);
-const LEGACY_LIMITATIONS = Object.freeze([
-    'The report intentionally omits domains, queries and raw evidence. It groups saved observations only by suffix and capability profile.',
-    `Cohorts with fewer than ${MIN_REGISTRY_COHORT_SAMPLE} observations remain insufficient sample and must not drive catalogue changes.`,
-    'Repeated observations from one environment are not representative by themselves. Review fixture provenance and source health before changing a parser or access profile.',
-]);
 function record(value, label) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new CliUsageError(`${label} must be an object.`);
@@ -56,10 +49,10 @@ function timestamp(value, label) {
     if (typeof value !== 'string' || value.length > 64 || /[\u0000-\u001f\u007f]/u.test(value)) {
         throw new CliUsageError(`${label} is invalid.`);
     }
-    const parsed = Date.parse(value);
-    if (!Number.isFinite(parsed))
-        throw new CliUsageError(`${label} is invalid.`);
-    return new Date(parsed).toISOString();
+    const normalized = normalizeExplicitIsoTimestamp(value);
+    if (normalized)
+        return normalized;
+    throw new CliUsageError(`${label} is invalid.`);
 }
 function identifier(value, label) {
     if (typeof value !== 'string' || !/^[a-z0-9][a-z0-9_-]{0,119}$/u.test(value))
@@ -219,39 +212,6 @@ function sourceReportsFromLookups(documents, generatedAt) {
     const observed = reports.map((report) => report.generatedAt).sort();
     return [Object.freeze({ generatedAt, sampleWindow: Object.freeze({ from: observed[0], to: observed.at(-1) }), cohorts: Object.freeze(cohorts), duplicateTimelinePoints: 0 })];
 }
-function parseLegacyReport(value) {
-    const root = exact(value, LEGACY_ROOT_KEYS, 'Registry cohort v1 report');
-    if (root.schema !== REGISTRY_COHORT_SCHEMA || root.version !== LEGACY_REGISTRY_COHORT_VERSION)
-        throw new CliUsageError('Registry cohort report version is unsupported.');
-    const generatedAt = timestamp(root.generatedAt, 'Registry cohort v1 generatedAt');
-    const sampleCount = integer(root.sampleCount, 1, MAX_REGISTRY_COHORT_SAMPLES, 'Registry cohort v1 sample count');
-    if (root.minimumCohortSample !== MIN_REGISTRY_COHORT_SAMPLE)
-        throw new CliUsageError('Registry cohort v1 minimum sample is unsupported.');
-    boundedLimitations(root.limitations, LEGACY_LIMITATIONS, 'Registry cohort v1');
-    if (!Array.isArray(root.cohorts) || !root.cohorts.length || root.cohorts.length > MAX_REGISTRY_COHORT_GROUPS)
-        throw new CliUsageError('Registry cohort v1 groups are invalid.');
-    const seen = new Set();
-    let represented = 0;
-    const cohorts = root.cohorts.map((candidate, index) => {
-        const item = exact(candidate, LEGACY_COHORT_KEYS, `Registry cohort v1 group ${index + 1}`);
-        const count = integer(item.sampleCount, 1, sampleCount, 'Registry cohort v1 group sample count');
-        const sources = sourceAlignment(item.sourceAlignment, count, 'Registry cohort v1 source alignment');
-        const published = publication(item.publication, count, 'Registry cohort v1 publication');
-        const pointState = state(item.state, 'Registry cohort v1 state');
-        if (pointState !== derivedState(count, sources, published))
-            throw new CliUsageError('Registry cohort v1 state does not match its retained counts.');
-        const key = `${suffix(item.suffix)}\u0000${identifier(item.profileId, 'Registry cohort v1 profile ID')}`;
-        if (seen.has(key))
-            throw new CliUsageError('Registry cohort v1 groups must be unique.');
-        seen.add(key);
-        represented += count;
-        const point = Object.freeze({ reportGeneratedAt: generatedAt, sampleWindow: Object.freeze({ from: generatedAt, to: generatedAt }), sampleCount: count, state: pointState, sourceAlignment: sources, publication: published });
-        return Object.freeze({ suffix: key.split('\u0000')[0], profileId: key.split('\u0000')[1], sampleWindow: point.sampleWindow, points: Object.freeze([point]), inheritedState: pointState, upstreamTimelineOmitted: 0 });
-    });
-    if (represented !== sampleCount)
-        throw new CliUsageError('Registry cohort v1 sample count does not match its groups.');
-    return Object.freeze({ generatedAt, sampleWindow: Object.freeze({ from: generatedAt, to: generatedAt }), cohorts: Object.freeze(cohorts), duplicateTimelinePoints: 0 });
-}
 function parseCurrentReport(value) {
     const root = exact(value, ROOT_KEYS, 'Registry cohort v2 report');
     if (root.schema !== REGISTRY_COHORT_SCHEMA || root.version !== REGISTRY_COHORT_VERSION)
@@ -406,11 +366,9 @@ export function buildRegistryCohortReport(text, generatedAt = new Date().toISOSt
     const reports = [];
     let retainedPoints = 0;
     for (const document of documents) {
-        const report = document.version === LEGACY_REGISTRY_COHORT_VERSION
-            ? parseLegacyReport(document)
-            : document.version === REGISTRY_COHORT_VERSION
-                ? parseCurrentReport(document)
-                : (() => { throw new CliUsageError('Registry cohort report version is unsupported.'); })();
+        const report = document.version === REGISTRY_COHORT_VERSION
+            ? parseCurrentReport(document)
+            : (() => { throw new CliUsageError('Registry cohort report version is unsupported.'); })();
         retainedPoints += report.cohorts.reduce((total, cohort) => total + cohort.points.length, 0);
         if (retainedPoints > MAX_REGISTRY_COHORT_INPUT_POINTS) {
             throw new CliUsageError(`Retained registry cohort input contains more than ${MAX_REGISTRY_COHORT_INPUT_POINTS} timeline points.`);

package/cli/registry-doctor.mjs

@@ -1,9 +1,10 @@
 import { registryCapabilityFor, REGISTRY_CAPABILITIES_VERSION } from "../lib/registry-capabilities.mjs";
 import { recordOrEmpty } from "../lib/bounded-contract-normalizers.mjs";
+import { registryDateIso } from "../lib/registry-dates.mjs";
 import { CliUsageError } from "./errors.mjs";
 import { parseSavedLookupDocument } from "./saved-lookup.mjs";
 const REGISTRY_DOCTOR_SCHEMA = 'whoisleuth.cli.registry-doctor';
-const REGISTRY_DOCTOR_VERSION = 2;
+const REGISTRY_DOCTOR_VERSION = 3;
 function status(value) {
     return typeof value === 'string'
         ? value.replace(/[\u0000-\u001f\u007f]+/gu, ' ').trim().toLowerCase().slice(0, 40) || 'unavailable'
@@ -41,27 +42,37 @@ function publicationQuality(parsed, rdapStatus) {
             objectClass: unavailable,
             objectIdentifier: unavailable,
             mediaType: unavailable,
-            baseConformance: { state: 'unavailable', declarations: [] },
+            baseConformance: { state: 'unavailable', declarations: [], truncated: false },
             redactionMetadata: { state: 'unavailable', count: 0, truncated: false },
-            selfLink: { state: 'unavailable', observedRelations: [] },
-            events: { state: 'unavailable', count: 0, conflictingActions: [] },
+            selfLink: { state: 'unavailable', observedRelations: [], truncated: false },
+            events: { state: 'unavailable', count: 0, conflictingActions: [], truncated: false },
             reviewItems: 0,
         };
     }
     const objectClassName = typeof parsed.objectClassName === 'string' ? parsed.objectClassName.trim().toLowerCase() : '';
     const identifier = [parsed.handle, parsed.objectIdentifier, parsed.registryObjectId, parsed.id]
         .find((value) => typeof value === 'string' && Boolean(value.trim()))?.trim() ?? null;
-    const declarations = stringArray(parsed.conformance);
+    const conformanceValues = Array.isArray(parsed.conformance) ? parsed.conformance : [];
+    const conformanceTruncated = parsed.conformanceTruncated === true || conformanceValues.length > 100;
+    const declarations = stringArray(conformanceValues);
     const redactions = Array.isArray(parsed.redactions) ? parsed.redactions.slice(0, 100) : [];
-    const links = Array.isArray(parsed.links) ? parsed.links.slice(0, 100).map(recordOrEmpty) : [];
+    const redactionsTruncated = parsed.redactionsTruncated === true
+        || (Array.isArray(parsed.redactions) && parsed.redactions.length > 100);
+    const linkValues = Array.isArray(parsed.links) ? parsed.links : [];
+    const links = linkValues.slice(0, 100).map(recordOrEmpty);
+    const linksTruncated = parsed.linksTruncated === true
+        || linkValues.length > 100
+        || links.some((link) => Array.isArray(link.rel) && link.rel.length > 10);
     const relations = [...new Set(links.flatMap((link) => stringArray(link.rel, 10).length
             ? stringArray(link.rel, 10)
             : typeof link.rel === 'string' ? [link.rel.trim().toLowerCase()] : []).filter(Boolean))];
-    const events = Array.isArray(parsed.events) ? parsed.events.slice(0, 100).map(recordOrEmpty) : [];
+    const eventValues = Array.isArray(parsed.events) ? parsed.events : [];
+    const events = eventValues.slice(0, 100).map(recordOrEmpty);
+    const eventsTruncated = parsed.eventsTruncated === true || eventValues.length > 100;
     const actionDates = new Map();
     for (const event of events) {
         const action = typeof event.action === 'string' ? event.action.trim().toLowerCase() : '';
-        const date = typeof event.date === 'string' ? event.date.trim() : '';
+        const date = registryDateIso(event.date);
         if (!action || !date)
             continue;
         const dates = actionDates.get(action) ?? [];
@@ -79,8 +90,21 @@ function publicationQuality(parsed, rdapStatus) {
         ['reinstantiation', 'reinstantiationDateIso', true],
         ['last update of rdap database', 'databaseUpdatedDateIso', true],
     ];
+    const lifecycleDates = new Map();
+    let lifecycleMalformed = false;
+    for (const [, field] of lifecycleMappings) {
+        const supplied = lifecycle[field];
+        if (supplied === undefined || supplied === null)
+            continue;
+        const normalized = registryDateIso(supplied);
+        if (normalized)
+            lifecycleDates.set(field, normalized);
+        else
+            lifecycleMalformed = true;
+    }
     const conflictingActions = lifecycleMappings.flatMap(([action, field, newest]) => {
-        const published = typeof lifecycle[field] === 'string' ? Date.parse(lifecycle[field]) : Number.NaN;
+        const publishedDate = lifecycleDates.get(field);
+        const published = publishedDate ? Date.parse(publishedDate) : Number.NaN;
         if (!Number.isFinite(published))
             return [];
         const dates = (actionDates.get(action) ?? []).map(Date.parse).filter(Number.isFinite);
@@ -90,30 +114,41 @@ function publicationQuality(parsed, rdapStatus) {
         return selected === published ? [] : [action];
     }).sort();
     const objectClassState = !objectClassName ? 'not_observed' : objectClassName === 'domain' ? 'observed' : 'inconsistent';
-    const baseConformanceState = declarations.includes('rdap_level_0') ? 'observed' : 'not_observed';
-    const selfLinkState = relations.includes('self') ? 'observed' : 'not_observed';
-    const hasLifecycle = lifecycleMappings.some(([, field]) => typeof lifecycle[field] === 'string');
-    const eventsState = conflictingActions.length
-        ? 'inconsistent'
-        : events.length && hasLifecycle
-            ? 'observed'
-            : events.length
-                ? 'unavailable'
-                : 'not_observed';
+    const baseConformanceState = declarations.includes('rdap_level_0')
+        ? 'observed'
+        : conformanceTruncated ? 'unavailable' : 'not_observed';
+    const selfLinkState = relations.includes('self')
+        ? 'observed'
+        : linksTruncated ? 'unavailable' : 'not_observed';
+    const hasLifecycle = lifecycleDates.size > 0;
+    const eventsState = eventsTruncated || lifecycleMalformed
+        ? 'unavailable'
+        : conflictingActions.length
+            ? 'inconsistent'
+            : events.length && hasLifecycle
+                ? 'observed'
+                : events.length
+                    ? 'unavailable'
+                    : 'not_observed';
     return {
         objectClass: { state: objectClassState, value: objectClassName || null },
         objectIdentifier: { state: identifier ? 'observed' : 'not_observed', value: identifier },
         mediaType: { state: 'unavailable', value: null },
-        baseConformance: { state: baseConformanceState, declarations },
+        baseConformance: { state: baseConformanceState, declarations, truncated: conformanceTruncated },
         redactionMetadata: {
-            state: redactions.length ? 'observed' : 'not_observed',
+            state: redactions.length ? 'observed' : redactionsTruncated ? 'unavailable' : 'not_observed',
             count: redactions.length,
-            truncated: parsed.redactionsTruncated === true,
+            truncated: redactionsTruncated,
+        },
+        selfLink: { state: selfLinkState, observedRelations: relations.sort(), truncated: linksTruncated },
+        events: {
+            state: eventsState,
+            count: events.length,
+            conflictingActions: eventsTruncated || lifecycleMalformed ? [] : conflictingActions,
+            truncated: eventsTruncated,
         },
-        selfLink: { state: selfLinkState, observedRelations: relations.sort() },
-        events: { state: eventsState, count: events.length, conflictingActions },
         reviewItems: [objectClassState, baseConformanceState, selfLinkState, eventsState]
-            .filter((state) => state === 'inconsistent' || state === 'not_observed').length,
+            .filter((state) => state !== 'observed').length,
     };
 }
 function buildRegistryDoctorReport(raw, generatedAt = new Date().toISOString()) {
@@ -182,6 +217,10 @@ function buildRegistryDoctorReport(raw, generatedAt = new Date().toISOString())
             'A catalogue alignment does not prove live reachability, parser completeness, current registry policy, registration, availability, ownership, safety, or maliciousness.',
             'A missing registry object identifier can be a publication characteristic. It remains not observed and is not converted into a collection failure.',
             'Publication-quality observations describe the saved normalised RDAP object. The saved Lookup format does not retain the response media type, so that field remains unavailable.',
+            ...(publication.baseConformance.truncated || publication.redactionMetadata.truncated
+                || publication.selfLink.truncated || publication.events.truncated
+                ? ['One or more bounded RDAP publication families were truncated; omitted values remain unavailable and cannot support absence or consistency conclusions.']
+                : []),
             'Use fixture-based maintenance checks before changing a registry parser or access profile; automated tests must not contact live registries.',
         ],
     };
@@ -203,9 +242,9 @@ function formatRegistryDoctorReport(report) {
     output.push('', 'RDAP publication quality');
     output.push(`  Object class: ${report.publication.objectClass.state.replaceAll('_', ' ')}`);
     output.push(`  Object identifier: ${report.publication.objectIdentifier.state.replaceAll('_', ' ')}`);
-    output.push(`  Base conformance: ${report.publication.baseConformance.state.replaceAll('_', ' ')}`);
-    output.push(`  Self link: ${report.publication.selfLink.state.replaceAll('_', ' ')}`);
-    output.push(`  Events: ${report.publication.events.state.replaceAll('_', ' ')}`);
+    output.push(`  Base conformance: ${report.publication.baseConformance.state.replaceAll('_', ' ')}${report.publication.baseConformance.truncated ? ' (partial)' : ''}`);
+    output.push(`  Self link: ${report.publication.selfLink.state.replaceAll('_', ' ')}${report.publication.selfLink.truncated ? ' (partial)' : ''}`);
+    output.push(`  Events: ${report.publication.events.state.replaceAll('_', ' ')}${report.publication.events.truncated ? ' (partial)' : ''}`);
     output.push('  Media type: unavailable in the saved Lookup contract');
     if (report.recommendations.length) {
         output.push('', 'Recommendations:');

package/cli/retained-artifact-diff.mjs

@@ -1,17 +1,16 @@
 import { Buffer } from 'node:buffer';
 import { createHash } from 'node:crypto';
-import { canonicalArtifactJsonV2 } from "../frontend/src/lib/analysis/artifact-integrity.js";
-import { BULK_SESSION_SCHEMA, MAX_BULK_SESSIONS, MAX_BULK_SESSION_ROWS, SUPPORTED_BULK_SESSION_SCHEMA_VERSIONS, mergeBulkSessions, normalizeBulkSession, } from "../frontend/src/lib/analysis/bulk-session-model.js";
-import { buildBulkComparisonCandidates } from "../frontend/src/lib/analysis/comparison-ledger-bulk.js";
-import { MAX_COMPARISON_LEDGER_DETAIL_ROWS, boundedComparisonLedgerLimitations, comparisonLedgerCollector, comparisonLedgerValuePresent, freshComparisonLedgerCounters, makeComparisonLedgerCandidate, normaliseComparisonLedgerRowWithCounters, stableComparisonLedgerId, stableComparisonLedgerJson, } from "../frontend/src/lib/analysis/comparison-ledger-contract.js";
+import { canonicalArtifactJsonV2 } from "../packages/evidence/artifact-integrity.mjs";
+import { BULK_SESSION_SCHEMA, MAX_BULK_SESSIONS, MAX_BULK_SESSION_ROWS, SUPPORTED_BULK_SESSION_SCHEMA_VERSIONS, mergeBulkSessions, normalizeBulkSession, } from "../packages/workspace/bulk-session-model.mjs";
+import { buildBulkComparisonCandidates } from "../packages/comparison/comparison-ledger-bulk.mjs";
+import { MAX_COMPARISON_LEDGER_DETAIL_ROWS, boundedComparisonLedgerLimitations, comparisonLedgerCollector, comparisonLedgerValuePresent, freshComparisonLedgerCounters, makeComparisonLedgerCandidate, normaliseComparisonLedgerRowWithCounters, stableComparisonLedgerId, stableComparisonLedgerJson, } from "../packages/comparison/comparison-ledger-contract.mjs";
 import { DOMAIN_PORTFOLIO_INPUT_SCHEMA, DOMAIN_PORTFOLIO_REVIEW_SCHEMA, DOMAIN_PORTFOLIO_REVIEW_VERSION, reviewDomainPortfolio, } from "../lib/domain-portfolio-review.mjs";
 import { parseBoundedJsonObject } from "./bounded-json.mjs";
 import { CliUsageError } from "./errors.mjs";
 import { buildCliLookupDiff, formatCliLookupDiff } from "./lookup-diff.mjs";
 import { SAVED_LOOKUP_SCHEMA } from "./saved-lookup.mjs";
-export const CLI_COMPARISON_LEDGER_SCHEMA = 'whoisleuth.cli.comparison-ledger';
-export const CLI_COMPARISON_LEDGER_VERSION = 1;
-export const MAX_RETAINED_ARTIFACT_DIFF_BYTES = 8 * 1024 * 1024;
+import { CLI_COMPARISON_LEDGER_SCHEMA, CLI_COMPARISON_LEDGER_VERSION, MAX_RETAINED_ARTIFACT_DIFF_BYTES, } from "../packages/contracts/offline-comparison.mjs";
+export { CLI_COMPARISON_LEDGER_SCHEMA, CLI_COMPARISON_LEDGER_VERSION, MAX_RETAINED_ARTIFACT_DIFF_BYTES };
 const BULK_ROOT_KEYS = new Set(['schema', 'version', 'generatedAt', 'sessions', 'limitations']);
 const PORTFOLIO_ROOT_KEYS = new Set(['schema', 'version', 'generatedAt', 'portfolioLabel', 'assets', 'simulations', 'renewalQueue', 'recoveryCycles', 'unknownCounts', 'limitations']);
 const SAFE_SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/u;
@@ -63,7 +62,7 @@ function parseBulkExport(root) {
         const rawSession = record(candidate);
         const rawResults = Array.isArray(rawSession?.results) ? rawSession.results : null;
         const rawDomains = Array.isArray(rawSession?.domains) ? rawSession.domains : null;
-        const session = normalizeBulkSession(candidate, version);
+        const session = normalizeBulkSession(candidate);
         if (!session || !rawResults || !rawDomains
             || rawResults.length > MAX_BULK_SESSION_ROWS
             || rawResults.length !== session.results.length