@slicedearth/whoisleuth-cli 2.1.0 → 2.3.0

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

@@ -1,13 +1,10 @@
-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_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, MAX_CASES, MAX_NOTES_PER_CASE, deterministicId, caseTimestampOrNull, normalizeCase, normalizeDomain, normalizeEvidenceHistory, normalizeNotes, normalizeReviewReasonCode, normalizeTags, objectRecord, safeId, isValidDisposition, isValidSource, isValidStatus, } from "./case-record-model.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";
 import { caseInvestigationBranchReferences, mergeCaseInvestigationBranches, normalizeCaseInvestigationBranches, } from "./case-investigation-branch-model.mjs";
-import { buildCaseClosureLinkContext, mergeCaseActions, mergeCaseAssertions, mergeCaseClosureHistories, mergeCaseDecisions, mergeCaseEvidencePins, mergeCaseManualTrail, mergeCaseObservedEffectHistories, mergeCaseSightings, normalizeCaseActions, normalizeCaseAssertions, normalizeCaseClosureHistory, normalizeCaseDecisions, normalizeCaseEvidencePins, normalizeCaseManualTrail, normalizeCaseObservedEffectHistory, normalizeCaseSightings, } from "./case-response-model.mjs";
-const STATUS_VALUES = new Set(CASE_STATUSES.map((item) => item.value));
-const DISPOSITION_VALUES = new Set(CASE_DISPOSITIONS.map((item) => item.value));
-const SOURCE_VALUES = new Set(CASE_SOURCES.map((item) => item.value));
+import { buildCaseClosureLinkContext, mergeCaseActions, mergeCaseClosureHistories, mergeCaseObservedEffectHistories, MAX_CASE_ASSERTIONS, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_SIGHTINGS, normalizeCaseActions, normalizeCaseAssertions, normalizeCaseClosureHistory, normalizeCaseDecisions, normalizeCaseEvidencePins, normalizeCaseManualTrail, normalizeCaseObservedEffectHistory, normalizeCaseSightings, } from "./case-response-model.mjs";
 export const MAX_CASE_INPUT_RECORDS = 2_000;
 function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
@@ -51,7 +48,7 @@ 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 supported compatibility boundary. Exact published schemas 12 and 13 migrate 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 ${CASE_IMPORT_VERSIONS.filter((version) => version < CASE_SCHEMA_VERSION).join(', ')} 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.`);
@@ -92,6 +89,17 @@ function assertCurrentCaseShape(raw) {
             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.`);
             }
+            if (Object.keys(record).length > 0 && !Object.hasOwn(record, 'routeReviewAfter')) {
+                throw new TypeError(`Case schema ${CASE_SCHEMA_VERSION} response actions must declare their route review deadline, including null; unreleased local Case checkpoints are not interpreted as the current format and no data was changed.`);
+            }
+        }
+        const decisions = itemRecord.decisions;
+        for (const decision of Array.isArray(decisions) ? decisions : []) {
+            const record = objectRecord(decision);
+            if (Object.keys(record).length > 0
+                && (!Object.hasOwn(record, 'confidence') || !Object.hasOwn(record, 'confidenceBasis'))) {
+                throw new TypeError(`Case schema ${CASE_SCHEMA_VERSION} analyst decisions must declare confidence and its basis; unreleased local Case checkpoints are not interpreted as the current format and no data was changed.`);
+            }
         }
     }
 }
@@ -140,9 +148,6 @@ function boundedCaseList(raw) {
  * @param {string} [nowIso]
  * @returns {CaseRecord}
  */
-function importScalar(value, valid) {
-    return typeof value === 'string' && valid.has(value) ? value : undefined;
-}
 /**
  * Validates one imported record into a patch. Unlike normalizeCase, absent or
  * invalid scalar fields stay `undefined` (never defaulted) and a missing/invalid
@@ -174,6 +179,8 @@ function extractImportPatch(raw, importedVersion) {
     const pinIds = new Set(evidencePins.map((item) => item.id));
     const actions = normalizeCaseActions(record.actions, normalizedFallback, { ...timestampOptions, validEvidencePinIds: pinIds });
     const assertions = normalizeCaseAssertions(record.assertions, normalizedFallback, pinIds, timestampOptions);
+    const decisions = normalizeCaseDecisions(record.decisions, normalizedFallback, pinIds, timestampOptions);
+    const manualTrail = normalizeCaseManualTrail(record.manualTrail, normalizedFallback, timestampOptions);
     const sightings = normalizeCaseSightings(record.sightings, normalizedFallback, pinIds, timestampOptions);
     const observedEffects = normalizeCaseObservedEffectHistory(importedVersion >= 13 ? record.observedEffects : undefined, normalizedFallback, pinIds, new Set(sightings.map((item) => item.id)), timestampOptions);
     const closures = normalizeCaseClosureHistory(importedVersion >= 13 ? record.closures : undefined, normalizedFallback, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), timestampOptions, buildCaseClosureLinkContext(observedEffects, actions));
@@ -181,17 +188,26 @@ function extractImportPatch(raw, importedVersion) {
     const brandProfileReferences = importedVersion >= 12
         ? inspectCaseBrandProfileIds(record.brandProfileIds)
         : { ids: [], omitted: 0 };
+    const authoredHistoryOmitted = [
+        [record.evidencePins, evidencePins],
+        [record.decisions, decisions],
+        [record.assertions, assertions],
+        [record.manualTrail, manualTrail],
+        [record.sightings, sightings],
+    ].reduce((total, [candidates, retained]) => total
+        + Math.max(0, (Array.isArray(candidates) ? candidates.length : 0) - retained.length), 0);
     return {
         domain,
         rawId: typeof record.id === 'string' ? record.id : null,
-        status: importScalar(record.status, STATUS_VALUES),
-        disposition: importScalar(record.disposition, DISPOSITION_VALUES),
+        status: isValidStatus(record.status) ? record.status : undefined,
+        disposition: isValidDisposition(record.disposition) ? record.disposition : undefined,
         reviewReasonCode: Object.hasOwn(record, 'reviewReasonCode')
             ? normalizeReviewReasonCode(record.reviewReasonCode)
             : undefined,
         brandProfileIds: brandProfileReferences.ids,
         brandProfileReferencesOmitted: brandProfileReferences.omitted,
-        source: importScalar(record.source, SOURCE_VALUES),
+        authoredHistoryOmitted,
+        source: isValidSource(record.source) ? record.source : undefined,
         evidenceHistory: normalizeEvidenceHistory(rawEvidence, {
             source: 'import',
             fallback: importFallback,
@@ -199,10 +215,10 @@ function extractImportPatch(raw, importedVersion) {
             caseDomain: domain,
         }),
         evidencePins,
-        decisions: normalizeCaseDecisions(record.decisions, normalizedFallback, pinIds, timestampOptions),
+        decisions,
         actions,
         assertions,
-        manualTrail: normalizeCaseManualTrail(record.manualTrail, normalizedFallback, timestampOptions),
+        manualTrail,
         sightings,
         observedEffects,
         closures,
@@ -229,6 +245,22 @@ function unionNotes(a, b) {
     const notes = [...byId.values()].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
     return notes.slice(Math.max(0, notes.length - MAX_NOTES_PER_CASE));
 }
+function retainLocalAuthoredRecords(local, imported, maximum) {
+    const records = [...local];
+    const retainedIds = new Set(records.map((item) => item.id));
+    let omitted = 0;
+    for (const item of imported) {
+        if (retainedIds.has(item.id))
+            continue;
+        if (records.length >= maximum) {
+            omitted += 1;
+            continue;
+        }
+        records.push(item);
+        retainedIds.add(item.id);
+    }
+    return { records, omitted };
+}
 // Additive, deduplicated union of two evidence histories. Identical material
 // collapses (earliest firstCapturedAt, latest capturedAt), distinct snapshots
 // are retained subject to the per-case bound, and an older import can never
@@ -274,16 +306,29 @@ function caseFromPatch(patch, now) {
 function applyImportPatch(local, patch) {
     const importNewer = patch.updatedAt !== null && Date.parse(patch.updatedAt) > Date.parse(local.updatedAt);
     const fallback = patch.updatedAt || local.updatedAt;
-    const evidencePins = mergeCaseEvidencePins(local.evidencePins, patch.evidencePins, fallback);
+    const pinSelection = retainLocalAuthoredRecords(local.evidencePins, patch.evidencePins, MAX_CASE_EVIDENCE_PINS);
+    const evidencePins = normalizeCaseEvidencePins(pinSelection.records, fallback);
     const pinIds = new Set(evidencePins.map((item) => item.id));
     const actions = mergeCaseActions(local.actions, patch.actions, fallback, pinIds);
-    const assertions = mergeCaseAssertions(local.assertions, patch.assertions, fallback, pinIds);
+    const assertionSelection = retainLocalAuthoredRecords(local.assertions, patch.assertions, MAX_CASE_ASSERTIONS);
+    const assertions = normalizeCaseAssertions(assertionSelection.records, fallback, pinIds);
     const branchReferences = caseInvestigationBranchReferences({ evidencePins, actions, assertions });
-    const sightings = mergeCaseSightings(local.sightings, patch.sightings, fallback, pinIds);
+    const sightingSelection = retainLocalAuthoredRecords(local.sightings, patch.sightings, MAX_CASE_SIGHTINGS);
+    const sightings = normalizeCaseSightings(sightingSelection.records, fallback, pinIds);
     const sightingIds = new Set(sightings.map((item) => item.id));
     const observedEffects = mergeCaseObservedEffectHistories(local.observedEffects, patch.observedEffects, fallback, pinIds, sightingIds);
     const closures = mergeCaseClosureHistories(local.closures, patch.closures, fallback, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), buildCaseClosureLinkContext(observedEffects, actions));
     const brandProfileReferences = unionCaseBrandProfileIds(local.brandProfileIds, patch.brandProfileIds);
+    const decisionSelection = retainLocalAuthoredRecords(local.decisions, patch.decisions, MAX_CASE_DECISIONS);
+    const decisions = normalizeCaseDecisions(decisionSelection.records, fallback, pinIds);
+    const trailSelection = retainLocalAuthoredRecords(local.manualTrail, patch.manualTrail, MAX_CASE_MANUAL_TRAIL_EVENTS);
+    const manualTrail = normalizeCaseManualTrail(trailSelection.records, fallback);
+    const authoredHistoryOmitted = patch.authoredHistoryOmitted
+        + pinSelection.omitted
+        + decisionSelection.omitted
+        + assertionSelection.omitted
+        + trailSelection.omitted
+        + sightingSelection.omitted;
     return { record: {
             ...local,
             status: patch.status !== undefined && importNewer ? patch.status : local.status,
@@ -293,10 +338,10 @@ function applyImportPatch(local, patch) {
             source: patch.source !== undefined && importNewer ? patch.source : local.source,
             evidenceHistory: mergeEvidenceHistories(local.evidenceHistory, patch.evidenceHistory, local.domain),
             evidencePins,
-            decisions: mergeCaseDecisions(local.decisions, patch.decisions, fallback, pinIds),
+            decisions,
             actions,
             assertions,
-            manualTrail: mergeCaseManualTrail(local.manualTrail, patch.manualTrail, fallback),
+            manualTrail,
             sightings,
             observedEffects,
             closures,
@@ -305,7 +350,7 @@ function applyImportPatch(local, patch) {
             notes: unionNotes(local.notes, patch.notes),
             createdAt: patch.createdAt && Date.parse(patch.createdAt) < Date.parse(local.createdAt) ? patch.createdAt : local.createdAt,
             updatedAt: importNewer ? (patch.updatedAt ?? local.updatedAt) : local.updatedAt,
-        }, brandProfileReferencesOmitted: brandProfileReferences.omitted };
+        }, brandProfileReferencesOmitted: brandProfileReferences.omitted, authoredHistoryOmitted };
 }
 function pickFreeId(preferred, domain, used) {
     const wanted = safeId(preferred);
@@ -418,7 +463,7 @@ function caseCollectionImportEnvelope(importedRaw) {
  * reinterpreted.
  * @param {CaseRecord[]} localCases
  * @param {unknown} importedRaw
- * @returns {{ cases: CaseRecord[], added: number, updated: number, skipped: number, brandProfileReferencesOmitted: number }}
+ * @returns {{ cases: CaseRecord[], added: number, updated: number, skipped: number, brandProfileReferencesOmitted: number, authoredHistoryOmitted: number }}
  */
 export function mergeCases(localCases, importedRaw) {
     assertBoundedJsonStructure(importedRaw, 'Case import', CASE_INPUT_JSON_LIMITS);
@@ -426,7 +471,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 supported compatibility boundary. Exact published schemas 12 and 13 migrate 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 ${CASE_IMPORT_VERSIONS.filter((version) => version < CASE_SCHEMA_VERSION).join(', ')} 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.`);
@@ -446,6 +491,7 @@ export function mergeCases(localCases, importedRaw) {
     const imported = boundedCaseList(importedEnvelope);
     let skipped = imported.omitted;
     let brandProfileReferencesOmitted = 0;
+    let authoredHistoryOmitted = 0;
     const fallback = new Date(0).toISOString();
     for (const item of imported.items) {
         const patch = extractImportPatch(item, supportedImportedVersion);
@@ -458,6 +504,7 @@ export function mergeCases(localCases, importedRaw) {
             const merged = applyImportPatch(existing, patch);
             byDomain.set(patch.domain, merged.record);
             brandProfileReferencesOmitted += patch.brandProfileReferencesOmitted + merged.brandProfileReferencesOmitted;
+            authoredHistoryOmitted += merged.authoredHistoryOmitted;
             updated += 1;
         }
         else if (byDomain.size < MAX_CASES) {
@@ -466,6 +513,7 @@ export function mergeCases(localCases, importedRaw) {
             usedIds.add(record.id);
             byDomain.set(patch.domain, record);
             brandProfileReferencesOmitted += patch.brandProfileReferencesOmitted;
+            authoredHistoryOmitted += patch.authoredHistoryOmitted;
             added += 1;
         }
         else {
@@ -478,5 +526,6 @@ export function mergeCases(localCases, importedRaw) {
         updated,
         skipped,
         brandProfileReferencesOmitted,
+        authoredHistoryOmitted,
     };
 }

package/packages/cases/case-record-contracts.mjs

@@ -1,30 +1,15 @@
 import { ANALYST_REVIEW_REASONS } from "../../lib/analyst-taxonomy.mjs";
 import { CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, PUBLIC_CASE_SCHEMA_VERSION, MAX_CASE_BRAND_PROFILE_ID_CANDIDATES, MAX_CASE_BRAND_PROFILE_IDS, MAX_CASE_IMPORT_BYTES, MAX_CASE_STORE_BYTES, MAX_CASES, MAX_DOMAIN_LENGTH, MAX_EVIDENCE_CHANGES, MAX_EVIDENCE_DETAIL_LENGTH, MAX_EVIDENCE_FACTORS, MAX_EVIDENCE_MUTATIONS, MAX_EVIDENCE_NAMESERVERS, MAX_EVIDENCE_SNAPSHOTS_PER_CASE, MAX_EVIDENCE_STRING_LENGTH, MAX_EVIDENCE_TITLE_LENGTH, MAX_NOTE_LENGTH, MAX_NOTES_PER_CASE, MAX_TAG_LENGTH, MAX_TAGS_PER_CASE, } from "../contracts/case-portability.mjs";
+import { CASE_DISPOSITIONS, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_STATUS, } from "./case-record-decisions.mjs";
 export { CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, PUBLIC_CASE_SCHEMA_VERSION, MAX_CASE_BRAND_PROFILE_ID_CANDIDATES, MAX_CASE_BRAND_PROFILE_IDS, MAX_CASE_IMPORT_BYTES, MAX_CASE_STORE_BYTES, MAX_CASES, MAX_DOMAIN_LENGTH, MAX_EVIDENCE_CHANGES, MAX_EVIDENCE_DETAIL_LENGTH, MAX_EVIDENCE_FACTORS, MAX_EVIDENCE_MUTATIONS, MAX_EVIDENCE_NAMESERVERS, MAX_EVIDENCE_SNAPSHOTS_PER_CASE, MAX_EVIDENCE_STRING_LENGTH, MAX_EVIDENCE_TITLE_LENGTH, MAX_NOTE_LENGTH, MAX_NOTES_PER_CASE, MAX_TAG_LENGTH, MAX_TAGS_PER_CASE, };
-export const CASE_STATUSES = [
-    { value: 'new', label: 'New' },
-    { value: 'reviewing', label: 'Reviewing' },
-    { value: 'monitoring', label: 'Monitoring' },
-    { value: 'escalated', label: 'Escalated' },
-    { value: 'resolved', label: 'Resolved' },
-];
-export const CASE_DISPOSITIONS = [
-    { value: 'unreviewed', label: 'Unreviewed' },
-    { value: 'suspicious', label: 'Suspicious' },
-    { value: 'confirmed_abuse', label: 'Confirmed abuse' },
-    { value: 'false_positive', label: 'False positive' },
-    { value: 'expected', label: 'Expected' },
-    { value: 'closed_no_action', label: 'Closed without action' },
-];
+export { CASE_DISPOSITIONS, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_STATUS, };
 export const CASE_REVIEW_REASONS = ANALYST_REVIEW_REASONS.map((item) => ({ ...item }));
-export const CASE_SOURCES = [
+export const CASE_SOURCES = Object.freeze([
     { value: 'lookup', label: 'Lookup' },
     { value: 'bulk', label: 'Bulk' },
     { value: 'monitor', label: 'Monitor' },
     { value: 'manual', label: 'Manual' },
     { value: 'unknown', label: 'Unknown' },
-];
-export const EVIDENCE_SOURCES = ['lookup', 'bulk', 'monitor', 'import', 'unknown'];
-export const DEFAULT_STATUS = 'new';
-export const DEFAULT_DISPOSITION = 'unreviewed';
+]);
+export const EVIDENCE_SOURCES = Object.freeze(['lookup', 'bulk', 'monitor', 'import', 'unknown']);
 export const DEFAULT_SOURCE = 'unknown';

package/packages/cases/case-record-core.mjs

@@ -1,6 +1,7 @@
 // Pure, framework-neutral analyst-case records, evidence histories, bounded
 // record normalization, and analyst updates.
-import { CASE_DISPOSITIONS, CASE_SCHEMA_VERSION, CASE_REVIEW_REASONS, CASE_SOURCES, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, EVIDENCE_SOURCES, MAX_DOMAIN_LENGTH, MAX_NOTES_PER_CASE, MAX_NOTE_LENGTH, MAX_TAGS_PER_CASE, MAX_TAG_LENGTH, } from "./case-record-contracts.mjs";
+import { CASE_SCHEMA_VERSION, CASE_REVIEW_REASONS, CASE_SOURCES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, EVIDENCE_SOURCES, MAX_DOMAIN_LENGTH, MAX_NOTES_PER_CASE, MAX_NOTE_LENGTH, MAX_TAGS_PER_CASE, MAX_TAG_LENGTH, } from "./case-record-contracts.mjs";
+import { dispositionLabel, isValidDisposition, isValidStatus, statusLabel, } from "./case-record-decisions.mjs";
 import { normalizeExplicitIsoTimestamp, normalizeLegacyIsoTimestamp } from "../evidence/observation.mjs";
 import { canonicalRegistrableDomain } from "../../lib/registrable-domain.mjs";
 // Forward-version policy (two distinct guarantees):
@@ -26,13 +27,9 @@ export const EVIDENCE_SOURCE_RANK = {
     import: 1,
     unknown: 0,
 };
-const STATUS_VALUES = new Set(CASE_STATUSES.map((item) => item.value));
-const DISPOSITION_VALUES = new Set(CASE_DISPOSITIONS.map((item) => item.value));
 const REVIEW_REASON_VALUES = new Set(CASE_REVIEW_REASONS.map((item) => item.value).filter(Boolean));
 const SOURCE_VALUES = new Set(CASE_SOURCES.map((item) => item.value));
-const STATUS_LABELS = Object.fromEntries(CASE_STATUSES.map((item) => [item.value, item.label]));
-const DISPOSITION_LABELS = Object.fromEntries(CASE_DISPOSITIONS.map((item) => [item.value, item.label]));
-const SOURCE_LABELS = Object.fromEntries(CASE_SOURCES.map((item) => [item.value, item.label]));
+const SOURCE_LABELS = new Map(CASE_SOURCES.map((item) => [item.value, item.label]));
 // Availability tokens that actually assert something about the domain. Anything
 // else ('unknown', 'error', empty) is not, on its own, material evidence.
 export const CONCLUSIVE_AVAILABILITY = new Set([
@@ -59,21 +56,13 @@ export function objectRecord(value) {
         ? value
         : {};
 }
-export function statusLabel(value) {
-    return (typeof value === 'string' ? STATUS_LABELS[value] : '') || String(value || '');
-}
-export function dispositionLabel(value) {
-    return (typeof value === 'string' ? DISPOSITION_LABELS[value] : '') || String(value || '');
-}
 export function sourceLabel(value) {
-    return (typeof value === 'string' ? SOURCE_LABELS[value] : '') || String(value || '');
-}
-export function isValidStatus(value) {
-    return typeof value === 'string' && STATUS_VALUES.has(value);
+    return isValidSource(value) ? SOURCE_LABELS.get(value) : String(value || '');
 }
-export function isValidDisposition(value) {
-    return typeof value === 'string' && DISPOSITION_VALUES.has(value);
+export function isValidSource(value) {
+    return typeof value === 'string' && SOURCE_VALUES.has(value);
 }
+export { dispositionLabel, isValidDisposition, isValidStatus, statusLabel, };
 /** Fresh, safe, effectively-unique id for a brand-new local record. */
 export function makeId() {
     if (typeof globalThis.crypto?.randomUUID === 'function')
@@ -147,16 +136,16 @@ export function normalizeEvidenceHostnameForCase(value, caseDomain) {
     return canonicalRegistrableDomain(hostname) === canonicalCase ? hostname : null;
 }
 export function normalizeStatus(value) {
-    return typeof value === 'string' && STATUS_VALUES.has(value) ? value : DEFAULT_STATUS;
+    return isValidStatus(value) ? value : DEFAULT_STATUS;
 }
 export function normalizeDisposition(value) {
-    return typeof value === 'string' && DISPOSITION_VALUES.has(value) ? value : DEFAULT_DISPOSITION;
+    return isValidDisposition(value) ? value : DEFAULT_DISPOSITION;
 }
 export function normalizeReviewReasonCode(value) {
     return typeof value === 'string' && REVIEW_REASON_VALUES.has(value) ? value : null;
 }
 export function normalizeSource(value) {
-    return typeof value === 'string' && SOURCE_VALUES.has(value) ? value : DEFAULT_SOURCE;
+    return isValidSource(value) ? value : DEFAULT_SOURCE;
 }
 /** Parsed ISO string, or null when missing/invalid (used for import ordering). */
 export function isoOrNull(value) {

package/packages/cases/case-record-decisions.mjs

@@ -0,0 +1,72 @@
+// Lightweight canonical Case status and disposition definitions. Persistence,
+// portability and presentation consumers derive these identities and policies
+// without importing the wider Case record or serialisation graph.
+export const CASE_STATUSES = Object.freeze([
+    { value: 'new', label: 'New' },
+    { value: 'reviewing', label: 'Reviewing' },
+    { value: 'monitoring', label: 'Monitoring' },
+    { value: 'escalated', label: 'Escalated' },
+    { value: 'resolved', label: 'Resolved' },
+]);
+export const CASE_DISPOSITIONS = Object.freeze([
+    { value: 'unreviewed', label: 'Unreviewed' },
+    { value: 'suspicious', label: 'Suspicious' },
+    { value: 'confirmed_abuse', label: 'Confirmed abuse' },
+    { value: 'false_positive', label: 'False positive' },
+    { value: 'expected', label: 'Expected' },
+    { value: 'closed_no_action', label: 'Closed without action' },
+]);
+export const DEFAULT_STATUS = 'new';
+export const DEFAULT_DISPOSITION = 'unreviewed';
+const CASE_STATUS_OPERATION_POLICIES = Object.freeze({
+    new: { closed: false, closureRequired: false, directEdit: 'allowed' },
+    reviewing: { closed: false, closureRequired: false, directEdit: 'allowed' },
+    monitoring: { closed: false, closureRequired: false, directEdit: 'allowed' },
+    escalated: { closed: false, closureRequired: false, directEdit: 'allowed' },
+    resolved: { closed: true, closureRequired: true, directEdit: 'existing_only' },
+});
+const CASE_DISPOSITION_DECISION_POLICIES = Object.freeze({
+    unreviewed: { reviewed: false, supportsDefensiveResponse: false },
+    suspicious: { reviewed: true, supportsDefensiveResponse: true },
+    confirmed_abuse: { reviewed: true, supportsDefensiveResponse: true },
+    false_positive: { reviewed: true, supportsDefensiveResponse: false },
+    expected: { reviewed: true, supportsDefensiveResponse: false },
+    closed_no_action: { reviewed: true, supportsDefensiveResponse: false },
+});
+function statusOption(value) {
+    return CASE_STATUSES.find((option) => option.value === value);
+}
+function dispositionOption(value) {
+    return CASE_DISPOSITIONS.find((option) => option.value === value);
+}
+export function isValidStatus(value) {
+    return Boolean(statusOption(value));
+}
+export function isValidDisposition(value) {
+    return Boolean(dispositionOption(value));
+}
+export function statusLabel(value) {
+    return statusOption(value)?.label ?? String(value || '');
+}
+export function dispositionLabel(value) {
+    return dispositionOption(value)?.label ?? String(value || '');
+}
+export function caseStatusRequiresClosure(value) {
+    const option = statusOption(value);
+    return option ? CASE_STATUS_OPERATION_POLICIES[option.value].closureRequired : false;
+}
+export function caseStatusIsClosed(value) {
+    const option = statusOption(value);
+    return option ? CASE_STATUS_OPERATION_POLICIES[option.value].closed : false;
+}
+export function isReviewedCaseDisposition(value) {
+    const option = dispositionOption(value);
+    return option ? CASE_DISPOSITION_DECISION_POLICIES[option.value].reviewed : false;
+}
+export function caseDispositionSupportsDefensiveResponse(value) {
+    const option = dispositionOption(value);
+    return option ? CASE_DISPOSITION_DECISION_POLICIES[option.value].supportsDefensiveResponse : false;
+}
+export function caseStatusOptionsForDirectEdit(currentStatus) {
+    return CASE_STATUSES.filter((option) => (CASE_STATUS_OPERATION_POLICIES[option.value].directEdit === 'allowed' || option.value === currentStatus));
+}

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

@@ -6,4 +6,5 @@ export * from "./case-record-core.mjs";
 export * from "./case-brand-profile-references.mjs";
 export * from "./case-evidence-model.mjs";
 export * from "./case-record-operations.mjs";
+export * from "./case-record-projection.mjs";
 export * from "./case-investigation-branch-model.mjs";