@slicedearth/whoisleuth-cli 2.3.0 → 2.5.1

package/cli/artifact-validation/case-response.mjs

@@ -1,8 +1,9 @@
 import { createHash } from 'node:crypto';
+import { readCaseEvidenceRequest, readCasePacketAmendment, assertEvidenceRequestEvent, assertEvidenceRequestHistory, assertPacketAmendmentSelection } from "../../packages/cases/case-requested-evidence.mjs";
 import { canonicalArtifactJsonV2 } from "../../packages/evidence/artifact-integrity.mjs";
-import { CASE_RESPONSE_PACKET_VERSION, LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION, PUBLIC_CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION, CASE_RESPONSE_REVIEW_INPUTS_SCHEMA, CASE_RESPONSE_REVIEW_INPUTS_VERSION, LATEST_PUBLIC_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, MAX_ABUSIVE_URLS, MAX_RESPONSE_ARTEFACT_REFERENCES, MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_CONTACTS, MAX_RESPONSE_CONTRADICTIONS, MAX_RESPONSE_SELECTED_EVIDENCE, RESPONSE_AUTHORISATION_CONFIRMATION_IDS, RESPONSE_PACKET_PROFILES, RESPONSE_CONTACT_KINDS, RESPONSE_PACKET_PROFILE_IDS, RESPONSE_READINESS_ROW_IDS, RESPONSE_READINESS_STATES, RESPONSE_ROUTE_STALE_AFTER_DAYS, } from "../../packages/cases/case-response-packet.mjs";
+import { CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_2_CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION, PUBLIC_CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION, CASE_RESPONSE_REVIEW_INPUTS_SCHEMA, CASE_RESPONSE_REVIEW_INPUTS_VERSION, LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION, LATEST_PUBLIC_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, MAX_ABUSIVE_URLS, MAX_RESPONSE_ARTEFACT_REFERENCES, MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_CONTACTS, MAX_RESPONSE_CONTRADICTIONS, MAX_RESPONSE_SELECTED_EVIDENCE, RESPONSE_AUTHORISATION_CONFIRMATION_IDS, RESPONSE_PACKET_PROFILES, RESPONSE_CONTACT_KINDS, RESPONSE_PACKET_PROFILE_IDS, RESPONSE_READINESS_ROW_IDS, RESPONSE_READINESS_STATES, RESPONSE_ROUTE_STALE_AFTER_DAYS, } from "../../packages/cases/case-response-packet.mjs";
 import { CASE_ACTION_EVENT_SOURCE_CLASSES, CASE_ACTION_STATES, CASE_ACTION_TYPES, CASE_CLOSURE_REASONS, CASE_OBSERVED_EFFECT_SOURCE_CLASSES, CASE_OBSERVED_EFFECT_STATES, CASE_PROVIDER_OUTCOMES, isLegalCaseActionTransition, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RECIPIENT_LENGTH, } from "../../packages/cases/case-response-model.mjs";
-import { HEX_DIGEST_RE, array, boolean, domain, enumeration, exact, fail, integer, iso, optionalText, sameValues, strings, text, } from "./structure-primitives.mjs";
+import { HEX_DIGEST_RE, array, boolean, domain, enumeration, exact, exactOptional, fail, integer, iso, optionalText, sameValues, strings, text, } from "./structure-primitives.mjs";
 const CASE_RESPONSE_PREFLIGHT_IDS_V6 = [
     'required_incident_fields',
     'evidence_pins',
@@ -224,15 +225,15 @@ function validateCurrentActionSummary(value, label) {
     }
     return total;
 }
-function validateCaseResponsePacketV7ToV9(value, version) {
-    const current = version === CASE_RESPONSE_PACKET_VERSION;
-    const modern = version === LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION || current;
+function validateVersionedCaseResponsePacket(value, version) {
+    const hasPlatformRoutes = version >= PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION;
+    const hasActionBinding = version >= PUBLISHED_V2_2_CASE_RESPONSE_PACKET_VERSION;
     const root = exact(value, [
         'schema', 'schemaVersion', 'generatedAt', 'reviewRequired', 'submissionPerformed', 'profile', 'case',
         'incident', 'contacts', 'selectedEvidence', 'contradictions', 'readiness', 'artefactReferences',
         'authorisation', 'preflight', 'escalationHistory', 'escalationHistoryOmitted',
         'escalationHistoryLimitations', 'responseLifecycle', 'provenance', 'integrity',
-        ...(modern ? ['recipientRoute', 'actionBinding'] : []),
+        ...(hasActionBinding ? ['recipientRoute', 'actionBinding'] : []),
     ], `Case-response packet v${version}`);
     if (root.schemaVersion !== version)
         fail(`Case-response packet v${version}`);
@@ -240,14 +241,14 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     if (root.reviewRequired !== true || root.submissionPerformed !== false)
         fail('Case-response packet review state');
     const profile = exact(root.profile, ['id', 'label', 'audience', 'subject', 'checklist', 'evidenceOrder', 'includedEvidence', 'excludedEvidence', 'redactions', 'attachments', 'followUpFields'], 'Case-response profile');
-    const profileId = enumeration(profile.id, current ? RESPONSE_PACKET_PROFILE_IDS : PRE_PLATFORM_PROFILE_IDS, 'Case-response profile id');
+    const profileId = enumeration(profile.id, hasPlatformRoutes ? RESPONSE_PACKET_PROFILE_IDS : PRE_PLATFORM_PROFILE_IDS, 'Case-response profile id');
     text(profile.label, 'Case-response profile label', 200);
     text(profile.audience, 'Case-response profile audience', 300);
     text(profile.subject, 'Case-response profile subject', 500);
     for (const key of ['checklist', 'evidenceOrder', 'includedEvidence', 'excludedEvidence', 'redactions', 'attachments', 'followUpFields'])
         strings(profile[key], `Case-response profile ${key}`, 24, 500);
     const selectedProfile = RESPONSE_PACKET_PROFILES.find((candidate) => candidate.id === profileId);
-    const expectedRedactions = modern ? selectedProfile?.redactions : legacyProfileRedactions(profileId);
+    const expectedRedactions = hasActionBinding ? selectedProfile?.redactions : legacyProfileRedactions(profileId);
     if (!selectedProfile
         || profile.label !== selectedProfile.label
         || profile.audience !== selectedProfile.audience
@@ -287,9 +288,9 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     const contactKeys = new Set();
     for (const candidate of contacts) {
         const contact = exact(candidate, [
-            'kind', 'contact', 'source', 'observedAt', ...(current ? ['reviewAfter'] : []), 'freshness', 'limitations',
+            'kind', 'contact', 'source', 'observedAt', ...(hasPlatformRoutes ? ['reviewAfter'] : []), 'freshness', 'limitations',
         ], 'Case-response contact');
-        const kind = enumeration(contact.kind, current ? RESPONSE_CONTACT_KINDS : PRE_PLATFORM_CONTACT_KINDS, 'Case-response contact kind');
+        const kind = enumeration(contact.kind, hasPlatformRoutes ? RESPONSE_CONTACT_KINDS : PRE_PLATFORM_CONTACT_KINDS, 'Case-response contact kind');
         const contactValue = text(contact.contact, 'Case-response contact value', MAX_RESPONSE_RECIPIENT_LENGTH);
         const key = `${kind}\u0000${contactValue.toLowerCase()}`;
         if (contactKeys.has(key))
@@ -297,13 +298,13 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         contactKeys.add(key);
         text(contact.source, 'Case-response contact source', 120);
         iso(contact.observedAt, 'Case-response contact observedAt', true);
-        if (current)
+        if (hasPlatformRoutes)
             iso(contact.reviewAfter, 'Case-response contact reviewAfter', true);
         const freshness = enumeration(contact.freshness, ['current', 'stale', 'unknown'], 'Case-response contact freshness');
         const routeAge = contact.observedAt === null
             ? null
             : Date.parse(root.generatedAt) - Date.parse(contact.observedAt);
-        const reviewExpired = current && contact.reviewAfter !== null
+        const reviewExpired = hasPlatformRoutes && contact.reviewAfter !== null
             && Date.parse(root.generatedAt) >= Date.parse(contact.reviewAfter);
         const expectedFreshness = routeAge === null
             ? 'unknown'
@@ -319,23 +320,23 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     let selectedActionId = null;
     let lineageActionIds = [];
     let lineageComplete = true;
-    if (modern) {
+    if (hasActionBinding) {
         if (root.recipientRoute !== null) {
             recipientRoute = exact(root.recipientRoute, [
-                'actionId', 'kind', 'contact', 'source', 'observedAt', ...(current ? ['reviewAfter'] : []), 'freshness', 'limitations',
+                'actionId', 'kind', 'contact', 'source', 'observedAt', ...(hasPlatformRoutes ? ['reviewAfter'] : []), 'freshness', 'limitations',
             ], 'Case-response recipient route');
             text(recipientRoute.actionId, 'Case-response recipient action id', 64);
-            enumeration(recipientRoute.kind, [...(current ? RESPONSE_CONTACT_KINDS : PRE_PLATFORM_CONTACT_KINDS), 'manual'], 'Case-response recipient kind');
+            enumeration(recipientRoute.kind, [...(hasPlatformRoutes ? RESPONSE_CONTACT_KINDS : PRE_PLATFORM_CONTACT_KINDS), 'manual'], 'Case-response recipient kind');
             text(recipientRoute.contact, 'Case-response recipient value', MAX_RESPONSE_RECIPIENT_LENGTH);
             text(recipientRoute.source, 'Case-response recipient source', 120);
             iso(recipientRoute.observedAt, 'Case-response recipient observedAt', true);
-            if (current)
+            if (hasPlatformRoutes)
                 iso(recipientRoute.reviewAfter, 'Case-response recipient reviewAfter', true);
             const freshness = enumeration(recipientRoute.freshness, ['current', 'stale', 'unknown'], 'Case-response recipient freshness');
             const routeAge = recipientRoute.observedAt === null
                 ? null
                 : Date.parse(root.generatedAt) - Date.parse(recipientRoute.observedAt);
-            const reviewExpired = current && recipientRoute.reviewAfter !== null
+            const reviewExpired = hasPlatformRoutes && recipientRoute.reviewAfter !== null
                 && Date.parse(root.generatedAt) >= Date.parse(recipientRoute.reviewAfter);
             const expectedFreshness = routeAge === null
                 ? 'unknown'
@@ -370,7 +371,7 @@ function validateCaseResponsePacketV7ToV9(value, version) {
                 || selectedContact.contact !== recipientRoute.contact
                 || selectedContact.source !== recipientRoute.source
                 || selectedContact.observedAt !== recipientRoute.observedAt
-                || (current && selectedContact.reviewAfter !== recipientRoute.reviewAfter)
+                || (hasPlatformRoutes && selectedContact.reviewAfter !== recipientRoute.reviewAfter)
                 || selectedContact.freshness !== recipientRoute.freshness)
                 fail('Case-response selected contact projection');
         }
@@ -378,14 +379,16 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     const evidence = array(root.selectedEvidence, 'Case-response selected evidence', MAX_RESPONSE_SELECTED_EVIDENCE);
     const evidenceIds = new Set();
     for (const candidate of evidence) {
-        const item = exact(candidate, ['id', 'label', 'source', 'observedAt', 'completeness', 'limitations'], 'Case-response selected evidence');
+        const item = exactOptional(candidate, ['id', 'label', 'source', 'observedAt', 'completeness', 'limitations'], version > PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION ? ['observationHostname'] : [], 'Case-response selected evidence');
         const id = text(item.id, 'Case-response evidence id', 64);
         if (evidenceIds.has(id))
             fail('Case-response selected evidence');
         evidenceIds.add(id);
         text(item.label, 'Case-response evidence label', 80);
         text(item.source, 'Case-response evidence source', 120);
-        iso(item.observedAt, 'Case-response evidence observedAt');
+        if (item.observationHostname !== undefined)
+            domain(item.observationHostname, 'Case-response evidence hostname');
+        iso(item.observedAt, 'Case-response evidence observedAt', version > PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION);
         enumeration(item.completeness, ['complete', 'partial', 'inconclusive', 'unknown'], 'Case-response evidence completeness');
         strings(item.limitations, 'Case-response evidence limitations', 8, 240);
     }
@@ -412,7 +415,7 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         ...(profileId === 'internal_soc' ? [] : ['recipient_route']),
         ...(['registrar', 'registry', 'network_hosting'].includes(profileId) ? ['infrastructure_responsibility'] : []),
     ]);
-    const requiredContact = modern
+    const requiredContact = hasActionBinding
         ? recipientRoute ?? undefined
         : selectedProfile?.requiredContactKind
             ? contacts.find((candidate) => candidate.kind === selectedProfile.requiredContactKind)
@@ -421,7 +424,7 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         observed_behaviour: 'complete',
         exact_url: 'complete',
         observation_time: expectedObservationAge(incident.observedAt, root.generatedAt).refreshRecommended ? 'stale' : 'complete',
-        capture_provenance: evidence.length ? 'complete' : 'unavailable',
+        capture_provenance: !evidence.length ? 'unavailable' : evidence.every((candidate) => candidate.observedAt !== null) ? 'complete' : 'partial',
         recipient_route: !requiredContact
             ? 'not_provided'
             : requiredContact.freshness === 'stale'
@@ -507,8 +510,8 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         || (authorisationStatus === 'draft' && authorisation.confirmedAt !== null))
         fail('Case-response authorisation');
     const preflight = exact(root.preflight, ['version', 'status', 'canExport', 'counts', 'checks', 'actionSummary'], 'Case-response preflight');
-    const preflightIds = modern ? CASE_RESPONSE_PREFLIGHT_IDS_V8 : CASE_RESPONSE_PREFLIGHT_IDS_V7;
-    if (preflight.version !== (modern ? 3 : 2))
+    const preflightIds = hasActionBinding ? CASE_RESPONSE_PREFLIGHT_IDS_V8 : CASE_RESPONSE_PREFLIGHT_IDS_V7;
+    if (preflight.version !== (hasActionBinding ? 3 : 2))
         fail('Case-response preflight');
     const checks = array(preflight.checks, 'Case-response preflight checks', preflightIds.length, preflightIds.length);
     const actualCounts = { block: 0, caution: 0, pass: 0 };
@@ -532,8 +535,8 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     const history = array(root.escalationHistory, 'Case-response escalation history', MAX_RESPONSE_ACTION_HISTORY);
     const escalationHistoryOmitted = integer(root.escalationHistoryOmitted, 'Case-response omitted actions', 0, MAX_CASE_ACTIONS);
     const escalationHistoryLimitations = strings(root.escalationHistoryLimitations, 'Case-response history limitations', 4, 600);
-    if ((!modern && history.length !== Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
-        || (modern && history.length > Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
+    if ((!hasActionBinding && history.length !== Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
+        || (hasActionBinding && history.length > Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
         || escalationHistoryOmitted !== actionTotal - history.length
         || (escalationHistoryOmitted > 0) !== (escalationHistoryLimitations.length > 0))
         fail('Case-response action-history bounds');
@@ -541,24 +544,25 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     const actionIdOrder = [];
     const providerEvents = [];
     for (const candidate of history) {
-        const action = exact(candidate, [
+        const action = exactOptional(candidate, [
             'actionId', 'type', 'recipient', 'contactSource', 'state', 'reference',
             'providerOutcome', 'outcomeDetail', 'originActionId', 'historyOmitted',
             'historyLimitations', 'transitions', 'createdAt', 'updatedAt',
-            ...(modern ? ['routeObservedAt'] : []),
-            ...(current ? ['routeReviewAfter'] : []),
-        ], 'Case-response escalation action');
+            ...(hasActionBinding ? ['routeObservedAt'] : []),
+            ...(hasPlatformRoutes ? ['routeReviewAfter'] : []),
+        ], Number(root.schemaVersion) >= 11 ? ['amendment'] : [], 'Case-response escalation action');
+        readCasePacketAmendment(action.amendment);
         const actionId = text(action.actionId, 'Case-response action id', 64);
         if (actionIds.has(actionId))
             fail('Case-response action identity');
         actionIds.add(actionId);
         actionIdOrder.push(actionId);
-        enumeration(action.type, current ? CASE_ACTION_TYPES : PRE_PLATFORM_ACTION_TYPES, 'Case-response action type');
+        enumeration(action.type, hasPlatformRoutes ? CASE_ACTION_TYPES : PRE_PLATFORM_ACTION_TYPES, 'Case-response action type');
         text(action.recipient, 'Case-response action recipient', 320);
         text(action.contactSource, 'Case-response action source', 120);
-        if (modern)
+        if (hasActionBinding)
             iso(action.routeObservedAt, 'Case-response action route observedAt', true);
-        if (current)
+        if (hasPlatformRoutes)
             iso(action.routeReviewAfter, 'Case-response action route reviewAfter', true);
         enumeration(action.state, CASE_ACTION_STATES, 'Case-response action state');
         optionalText(action.reference, 'Case-response action reference', 500);
@@ -569,6 +573,7 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         integer(action.historyOmitted, 'Case-response action omitted history', 0, 1_000_000);
         strings(action.historyLimitations, 'Case-response action history limitations', 8, 240);
         const transitions = array(action.transitions, 'Case-response action transitions', MAX_CASE_ACTION_EVENTS_PER_ACTION, 1);
+        const requestEvents = [];
         const eventIds = new Set();
         let projectedState = null;
         let latestReference = null;
@@ -578,8 +583,11 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         let previousTime = Number.NEGATIVE_INFINITY;
         let previousEventId = '';
         for (const eventCandidate of transitions) {
-            const event = exact(eventCandidate, ['id', 'previousState', 'nextState', 'occurredAt', 'sourceClass', 'provenance', 'reference', 'evidencePinId', 'limitations', 'providerOutcome', 'outcomeDetail', 'originActionId', 'applied'], 'Case-response action transition');
+            const event = exactOptional(eventCandidate, ['id', 'previousState', 'nextState', 'occurredAt', 'sourceClass', 'provenance', 'reference', 'evidencePinId', 'limitations', 'providerOutcome', 'outcomeDetail', 'originActionId', 'applied'], Number(root.schemaVersion) >= 11 ? ['evidenceRequest'] : [], 'Case-response action transition');
+            const evidenceRequest = readCaseEvidenceRequest(event.evidenceRequest);
+            assertEvidenceRequestEvent(evidenceRequest, event);
             const eventId = text(event.id, 'Case-response action event id', 64);
+            requestEvents.push({ id: eventId, ...(evidenceRequest ? { evidenceRequest } : {}) });
             if (eventIds.has(eventId))
                 fail('Case-response action event identity');
             eventIds.add(eventId);
@@ -648,6 +656,7 @@ function validateCaseResponsePacketV7ToV9(value, version) {
                 }
             }
         }
+        assertEvidenceRequestHistory(requestEvents, Number(action.historyOmitted) > 0);
         if ((projectedState ?? 'drafting') !== action.state
             || latestReference !== action.reference
             || latestProviderOutcome !== action.providerOutcome
@@ -658,13 +667,18 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         iso(action.createdAt, 'Case-response action createdAt');
         iso(action.updatedAt, 'Case-response action updatedAt');
     }
-    if (modern) {
+    if (hasActionBinding) {
         if (actionIds.size !== lineageActionIds.length
             || actionIdOrder.some((id, index) => lineageActionIds[index] !== id))
             fail('Case-response action lineage');
         if (recipientRoute && !actionIds.has(recipientRoute.actionId))
             fail('Case-response recipient action');
     }
+    if (version >= 11)
+        assertPacketAmendmentSelection(history.map(candidate => {
+            const action = candidate;
+            return { id: action.actionId, history: action.transitions, originActionId: action.originActionId, amendment: action.amendment };
+        }), selectedActionId, evidenceIds);
     const lifecycle = exact(root.responseLifecycle, ['providerOutcomeState', 'latestProviderOutcome', 'observedChangeState', 'latestObservedEffect', 'latestObservedChangeAt', 'closure', 'limitations'], 'Case-response lifecycle');
     const providerOutcomeState = enumeration(lifecycle.providerOutcomeState, ['available', 'missing', 'ambiguous'], 'Case-response lifecycle provider state');
     let actualLatestProvider = null;
@@ -690,11 +704,11 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     const latestProviderEvents = latestProviderTime === null
         ? []
         : providerEvents.filter((event) => event.occurredAt === latestProviderTime);
-    const expectedLatestProvider = (modern ? lineageComplete : escalationHistoryOmitted === 0)
+    const expectedLatestProvider = (hasActionBinding ? lineageComplete : escalationHistoryOmitted === 0)
         && latestProviderEvents.length === 1 && latestProviderEvents[0].applied
         ? latestProviderEvents[0]
         : null;
-    const expectedProviderState = (modern ? !lineageComplete : escalationHistoryOmitted > 0)
+    const expectedProviderState = (hasActionBinding ? !lineageComplete : escalationHistoryOmitted > 0)
         ? 'ambiguous'
         : providerEvents.length === 0 ? 'missing' : expectedLatestProvider ? 'available' : 'ambiguous';
     if (providerOutcomeState !== expectedProviderState
@@ -727,9 +741,11 @@ function validateCaseResponsePacketV7ToV9(value, version) {
     strings(lifecycle.limitations, 'Case-response lifecycle limitations', 8, 600);
     const reviewedInputs = {
         contract: CASE_RESPONSE_REVIEW_INPUTS_SCHEMA,
-        version: current
+        version: version === CASE_RESPONSE_PACKET_VERSION
             ? CASE_RESPONSE_REVIEW_INPUTS_VERSION
-            : modern ? LATEST_PUBLIC_CASE_RESPONSE_REVIEW_INPUTS_VERSION : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION,
+            : version === LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION ? LATEST_PUBLIC_CASE_RESPONSE_REVIEW_INPUTS_VERSION
+                : hasPlatformRoutes ? PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION
+                    : hasActionBinding ? PUBLISHED_V2_2_CASE_RESPONSE_REVIEW_INPUTS_VERSION : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION,
         profile: {
             id: profile.id,
             label: profile.label,
@@ -743,7 +759,7 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         case: root.case,
         incident: root.incident,
         contacts: root.contacts,
-        ...(modern ? { recipientRoute: root.recipientRoute, actionBinding: root.actionBinding } : {}),
+        ...(hasActionBinding ? { recipientRoute: root.recipientRoute, actionBinding: root.actionBinding } : {}),
         selectedEvidence: root.selectedEvidence,
         contradictions: root.contradictions,
         readiness: root.readiness,
@@ -778,13 +794,18 @@ function validateCaseResponsePacketV7ToV9(value, version) {
         fail('Case-response integrity');
 }
 export function validateCaseResponsePacket(value) {
+    if (value.schemaVersion === LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION)
+        return validateVersionedCaseResponsePacket(value, LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION);
     if (value.schemaVersion === PUBLIC_CASE_RESPONSE_PACKET_VERSION)
         return validateCaseResponsePacketV6(value);
     if (value.schemaVersion === PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION) {
-        return validateCaseResponsePacketV7ToV9(value, PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION);
+        return validateVersionedCaseResponsePacket(value, PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION);
     }
-    if (value.schemaVersion === LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION) {
-        return validateCaseResponsePacketV7ToV9(value, LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION);
+    if (value.schemaVersion === PUBLISHED_V2_2_CASE_RESPONSE_PACKET_VERSION) {
+        return validateVersionedCaseResponsePacket(value, PUBLISHED_V2_2_CASE_RESPONSE_PACKET_VERSION);
+    }
+    if (value.schemaVersion === PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION) {
+        return validateVersionedCaseResponsePacket(value, PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION);
     }
     if (Number.isSafeInteger(value.schemaVersion) && value.schemaVersion < CASE_RESPONSE_PACKET_VERSION) {
         throw new TypeError(`Case-response packet version ${String(value.schemaVersion)} is not part of the public compatibility boundary; no data was changed.`);
@@ -792,5 +813,5 @@ export function validateCaseResponsePacket(value) {
     if (Number.isSafeInteger(value.schemaVersion) && value.schemaVersion > CASE_RESPONSE_PACKET_VERSION) {
         throw new TypeError(`Case-response packet version ${String(value.schemaVersion)} is newer than the supported version ${CASE_RESPONSE_PACKET_VERSION}; no data was changed.`);
     }
-    validateCaseResponsePacketV7ToV9(value, CASE_RESPONSE_PACKET_VERSION);
+    validateVersionedCaseResponsePacket(value, CASE_RESPONSE_PACKET_VERSION);
 }

package/cli/artifact-validation/investigation-capsule.mjs

@@ -1,6 +1,7 @@
-import { INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION, INVESTIGATION_CAPSULE_VERSION, PUBLIC_INVESTIGATION_CAPSULE_VERSION, } from "../../packages/investigation/investigation-capsule.mjs";
+import { investigationCapsuleContracts, MAX_LOOKUP_ASSET_NODES, MAX_LOOKUP_ASSET_EDGES, MAX_LOOKUP_ASSET_LIMITATIONS, MAX_LOOKUP_ASSET_INPUT_ROWS } from "../../packages/contracts/investigation-portability.mjs";
+import { INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION, investigationCapsuleProjectionsMatch, } from "../../packages/investigation/investigation-capsule.mjs";
 import { LOOKUP_ASSET_GRAPH_SCHEMA, LOOKUP_ASSET_GRAPH_VERSION, } from "../../packages/investigation/lookup-asset-graph.mjs";
-import { PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION, LOOKUP_INVESTIGATION_BRIEF_SCHEMA, LOOKUP_INVESTIGATION_BRIEF_VERSION, MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES, } from "../../packages/investigation/lookup-investigation-brief.mjs";
+import { PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION, LOOKUP_INVESTIGATION_BRIEF_SCHEMA, MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES, } from "../../packages/investigation/lookup-investigation-brief.mjs";
 import { DECISION_FACT_CONSISTENCY_STATES, DECISION_FACT_EVIDENCE_STATES, DECISION_FACT_FRESHNESS_STATES, DECISION_FACT_PROVENANCE_STATES, DECISION_FACT_PROJECTION_VERSION, DECISION_FACT_VERSION, MAX_DECISION_FACT_CONTRIBUTORS, MAX_DECISION_FACT_CONTRADICTIONS, MAX_DECISION_FACT_LIMITATIONS, MAX_DECISION_FACT_NEXT_ACTIONS, MAX_DECISION_FACT_PROJECTION_CONTRADICTIONS, MAX_DECISION_FACT_PROJECTION_BYTES, MAX_DECISION_FACT_PROJECTION_FACTS, MAX_DECISION_FACT_PROJECTION_LIMITATIONS, MAX_DECISION_FACT_PROJECTION_NEXT_ACTIONS, MAX_DECISION_FACT_PROJECTION_REFERENCES, MAX_DECISION_FACT_PROJECTION_SOURCES, MAX_DECISION_FACT_PROJECTION_SOURCE_LIMITATIONS, MAX_DECISION_FACT_PROJECTION_SOURCE_REFERENCES, MAX_DECISION_FACT_REFERENCES, MAX_DECISION_FACTS, decisionFactCompleteness, } from "../../packages/evidence/decision-fact.mjs";
 import { MAX_CASE_ASSERTIONS, MAX_CASE_DECISIONS, MAX_DECISION_PIN_REFERENCES, } from "../../packages/cases/case-response-model.mjs";
 import { array, boolean, digest, enumeration, exact, exactOptional, fail, integer, iso, optionalText, sameValues, strings, text, } from "./structure-primitives.mjs";
@@ -221,10 +222,10 @@ function validateDecisionFactProjection(value) {
         fail('Investigation capsule Decision Fact projection byte limit');
     }
 }
-function validateCurrentBrief(value) {
+function validateCurrentBrief(value, expectedVersion) {
     const brief = exact(value, ['schema', 'schemaVersion', 'generatedAt', 'target', 'targetType', 'task', 'taskLabel', 'question', 'summary', 'observation', 'decisionFacts', 'relationships', 'limitations'], 'Investigation capsule brief');
     if (brief.schema !== LOOKUP_INVESTIGATION_BRIEF_SCHEMA
-        || brief.schemaVersion !== LOOKUP_INVESTIGATION_BRIEF_VERSION)
+        || brief.schemaVersion !== expectedVersion)
         fail('Investigation capsule brief');
     iso(brief.generatedAt, 'Investigation capsule brief generatedAt');
     text(brief.target, 'Investigation capsule brief target', 253);
@@ -250,21 +251,22 @@ function validateCurrentBrief(value) {
         integer(thresholds[key], 'Investigation capsule freshness threshold', 0, 3650);
     validateDecisionFactProjection(brief.decisionFacts);
     const relationships = exact(brief.relationships, ['nodes', 'edges', 'truncated', 'kinds'], 'Investigation capsule relationship summary');
-    integer(relationships.nodes, 'Investigation capsule relationship node count', 0, 72);
-    integer(relationships.edges, 'Investigation capsule relationship edge count', 0, 120);
+    integer(relationships.nodes, 'Investigation capsule relationship node count', 0, expectedVersion === 2 ? 72 : MAX_LOOKUP_ASSET_NODES);
+    integer(relationships.edges, 'Investigation capsule relationship edge count', 0, expectedVersion === 2 ? 120 : MAX_LOOKUP_ASSET_EDGES);
     boolean(relationships.truncated, 'Investigation capsule relationship truncation');
-    strings(relationships.kinds, 'Investigation capsule relationship kinds', 12, 320);
+    strings(relationships.kinds, 'Investigation capsule relationship kinds', expectedVersion === 2 ? 12 : 64, 320);
     strings(brief.limitations, 'Investigation capsule brief limitations', 20, 320);
     if (new TextEncoder().encode(JSON.stringify(brief)).byteLength > MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES) {
         fail('Investigation capsule brief byte limit');
     }
 }
-function validateGraph(value) {
-    const graph = exact(value, ['version', 'targetId', 'nodes', 'edges', 'sources', 'truncated', 'limitations'], 'Investigation capsule graph');
-    if (graph.version !== LOOKUP_ASSET_GRAPH_VERSION)
+function validateGraph(value, expectedVersion) {
+    const current = expectedVersion === LOOKUP_ASSET_GRAPH_VERSION;
+    const graph = exact(value, ['version', 'targetId', 'nodes', 'edges', 'sources', 'truncated', 'limitations', ...(current ? ['coverage'] : [])], 'Investigation capsule graph');
+    if (graph.version !== expectedVersion)
         fail('Investigation capsule graph');
     text(graph.targetId, 'Investigation capsule graph target', 160);
-    const nodes = array(graph.nodes, 'Investigation capsule graph nodes', 72, 1);
+    const nodes = array(graph.nodes, 'Investigation capsule graph nodes', current ? MAX_LOOKUP_ASSET_NODES : 72, 1);
     const nodeIds = new Set();
     for (const candidate of nodes) {
         const node = exact(candidate, ['id', 'label', 'kind', 'detail'], 'Investigation capsule graph node');
@@ -279,7 +281,7 @@ function validateGraph(value) {
     if (!nodeIds.has(graph.targetId))
         fail('Investigation capsule graph target');
     const sourceIds = new Set();
-    for (const candidate of array(graph.sources, 'Investigation capsule graph sources', 32)) {
+    for (const candidate of array(graph.sources, 'Investigation capsule graph sources', current ? 128 : 32)) {
         const source = exact(candidate, ['id', 'label', 'href', 'observedAt', 'completeness', 'limitations'], 'Investigation capsule graph source');
         const id = text(source.id, 'Investigation capsule graph source id', 160);
         if (sourceIds.has(id))
@@ -290,9 +292,9 @@ function validateGraph(value) {
             fail('Investigation capsule graph source href');
         iso(source.observedAt, 'Investigation capsule graph source observedAt', true);
         enumeration(source.completeness, ['complete', 'partial', 'unknown'], 'Investigation capsule graph source completeness');
-        strings(source.limitations, 'Investigation capsule graph source limitations', 5, 320);
+        strings(source.limitations, 'Investigation capsule graph source limitations', current ? MAX_LOOKUP_ASSET_LIMITATIONS : 5, 320);
     }
-    const edges = array(graph.edges, 'Investigation capsule graph edges', 120);
+    const edges = array(graph.edges, 'Investigation capsule graph edges', current ? MAX_LOOKUP_ASSET_EDGES : 120);
     const edgeIds = new Set();
     for (const candidate of edges) {
         const edge = exactOptional(candidate, ['id', 'sourceId', 'source', 'target', 'kind', 'label', 'sourceLabel', 'observedAt', 'completeness', 'limitations', 'lenses', 'href'], ['boundary'], 'Investigation capsule graph edge');
@@ -310,13 +312,36 @@ function validateGraph(value) {
         text(edge.sourceLabel, 'Investigation capsule graph edge source label', 320);
         iso(edge.observedAt, 'Investigation capsule graph edge observedAt', true);
         enumeration(edge.completeness, ['complete', 'partial', 'unknown'], 'Investigation capsule graph edge completeness');
-        strings(edge.limitations, 'Investigation capsule graph edge limitations', 5, 320);
+        strings(edge.limitations, 'Investigation capsule graph edge limitations', current ? MAX_LOOKUP_ASSET_LIMITATIONS : 5, 320);
         strings(edge.lenses, 'Investigation capsule graph edge lenses', 4, 40).forEach((lens) => enumeration(lens, ['all', 'identity', 'delegation', 'certificate'], 'Investigation capsule graph edge lens'));
         if (typeof edge.href !== 'string' || !/^#[^\u0000-\u001f\u007f]{1,160}$/u.test(edge.href))
             fail('Investigation capsule graph edge href');
         if (edge.boundary !== undefined)
             enumeration(edge.boundary, ['external', 'reviewed_profile', 'same_origin', 'same_registrable_domain', 'unresolved'], 'Investigation capsule graph edge boundary');
     }
+    if (current) {
+        const coverage = exact(graph.coverage, ['inputs'], 'Investigation capsule graph coverage');
+        const ids = new Set();
+        let incomplete = false;
+        for (const candidate of array(coverage.inputs, 'Investigation capsule graph input coverage', MAX_LOOKUP_ASSET_INPUT_ROWS)) {
+            const row = exact(candidate, ['id', 'supplied', 'inspected', 'admitted', 'invalid', 'duplicates', 'omitted'], 'Investigation capsule graph input coverage row');
+            const id = text(row.id, 'Investigation capsule graph input id', 160);
+            if (ids.has(id))
+                fail('Investigation capsule graph input ids');
+            ids.add(id);
+            const supplied = integer(row.supplied, 'Investigation capsule graph supplied input', 0, 0xffff_ffff);
+            const inspected = integer(row.inspected, 'Investigation capsule graph inspected input', 0, 800);
+            const admitted = integer(row.admitted, 'Investigation capsule graph admitted input', 0, inspected);
+            const invalid = integer(row.invalid, 'Investigation capsule graph invalid input', 0, inspected);
+            const duplicates = integer(row.duplicates, 'Investigation capsule graph duplicate input', 0, inspected);
+            const omitted = integer(row.omitted, 'Investigation capsule graph omitted input', 0, inspected);
+            if (inspected > supplied || admitted + invalid + duplicates + omitted !== inspected)
+                fail('Investigation capsule graph input accounting');
+            incomplete ||= supplied > inspected || invalid > 0 || omitted > 0;
+        }
+        if (graph.truncated !== incomplete)
+            fail('Investigation capsule graph coverage linkage');
+    }
     boolean(graph.truncated, 'Investigation capsule graph truncation');
     strings(graph.limitations, 'Investigation capsule graph limitations', 20, 320);
 }
@@ -349,8 +374,8 @@ function validateAnalystRecords(value) {
 }
 export function validateInvestigationCapsuleStructure(value) {
     const root = exact(value, ['schema', 'schemaVersion', 'generatedAt', 'application', 'target', 'sourceContracts', 'investigationBrief', 'graphSnapshot', 'analystRecords', 'integrity', 'limitations'], 'Investigation capsule');
-    if (root.schemaVersion !== PUBLIC_INVESTIGATION_CAPSULE_VERSION
-        && root.schemaVersion !== INVESTIGATION_CAPSULE_VERSION)
+    const expected = investigationCapsuleContracts(root.schemaVersion);
+    if (!expected)
         fail('Investigation capsule');
     iso(root.generatedAt, 'Investigation capsule generatedAt');
     const application = exact(root.application, ['name', 'version'], 'Investigation capsule application');
@@ -376,9 +401,7 @@ export function validateInvestigationCapsuleStructure(value) {
     const expectedContractIds = root.analystRecords === null
         ? ['lookup-evidence', 'investigation-brief', 'asset-graph']
         : ['lookup-evidence', 'investigation-brief', 'asset-graph', 'analyst-records'];
-    const expectedBriefVersion = root.schemaVersion === INVESTIGATION_CAPSULE_VERSION
-        ? LOOKUP_INVESTIGATION_BRIEF_VERSION
-        : PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION;
+    const expectedBriefVersion = expected.brief;
     if (!sameValues(contracts.map((candidate) => candidate.id), expectedContractIds))
         fail('Investigation capsule source contracts');
     if (!byId.has('lookup-evidence') || !byId.has('investigation-brief') || !byId.has('asset-graph')
@@ -387,25 +410,23 @@ export function validateInvestigationCapsuleStructure(value) {
         || byId.get('investigation-brief')?.version !== expectedBriefVersion
         || byId.get('investigation-brief')?.embedded !== true
         || byId.get('asset-graph')?.schema !== LOOKUP_ASSET_GRAPH_SCHEMA
-        || byId.get('asset-graph')?.version !== LOOKUP_ASSET_GRAPH_VERSION
+        || byId.get('asset-graph')?.version !== expected.graph
         || byId.get('asset-graph')?.embedded !== true
         || (byId.has('analyst-records') && (byId.get('analyst-records')?.schema !== INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA
             || byId.get('analyst-records')?.version !== INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION
             || byId.get('analyst-records')?.embedded !== true)))
         fail('Investigation capsule source contracts');
-    if (root.schemaVersion === INVESTIGATION_CAPSULE_VERSION)
-        validateCurrentBrief(root.investigationBrief);
-    else
+    if (expectedBriefVersion === 1)
         validatePublicBrief(root.investigationBrief);
-    validateGraph(root.graphSnapshot);
+    else
+        validateCurrentBrief(root.investigationBrief, expectedBriefVersion);
+    validateGraph(root.graphSnapshot, expected.graph);
     validateAnalystRecords(root.analystRecords);
-    const brief = root.investigationBrief;
-    const graph = root.graphSnapshot;
-    if (target.value !== brief.target || target.type !== brief.targetType
-        || graph.targetId === undefined
-        || brief.relationships.nodes !== graph.nodes.length
-        || brief.relationships.edges !== graph.edges.length)
+    // The version-specific validators above independently establish these common fields.
+    const projections = root;
+    if (!investigationCapsuleProjectionsMatch(projections.target, projections.investigationBrief, projections.graphSnapshot)) {
         fail('Investigation capsule projection linkage');
+    }
     const integrity = exact(root.integrity, ['algorithm', 'canonicalization', 'scope', 'briefDigest', 'graphDigest', 'analystRecordsDigest', 'digestSha256'], 'Investigation capsule integrity');
     if (integrity.algorithm !== 'SHA-256')
         fail('Investigation capsule integrity');

package/cli/artifact-validation/lookup-evidence.mjs

@@ -1,9 +1,10 @@
 import { isDeepStrictEqual } from 'node:util';
-import { assertLookupEvidencePrivacySafeTree, assertLookupEvidencePortableTree, LOOKUP_EVIDENCE_SCHEMA, LOOKUP_EVIDENCE_SCHEMA_VERSION, PRIVACY_MINIMIZED_LOOKUP_EVIDENCE_SCHEMA_VERSION, V1_PUBLIC_LOOKUP_EVIDENCE_SCHEMA_VERSION, projectLookupEvidenceAvailability, projectLookupEvidenceAvailabilityPublic, projectLookupEvidenceQuery, projectLookupEvidenceRdapPublication, projectLookupEvidenceRegistryInsights, projectLookupEvidenceWhoisPublication, SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS, } from "../../lib/evidence-export.mjs";
+import { assertLookupEvidencePrivacySafeTree, assertLookupEvidencePortableTree, LOOKUP_EVIDENCE_SCHEMA, LOOKUP_EVIDENCE_SCHEMA_VERSION, HOSTNAME_SCOPED_LOOKUP_EVIDENCE_SCHEMA_VERSION, PRIVACY_MINIMIZED_LOOKUP_EVIDENCE_SCHEMA_VERSION, REGISTRAR_STANDING_LOOKUP_EVIDENCE_SCHEMA_VERSION, V1_PUBLIC_LOOKUP_EVIDENCE_SCHEMA_VERSION, projectLookupEvidenceAvailability, projectLookupEvidenceAvailabilityPublic, projectLookupEvidenceQuery, projectLookupEvidenceRdapPublication, projectLookupEvidenceRegistryInsights, projectLookupEvidenceWhoisPublication, SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS, } from "../../lib/evidence-export.mjs";
+import { validLookupObservationScope } from "../../packages/evidence/lookup-target.mjs";
 import { registrarStandingObservedBy, resolveRegistrarIanaId, validRegistrarStanding, } from "../../lib/registrar-standing-contract.mjs";
 import { compareRegistrySources } from "../../lib/registry-comparison.mjs";
 import { buildRegistryInsights } from "../../lib/registry-insights.mjs";
-import { WHOISLEUTH_SOURCE_REPOSITORY_URL } from "../../lib/project-metadata.mjs";
+import { WHOISLEUTH_SOURCE_REPOSITORY_URL } from "../../packages/analysis/project-metadata.mjs";
 import { validHttpDeliveryMetadata, validPagePublicationMetadata, } from "../../lib/homepage-metadata-contract.mjs";
 import { HEX_DIGEST_RE, SEMANTIC_VERSION_RE, absoluteUrl, array, boolean, domain, enumeration, exact, exactOptional, fail, integer, iso, nullableRecord, optionalText, record, strings, text, } from "./structure-primitives.mjs";
 const LOOKUP_RDAP_ATTEMPT_OUTCOMES = [
@@ -649,27 +650,32 @@ export function validateLookupEvidenceArtifactStructure(value) {
     }
     validateLookupEvidenceSecurityTxt(sources.securityTxt);
     validateLookupEvidenceSslbl(sources.sslbl);
-    const analysis = exact(root.analysis, version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+    const analysis = exact(root.analysis, version >= REGISTRAR_STANDING_LOOKUP_EVIDENCE_SCHEMA_VERSION
         ? ['availability', 'idn', 'registryInsights', 'registryComparison', 'registrarPublicationComparison', 'registrarStanding']
         : ['availability', 'idn', 'registryInsights', 'registryComparison', 'registrarPublicationComparison'], 'Lookup evidence analysis');
-    if (version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+    if (version >= REGISTRAR_STANDING_LOOKUP_EVIDENCE_SCHEMA_VERSION
         && analysis.registrarStanding !== null
         && !validRegistrarStanding(analysis.registrarStanding))
         fail('Lookup evidence registrar standing');
-    if (version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+    if (version >= REGISTRAR_STANDING_LOOKUP_EVIDENCE_SCHEMA_VERSION
         && analysis.registrarStanding !== null
         && !registrarStandingObservedBy(analysis.registrarStanding, root.generatedAt)) {
         fail('Lookup evidence registrar standing observation time');
     }
     if (analysis.availability !== null) {
         const currentAvailability = version >= PRIVACY_MINIMIZED_LOOKUP_EVIDENCE_SCHEMA_VERSION;
-        const availability = exactOptional(analysis.availability, currentAvailability ? ['registryContactsExcluded'] : [], currentAvailability ? LOOKUP_AVAILABILITY_ANALYSIS_KEYS : PUBLIC_LOOKUP_AVAILABILITY_ANALYSIS_KEYS, 'Lookup evidence availability analysis');
+        const availability = exactOptional(analysis.availability, currentAvailability ? ['registryContactsExcluded'] : [], currentAvailability
+            ? [...LOOKUP_AVAILABILITY_ANALYSIS_KEYS, ...(version >= HOSTNAME_SCOPED_LOOKUP_EVIDENCE_SCHEMA_VERSION ? ['observationHostname', 'webObservationMode'] : [])]
+            : PUBLIC_LOOKUP_AVAILABILITY_ANALYSIS_KEYS, 'Lookup evidence availability analysis');
         if (currentAvailability && availability.registryContactsExcluded !== true) {
             fail('Lookup evidence availability contact exclusion');
         }
+        if (!validLookupObservationScope(availability, query)) {
+            fail('Lookup evidence observation hostname binding');
+        }
         validateLookupEvidenceHomepageMetadata(availability, version);
         if (!isDeepStrictEqual(analysis.availability, currentAvailability
-            ? projectLookupEvidenceAvailability(analysis.availability)
+            ? projectLookupEvidenceAvailability(analysis.availability, { legacyUris: version < HOSTNAME_SCOPED_LOOKUP_EVIDENCE_SCHEMA_VERSION })
             : projectLookupEvidenceAvailabilityPublic(analysis.availability)))
             fail('Lookup evidence availability analysis');
     }
@@ -684,7 +690,7 @@ export function validateLookupEvidenceArtifactStructure(value) {
         const whois = record(sources.whois, 'Lookup evidence WHOIS source');
         const rdapParsed = ['success', 'partial'].includes(rdapDiagnosticStatus) ? rdap.parsed : null;
         const whoisParsed = ['complete', 'partial'].includes(whoisDiagnosticStatus) ? whois.parsed : null;
-        if (version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+        if (version >= REGISTRAR_STANDING_LOOKUP_EVIDENCE_SCHEMA_VERSION
             && validRegistrarStanding(analysis.registrarStanding)
             && analysis.registrarStanding.ianaId !== resolveRegistrarIanaId(rdapParsed, whoisParsed)) {
             fail('Lookup evidence registrar standing source binding');
@@ -709,7 +715,7 @@ export function validateLookupEvidenceArtifactStructure(value) {
         if (!isDeepStrictEqual(registryInsights, expectedInsights))
             fail('Lookup evidence registry insight derivation');
         try {
-            assertLookupEvidencePrivacySafeTree(root);
+            assertLookupEvidencePrivacySafeTree(root, { legacyUris: version < HOSTNAME_SCOPED_LOOKUP_EVIDENCE_SCHEMA_VERSION });
         }
         catch {
             fail('Lookup evidence privacy boundary');