@slicedearth/whoisleuth-cli 1.43.0 → 1.47.4

package/frontend/src/lib/analysis/bulk-session-model.js

@@ -4,8 +4,8 @@
 import { normalizeDomain } from "./case-model.js";
 import { normalizeCaaCritical } from "./dns-record-normalization.js";
 export const BULK_SESSION_SCHEMA = 'whoisleuth.bulk-sessions';
-export const BULK_SESSION_SCHEMA_VERSION = 3;
-export const SUPPORTED_BULK_SESSION_SCHEMA_VERSIONS = Object.freeze([1, 2, BULK_SESSION_SCHEMA_VERSION]);
+export const BULK_SESSION_SCHEMA_VERSION = 4;
+export const SUPPORTED_BULK_SESSION_SCHEMA_VERSIONS = Object.freeze([1, 2, 3, BULK_SESSION_SCHEMA_VERSION]);
 export const MAX_BULK_SESSIONS = 10;
 export const MAX_BULK_SESSION_ROWS = 2_000;
 export const MAX_BULK_SESSION_STORE_BYTES = 4 * 1024 * 1024;
@@ -13,6 +13,11 @@ export const MAX_BULK_SESSION_NAME_LENGTH = 100;
 export const MAX_BULK_SESSION_TEXT_LENGTH = 500;
 export const MAX_BULK_SESSION_ARRAY_VALUES = 100;
 export const MAX_BULK_SESSION_SOURCES = 12;
+export const MAX_BULK_PROFILE_CONTEXT_LIMITATION_LENGTH = 300;
+export const BULK_PROFILE_CONTEXT_UNAVAILABLE_LIMITATION = 'Brand Profile context was unavailable when this row was evaluated. Trust, profile matches, and the profile-dependent Risk assessment remain inconclusive.';
+export const BULK_PROFILE_CONTEXT_LEGACY_LIMITATION = 'This legacy Bulk row did not retain profile-context provenance. Trust, profile matches, and the potentially profile-influenced Risk assessment are withheld until the domain is rescanned.';
+export const BULK_PROFILE_CONTEXT_MISMATCH_LIMITATION = 'This saved Bulk row was evaluated with a different or unreadable Brand Profile context. Profile-derived conclusions and the Risk assessment are withheld until the domain is rescanned.';
+export const BULK_PROFILE_CONTEXT_IMPORTED_LIMITATION = 'This row came from a portable import whose claimed Brand Profile identity and revision cannot authenticate profile-derived conclusions. Trust, profile matches, and the potentially profile-influenced Risk assessment are withheld until the domain is rescanned locally.';
 const CONTROL_RE = /[\x00-\x1f\x7f]/u;
 const SAFE_ID_RE = /^[A-Za-z0-9_-]{1,128}$/u;
 const DIGEST_RE = /^sha256:[a-f0-9]{64}$/u;
@@ -49,6 +54,74 @@ function timestamp(value, fallback = null) {
     const text = boundedText(value, 64);
     return text && Number.isFinite(Date.parse(text)) ? new Date(text).toISOString() : fallback;
 }
+function profileContextLimitation(value, fallback) {
+    return boundedText(value, MAX_BULK_PROFILE_CONTEXT_LIMITATION_LENGTH) || fallback;
+}
+export function unavailableBulkProfileContext(limitation = BULK_PROFILE_CONTEXT_UNAVAILABLE_LIMITATION) {
+    return {
+        sourceState: 'unavailable',
+        activeProfileId: null,
+        profileUpdatedAt: null,
+        limitation: profileContextLimitation(limitation, BULK_PROFILE_CONTEXT_UNAVAILABLE_LIMITATION),
+    };
+}
+export function bulkProfileContextProvenance(sourceState, profileRaw) {
+    if (sourceState !== 'ready')
+        return unavailableBulkProfileContext();
+    if (profileRaw === null || profileRaw === undefined) {
+        return { sourceState: 'ready', activeProfileId: null, profileUpdatedAt: null, limitation: '' };
+    }
+    const profile = record(profileRaw);
+    const activeProfileId = typeof profile?.id === 'string' && SAFE_ID_RE.test(profile.id) ? profile.id : null;
+    const profileUpdatedAt = timestamp(profile?.updatedAt);
+    return activeProfileId && profileUpdatedAt
+        ? { sourceState: 'ready', activeProfileId, profileUpdatedAt, limitation: '' }
+        : unavailableBulkProfileContext('The active Brand Profile identity or revision was invalid when this row was evaluated. Profile-derived conclusions and the Risk assessment remain inconclusive.');
+}
+export function normalizeBulkProfileContext(value, fallbackLimitation = BULK_PROFILE_CONTEXT_UNAVAILABLE_LIMITATION) {
+    const item = record(value);
+    const sourceState = item?.sourceState;
+    if (sourceState === 'ready') {
+        if (item?.activeProfileId === null && item.profileUpdatedAt === null) {
+            return { sourceState: 'ready', activeProfileId: null, profileUpdatedAt: null, limitation: '' };
+        }
+        const activeProfileId = typeof item?.activeProfileId === 'string' && SAFE_ID_RE.test(item.activeProfileId)
+            ? item.activeProfileId
+            : null;
+        const profileUpdatedAt = timestamp(item?.profileUpdatedAt);
+        if (activeProfileId && profileUpdatedAt) {
+            return { sourceState: 'ready', activeProfileId, profileUpdatedAt, limitation: '' };
+        }
+    }
+    if (sourceState === 'mixed') {
+        return {
+            sourceState: 'mixed',
+            activeProfileId: null,
+            profileUpdatedAt: null,
+            limitation: profileContextLimitation(item?.limitation, 'Rows in this saved Bulk session were evaluated under more than one Brand Profile context. Review each row provenance before comparison.'),
+        };
+    }
+    return unavailableBulkProfileContext(profileContextLimitation(item?.limitation, fallbackLimitation));
+}
+function sameProfileContext(left, right) {
+    return left.sourceState === right.sourceState
+        && left.activeProfileId === right.activeProfileId
+        && left.profileUpdatedAt === right.profileUpdatedAt
+        && left.limitation === right.limitation;
+}
+export function summarizeBulkProfileContexts(rows) {
+    const first = rows[0]?.profileContext;
+    if (!first)
+        return unavailableBulkProfileContext('This saved Bulk session contains no settled row with profile-context provenance.');
+    if (rows.every((row) => sameProfileContext(first, row.profileContext)))
+        return { ...first };
+    return {
+        sourceState: 'mixed',
+        activeProfileId: null,
+        profileUpdatedAt: null,
+        limitation: 'Rows in this saved Bulk session were evaluated under more than one Brand Profile context. Review each row provenance before comparison.',
+    };
+}
 function nullableBoolean(value) {
     return typeof value === 'boolean' ? value : null;
 }
@@ -208,14 +281,37 @@ export function normalizeBulkComparisonEvidence(value) {
         },
     };
 }
-export function normalizeBulkSessionResult(value) {
+export function normalizeBulkSessionResult(value, sourceVersion = BULK_SESSION_SCHEMA_VERSION) {
     const item = record(value);
     const domain = normalizeDomain(item?.domain);
     const status = boundedText(item?.status, 20);
     const scanDepth = boundedText(item?.scanDepth, 10);
     if (!item || !domain || !RESULT_STATES.has(status) || !MODES.has(scanDepth))
         return null;
+    const rawProfileContext = record(item.profileContext);
+    if (sourceVersion >= 4
+        && (!rawProfileContext || !['ready', 'unavailable'].includes(String(rawProfileContext.sourceState))))
+        return null;
+    const profileContext = sourceVersion >= 4
+        ? normalizeBulkProfileContext(rawProfileContext)
+        : unavailableBulkProfileContext(BULK_PROFILE_CONTEXT_LEGACY_LIMITATION);
+    if (sourceVersion >= 4 && rawProfileContext?.sourceState === 'ready' && profileContext.sourceState !== 'ready')
+        return null;
+    const profileContextReady = profileContext.sourceState === 'ready';
     const trusted = boundedText(item.trusted, 20);
+    const relationship = normalizeRelationship(item.relationship);
+    const readyWithoutActiveProfile = profileContextReady && profileContext.activeProfileId === null;
+    const impossibleNoProfileClaim = readyWithoutActiveProfile && (TRUST_STATES.has(trusted)
+        || item.faviconMatch === true
+        || item.faviconNearMatch === true
+        || item.reusesOfficialAssets === true
+        || item.idnReferenceMatch === true
+        || item.pageBaselineMatch === true
+        || item.hasActiveBrandProfile === true
+        || relationship.officialAssetHosts.length > 0);
+    const profileClaimsUsable = profileContextReady && !impossibleNoProfileClaim;
+    if (!profileClaimsUsable || readyWithoutActiveProfile)
+        relationship.officialAssetHosts = [];
     return {
         domain,
         status: status,
@@ -223,10 +319,10 @@ export function normalizeBulkSessionResult(value) {
         confidence: boundedText(item.confidence, 40) || 'unknown',
         registrar: boundedText(item.registrar, 300) || '—',
         activity: boundedText(item.activity, 300) || '—',
-        risk: nullableScore(item.risk),
+        risk: profileClaimsUsable ? nullableScore(item.risk) : null,
         opportunity: nullableScore(item.opportunity),
         mutationTypes: boundedStrings(item.mutationTypes, 40),
-        trusted: TRUST_STATES.has(trusted) ? trusted : null,
+        trusted: profileClaimsUsable && !readyWithoutActiveProfile && TRUST_STATES.has(trusted) ? trusted : null,
         error: boundedText(item.error),
         scanDepth: scanDepth,
         createdDate: boundedText(item.createdDate, 64) || null,
@@ -241,26 +337,27 @@ export function normalizeBulkSessionResult(value) {
         pageTitle: boundedText(item.pageTitle, 300) || null,
         faviconHash: nullableHash(item.faviconHash, HASH_64_RE),
         faviconPHash: nullableHash(item.faviconPHash, PHASH_RE),
-        faviconMatch: item.faviconMatch === true,
-        faviconNearMatch: item.faviconNearMatch === true,
-        reusesOfficialAssets: item.reusesOfficialAssets === true,
+        faviconMatch: profileClaimsUsable ? nullableBoolean(item.faviconMatch) : null,
+        faviconNearMatch: profileClaimsUsable ? nullableBoolean(item.faviconNearMatch) : null,
+        reusesOfficialAssets: profileClaimsUsable ? nullableBoolean(item.reusesOfficialAssets) : null,
         hasPasswordField: item.hasPasswordField === true,
         hasExternalFormAction: nullableBoolean(item.hasExternalFormAction),
         phishingLanguageMatch: boundedText(item.phishingLanguageMatch, 300) || null,
-        idnReferenceMatch: nullableBoolean(item.idnReferenceMatch),
-        pageBaselineMatch: nullableBoolean(item.pageBaselineMatch),
-        hasActiveBrandProfile: nullableBoolean(item.hasActiveBrandProfile),
-        riskModelVersion: nullableVersion(item.riskModelVersion),
+        idnReferenceMatch: profileClaimsUsable ? nullableBoolean(item.idnReferenceMatch) : null,
+        pageBaselineMatch: profileClaimsUsable ? nullableBoolean(item.pageBaselineMatch) : null,
+        hasActiveBrandProfile: profileClaimsUsable ? nullableBoolean(item.hasActiveBrandProfile) : null,
+        riskModelVersion: profileClaimsUsable ? nullableVersion(item.riskModelVersion) : null,
         opportunityModelVersion: nullableVersion(item.opportunityModelVersion),
-        riskFactors: normalizeRiskFactors(item.riskFactors),
+        riskFactors: profileClaimsUsable ? normalizeRiskFactors(item.riskFactors) : [],
         dns: normalizeDns(item.dns),
         dnssec: boundedText(item.dnssec, 40) || null,
         comparisonEvidence: normalizeBulkComparisonEvidence(item.comparisonEvidence),
-        relationship: normalizeRelationship(item.relationship),
+        relationship,
         sourceCoverage: normalizeSourceCoverage(item.sourceCoverage),
+        profileContext,
     };
 }
-export function normalizeBulkSession(value) {
+export function normalizeBulkSession(value, sourceVersion = BULK_SESSION_SCHEMA_VERSION) {
     const item = record(value);
     const id = boundedText(item?.id, 128);
     const name = boundedText(item?.name, MAX_BULK_SESSION_NAME_LENGTH);
@@ -282,18 +379,33 @@ export function normalizeBulkSession(value) {
     const domains = domainList(item.domains);
     if (!domains.length)
         return null;
+    if (sourceVersion >= 4 && !Array.isArray(item.results))
+        return null;
     const allowed = new Set(domains);
     const results = [];
     const seen = new Set();
     for (const candidate of Array.isArray(item.results) ? item.results.slice(0, MAX_BULK_SESSION_ROWS * 2) : []) {
-        const result = normalizeBulkSessionResult(candidate);
-        if (!result || !allowed.has(result.domain) || seen.has(result.domain))
+        const result = normalizeBulkSessionResult(candidate, sourceVersion);
+        if (!result || !allowed.has(result.domain) || seen.has(result.domain)) {
+            if (sourceVersion >= 4)
+                return null;
             continue;
+        }
         seen.add(result.domain);
         results.push(result);
-        if (results.length >= MAX_BULK_SESSION_ROWS)
+        if (sourceVersion < 4 && results.length >= MAX_BULK_SESSION_ROWS)
             break;
     }
+    if (sourceVersion >= 4 && ((state === 'complete') !== (results.length === domains.length)))
+        return null;
+    const profileContext = summarizeBulkProfileContexts(results);
+    if (sourceVersion >= 4) {
+        if (!record(item.profileContext))
+            return null;
+        const declaredProfileContext = normalizeBulkProfileContext(item.profileContext);
+        if (!sameProfileContext(declaredProfileContext, profileContext))
+            return null;
+    }
     return {
         id,
         name,
@@ -305,6 +417,7 @@ export function normalizeBulkSession(value) {
         startedAt,
         updatedAt,
         completedAt,
+        profileContext,
     };
 }
 export function bulkSessionStoreVersion(raw) {
@@ -315,6 +428,10 @@ export function bulkSessionStoreVersion(raw) {
 }
 export function normalizeBulkSessionStore(raw) {
     const value = record(raw);
+    const sourceVersion = value?.schema === BULK_SESSION_SCHEMA
+        && SUPPORTED_BULK_SESSION_SCHEMA_VERSIONS.includes(Number(value.version))
+        ? Number(value.version)
+        : null;
     const candidates = Array.isArray(raw)
         ? raw
         : value?.schema === BULK_SESSION_SCHEMA
@@ -324,7 +441,17 @@ export function normalizeBulkSessionStore(raw) {
             : [];
     const byId = new Map();
     for (const candidate of candidates.slice(0, MAX_BULK_SESSIONS * 4)) {
-        const session = normalizeBulkSession(candidate);
+        const candidateRecord = record(candidate);
+        const resultRecords = Array.isArray(candidateRecord?.results)
+            ? candidateRecord.results.map(record).filter((item) => Boolean(item))
+            : [];
+        const whollyUnversionedLegacy = Array.isArray(raw)
+            && !Object.hasOwn(candidateRecord ?? {}, 'profileContext')
+            && resultRecords.every((item) => !Object.hasOwn(item, 'profileContext'));
+        const candidateVersion = Array.isArray(raw)
+            ? whollyUnversionedLegacy ? 3 : BULK_SESSION_SCHEMA_VERSION
+            : sourceVersion ?? BULK_SESSION_SCHEMA_VERSION;
+        const session = normalizeBulkSession(candidate, candidateVersion);
         if (!session)
             continue;
         const existing = byId.get(session.id);
@@ -389,12 +516,22 @@ export function deleteBulkSession(raw, idRaw) {
 function sourceStateMap(value) {
     return new Map(value.sourceCoverage.map((item) => [item.source, item.state]));
 }
+function comparableRisk(previous, current) {
+    return previous.profileContext.sourceState === 'ready'
+        && current.profileContext.sourceState === 'ready'
+        && sameProfileContext(previous.profileContext, current.profileContext)
+        && previous.risk !== null
+        && current.risk !== null
+        && previous.riskModelVersion !== null
+        && previous.riskModelVersion === current.riskModelVersion;
+}
 function resultChanges(previous, current) {
     const changes = [];
     if (previous.availability !== current.availability)
         changes.push(`Registration: ${previous.availability} → ${current.availability}`);
-    if (previous.risk !== current.risk)
+    if (comparableRisk(previous, current) && previous.risk !== current.risk) {
         changes.push(`Risk: ${previous.risk ?? 'unavailable'} → ${current.risk ?? 'unavailable'}`);
+    }
     if (previous.registrar !== current.registrar)
         changes.push(`Registrar: ${previous.registrar} → ${current.registrar}`);
     if (previous.activity !== current.activity)
@@ -429,6 +566,7 @@ export function compareBulkSessions(baselineRaw, currentRaw) {
     const before = new Map(baseline.results.map((result) => [result.domain, result]));
     const after = new Map(current.results.map((result) => [result.domain, result]));
     const rows = [];
+    let riskIncomparable = false;
     let added = 0;
     let removed = 0;
     let unchanged = 0;
@@ -444,6 +582,8 @@ export function compareBulkSessions(baselineRaw, currentRaw) {
             rows.push({ domain, changes: ['Absent from the later settled result set.'] });
         }
         else {
+            if (!comparableRisk(previous, next))
+                riskIncomparable = true;
             const changes = resultChanges(previous, next);
             if (changes.length)
                 rows.push({ domain, changes });
@@ -463,6 +603,9 @@ export function compareBulkSessions(baselineRaw, currentRaw) {
             'This compares compact saved observations, not historical provider data or raw source payloads.',
             'A source-state change may reflect collection availability rather than a change to the domain.',
             'A missing row means it was not completed in that saved session; it does not establish domain removal.',
+            ...(riskIncomparable
+                ? ['Risk deltas are omitted unless both rows retain the same ready Brand Profile provenance and the same versioned Risk model.']
+                : []),
         ],
     };
 }
@@ -494,21 +637,44 @@ export function mergeBulkSessions(localRaw, importedRaw) {
     let added = 0;
     let updated = 0;
     let skipped = 0;
+    const importedVersion = Number(imported.version);
     for (const candidate of imported.sessions.slice(0, MAX_BULK_SESSIONS * 4)) {
-        const session = normalizeBulkSession(candidate);
+        const normalized = normalizeBulkSession(candidate, importedVersion);
+        if (!normalized) {
+            skipped += 1;
+            continue;
+        }
+        const importedProfileContext = unavailableBulkProfileContext(BULK_PROFILE_CONTEXT_IMPORTED_LIMITATION);
+        const quarantinedResults = normalized.results.map((result) => ({
+            ...result,
+            risk: null,
+            trusted: null,
+            faviconMatch: null,
+            faviconNearMatch: null,
+            reusesOfficialAssets: null,
+            idnReferenceMatch: null,
+            pageBaselineMatch: null,
+            hasActiveBrandProfile: null,
+            riskModelVersion: null,
+            riskFactors: [],
+            relationship: { ...result.relationship, officialAssetHosts: [] },
+            profileContext: importedProfileContext,
+        }));
+        const session = normalizeBulkSession({
+            ...normalized,
+            results: quarantinedResults,
+            profileContext: summarizeBulkProfileContexts(quarantinedResults),
+        });
         if (!session) {
             skipped += 1;
             continue;
         }
         const existing = sessions.find((item) => item.id === session.id);
-        if (!existing)
-            added += 1;
-        else if (existing.updatedAt !== session.updatedAt)
-            updated += 1;
-        else {
+        if (existing) {
             skipped += 1;
             continue;
         }
+        added += 1;
         sessions = upsertBulkSession(sessions, session).sessions;
     }
     const bounded = enforceBulkSessionStoreBudget({

package/frontend/src/lib/analysis/bulk-sort.js

@@ -1,3 +1,7 @@
+/** Opportunity remains a retained data/export field, but is no longer a Bulk presentation sort. */
+export function normalizeBulkPresentationSortKey(key) {
+    return key === 'opportunity' ? 'risk' : key;
+}
 const CONFIDENCE_RANK = {
     low: 0,
     medium: 1,

package/frontend/src/lib/analysis/case-brand-profile-references.js

@@ -0,0 +1,85 @@
+import { MAX_CASE_BRAND_PROFILE_ID_CANDIDATES, MAX_CASE_BRAND_PROFILE_IDS, } from "./case-record-contracts.js";
+import { normalizeOpaqueReferenceId } from "./opaque-reference-id.js";
+/**
+ * Reads an untrusted stored or imported reference list without repairing any
+ * identifier. At most 32 candidates are inspected and at most eight unique,
+ * exact identifiers are retained.
+ */
+export function inspectCaseBrandProfileIds(value) {
+    if (!Array.isArray(value))
+        return { ids: [], omitted: 0 };
+    const ids = [];
+    const seen = new Set();
+    let omitted = Math.max(0, value.length - MAX_CASE_BRAND_PROFILE_ID_CANDIDATES);
+    for (const candidate of value.slice(0, MAX_CASE_BRAND_PROFILE_ID_CANDIDATES)) {
+        const id = normalizeOpaqueReferenceId(candidate);
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        if (ids.length < MAX_CASE_BRAND_PROFILE_IDS)
+            ids.push(id);
+        else
+            omitted += 1;
+    }
+    return { ids, omitted };
+}
+/** Current-store recovery is bounded and lenient, but never repairs ids. */
+export function normalizeCaseBrandProfileIds(value) {
+    return inspectCaseBrandProfileIds(value).ids;
+}
+/** Explicit analyst edits replace the complete set and fail closed. */
+export function assertCaseBrandProfileIds(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Brand Profile associations must be an array of opaque identifiers.');
+    }
+    if (value.length > MAX_CASE_BRAND_PROFILE_IDS) {
+        throw new Error(`Each case is limited to ${MAX_CASE_BRAND_PROFILE_IDS} Brand Profile associations.`);
+    }
+    const ids = [];
+    const seen = new Set();
+    for (const candidate of value) {
+        const id = normalizeOpaqueReferenceId(candidate);
+        if (!id)
+            throw new Error('A Brand Profile association identifier is invalid.');
+        if (seen.has(id))
+            throw new Error('Brand Profile association identifiers must be unique.');
+        seen.add(id);
+        ids.push(id);
+    }
+    return ids;
+}
+/** Add one exact association without accepting a stale whole-list snapshot. */
+export function addCaseBrandProfileId(value, profileId) {
+    const ids = assertCaseBrandProfileIds(value);
+    const [id] = assertCaseBrandProfileIds([profileId]);
+    if (!id || ids.includes(id))
+        return [...ids];
+    if (ids.length >= MAX_CASE_BRAND_PROFILE_IDS) {
+        throw new Error(`Each case is limited to ${MAX_CASE_BRAND_PROFILE_IDS} Brand Profile associations.`);
+    }
+    return [...ids, id];
+}
+/** Remove one exact association while preserving every unrelated reference. */
+export function removeCaseBrandProfileId(value, profileId) {
+    const ids = assertCaseBrandProfileIds(value);
+    const [id] = assertCaseBrandProfileIds([profileId]);
+    return id ? ids.filter((candidate) => candidate !== id) : [...ids];
+}
+/** Import unions are existing-first so omission can never clear a local ref. */
+export function unionCaseBrandProfileIds(existingValue, importedValue) {
+    const existing = normalizeCaseBrandProfileIds(existingValue);
+    const imported = normalizeCaseBrandProfileIds(importedValue);
+    const ids = [...existing];
+    const seen = new Set(ids);
+    let omitted = 0;
+    for (const id of imported) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        if (ids.length < MAX_CASE_BRAND_PROFILE_IDS)
+            ids.push(id);
+        else
+            omitted += 1;
+    }
+    return { ids, omitted };
+}

package/frontend/src/lib/analysis/case-evidence-model.js

@@ -2,7 +2,7 @@
 // record normalization, and analyst updates.
 import { normalizeHttpSummary } from "./http-summary.js";
 import { normalizeOpportunityModelVersion, normalizeRiskModelVersion } from "./scoring.js";
-import { CASE_DISPOSITIONS, CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, CASE_SOURCES, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, EVIDENCE_SOURCES, MAX_CASES, MAX_CASE_IMPORT_BYTES, MAX_CASE_STORE_BYTES, 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_NOTES_PER_CASE, MAX_NOTE_LENGTH, MAX_TAGS_PER_CASE, MAX_TAG_LENGTH, } from "./case-record-contracts.js";
+import { 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, } from "./case-record-contracts.js";
 import { CONCLUSIVE_AVAILABILITY, DEFAULT_EVIDENCE_SOURCE, EVIDENCE_SOURCE_RANK, EVIDENCE_SOURCE_SET, REGISTERED_LIKE, hashString, isoOrNull, objectRecord, safeId, } from "./case-record-core.js";
 function evidenceString(value, max = MAX_EVIDENCE_STRING_LENGTH) {
     if (value == null)
@@ -114,6 +114,7 @@ const MATERIAL_FIELD_ORDER = [
     'httpCrossOriginRedirect', 'httpHttpsDowngrade', 'httpContentType', 'httpSecurityHeaders',
     'faviconMatch', 'faviconNearMatch', 'reusesOfficialAssets', 'hasPasswordField', 'hasExternalFormAction', 'phishingLanguageMatch',
     'privacyProtected', 'idnReferenceMatch', 'pageBaselineMatch', 'hasActiveBrandProfile',
+    'profileContextState', 'profileContextLimitation',
     'mutationTypes',
 ];
 // The canonical, comparison-safe value of a material field. Registrar casing,
@@ -199,6 +200,7 @@ function buildSnapshot(raw, options) {
     const record = objectRecord(raw);
     const scanDepth = normalizeScanDepth(record.scanDepth);
     const httpSummary = normalizeHttpSummary(record);
+    const acceptsProfileContext = options.sourceVersion === undefined || Number(options.sourceVersion) >= 12;
     const fields = {
         scanDepth,
         availability: evidenceString(record.availability),
@@ -239,6 +241,12 @@ function buildSnapshot(raw, options) {
         idnReferenceMatch: boolOrNull(record.idnReferenceMatch),
         pageBaselineMatch: boolOrNull(record.pageBaselineMatch),
         hasActiveBrandProfile: boolOrNull(record.hasActiveBrandProfile),
+        profileContextState: acceptsProfileContext && ['loading', 'ready', 'unavailable'].includes(String(record.profileContextState))
+            ? record.profileContextState
+            : null,
+        profileContextLimitation: acceptsProfileContext
+            ? evidenceString(record.profileContextLimitation, MAX_EVIDENCE_DETAIL_LENGTH)
+            : null,
         mutationTypes: normalizeMutationList(record.mutationTypes),
     };
     // A version without an actual risk assessment is orphaned metadata. Drop it

package/frontend/src/lib/analysis/case-investigation-branch-model.js

@@ -0,0 +1,134 @@
+export const MAX_CASE_INVESTIGATION_BRANCHES = 8;
+export const MAX_CASE_BRANCH_NAME_LENGTH = 80;
+export const MAX_CASE_BRANCH_REFERENCES = 12;
+export const CASE_INVESTIGATION_BRANCH_STATES = ['active', 'resolved'];
+const SAFE_ID_RE = /^[A-Za-z0-9_-]{1,64}$/u;
+const CONTROL_REPLACE_RE = /[\u0000-\u001f\u007f]+/gu;
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function text(value, maximum) {
+    return typeof value === 'string'
+        ? value.replace(CONTROL_REPLACE_RE, ' ').replace(/\s+/gu, ' ').trim().slice(0, maximum)
+        : '';
+}
+function iso(value, fallback) {
+    if (typeof value === 'string' && value.length <= 64 && !/[\u0000-\u001f\u007f]/u.test(value)) {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed))
+            return new Date(parsed).toISOString();
+    }
+    return fallback;
+}
+function hash(value) {
+    let output = 2166136261 >>> 0;
+    for (let index = 0; index < value.length; index += 1) {
+        output ^= value.charCodeAt(index);
+        output = Math.imul(output, 16777619);
+    }
+    return (output >>> 0).toString(36);
+}
+function safeId(value, raw) {
+    return typeof value === 'string' && SAFE_ID_RE.test(value) ? value : `branch-${hash(JSON.stringify(raw))}`;
+}
+function freshId() {
+    return typeof globalThis.crypto?.randomUUID === 'function'
+        ? globalThis.crypto.randomUUID()
+        : `branch-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function ids(value, valid) {
+    if (!Array.isArray(value))
+        return [];
+    const output = new Set();
+    for (const item of value.slice(0, MAX_CASE_BRANCH_REFERENCES * 2)) {
+        if (typeof item === 'string' && SAFE_ID_RE.test(item) && valid.has(item))
+            output.add(item);
+        if (output.size >= MAX_CASE_BRANCH_REFERENCES)
+            break;
+    }
+    return [...output];
+}
+function normalizeBranch(value, fallback, references) {
+    const item = record(value);
+    const name = text(item.name, MAX_CASE_BRANCH_NAME_LENGTH);
+    if (!name)
+        return null;
+    const createdAt = iso(item.createdAt, fallback);
+    const branch = Object.freeze({
+        id: safeId(item.id, { name, createdAt }),
+        name,
+        state: item.state === 'resolved' ? 'resolved' : 'active',
+        evidencePinIds: Object.freeze(ids(item.evidencePinIds, references.evidencePinIds)),
+        checkpointIds: Object.freeze(ids(item.checkpointIds, references.checkpointIds)),
+        assertionIds: Object.freeze(ids(item.assertionIds, references.assertionIds)),
+        actionIds: Object.freeze(ids(item.actionIds, references.actionIds)),
+        createdAt,
+        updatedAt: iso(item.updatedAt, createdAt),
+    });
+    return branch.evidencePinIds.length || branch.checkpointIds.length || branch.assertionIds.length || branch.actionIds.length
+        ? branch
+        : null;
+}
+export function caseInvestigationBranchReferences(input) {
+    return Object.freeze({
+        evidencePinIds: new Set(input.evidencePins.map((item) => item.id)),
+        checkpointIds: new Set(input.evidencePins.flatMap((item) => item.checkpointId ? [item.checkpointId] : [])),
+        assertionIds: new Set(input.assertions.map((item) => item.id)),
+        actionIds: new Set(input.actions.map((item) => item.id)),
+    });
+}
+export function normalizeCaseInvestigationBranches(value, fallback, references) {
+    if (!Array.isArray(value))
+        return [];
+    const byId = new Map();
+    for (const item of value.slice(0, MAX_CASE_INVESTIGATION_BRANCHES * 2)) {
+        const normalized = normalizeBranch(item, fallback, references);
+        if (!normalized)
+            continue;
+        const current = byId.get(normalized.id);
+        if (!current || normalized.updatedAt > current.updatedAt)
+            byId.set(normalized.id, normalized);
+    }
+    return [...byId.values()]
+        .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
+        .slice(-MAX_CASE_INVESTIGATION_BRANCHES);
+}
+export function appendCaseInvestigationBranch(current, value, now, references) {
+    if (current.length >= MAX_CASE_INVESTIGATION_BRANCHES) {
+        throw new Error(`Each case is limited to ${MAX_CASE_INVESTIGATION_BRANCHES} investigation branches.`);
+    }
+    const item = record(value);
+    const branch = normalizeBranch({ ...item, id: freshId(), createdAt: now, updatedAt: now }, now, references);
+    if (!branch)
+        throw new Error('An investigation branch requires a name and at least one valid case reference.');
+    return normalizeCaseInvestigationBranches([...current, branch], now, references);
+}
+export function updateCaseInvestigationBranch(current, value, now, references) {
+    const patch = record(value);
+    const id = typeof patch.id === 'string' && SAFE_ID_RE.test(patch.id) ? patch.id : '';
+    const index = current.findIndex((item) => item.id === id);
+    if (index < 0)
+        throw new Error('That investigation branch no longer exists.');
+    const existing = current[index];
+    if (!existing)
+        throw new Error('That investigation branch no longer exists.');
+    const normalized = normalizeBranch({
+        ...existing,
+        ...(Object.hasOwn(patch, 'name') ? { name: patch.name } : {}),
+        ...(Object.hasOwn(patch, 'state') ? { state: patch.state } : {}),
+        ...(Object.hasOwn(patch, 'evidencePinIds') ? { evidencePinIds: patch.evidencePinIds } : {}),
+        ...(Object.hasOwn(patch, 'checkpointIds') ? { checkpointIds: patch.checkpointIds } : {}),
+        ...(Object.hasOwn(patch, 'assertionIds') ? { assertionIds: patch.assertionIds } : {}),
+        ...(Object.hasOwn(patch, 'actionIds') ? { actionIds: patch.actionIds } : {}),
+        id,
+        updatedAt: now,
+    }, now, references);
+    if (!normalized)
+        throw new Error('An investigation branch requires a name and at least one valid case reference.');
+    const next = [...current];
+    next[index] = normalized;
+    return normalizeCaseInvestigationBranches(next, now, references);
+}
+export function mergeCaseInvestigationBranches(local, imported, fallback, references) {
+    return normalizeCaseInvestigationBranches([...local, ...imported], fallback, references);
+}