@slicedearth/whoisleuth-cli 2.2.0 → 2.3.0

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

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { canonicalArtifactJsonV2 } from "../../packages/evidence/artifact-integrity.mjs";
-import { 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, 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, 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_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";
 const CASE_RESPONSE_PREFLIGHT_IDS_V6 = [
@@ -21,6 +21,9 @@ const CASE_RESPONSE_PREFLIGHT_IDS_V8 = [
     'action_tracking',
 ];
 const PUBLIC_CASE_ACTION_STATES = ['planned', 'ready_for_review', 'submitted', 'acknowledged', 'resolved', 'closed'];
+const PRE_PLATFORM_PROFILE_IDS = RESPONSE_PACKET_PROFILE_IDS.filter((id) => id !== 'application_platform');
+const PRE_PLATFORM_CONTACT_KINDS = RESPONSE_CONTACT_KINDS.filter((kind) => kind !== 'application_platform');
+const PRE_PLATFORM_ACTION_TYPES = CASE_ACTION_TYPES.filter((type) => type !== 'platform_report');
 function legacyProfileRedactions(profileId) {
     if (profileId === 'registrar' || profileId === 'registry') {
         return ['Remove unnecessary personal registration data', 'Remove credentials, tokens, and URL fragments'];
@@ -68,7 +71,7 @@ function validateCaseResponsePacketV6(value) {
     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, RESPONSE_PACKET_PROFILE_IDS, 'Case-response profile id');
+    const profileId = enumeration(profile.id, 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);
@@ -124,7 +127,7 @@ function validateCaseResponsePacketV6(value) {
     const contactKeys = new Set();
     for (const candidate of contacts) {
         const contact = exact(candidate, ['kind', 'contact', 'source', 'limitations'], 'Case-response contact');
-        const kind = enumeration(contact.kind, RESPONSE_CONTACT_KINDS, 'Case-response contact kind');
+        const kind = enumeration(contact.kind, PRE_PLATFORM_CONTACT_KINDS, 'Case-response contact kind');
         const contactValue = text(contact.contact, 'Case-response contact value', MAX_RESPONSE_RECIPIENT_LENGTH);
         const contactKey = `${kind}\u0000${contactValue.toLowerCase()}`;
         if (contactKeys.has(contactKey))
@@ -160,7 +163,7 @@ function validateCaseResponsePacketV6(value) {
     const history = array(root.escalationHistory, 'Case-response escalation history', MAX_RESPONSE_ACTION_HISTORY);
     for (const candidate of history) {
         const action = exact(candidate, ['type', 'recipient', 'contactSource', 'state', 'reference', 'outcome', 'createdAt', 'updatedAt'], 'Case-response escalation action');
-        enumeration(action.type, CASE_ACTION_TYPES, 'Case-response action type');
+        enumeration(action.type, PRE_PLATFORM_ACTION_TYPES, 'Case-response action type');
         text(action.recipient, 'Case-response action recipient', 320, true);
         text(action.contactSource, 'Case-response action source', 120, true);
         enumeration(action.state, PUBLIC_CASE_ACTION_STATES, 'Case-response action state');
@@ -221,14 +224,15 @@ function validateCurrentActionSummary(value, label) {
     }
     return total;
 }
-function validateCaseResponsePacketV7OrV8(value, version) {
+function validateCaseResponsePacketV7ToV9(value, version) {
     const current = version === CASE_RESPONSE_PACKET_VERSION;
+    const modern = version === LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION || current;
     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',
-        ...(current ? ['recipientRoute', 'actionBinding'] : []),
+        ...(modern ? ['recipientRoute', 'actionBinding'] : []),
     ], `Case-response packet v${version}`);
     if (root.schemaVersion !== version)
         fail(`Case-response packet v${version}`);
@@ -236,14 +240,14 @@ function validateCaseResponsePacketV7OrV8(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, RESPONSE_PACKET_PROFILE_IDS, 'Case-response profile id');
+    const profileId = enumeration(profile.id, current ? 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 = current ? selectedProfile?.redactions : legacyProfileRedactions(profileId);
+    const expectedRedactions = modern ? selectedProfile?.redactions : legacyProfileRedactions(profileId);
     if (!selectedProfile
         || profile.label !== selectedProfile.label
         || profile.audience !== selectedProfile.audience
@@ -282,8 +286,10 @@ function validateCaseResponsePacketV7OrV8(value, version) {
     const contacts = array(root.contacts, 'Case-response contacts', MAX_RESPONSE_CONTACTS);
     const contactKeys = new Set();
     for (const candidate of contacts) {
-        const contact = exact(candidate, ['kind', 'contact', 'source', 'observedAt', 'freshness', 'limitations'], 'Case-response contact');
-        const kind = enumeration(contact.kind, RESPONSE_CONTACT_KINDS, 'Case-response contact kind');
+        const contact = exact(candidate, [
+            'kind', 'contact', 'source', 'observedAt', ...(current ? ['reviewAfter'] : []), 'freshness', 'limitations',
+        ], 'Case-response contact');
+        const kind = enumeration(contact.kind, current ? 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))
@@ -291,13 +297,18 @@ function validateCaseResponsePacketV7OrV8(value, version) {
         contactKeys.add(key);
         text(contact.source, 'Case-response contact source', 120);
         iso(contact.observedAt, 'Case-response contact observedAt', true);
+        if (current)
+            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
+            && Date.parse(root.generatedAt) >= Date.parse(contact.reviewAfter);
         const expectedFreshness = routeAge === null
             ? 'unknown'
-            : routeAge < -300_000 || routeAge > RESPONSE_ROUTE_STALE_AFTER_DAYS * 86_400_000
+            : routeAge < -300_000 || reviewExpired
+                || (contact.reviewAfter == null && routeAge > RESPONSE_ROUTE_STALE_AFTER_DAYS * 86_400_000)
                 ? 'stale'
                 : 'current';
         if (freshness !== expectedFreshness)
@@ -308,24 +319,29 @@ function validateCaseResponsePacketV7OrV8(value, version) {
     let selectedActionId = null;
     let lineageActionIds = [];
     let lineageComplete = true;
-    if (current) {
+    if (modern) {
         if (root.recipientRoute !== null) {
             recipientRoute = exact(root.recipientRoute, [
-                'actionId', 'kind', 'contact', 'source', 'observedAt', 'freshness', 'limitations',
+                'actionId', 'kind', 'contact', 'source', 'observedAt', ...(current ? ['reviewAfter'] : []), 'freshness', 'limitations',
             ], 'Case-response recipient route');
             text(recipientRoute.actionId, 'Case-response recipient action id', 64);
-            enumeration(recipientRoute.kind, [...RESPONSE_CONTACT_KINDS, 'manual'], 'Case-response recipient kind');
+            enumeration(recipientRoute.kind, [...(current ? 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)
+                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
+                && Date.parse(root.generatedAt) >= Date.parse(recipientRoute.reviewAfter);
             const expectedFreshness = routeAge === null
                 ? 'unknown'
                 : routeAge < -MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS
-                    || routeAge > RESPONSE_ROUTE_STALE_AFTER_DAYS * 86_400_000 ? 'stale' : 'current';
+                    || reviewExpired
+                    || (recipientRoute.reviewAfter == null && routeAge > RESPONSE_ROUTE_STALE_AFTER_DAYS * 86_400_000) ? 'stale' : 'current';
             if (freshness !== expectedFreshness)
                 fail('Case-response recipient freshness');
             strings(recipientRoute.limitations, 'Case-response recipient limitations', MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_LIMITATION_LENGTH);
@@ -354,6 +370,7 @@ function validateCaseResponsePacketV7OrV8(value, version) {
                 || selectedContact.contact !== recipientRoute.contact
                 || selectedContact.source !== recipientRoute.source
                 || selectedContact.observedAt !== recipientRoute.observedAt
+                || (current && selectedContact.reviewAfter !== recipientRoute.reviewAfter)
                 || selectedContact.freshness !== recipientRoute.freshness)
                 fail('Case-response selected contact projection');
         }
@@ -395,7 +412,7 @@ function validateCaseResponsePacketV7OrV8(value, version) {
         ...(profileId === 'internal_soc' ? [] : ['recipient_route']),
         ...(['registrar', 'registry', 'network_hosting'].includes(profileId) ? ['infrastructure_responsibility'] : []),
     ]);
-    const requiredContact = current
+    const requiredContact = modern
         ? recipientRoute ?? undefined
         : selectedProfile?.requiredContactKind
             ? contacts.find((candidate) => candidate.kind === selectedProfile.requiredContactKind)
@@ -490,8 +507,8 @@ function validateCaseResponsePacketV7OrV8(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 = current ? CASE_RESPONSE_PREFLIGHT_IDS_V8 : CASE_RESPONSE_PREFLIGHT_IDS_V7;
-    if (preflight.version !== (current ? 3 : 2))
+    const preflightIds = modern ? CASE_RESPONSE_PREFLIGHT_IDS_V8 : CASE_RESPONSE_PREFLIGHT_IDS_V7;
+    if (preflight.version !== (modern ? 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 };
@@ -515,8 +532,8 @@ function validateCaseResponsePacketV7OrV8(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 ((!current && history.length !== Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
-        || (current && history.length > Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
+    if ((!modern && history.length !== Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
+        || (modern && history.length > Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY))
         || escalationHistoryOmitted !== actionTotal - history.length
         || (escalationHistoryOmitted > 0) !== (escalationHistoryLimitations.length > 0))
         fail('Case-response action-history bounds');
@@ -528,18 +545,21 @@ function validateCaseResponsePacketV7OrV8(value, version) {
             'actionId', 'type', 'recipient', 'contactSource', 'state', 'reference',
             'providerOutcome', 'outcomeDetail', 'originActionId', 'historyOmitted',
             'historyLimitations', 'transitions', 'createdAt', 'updatedAt',
-            ...(current ? ['routeObservedAt'] : []),
+            ...(modern ? ['routeObservedAt'] : []),
+            ...(current ? ['routeReviewAfter'] : []),
         ], 'Case-response escalation action');
         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, CASE_ACTION_TYPES, 'Case-response action type');
+        enumeration(action.type, current ? 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 (current)
+        if (modern)
             iso(action.routeObservedAt, 'Case-response action route observedAt', true);
+        if (current)
+            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);
         if (action.providerOutcome !== null)
@@ -638,7 +658,7 @@ function validateCaseResponsePacketV7OrV8(value, version) {
         iso(action.createdAt, 'Case-response action createdAt');
         iso(action.updatedAt, 'Case-response action updatedAt');
     }
-    if (current) {
+    if (modern) {
         if (actionIds.size !== lineageActionIds.length
             || actionIdOrder.some((id, index) => lineageActionIds[index] !== id))
             fail('Case-response action lineage');
@@ -670,11 +690,11 @@ function validateCaseResponsePacketV7OrV8(value, version) {
     const latestProviderEvents = latestProviderTime === null
         ? []
         : providerEvents.filter((event) => event.occurredAt === latestProviderTime);
-    const expectedLatestProvider = (current ? lineageComplete : escalationHistoryOmitted === 0)
+    const expectedLatestProvider = (modern ? lineageComplete : escalationHistoryOmitted === 0)
         && latestProviderEvents.length === 1 && latestProviderEvents[0].applied
         ? latestProviderEvents[0]
         : null;
-    const expectedProviderState = (current ? !lineageComplete : escalationHistoryOmitted > 0)
+    const expectedProviderState = (modern ? !lineageComplete : escalationHistoryOmitted > 0)
         ? 'ambiguous'
         : providerEvents.length === 0 ? 'missing' : expectedLatestProvider ? 'available' : 'ambiguous';
     if (providerOutcomeState !== expectedProviderState
@@ -707,7 +727,9 @@ function validateCaseResponsePacketV7OrV8(value, version) {
     strings(lifecycle.limitations, 'Case-response lifecycle limitations', 8, 600);
     const reviewedInputs = {
         contract: CASE_RESPONSE_REVIEW_INPUTS_SCHEMA,
-        version: current ? CASE_RESPONSE_REVIEW_INPUTS_VERSION : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION,
+        version: current
+            ? CASE_RESPONSE_REVIEW_INPUTS_VERSION
+            : modern ? LATEST_PUBLIC_CASE_RESPONSE_REVIEW_INPUTS_VERSION : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION,
         profile: {
             id: profile.id,
             label: profile.label,
@@ -721,7 +743,7 @@ function validateCaseResponsePacketV7OrV8(value, version) {
         case: root.case,
         incident: root.incident,
         contacts: root.contacts,
-        ...(current ? { recipientRoute: root.recipientRoute, actionBinding: root.actionBinding } : {}),
+        ...(modern ? { recipientRoute: root.recipientRoute, actionBinding: root.actionBinding } : {}),
         selectedEvidence: root.selectedEvidence,
         contradictions: root.contradictions,
         readiness: root.readiness,
@@ -759,7 +781,10 @@ export function validateCaseResponsePacket(value) {
     if (value.schemaVersion === PUBLIC_CASE_RESPONSE_PACKET_VERSION)
         return validateCaseResponsePacketV6(value);
     if (value.schemaVersion === PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION) {
-        return validateCaseResponsePacketV7OrV8(value, PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION);
+        return validateCaseResponsePacketV7ToV9(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 (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.`);
@@ -767,5 +792,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.`);
     }
-    validateCaseResponsePacketV7OrV8(value, CASE_RESPONSE_PACKET_VERSION);
+    validateCaseResponsePacketV7ToV9(value, CASE_RESPONSE_PACKET_VERSION);
 }

package/cli/artifact-validation/signed-review.mjs

@@ -5,7 +5,7 @@ import { BULK_REVIEW_MANIFEST_SCHEMA, BULK_REVIEW_MANIFEST_VERSION, } from "../.
 import { LOOKUP_CLAIM_PASSPORT_SCHEMA, LOOKUP_CLAIM_PASSPORT_TARGET_TYPES, LOOKUP_CLAIM_PASSPORT_VERSION, MAX_LOOKUP_CLAIM_PASSPORT_LIMITATIONS, MAX_LOOKUP_CLAIM_PASSPORT_REQUIREMENTS, } from "../../packages/investigation/lookup-claim-passport.mjs";
 import { LOOKUP_CLAIM_IDS, LOOKUP_CLAIM_READINESS_VERSION, LOOKUP_CLAIM_REQUIREMENT_IDS, } from "../../packages/investigation/lookup-claim-readiness.mjs";
 import { normalizeDomainControlManifestDocument } from "../../packages/evidence/domain-control-runtime.mjs";
-import { DOMAIN_CHANGE_PACKET_SCHEMA, DOMAIN_CHANGE_PACKET_VERSION } from "../../lib/domain-change-packet.mjs";
+import { DOMAIN_CHANGE_PACKET_SCHEMA, DOMAIN_CHANGE_PACKET_VERSION, } from "../../lib/domain-change-packet.mjs";
 import { DOMAIN_CONTROL_MANIFEST_SCHEMA } from "../../packages/contracts/domain-control-manifest.mjs";
 import { INVESTIGATION_MANIFEST_SCHEMA, INVESTIGATION_MANIFEST_VERSION, MAX_INVESTIGATION_MANIFEST_ARTIFACTS, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES, } from "../investigation-manifest.mjs";
 import { array, boolean, domain, digest, enumeration, exact, fail, integer, iso, optionalText, sameValues, strings, text, validateIntegrity, } from "./structure-primitives.mjs";
@@ -501,18 +501,36 @@ function expectedDomainChangeSummary(before, after) {
     const beforeRows = rows(before);
     const afterRows = rows(after);
     const keys = [...new Set([...beforeRows.keys(), ...afterRows.keys()])].sort();
-    return keys.slice(0, 500).flatMap((key) => {
-        const left = beforeRows.get(key);
-        const right = afterRows.get(key);
-        const values = (row) => [...new Set((row?.observations ?? [])
-                .flatMap((observation) => observation.values))].sort();
-        const beforeValues = values(left);
-        const afterValues = values(right);
-        if (sameValues(beforeValues, afterValues))
-            return [];
+    const collectionComplete = (review) => {
+        const row = (review.authoritativeRecordMatrix[0]);
+        const observations = row?.observations ?? [];
+        return observations.length >= 2 && observations.every((item) => item.state === 'observed');
+    };
+    const rowEvidence = (review, row) => {
+        if (!row)
+            return { state: collectionComplete(review) ? 'complete' : 'unavailable', values: [] };
+        const observations = row.observations;
+        if (observations.some((item) => item.state !== 'observed'))
+            return { state: 'partial', values: [] };
+        if (row.state === 'different')
+            return { state: 'inconsistent', values: [] };
+        if (row.state !== 'aligned')
+            return { state: 'insufficient', values: [] };
+        return { state: 'complete', values: [...new Set(observations.flatMap((item) => item.values))].sort() };
+    };
+    const changed = [];
+    for (const key of keys.slice(0, 500)) {
+        const left = rowEvidence(before, beforeRows.get(key));
+        const right = rowEvidence(after, afterRows.get(key));
         const [owner, type] = key.split('\u0000');
-        return [{ owner: owner ?? '', type: type ?? '', beforeValues, afterValues }];
-    });
+        if (left.state !== 'complete' || right.state !== 'complete') {
+            continue;
+        }
+        else if (!sameValues(left.values, right.values)) {
+            changed.push({ owner: owner ?? '', type: type ?? '', beforeValues: left.values, afterValues: right.values });
+        }
+    }
+    return changed;
 }
 function validateDomainChangePacket(value) {
     const root = exact(value, ['schema', 'version', 'generatedAt', 'domain', 'reference', 'state', 'gate', 'summary', 'evidence', 'limitations', 'integrity'], 'Domain change packet');

package/cli/bulk-checkpoint.mjs

@@ -54,6 +54,24 @@ function normalizeCompactResult(value) {
         return null;
     return result;
 }
+function normalizeCollectionContext(value) {
+    if (value === undefined)
+        return undefined;
+    const context = recordOrNull(value);
+    if (!context || Object.keys(context).some((key) => !['dnsResolver', 'resolverServers'].includes(key)))
+        return null;
+    const resolverServers = context.resolverServers;
+    if (!Array.isArray(resolverServers) || resolverServers.length > 3
+        || resolverServers.some((server) => typeof server !== 'string' || !server || server.length > 45))
+        return null;
+    if (context.dnsResolver === 'system_default' && resolverServers.length === 0) {
+        return { dnsResolver: 'system_default', resolverServers: [] };
+    }
+    if (context.dnsResolver === 'analyst_selected' && resolverServers.length > 0) {
+        return { dnsResolver: 'analyst_selected', resolverServers: [...resolverServers] };
+    }
+    return null;
+}
 function normalizeCheckpointResult(value, queries, classifyQuery) {
     const item = recordOrNull(value);
     const index = item?.index;
@@ -67,10 +85,16 @@ function normalizeCheckpointResult(value, queries, classifyQuery) {
         : normalizedTimestamp(item.observedAt) ?? undefined;
     if (observedAt === undefined)
         return null;
+    const collectionContext = normalizeCollectionContext(item.collectionContext);
+    if (collectionContext === null)
+        return null;
     if (item.ok === false) {
         if (typeof item.error !== 'string' || !item.error || item.error.length > 300)
             return null;
-        return { index: Number(index), query, ok: false, error: item.error, observedAt };
+        return {
+            index: Number(index), query, ok: false, error: item.error, observedAt,
+            ...(collectionContext ? { collectionContext } : {}),
+        };
     }
     const result = normalizeCompactResult(item.result);
     if (item.ok !== true || !result)
@@ -79,7 +103,10 @@ function normalizeCheckpointResult(value, queries, classifyQuery) {
     const storedClassified = recordOrNull(item.classified);
     if (storedClassified?.type !== classified.type || storedClassified.value !== classified.value)
         return null;
-    return { index: Number(index), query, ok: true, classified, result, observedAt };
+    return {
+        index: Number(index), query, ok: true, classified, result, observedAt,
+        ...(collectionContext ? { collectionContext } : {}),
+    };
 }
 function parseBulkCheckpoint(text, options) {
     if (typeof text !== 'string' || Buffer.byteLength(text, 'utf8') > MAX_BULK_CHECKPOINT_BYTES) {
@@ -214,8 +241,10 @@ async function createBulkCheckpointWriter(options) {
         }
     }
     function scheduleWrite() {
+        if (writeFailure)
+            return;
         dirty = true;
-        if (activeWrite || writeFailure)
+        if (activeWrite)
             return;
         const pending = drainWrites();
         activeWrite = pending;
@@ -250,6 +279,8 @@ async function createBulkCheckpointWriter(options) {
         },
         async flush() {
             while (activeWrite || dirty) {
+                if (writeFailure && !activeWrite)
+                    break;
                 if (!activeWrite)
                     scheduleWrite();
                 if (activeWrite)

package/cli/case-pack.mjs

@@ -4,42 +4,16 @@ import { canonicalArtifactJson, canonicalArtifactJsonV2, SORTED_JSON_V2, } from
 import { buildCaseReport } from "../packages/cases/case-report.mjs";
 import { WHOISLEUTH_APPLICATION_VERSION } from "../lib/application-version.mjs";
 import { assertBoundedJsonStructure, scanBoundedJson } from "../lib/bounded-json.mjs";
-import { assertCaseBrandProfileIds, normalizeDomain, normalizeCaseStore, safeId, } from "../packages/cases/case-model.mjs";
+import { assertCaseBrandProfileIds, CASE_AUDIENCE_SENSITIVE_FIELD_NAMES, CASE_RECORD_FIELD_NAMES, caseAudienceExclusions, normalizeDomain, normalizeCaseStore, projectCaseForAudience, safeId, } from "../packages/cases/case-model.mjs";
 import { CASE_REPORT_SCHEMA, CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, CLI_CASE_PACK_SCHEMA, CLI_CASE_PACK_VERSION, CLI_CASE_PACK_CURRENT_REDACTION_KEYS, CLI_CASE_PACK_PUBLIC_REPORT_KEYS, CLI_CASE_PACK_INTEGRITY_KEYS as INTEGRITY_KEYS, CLI_CASE_PACK_LIMITATIONS as PACKET_LIMITATIONS, CLI_CASE_PACK_PACKET_KEYS as PACKET_KEYS, CLI_CASE_PACK_REPORT_KEYS as REPORT_KEYS, CLI_CASE_PACK_ROOT_KEYS as ROOT_KEYS, MAX_CASE_IMPORT_BYTES, MAX_CASE_PACK_CASES, MAX_CASE_PACK_INPUT_BYTES, PUBLIC_CASE_SCHEMA_VERSION, caseReportVersionMatchesCase, } from "../packages/contracts/case-portability.mjs";
 import { CliUsageError } from "./errors.mjs";
 export { CLI_CASE_PACK_SCHEMA, CLI_CASE_PACK_VERSION, MAX_CASE_PACK_CASES, MAX_CASE_PACK_INPUT_BYTES, };
 const MAX_CASE_PACK_REFERENCE_SCAN_DEPTH = 64;
-const INTERNAL_EXCLUSIONS = Object.freeze(['Raw upstream payloads and credentials are outside the case schema.']);
-const TRUSTED_EXCLUSIONS = Object.freeze(['Case notes', 'Recipient values', 'Manual trail targets', 'Raw upstream payloads and credentials']);
-const PUBLIC_EXCLUSIONS = Object.freeze([
-    'Case notes',
-    'Brand Profile references',
-    'Actions and recipient values',
-    'Analyst assertions',
-    'Investigation branches',
-    'Manual trail targets',
-    'Raw upstream payloads and credentials',
-    'Independent observed-effect reviews and closure history',
-]);
-const PUBLIC_V12_EXCLUSIONS = Object.freeze(PUBLIC_EXCLUSIONS.slice(0, -1));
-const SENSITIVE_CASE_PACK_FIELDS = Object.freeze([
-    'brandProfileIds', 'notes', 'actions', 'assertions', 'manualTrail', 'observedEffects',
-    'closures', 'branches', 'recipient', 'target',
-]);
-const PUBLIC_OBSERVED_EFFECT_LIMITATION = 'Independent observed-effect review records were excluded from this public Case pack.';
-const PUBLIC_CLOSURE_LIMITATION = 'Deliberate closure records were excluded from this public Case pack.';
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
         : null;
 }
-function expectedExclusions(audience, caseVersion = CASE_SCHEMA_VERSION) {
-    if (audience === 'internal')
-        return INTERNAL_EXCLUSIONS;
-    if (audience === 'trusted')
-        return TRUSTED_EXCLUSIONS;
-    return caseVersion === PUBLIC_CASE_SCHEMA_VERSION ? PUBLIC_V12_EXCLUSIONS : PUBLIC_EXCLUSIONS;
-}
 function stringListsMatch(value, expected) {
     return Array.isArray(value)
         && value.length === expected.length
@@ -105,7 +79,7 @@ function assertSensitiveFieldPlacement(root, serializedLength) {
         const entry = stack.pop();
         if (!entry || !entry.value || typeof entry.value !== 'object')
             continue;
-        for (const key of SENSITIVE_CASE_PACK_FIELDS) {
+        for (const key of CASE_AUDIENCE_SENSITIVE_FIELD_NAMES) {
             if (Object.hasOwn(entry.value, key) && !allowedSensitiveFieldPath(key, entry.path)) {
                 throw new TypeError('The CLI case pack contains audience-sensitive data outside its versioned case or report fields.');
             }
@@ -170,42 +144,22 @@ function assertCanonicalCaseIdentities(cases, label) {
     }
 }
 function assertCurrentCaseProjection(rawCases, normalised, label) {
-    if (rawCases.length !== normalised.length
-        || rawCases.some((item, index) => !canonicalValuesMatch(item, normalised[index]))) {
+    const requiredFields = new Set(CASE_RECORD_FIELD_NAMES);
+    if (rawCases.length !== normalised.length || rawCases.some((item, index) => {
+        const raw = record(item);
+        return !raw
+            || Object.keys(raw).length !== requiredFields.size
+            || Object.keys(raw).some((key) => !requiredFields.has(key))
+            || !canonicalValuesMatch(raw, normalised[index]);
+    })) {
         throw new TypeError(`${label} contains a schema ${CASE_SCHEMA_VERSION} Case that would be repaired, truncated, or otherwise changed during normalisation.`);
     }
 }
-function publicObservedEffectHistory(preV13HistoryUnavailable) {
-    return {
-        reviews: [],
-        omitted: 0,
-        preV13HistoryUnavailable,
-        limitations: [
-            ...(preV13HistoryUnavailable
-                ? ['Migrated from a pre-v13 Case; earlier independent observed-effect review history is unavailable.']
-                : []),
-            'Observed-effect reviews are independent point-in-time records; provider workflow events do not create or replace them.',
-            PUBLIC_OBSERVED_EFFECT_LIMITATION,
-        ].sort(),
-    };
-}
-function publicClosureHistory(preV13HistoryUnavailable) {
-    return {
-        records: [],
-        omitted: 0,
-        preV13HistoryUnavailable,
-        limitations: [
-            ...(preV13HistoryUnavailable
-                ? ['Migrated from a pre-v13 Case; earlier deliberate closure history is unavailable.']
-                : []),
-            'Closure records are deliberate analyst actions and do not establish absence, safety, provider performance, or legal sufficiency.',
-            PUBLIC_CLOSURE_LIMITATION,
-        ].sort(),
-    };
-}
-function assertAudienceFields(value, audience) {
+/** Historical packs keep their immutable wire shape, so only their retained audience guarantees are checked here. */
+function assertLegacyAudienceFields(value, normalised, audience) {
     if (audience === 'internal')
         return;
+    const expected = projectCaseForAudience(normalised, audience);
     if (Object.hasOwn(value, 'notes') && (!Array.isArray(value.notes) || value.notes.length !== 0)) {
         throw new TypeError('The CLI case pack contains Case notes excluded by its audience.');
     }
@@ -218,11 +172,8 @@ function assertAudienceFields(value, audience) {
         for (const [field, list] of [['observedEffects', 'reviews'], ['closures', 'records']]) {
             if (Object.hasOwn(value, field)) {
                 const history = record(value[field]);
-                const expected = field === 'observedEffects'
-                    ? publicObservedEffectHistory(history?.preV13HistoryUnavailable === true)
-                    : publicClosureHistory(history?.preV13HistoryUnavailable === true);
                 if (!history || !Array.isArray(history[list]) || history[list].length !== 0
-                    || !canonicalValuesMatch(history, expected)) {
+                    || !canonicalValuesMatch(history, expected[field])) {
                     throw new TypeError(`The public CLI case pack contains ${field} excluded by its audience.`);
                 }
             }
@@ -245,6 +196,20 @@ function assertAudienceFields(value, audience) {
         }
     }
 }
+function assertCurrentAudienceProjection(value, normalised, audience) {
+    const expected = projectCaseForAudience(normalised, audience);
+    for (const field of CASE_RECORD_FIELD_NAMES) {
+        if (!canonicalValuesMatch(value[field], expected[field])) {
+            throw new TypeError(`The CLI case pack contains ${field} excluded by its audience or transformed incorrectly.`);
+        }
+    }
+}
+function assertAudienceProjection(value, normalised, audience, currentSchema) {
+    if (currentSchema)
+        assertCurrentAudienceProjection(value, normalised, audience);
+    else
+        assertLegacyAudienceFields(value, normalised, audience);
+}
 function reportApplicationVersion(report) {
     return record(report.application)?.version;
 }
@@ -261,28 +226,6 @@ function assertCurrentReportProjection(report, rawCase) {
         throw new TypeError('The CLI case pack contains an invalid or mismatched Case report projection.');
     }
 }
-function redactedCase(record, audience) {
-    if (audience === 'internal')
-        return structuredClone(record);
-    return {
-        ...structuredClone(record),
-        status: audience === 'public' && record.status === 'resolved' && record.closures.records.length
-            ? 'reviewing'
-            : record.status,
-        brandProfileIds: audience === 'public' ? [] : [...record.brandProfileIds],
-        notes: [],
-        actions: audience === 'public' ? [] : record.actions.map((item) => ({ ...item, recipient: '[redacted]' })),
-        manualTrail: record.manualTrail.map((item) => ({ ...item, target: null })),
-        assertions: audience === 'public' ? [] : structuredClone(record.assertions),
-        observedEffects: audience === 'public'
-            ? publicObservedEffectHistory(record.observedEffects.preV13HistoryUnavailable)
-            : structuredClone(record.observedEffects),
-        closures: audience === 'public'
-            ? publicClosureHistory(record.closures.preV13HistoryUnavailable)
-            : structuredClone(record.closures),
-        branches: audience === 'public' ? [] : structuredClone(record.branches ?? []),
-    };
-}
 export function buildCliCasePack(input, options, generatedAt = new Date().toISOString()) {
     if (!options.reviewed)
         throw new CliUsageError('case-pack requires --reviewed after the audience-specific output has been checked.');
@@ -337,7 +280,7 @@ export function buildCliCasePack(input, options, generatedAt = new Date().toISOS
     catch (cause) {
         throw new CliUsageError(cause instanceof Error ? cause.message : `Case-pack schema ${CASE_SCHEMA_VERSION} input is not exact.`);
     }
-    const cases = normalised.map((item) => redactedCase(item, options.audience));
+    const cases = normalised.map((item) => projectCaseForAudience(item, options.audience));
     const brandProfileReferencesOmitted = options.audience === 'public'
         ? normalised.reduce((count, item) => count + item.brandProfileIds.length, 0)
         : 0;
@@ -346,7 +289,7 @@ export function buildCliCasePack(input, options, generatedAt = new Date().toISOS
         includeNotes: false,
         generatedAt,
     }).json);
-    const exclusions = expectedExclusions(options.audience);
+    const exclusions = caseAudienceExclusions(options.audience, CASE_SCHEMA_VERSION);
     const packet = Object.freeze({
         schema: CLI_CASE_PACK_SCHEMA,
         version: CLI_CASE_PACK_VERSION,
@@ -436,7 +379,7 @@ export function verifyCliCasePack(input) {
     const audience = packet.audience;
     if (!Number.isSafeInteger(redactionManifest.sourceCaseCount)
         || redactionManifest.sourceCaseCount !== root.cases.length
-        || !stringListsMatch(redactionManifest.excluded, expectedExclusions(audience, root.version))) {
+        || !stringListsMatch(redactionManifest.excluded, caseAudienceExclusions(audience, root.version))) {
         throw new TypeError('The CLI case pack has an invalid audience redaction manifest.');
     }
     assertCanonicalCaseIdentities(root.cases, 'The CLI case pack');
@@ -444,7 +387,8 @@ export function verifyCliCasePack(input) {
     if (normalised.length !== root.cases.length) {
         throw new TypeError('The CLI case pack contains an invalid case collection.');
     }
-    if (root.version === CASE_SCHEMA_VERSION)
+    const currentCaseSchema = root.version === CASE_SCHEMA_VERSION;
+    if (currentCaseSchema)
         assertCurrentCaseProjection(root.cases, normalised, 'The CLI case pack');
     const normalisedByDomain = new Map(normalised.map((item) => [item.domain, item]));
     const caseReferenceLists = [];
@@ -464,7 +408,10 @@ export function verifyCliCasePack(input) {
             || !normalisedByDomain.has(rawCase.domain)) {
             throw new TypeError('The CLI case pack contains an invalid or mismatched Case report.');
         }
-        assertAudienceFields(rawCase, audience);
+        const normalisedCase = normalisedByDomain.get(rawCase.domain);
+        if (!normalisedCase)
+            throw new TypeError('The CLI case pack contains an invalid Case projection.');
+        assertAudienceProjection(rawCase, normalisedCase, audience, currentCaseSchema);
         try {
             if (!Object.hasOwn(rawCase, 'brandProfileIds') || !Object.hasOwn(reportCase, 'brandProfileIds'))
                 throw new Error('missing');
@@ -474,8 +421,8 @@ export function verifyCliCasePack(input) {
         catch {
             throw new TypeError('The CLI case pack contains invalid Brand Profile references.');
         }
-        if (root.version === CASE_SCHEMA_VERSION)
-            assertCurrentReportProjection(report, rawCase);
+        if (currentCaseSchema)
+            assertCurrentReportProjection(report, normalisedCase);
     }
     const omitted = redactionManifest.brandProfileReferencesOmitted;
     if (!Object.hasOwn(redactionManifest, 'brandProfileReferencesOmitted')