@slicedearth/whoisleuth-cli 2.0.1 → 2.1.0

package/package.json

@@ -33,14 +33,14 @@
   "bugs": {
     "url": "https://github.com/slicedearth/whoisleuth/issues"
   },
-  "version": "2.0.1",
+  "version": "2.1.0",
   "dependencies": {
     "@peculiar/x509": "2.0.0",
     "maxmind": "5.0.7",
     "parse5": "8.0.1",
     "reflect-metadata": "0.2.2",
     "tldts": "7.4.11",
-    "undici": "8.10.0"
+    "undici": "8.10.1"
   },
   "files": [
     "bin/**/*.mjs",

package/packages/cases/case-evidence-model.mjs

@@ -413,6 +413,15 @@ export function latestCaseEvidence(record) {
     const history = record && Array.isArray(record.evidenceHistory) ? record.evidenceHistory : [];
     return history.at(-1) ?? null;
 }
+/**
+ * Returns the exact hostname from the latest retained observation when it is
+ * available. The registrable Case identity is the conservative fallback; an
+ * older hostname is never substituted for a newer observation with unknown
+ * hostname context.
+ */
+export function caseLookupTarget(record) {
+    return latestCaseEvidence(record)?.inputHostname || record.domain;
+}
 // ---------------------------------------------------------------------------
 // Material-change comparison (pure; no Svelte, DOM, or persistence access)
 // ---------------------------------------------------------------------------

package/packages/cases/case-migration-model.mjs

@@ -1,5 +1,5 @@
 import { CASE_DISPOSITIONS, CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, CASE_SOURCES, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, MAX_CASES, MAX_NOTES_PER_CASE, deterministicId, caseTimestampOrNull, normalizeCase, normalizeDomain, normalizeEvidenceHistory, normalizeNotes, normalizeReviewReasonCode, normalizeTags, objectRecord, safeId, } from "./case-record-model.mjs";
-import { CASE_REPORT_SCHEMA, caseReportVersionMatchesCase, CLI_CASE_PACK_CURRENT_REDACTION_KEYS, CLI_CASE_PACK_INTEGRITY_KEYS, CLI_CASE_PACK_LIMITATIONS, CLI_CASE_PACK_PACKET_KEYS, CLI_CASE_PACK_PUBLIC_REPORT_KEYS, CLI_CASE_PACK_REPORT_KEYS, CLI_CASE_PACK_ROOT_KEYS, CLI_CASE_PACK_SCHEMA, CLI_CASE_PACK_VERSION, } from "../contracts/case-portability.mjs";
+import { CASE_REPORT_SCHEMA, PUBLIC_CASE_SCHEMA_VERSION, caseReportVersionMatchesCase, CLI_CASE_PACK_CURRENT_REDACTION_KEYS, CLI_CASE_PACK_INTEGRITY_KEYS, CLI_CASE_PACK_LIMITATIONS, CLI_CASE_PACK_PACKET_KEYS, CLI_CASE_PACK_PUBLIC_REPORT_KEYS, CLI_CASE_PACK_REPORT_KEYS, CLI_CASE_PACK_ROOT_KEYS, CLI_CASE_PACK_SCHEMA, CLI_CASE_PACK_VERSION, } from "../contracts/case-portability.mjs";
 import { canonicalArtifactJsonV2 } from "../evidence/artifact-integrity.mjs";
 import { assertBoundedJsonStructure } from "../../lib/bounded-json.mjs";
 import { inspectCaseBrandProfileIds, unionCaseBrandProfileIds, } from "./case-brand-profile-references.mjs";
@@ -51,13 +51,13 @@ export function normalizeCaseStore(raw) {
             throw new TypeError(`Unversioned Case stores are retired. Export or reset them explicitly before using Case schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
         }
         if (!CASE_IMPORT_VERSIONS.includes(sourceVersion) && sourceVersion < CASE_SCHEMA_VERSION) {
-            throw new TypeError(`Case schema ${sourceVersion} is not part of the public compatibility boundary. Only public schema 12 migrates to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
+            throw new TypeError(`Case schema ${sourceVersion} is not part of the supported compatibility boundary. Exact published schemas 12 and 13 migrate to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
         }
         if (sourceVersion > CASE_SCHEMA_VERSION) {
             throw new TypeError(`Case schema ${sourceVersion} is newer than the supported schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
         }
         if (sourceVersion === CASE_SCHEMA_VERSION) {
-            assertCurrentEvidenceHostnameShape(raw);
+            assertCurrentCaseShape(raw);
         }
     }
     const byDomain = new Map();
@@ -76,17 +76,23 @@ export function normalizeCaseStore(raw) {
     assignUniqueIds(cases);
     return { version: CASE_SCHEMA_VERSION, cases };
 }
-function assertCurrentEvidenceHostnameShape(raw) {
+function assertCurrentCaseShape(raw) {
     for (const item of boundedCaseList(raw).items) {
-        const evidenceHistory = objectRecord(item).evidenceHistory;
-        if (!Array.isArray(evidenceHistory))
-            continue;
-        for (const snapshot of evidenceHistory) {
+        const itemRecord = objectRecord(item);
+        const evidenceHistory = itemRecord.evidenceHistory;
+        for (const snapshot of Array.isArray(evidenceHistory) ? evidenceHistory : []) {
             const record = objectRecord(snapshot);
             if (Object.keys(record).length > 0 && !Object.hasOwn(record, 'inputHostname')) {
                 throw new TypeError(`Case schema ${CASE_SCHEMA_VERSION} evidence snapshots must declare their exact submitted hostname, including null; unreleased local Case checkpoints are not interpreted as the v2 format and no data was changed.`);
             }
         }
+        const actions = itemRecord.actions;
+        for (const action of Array.isArray(actions) ? actions : []) {
+            const record = objectRecord(action);
+            if (Object.keys(record).length > 0 && !Object.hasOwn(record, 'routeObservedAt')) {
+                throw new TypeError(`Case schema ${CASE_SCHEMA_VERSION} response actions must declare their route observation time, including null; unreleased local Case checkpoints are not interpreted as the current format and no data was changed.`);
+            }
+        }
     }
 }
 /**
@@ -388,7 +394,7 @@ function caseCollectionImportEnvelope(importedRaw) {
     }
     for (const reportValue of reports) {
         const report = objectRecord(reportValue);
-        assertOnlyEnvelopeKeys(report, rootVersion === CASE_SCHEMA_VERSION ? CLI_CASE_PACK_REPORT_KEYS : CLI_CASE_PACK_PUBLIC_REPORT_KEYS, 'CLI Case-pack report');
+        assertOnlyEnvelopeKeys(report, rootVersion === PUBLIC_CASE_SCHEMA_VERSION ? CLI_CASE_PACK_PUBLIC_REPORT_KEYS : CLI_CASE_PACK_REPORT_KEYS, 'CLI Case-pack report');
         if (report.schema !== CASE_REPORT_SCHEMA
             || !caseReportVersionMatchesCase(rootVersion, report.schemaVersion)
             || report.generatedAt !== root.exportedAt) {
@@ -420,7 +426,7 @@ export function mergeCases(localCases, importedRaw) {
     const importedVersion = parseStoreVersion(importedEnvelope);
     if (importedVersion !== null && Number.isSafeInteger(importedVersion) && importedVersion < CASE_SCHEMA_VERSION
         && !CASE_IMPORT_VERSIONS.includes(importedVersion)) {
-        throw new Error(`Case schema ${importedVersion} is not part of the public compatibility boundary. Only public schema 12 migrates to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
+        throw new Error(`Case schema ${importedVersion} is not part of the supported compatibility boundary. Exact published schemas 12 and 13 migrate to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
     }
     if (importedVersion !== null && Number.isSafeInteger(importedVersion) && importedVersion > CASE_SCHEMA_VERSION) {
         throw new Error(`Case schema ${importedVersion} is newer than the supported schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
@@ -430,7 +436,7 @@ export function mergeCases(localCases, importedRaw) {
         throw new Error(`Expected a well-formed WHOISleuth Case export using schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
     }
     if (importedVersion === CASE_SCHEMA_VERSION)
-        assertCurrentEvidenceHostnameShape(importedEnvelope);
+        assertCurrentCaseShape(importedEnvelope);
     const local = normalizeCaseStore(localCases).cases;
     const supportedImportedVersion = importedVersion ?? 0;
     const byDomain = new Map(local.map((item) => [item.domain, item]));

package/packages/cases/case-response-model.mjs

@@ -2,7 +2,7 @@
 // deliberately separate from collected evidence snapshots: a pin describes a
 // fact selected by an analyst, a decision records analyst reasoning, and an
 // action records a reviewed external or internal follow-up.
-import { MAX_ASSERTION_PROVENANCE_LABELS, MAX_ASSERTION_PROVENANCE_MARKINGS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_CHECKPOINT_FACTS, MAX_CASE_CLOSURES, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_CASE_SIGHTINGS, MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_VALUE_LENGTH, MAX_TRAIL_TARGET_LENGTH, } from "../contracts/case-portability.mjs";
+import { MAX_ASSERTION_PROVENANCE_LABELS, MAX_ASSERTION_PROVENANCE_MARKINGS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_CHECKPOINT_FACTS, MAX_CASE_CLOSURES, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_CASE_SIGHTINGS, MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_VALUE_LENGTH, MAX_TRAIL_TARGET_LENGTH, CASE_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
 import { normalizeExplicitIsoTimestamp, normalizeLegacyIsoTimestamp } from "../evidence/observation.mjs";
 export { MAX_ASSERTION_PROVENANCE_LABELS, MAX_ASSERTION_PROVENANCE_MARKINGS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_CHECKPOINT_FACTS, MAX_CASE_CLOSURES, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_CASE_SIGHTINGS, MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_VALUE_LENGTH, MAX_TRAIL_TARGET_LENGTH, };
 export const CASE_EVIDENCE_RELATION_STANCES = ['supports', 'contradicts', 'unresolved'];
@@ -118,8 +118,8 @@ const SIGHTING_CATEGORIES = new Set(CASE_SIGHTING_CATEGORIES);
 const SHA256_RE = /^[a-f0-9]{64}$/u;
 function currentActionNormalizationOptions(validEvidencePinIds) {
     return validEvidencePinIds
-        ? { sourceVersion: 13, validEvidencePinIds }
-        : { sourceVersion: 13 };
+        ? { sourceVersion: CASE_SCHEMA_VERSION, validEvidencePinIds }
+        : { sourceVersion: CASE_SCHEMA_VERSION };
 }
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
@@ -668,6 +668,9 @@ function normalizeAction(raw, fallback, options = {}) {
             : 'internal_review',
         recipient,
         contactSource: text(item.contactSource, MAX_RESPONSE_LABEL_LENGTH) || 'analyst_supplied',
+        routeObservedAt: options.sourceVersion != null && options.sourceVersion < 14
+            ? null
+            : optionalIso(item.routeObservedAt, options),
         contactLimitations: limitations(item.contactLimitations),
         dueAt: optionalIso(item.dueAt, options),
         state: history.state,
@@ -699,7 +702,7 @@ function mergeNormalizedActions(left, right, fallback) {
         history: [...left.history, ...right.history],
         historyOmitted: Math.max(left.historyOmitted, right.historyOmitted),
         historyLimitations: [...left.historyLimitations, ...right.historyLimitations],
-    }, fallback, { sourceVersion: 13 });
+    }, fallback, { sourceVersion: CASE_SCHEMA_VERSION });
 }
 function boundActionCollection(actions, fallback) {
     const keep = new Set();
@@ -719,7 +722,7 @@ function boundActionCollection(actions, fallback) {
     let bounded = actions.map((action) => {
         const history = action.history.filter((event) => keep.has(`${action.id}\u0000${event.id}`));
         const omitted = action.historyOmitted + action.history.length - history.length;
-        return normalizeAction({ ...action, history, historyOmitted: omitted }, fallback, { sourceVersion: 13 });
+        return normalizeAction({ ...action, history, historyOmitted: omitted }, fallback, { sourceVersion: CASE_SCHEMA_VERSION });
     });
     while (bytes(bounded) > MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE) {
         const candidate = bounded
@@ -734,7 +737,7 @@ function boundActionCollection(actions, fallback) {
                 ...action,
                 history: action.history.filter((event) => event.id !== candidate.event.id),
                 historyOmitted: action.historyOmitted + 1,
-            }, fallback, { sourceVersion: 13 }));
+            }, fallback, { sourceVersion: CASE_SCHEMA_VERSION }));
     }
     if (bytes(bounded) > MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE && bounded.length > 1) {
         const byteOmissionPattern = /^(\d+) earlier response actions? omitted by the per-Case response-history byte bound\.$/u;
@@ -859,10 +862,10 @@ export function appendCaseAction(current, raw, now) {
         historyOmitted: 0,
         createdAt: now,
         metadataUpdatedAt: now,
-    }, now, { sourceVersion: 13 });
+    }, now, { sourceVersion: CASE_SCHEMA_VERSION });
     if (!created)
         throw new Error('An action requires a recipient or internal owner.');
-    return normalizeCaseActions([...current, created], now, { sourceVersion: 13 });
+    return normalizeCaseActions([...current, created], now, { sourceVersion: CASE_SCHEMA_VERSION });
 }
 export function appendCaseActionTransition(current, actionId, raw, now, validPinIds) {
     const action = current.find((item) => item.id === actionId);
@@ -927,6 +930,7 @@ export function updateCaseAction(current, raw, now, validPinIds) {
         type: Object.hasOwn(patch, 'type') ? patch.type : existing.type,
         recipient: Object.hasOwn(patch, 'recipient') ? patch.recipient : existing.recipient,
         contactSource: Object.hasOwn(patch, 'contactSource') ? patch.contactSource : existing.contactSource,
+        routeObservedAt: Object.hasOwn(patch, 'routeObservedAt') ? patch.routeObservedAt : existing.routeObservedAt,
         contactLimitations: Object.hasOwn(patch, 'contactLimitations') ? patch.contactLimitations : existing.contactLimitations,
         dueAt: Object.hasOwn(patch, 'dueAt') ? patch.dueAt : existing.dueAt,
         followUpAt: Object.hasOwn(patch, 'followUpAt') ? patch.followUpAt : existing.followUpAt,
@@ -940,7 +944,7 @@ export function updateCaseAction(current, raw, now, validPinIds) {
     let updated = normalizeAction(metadata, now, currentActionNormalizationOptions(validPinIds));
     if (!updated)
         throw new Error('An action requires a recipient or internal owner.');
-    const materialChanged = ['type', 'recipient', 'contactSource', 'contactLimitations', 'originActionId']
+    const materialChanged = ['type', 'recipient', 'contactSource', 'routeObservedAt', 'contactLimitations', 'originActionId']
         .some((key) => Object.hasOwn(patch, key) && JSON.stringify(record(existing)[key]) !== JSON.stringify(record(updated)[key]));
     if (materialChanged && ['submitted', 'acknowledged', 'terminal'].includes(existing.state)) {
         throw new Error('Submitted or terminal action identity and recipient metadata cannot be rewritten; create a linked follow-on action instead.');