@slicedearth/whoisleuth-cli 1.43.0 → 1.47.4

package/frontend/src/lib/analysis/visualization-models.js

@@ -1,21 +1,15 @@
 import { scaleBand, scaleLinear, scalePoint } from 'd3-scale';
 import { boundedVisualizationId as boundedId, boundedVisualizationNumber as boundedNumber, boundedVisualizationText as boundedText, validVisualizationDate as validDate, } from "./visualization-bounds.js";
 export { FORCE_GRAPH_LINK_KINDS, MAX_FORCE_GRAPH_LINKS, MAX_FORCE_GRAPH_NODES, projectBoundedForceGraph, } from "./visualization-force-graph.js";
-export { MAX_VISUAL_MATRIX_COLUMNS, MAX_VISUAL_MATRIX_ROWS, projectEvidenceMatrix, } from "./visualization-matrix.js";
+export { MAX_VISUAL_MATRIX_CELLS, MAX_VISUAL_MATRIX_COLUMNS, MAX_VISUAL_MATRIX_ROWS, projectEvidenceMatrix, } from "./visualization-matrix.js";
 export { MAX_COLLECTION_TIMING_SOURCES, MAX_LIFECYCLE_EVENTS, MAX_TREND_POINTS, projectCollectionTiming, projectLifecycleEvents, projectTrendPoints, } from "./visualization-time-series.js";
 export const MAX_REDIRECT_NODES = 9;
-export const MAX_TRIAGE_PLOT_POINTS = 300;
 export const WATCHLIST_ACTIVITY_DAYS = 28;
 export const MAX_SCORE_FACTORS = 16;
-export const MAX_COVERAGE_BAR_GROUPS = 18;
+export const MAX_SCORE_FACTOR_LABEL_LENGTH = 160;
+export const MAX_PROFILE_LISTING_BAR_GROUPS = 18;
 export const MAX_MONITOR_TIMELINE_EVENTS = 12;
 export const MAX_MONITOR_TIMELINE_LANES = 6;
-function boundedScore(value) {
-    if (value === null || value === undefined || value === '')
-        return null;
-    const score = Number(value);
-    return Number.isFinite(score) ? Math.max(0, Math.min(100, score)) : null;
-}
 function redirectLabel(value) {
     const text = boundedText(value, 320);
     try {
@@ -75,80 +69,21 @@ export function projectRedirectPath(rawRedirects) {
         truncated: rawCount > redirects.length,
     };
 }
-function deterministicSample(items, limit) {
-    const boundedLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
-    if (boundedLimit === 0)
-        return [];
-    if (items.length <= boundedLimit)
-        return items;
-    if (boundedLimit === 1)
-        return items.slice(0, 1);
-    return Array.from({ length: boundedLimit }, (_, index) => {
-        const sourceIndex = Math.round(index * (items.length - 1) / (boundedLimit - 1));
-        return items[sourceIndex];
-    }).filter((item) => item !== undefined);
-}
-export function projectTriagePoints(rawPoints) {
-    const eligible = (Array.isArray(rawPoints) ? rawPoints : [])
-        .map((point) => ({
-        domain: boundedText(point?.domain, 253).toLowerCase(),
-        risk: boundedScore(point?.risk),
-        opportunity: boundedScore(point?.opportunity),
-        availability: boundedText(point?.availability, 30).toLowerCase() || 'unknown',
-        trusted: Boolean(point?.trusted),
-    }))
-        .filter((point) => point.domain && point.risk !== null && point.opportunity !== null)
-        .sort((a, b) => a.domain.localeCompare(b.domain));
-    const sampled = deterministicSample(eligible, MAX_TRIAGE_PLOT_POINTS);
-    const quadrants = eligible.reduce((counts, point) => {
-        if (point.risk >= 50) {
-            if (point.opportunity >= 50)
-                counts.priorityReview += 1;
-            else
-                counts.riskLedReview += 1;
-        }
-        else if (point.opportunity >= 50) {
-            counts.availableReview += 1;
-        }
-        else {
-            counts.lowerScores += 1;
-        }
-        return counts;
-    }, {
-        availableReview: 0,
-        priorityReview: 0,
-        lowerScores: 0,
-        riskLedReview: 0,
-    });
-    const x = scaleLinear().domain([0, 100]).range([58, 842]).clamp(true);
-    const y = scaleLinear().domain([0, 100]).range([308, 28]).clamp(true);
-    const points = sampled.map((point) => ({
-        ...point,
-        risk: point.risk,
-        opportunity: point.opportunity,
-        x: x(point.risk),
-        y: y(point.opportunity),
-        tone: point.trusted
-            ? 'trusted'
-            : point.availability === 'available'
-                ? 'available'
-                : point.availability === 'error'
-                    ? 'error'
-                    : 'registered',
-    }));
-    return {
-        width: 900,
-        height: 360,
-        points,
-        eligibleCount: eligible.length,
-        omittedCount: Math.max(0, (Array.isArray(rawPoints) ? rawPoints.length : 0) - eligible.length),
-        sampled: eligible.length > sampled.length,
-        quadrants,
-    };
-}
 function utcDayKey(milliseconds) {
     return new Date(milliseconds).toISOString().slice(0, 10);
 }
+function utcWeekLabel(startMilliseconds, endMilliseconds) {
+    const start = new Date(startMilliseconds);
+    const end = new Date(endMilliseconds);
+    const startDay = start.getUTCDate();
+    const endDay = end.getUTCDate();
+    const startMonth = start.toLocaleDateString('en-AU', { month: 'short', timeZone: 'UTC' });
+    const endMonth = end.toLocaleDateString('en-AU', { month: 'short', timeZone: 'UTC' });
+    const endYear = end.getUTCFullYear();
+    return startMonth === endMonth
+        ? `${startDay}–${endDay} ${endMonth} ${endYear}`
+        : `${startDay} ${startMonth}–${endDay} ${endMonth} ${endYear}`;
+}
 export function projectWatchlistActivity(rawEvents) {
     const valid = (Array.isArray(rawEvents) ? rawEvents : [])
         .map((event) => {
@@ -162,7 +97,19 @@ export function projectWatchlistActivity(rawEvents) {
     })
         .filter((event) => Boolean(event));
     if (!valid.length) {
-        return { width: 620, height: 190, days: [], maxChanges: 0, totalChecks: 0, totalChanges: 0 };
+        return {
+            width: 660,
+            height: 235,
+            days: [],
+            weekdayLabels: [],
+            weekLabels: [],
+            timeBasis: 'UTC calendar days',
+            windowStart: null,
+            windowEnd: null,
+            maxChanges: 0,
+            totalChecks: 0,
+            totalChanges: 0,
+        };
     }
     const latest = Math.max(...valid.map((event) => event.milliseconds));
     const latestDay = Date.UTC(new Date(latest).getUTCFullYear(), new Date(latest).getUTCMonth(), new Date(latest).getUTCDate());
@@ -179,8 +126,8 @@ export function projectWatchlistActivity(rawEvents) {
         current.conclusive += event.conclusiveCount;
         byDay.set(key, current);
     }
-    const weekScale = scaleBand().domain([0, 1, 2, 3]).range([72, 580]).padding(0.12);
-    const dayScale = scaleBand().domain([0, 1, 2, 3, 4, 5, 6]).range([26, 165]).padding(0.12);
+    const weekScale = scaleBand().domain([0, 1, 2, 3]).range([92, 638]).padding(0.12);
+    const dayScale = scaleBand().domain([0, 1, 2, 3, 4, 5, 6]).range([42, 190]).padding(0.12);
     const dayWidth = weekScale.bandwidth();
     const dayHeight = dayScale.bandwidth();
     const days = Array.from({ length: WATCHLIST_ACTIVITY_DAYS }, (_, index) => {
@@ -199,10 +146,31 @@ export function projectWatchlistActivity(rawEvents) {
             ...activity,
         };
     });
+    const weekdayLabels = Array.from({ length: 7 }, (_, index) => ({
+        index,
+        label: new Date(start + index * 86_400_000).toLocaleDateString('en-AU', { weekday: 'short', timeZone: 'UTC' }),
+        y: (dayScale(index) ?? 0) + dayHeight / 2 + 3,
+    }));
+    const weekLabels = Array.from({ length: 4 }, (_, index) => {
+        const weekStart = start + index * 7 * 86_400_000;
+        const weekEnd = weekStart + 6 * 86_400_000;
+        return {
+            index,
+            label: utcWeekLabel(weekStart, weekEnd),
+            startDate: utcDayKey(weekStart),
+            endDate: utcDayKey(weekEnd),
+            x: (weekScale(index) ?? 0) + dayWidth / 2,
+        };
+    });
     return {
-        width: 620,
-        height: 190,
+        width: 660,
+        height: 235,
         days,
+        weekdayLabels,
+        weekLabels,
+        timeBasis: 'UTC calendar days',
+        windowStart: utcDayKey(start),
+        windowEnd: utcDayKey(latestDay),
         maxChanges: Math.max(0, ...days.map((day) => day.changes)),
         totalChecks: windowEvents.length,
         totalChanges: windowEvents.reduce((sum, event) => sum + event.changeCount, 0),
@@ -212,7 +180,7 @@ export function projectScoreFactors(rawFactors) {
     const candidates = (Array.isArray(rawFactors) ? rawFactors : [])
         .map((factor, index) => ({
         id: `${boundedId(factor?.label) || 'factor'}-${index}`,
-        label: boundedText(factor?.label, 56) || `Factor ${index + 1}`,
+        label: boundedText(factor?.label, MAX_SCORE_FACTOR_LABEL_LENGTH) || `Factor ${index + 1}`,
         delta: boundedNumber(factor?.delta, -100, 100),
     }));
     const factors = candidates.slice(0, MAX_SCORE_FACTORS);
@@ -237,34 +205,35 @@ export function projectScoreFactors(rawFactors) {
         truncated: candidates.length > factors.length,
     };
 }
-export function projectCoverageBars(rawGroups) {
+export function projectProfileListingBars(rawGroups) {
     const candidates = (Array.isArray(rawGroups) ? rawGroups : [])
         .map((group, index) => {
-        const values = {
-            protected: Math.trunc(boundedNumber(group?.protected, 0, 100_000)),
+        const outcomes = {
             registered: Math.trunc(boundedNumber(group?.registered, 0, 100_000)),
             available: Math.trunc(boundedNumber(group?.available, 0, 100_000)),
             unknown: Math.trunc(boundedNumber(group?.unknown, 0, 100_000)),
         };
+        const total = Object.values(outcomes).reduce((sum, value) => sum + value, 0);
         return {
             id: boundedId(group?.id) || `group-${index}`,
             label: boundedText(group?.label, 56) || `Group ${index + 1}`,
-            ...values,
-            total: Object.values(values).reduce((sum, value) => sum + value, 0),
+            ...outcomes,
+            total,
+            profileListed: Math.min(total, Math.trunc(boundedNumber(group?.profileListed, 0, 100_000))),
         };
     })
         .filter((group) => group.total > 0)
         .sort((a, b) => b.total - a.total || a.label.localeCompare(b.label));
-    const groups = candidates.slice(0, MAX_COVERAGE_BAR_GROUPS);
+    const groups = candidates.slice(0, MAX_PROFILE_LISTING_BAR_GROUPS);
     const maximum = Math.max(1, ...groups.map((group) => group.total));
     const x = scaleLinear().domain([0, maximum]).range([210, 860]).clamp(true);
-    const rowHeight = 31;
+    const rowHeight = 40;
     return {
         width: 900,
         height: Math.max(76, 40 + groups.length * rowHeight),
         groups: groups.map((group, index) => {
             let offset = 0;
-            const segments = ['protected', 'registered', 'available', 'unknown'].map((state) => {
+            const segments = ['registered', 'available', 'unknown'].map((state) => {
                 const value = group[state];
                 const start = offset;
                 offset += value;

package/frontend/src/lib/analysis/visualization-time-series.js

@@ -116,28 +116,69 @@ export function projectTrendPoints(rawPoints) {
         .filter((point) => Boolean(point))
         .sort((a, b) => a.milliseconds - b.milliseconds || a.id.localeCompare(b.id));
     const points = candidates.slice(-MAX_TREND_POINTS);
-    const x = scalePoint().domain(points.map((point) => point.id)).range([64, 850]).padding(0.45);
+    const firstMilliseconds = points[0]?.milliseconds ?? 0;
+    const latestMilliseconds = points.at(-1)?.milliseconds ?? firstMilliseconds;
+    const x = scaleLinear()
+        .domain(firstMilliseconds === latestMilliseconds
+        ? [firstMilliseconds - 1, latestMilliseconds + 1]
+        : [firstMilliseconds, latestMilliseconds])
+        .range([64, 850])
+        .clamp(true);
     const maximum = Math.max(1, ...points.map((point) => point.total));
     const y = scaleLinear().domain([0, maximum]).range([190, 24]).nice().clamp(true);
     const first = points[0] ?? null;
     const latest = points.at(-1) ?? null;
+    const projectedPoints = points.map((point, sequenceIndex) => ({
+        ...point,
+        sequenceIndex,
+        x: points.length > 1 ? x(point.milliseconds) : 450,
+        y: y(point.total),
+        addedY: y(point.added),
+    }));
+    // A capped point is a lower bound, so neither adjacent slope is measured.
+    // Retain only directly adjacent complete-to-complete segments and leave a
+    // visible gap around every capped point.
+    const segments = projectedPoints.slice(1).flatMap((to, index) => {
+        const from = projectedPoints[index];
+        return from && !from.partial && !to.partial ? [{
+                fromId: from.id,
+                toId: to.id,
+                x1: from.x,
+                y1: from.y,
+                x2: to.x,
+                y2: to.y,
+            }] : [];
+    });
+    const partialChecks = points.filter((point) => point.partial).length;
+    const hasPartialChecks = partialChecks > 0;
+    const summaryMetric = (value, lowerBound) => ({
+        value,
+        lowerBound,
+        label: lowerBound ? `At least ${value}` : String(value),
+    });
+    const peakTotal = points.reduce((peak, point) => Math.max(peak, point.total), 0);
+    const newlyObserved = points.reduce((total, point) => total + point.added, 0);
     return {
         width: 900,
         height: 225,
         maximum,
+        spacing: 'elapsed_time',
+        elapsed: {
+            firstAt: points[0]?.date ?? null,
+            latestAt: points.at(-1)?.date ?? null,
+            milliseconds: Math.max(0, latestMilliseconds - firstMilliseconds),
+        },
         ticks: y.ticks(4).map((value) => ({ value, y: y(value) })),
-        points: points.map((point) => ({
-            ...point,
-            x: x(point.id) ?? 450,
-            y: y(point.total),
-            addedY: y(point.added),
-        })),
+        points: projectedPoints,
+        segments,
         summary: {
-            firstTotal: first?.total ?? 0,
-            latestTotal: latest?.total ?? 0,
-            peakTotal: points.reduce((peak, point) => Math.max(peak, point.total), 0),
-            newlyObserved: points.reduce((total, point) => total + point.added, 0),
-            partialChecks: points.filter((point) => point.partial).length,
+            first: summaryMetric(first?.total ?? 0, Boolean(first?.partial)),
+            latest: summaryMetric(latest?.total ?? 0, Boolean(latest?.partial)),
+            // Any capped total can exceed the displayed observed maximum.
+            peak: summaryMetric(peakTotal, hasPartialChecks),
+            // Every capped new-count is itself a lower bound, including observed 0.
+            newlyObserved: summaryMetric(newlyObserved, hasPartialChecks),
+            partialChecks,
         },
         truncated: candidates.length > points.length,
     };

package/frontend/src/lib/analysis/website-snapshot-model.js

@@ -1,6 +1,7 @@
 import { normalizeDomain } from "./case-model.js";
 export const WEBSITE_SNAPSHOT_SCHEMA = 'whoisleuth.website-profile-snapshots';
 export const WEBSITE_SNAPSHOT_SCHEMA_VERSION = 4;
+export const SUPPORTED_WEBSITE_SNAPSHOT_SCHEMA_VERSIONS = Object.freeze([1, 2, 3, WEBSITE_SNAPSHOT_SCHEMA_VERSION]);
 export const MAX_WEBSITE_SNAPSHOTS = 60;
 export const MAX_WEBSITE_SNAPSHOTS_PER_DOMAIN = 12;
 export const MAX_WEBSITE_SNAPSHOT_STORE_BYTES = 512 * 1024;
@@ -188,6 +189,11 @@ export function normalizeWebsiteSnapshotStore(raw) {
         && Number(value?.version) > WEBSITE_SNAPSHOT_SCHEMA_VERSION) {
         throw new Error('This website-snapshot collection uses a newer schema and cannot be read safely.');
     }
+    if (value?.schema === WEBSITE_SNAPSHOT_SCHEMA
+        && Number.isSafeInteger(value.version)
+        && !SUPPORTED_WEBSITE_SNAPSHOT_SCHEMA_VERSIONS.includes(Number(value.version))) {
+        throw new Error('This website-snapshot collection uses an unsupported schema and cannot be read safely.');
+    }
     const sourceValues = Array.isArray(raw) ? raw : Array.isArray(value?.snapshots) ? value.snapshots : [];
     const snapshots = values(sourceValues, MAX_WEBSITE_SNAPSHOTS * 2, normalizeWebsiteProfileSnapshot);
     const perDomain = new Map();

package/frontend/src/lib/analysis/workspace-archive-crypto.js

@@ -1,7 +1,7 @@
 // Browser-local authenticated encryption for portable workspace archives.
 // This protects a downloaded file while it is locked. It does not encrypt the
 // active IndexedDB workspace or defend an unlocked page from same-origin code.
-import { MAX_WORKSPACE_ARCHIVE_BYTES, WORKSPACE_ARCHIVE_SCHEMA, WORKSPACE_ARCHIVE_VERSION, isSupportedWorkspaceArchiveVersion, readWorkspaceArchive, } from "./workspace-archive.js";
+import { MAX_WORKSPACE_ARCHIVE_BYTES, WORKSPACE_ARCHIVE_SCHEMA, isSupportedWorkspaceArchiveVersion, readWorkspaceArchive, } from "./workspace-archive.js";
 export const ENCRYPTED_WORKSPACE_ARCHIVE_SCHEMA = 'whoisleuth.encrypted-workspace-archive';
 export const ENCRYPTED_WORKSPACE_ARCHIVE_VERSION = 1;
 export const WORKSPACE_ARCHIVE_PBKDF2_ITERATIONS = 600_000;
@@ -26,9 +26,6 @@ function hasExactKeys(value, expected) {
     const keys = Object.keys(value);
     return keys.length === expected.length && keys.every((key) => expected.includes(key));
 }
-function byteLength(value) {
-    return encoder.encode(value).byteLength;
-}
 function arrayBuffer(bytes) {
     return bytes.slice().buffer;
 }

package/frontend/src/lib/analysis/workspace-archive.js

@@ -1,15 +1,15 @@
 // Pure, bounded workspace archive composition. Existing typed store models remain the
 // authority for normalization and merge semantics; this module only packages
 // their portable contracts, verifies integrity, and previews conflicts.
-import { buildCaseExport, CASE_SCHEMA_VERSION, enforceStoreBudget, mergeCases, } from "./case-model.js";
-import { assertBrandProfileStoreBudget, BRAND_PROFILE_SCHEMA, BRAND_PROFILE_SCHEMA_VERSION, buildBrandProfileExport, mergeBrandProfiles, } from "./brand-profile-model.js";
+import { buildCaseExport, CASE_SCHEMA_VERSION, CASE_IMPORT_VERSIONS, enforceStoreBudget, mergeCases, } from "./case-model.js";
+import { assertBrandProfileStoreBudget, BRAND_PROFILE_SCHEMA, BRAND_PROFILE_SCHEMA_VERSION, SUPPORTED_BRAND_PROFILE_SCHEMA_VERSIONS, buildBrandProfileExport, mergeBrandProfiles, normalizeBrandProfileId, } from "./brand-profile-model.js";
 import { assertCampaignStoreBudget, buildCampaignExport, CAMPAIGN_SCHEMA, CAMPAIGN_SCHEMA_VERSION, mergeCampaigns, } from "./campaign-model.js";
 import { assertWatchlistStoreBudget, buildWatchlistExport, mergeWatchlistStores, WATCHLIST_SCHEMA, WATCHLIST_SCHEMA_VERSION, } from "./watchlist-store.js";
-import { assertShortlistStoreBudget, buildShortlistExport, mergeShortlistStores, SHORTLIST_SCHEMA, SHORTLIST_SCHEMA_VERSION, } from "./shortlist-model.js";
+import { assertShortlistStoreBudget, buildShortlistExport, mergeShortlistStores, SHORTLIST_SCHEMA, SHORTLIST_SCHEMA_VERSION, SUPPORTED_SHORTLIST_SCHEMA_VERSIONS, } from "./shortlist-model.js";
 import { assertDetectionRuleStoreBudget, buildDetectionRuleExport, DETECTION_RULE_SCHEMA, DETECTION_RULE_SCHEMA_VERSION, mergeDetectionRules, } from "./detection-rule-model.js";
 import { buildRelationshipObservationExport, mergeRelationshipObservations, RELATIONSHIP_OBSERVATION_SCHEMA, RELATIONSHIP_OBSERVATION_SCHEMA_VERSION, } from "./relationship-observation-model.js";
-import { BULK_SESSION_SCHEMA, BULK_SESSION_SCHEMA_VERSION, buildBulkSessionExport, enforceBulkSessionStoreBudget, mergeBulkSessions, } from "./bulk-session-model.js";
-import { WEBSITE_SNAPSHOT_SCHEMA, WEBSITE_SNAPSHOT_SCHEMA_VERSION, buildWebsiteSnapshotExport, mergeWebsiteSnapshots, } from "./website-snapshot-model.js";
+import { BULK_SESSION_SCHEMA, BULK_SESSION_SCHEMA_VERSION, SUPPORTED_BULK_SESSION_SCHEMA_VERSIONS, buildBulkSessionExport, enforceBulkSessionStoreBudget, mergeBulkSessions, } from "./bulk-session-model.js";
+import { WEBSITE_SNAPSHOT_SCHEMA, WEBSITE_SNAPSHOT_SCHEMA_VERSION, SUPPORTED_WEBSITE_SNAPSHOT_SCHEMA_VERSIONS, buildWebsiteSnapshotExport, mergeWebsiteSnapshots, } from "./website-snapshot-model.js";
 import { INVESTIGATION_TEMPLATE_SCHEMA, INVESTIGATION_TEMPLATE_VERSION, buildInvestigationTemplateExport, mergeInvestigationTemplates, } from "./investigation-template-model.js";
 import { BULK_REVIEW_SCHEMA, BULK_REVIEW_SCHEMA_VERSION, buildBulkReviewExport, mergeBulkReviewStores, } from "./bulk-review-model.js";
 export const WORKSPACE_ARCHIVE_SCHEMA = 'whoisleuth.workspace-archive';
@@ -40,11 +40,25 @@ export function isSupportedWorkspaceArchiveVersion(value) {
         && SUPPORTED_WORKSPACE_ARCHIVE_VERSIONS.some((version) => version === value);
 }
 const CONTROL_RE = /[\x00-\x1f\x7f]/;
-const SAFE_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 const CHECKSUM_RE = /^sha256:[a-f0-9]{64}$/;
+const WORKSPACE_ARCHIVE_ROOT_KEYS = Object.freeze({
+    1: Object.freeze(['schema', 'version', 'generatedAt', 'manifest', 'sections', 'limitations']),
+    2: Object.freeze(['schema', 'version', 'generatedAt', 'manifest', 'sections', 'limitations']),
+    3: Object.freeze(['schema', 'version', 'generatedAt', 'manifest', 'sections', 'limitations']),
+    4: Object.freeze(['schema', 'version', 'generatedAt', 'manifest', 'sections', 'limitations']),
+    5: Object.freeze(['schema', 'version', 'generatedAt', 'manifest', 'sections', 'limitations']),
+});
+const WORKSPACE_ARCHIVE_MANIFEST_KEYS = Object.freeze(['sectionCount', 'totalRecords', 'sections']);
+const WORKSPACE_ARCHIVE_MANIFEST_ENTRY_KEYS = Object.freeze(['id', 'schema', 'version', 'recordCount', 'bytes', 'checksum']);
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
+function assertExactKeys(value, expected, label) {
+    const keys = Object.keys(value);
+    if (keys.length !== expected.length || keys.some((key) => !expected.includes(key))) {
+        throw new Error(`The workspace archive ${label} contains missing or undeclared fields.`);
+    }
+}
 function byteLength(value) {
     return new TextEncoder().encode(value).byteLength;
 }
@@ -101,9 +115,7 @@ async function checksum(value, cryptoProvider = globalThis.crypto) {
 }
 function settingsDocument(input) {
     const profiles = Array.isArray(input.brandProfiles) ? input.brandProfiles : [];
-    const requestedProfileId = typeof input.settings?.activeProfileId === 'string' && SAFE_ID_RE.test(input.settings.activeProfileId)
-        ? input.settings.activeProfileId
-        : '';
+    const requestedProfileId = normalizeBrandProfileId(input.settings?.activeProfileId) || '';
     const activeProfileId = profiles.some((profile) => profile?.id === requestedProfileId)
         ? requestedProfileId
         : '';
@@ -142,6 +154,7 @@ function objectCount(data, key) {
 const SECTION_DEFINITIONS = [
     {
         id: 'cases', label: 'Cases', schema: null, version: CASE_SCHEMA_VERSION,
+        supportedVersions: CASE_IMPORT_VERSIONS,
         count: (data) => arrayCount(data, 'cases'),
         merge: (local, data) => {
             const result = mergeCases(local.cases, data);
@@ -159,6 +172,7 @@ const SECTION_DEFINITIONS = [
     },
     {
         id: 'brandProfiles', label: 'Brand profiles', schema: BRAND_PROFILE_SCHEMA, version: BRAND_PROFILE_SCHEMA_VERSION,
+        supportedVersions: SUPPORTED_BRAND_PROFILE_SCHEMA_VERSIONS,
         count: (data) => arrayCount(data, 'profiles'),
         merge: (local, data, now) => {
             const result = mergeBrandProfiles(local.brandProfiles, data, { nowIso: now });
@@ -175,6 +189,7 @@ const SECTION_DEFINITIONS = [
     },
     {
         id: 'shortlist', label: 'Shortlist', schema: SHORTLIST_SCHEMA, version: SHORTLIST_SCHEMA_VERSION,
+        supportedVersions: SUPPORTED_SHORTLIST_SCHEMA_VERSIONS,
         count: (data) => arrayCount(data, 'entries'),
         merge: (local, data) => {
             const result = mergeShortlistStores(local.shortlist, data);
@@ -202,6 +217,7 @@ const SECTION_DEFINITIONS = [
         label: 'Saved Bulk sessions',
         schema: BULK_SESSION_SCHEMA,
         version: BULK_SESSION_SCHEMA_VERSION,
+        supportedVersions: SUPPORTED_BULK_SESSION_SCHEMA_VERSIONS,
         count: (data) => arrayCount(data, 'sessions'),
         merge: (local, data) => {
             const result = mergeBulkSessions(local.bulkSessions, data);
@@ -214,6 +230,7 @@ const SECTION_DEFINITIONS = [
         label: 'Website profile snapshots',
         schema: WEBSITE_SNAPSHOT_SCHEMA,
         version: WEBSITE_SNAPSHOT_SCHEMA_VERSION,
+        supportedVersions: SUPPORTED_WEBSITE_SNAPSHOT_SCHEMA_VERSIONS,
         count: (data) => arrayCount(data, 'snapshots'),
         merge: (local, data) => mergeWebsiteSnapshots(local.websiteSnapshots, data),
     },
@@ -342,11 +359,13 @@ export async function readWorkspaceArchive(raw, options = {}) {
     }
     const sourceVersion = value.version;
     const { bytes } = ensureArchiveBudget(value);
+    assertExactKeys(value, WORKSPACE_ARCHIVE_ROOT_KEYS[sourceVersion] ?? [], `version ${sourceVersion} envelope`);
     const manifest = record(value.manifest);
     const sectionValues = record(value.sections);
     if (!manifest || !sectionValues || !Array.isArray(manifest.sections)) {
         throw new Error('The workspace archive manifest is missing or malformed.');
     }
+    assertExactKeys(manifest, WORKSPACE_ARCHIVE_MANIFEST_KEYS, 'manifest');
     if (manifest.sections.length > MAX_WORKSPACE_ARCHIVE_SECTIONS) {
         throw new Error(`Workspace archives are limited to ${MAX_WORKSPACE_ARCHIVE_SECTIONS} sections.`);
     }
@@ -354,6 +373,10 @@ export async function readWorkspaceArchive(raw, options = {}) {
     const sections = [];
     let totalRecords = 0;
     for (const rawEntry of manifest.sections) {
+        const rawEntryRecord = record(rawEntry);
+        if (!rawEntryRecord)
+            throw new Error('The workspace archive manifest contains a malformed section entry.');
+        assertExactKeys(rawEntryRecord, WORKSPACE_ARCHIVE_MANIFEST_ENTRY_KEYS, 'manifest section entry');
         const entry = manifestEntry(rawEntry);
         if (!entry || seen.has(entry.id) || !Object.prototype.hasOwnProperty.call(sectionValues, entry.id)) {
             throw new Error('The workspace archive manifest contains an invalid, duplicate, or missing section.');
@@ -366,6 +389,21 @@ export async function readWorkspaceArchive(raw, options = {}) {
         if (await checksum(data, options.cryptoProvider) !== entry.checksum) {
             throw new Error(`${entry.id} failed its archive checksum check.`);
         }
+        const embedded = record(data);
+        const embeddedVersion = embedded?.version;
+        const embeddedSchema = embedded && Object.prototype.hasOwnProperty.call(embedded, 'schema')
+            ? embedded.schema
+            : null;
+        if (!embedded
+            || typeof embeddedVersion !== 'number'
+            || !Number.isSafeInteger(embeddedVersion)
+            || embeddedVersion < 1
+            || embeddedVersion > 1000
+            || (embeddedSchema !== null && typeof embeddedSchema !== 'string')
+            || embeddedVersion !== entry.version
+            || embeddedSchema !== entry.schema) {
+            throw new Error(`${entry.id} section contract does not match its archive manifest.`);
+        }
         const definition = DEFINITION_BY_ID.get(entry.id);
         let status = 'ready';
         let reason = '';
@@ -373,7 +411,7 @@ export async function readWorkspaceArchive(raw, options = {}) {
             status = 'unsupported';
             reason = 'This app does not recognise the archive section.';
         }
-        else if (entry.version !== definition.version || entry.schema !== definition.schema) {
+        else if (!(definition.supportedVersions ?? [definition.version]).includes(entry.version) || entry.schema !== definition.schema) {
             status = 'unsupported';
             reason = entry.version > definition.version
                 ? `This section uses newer schema ${entry.version}.`
@@ -406,15 +444,31 @@ export async function readWorkspaceArchive(raw, options = {}) {
 }
 function settingsPreview(data, local, mergedProfiles) {
     const value = record(data) || {};
-    const requestedProfileId = typeof value.activeProfileId === 'string' ? value.activeProfileId : '';
-    const activeProfileId = SAFE_ID_RE.test(requestedProfileId) ? requestedProfileId : '';
+    const rawActiveProfileId = value.activeProfileId;
+    const intentionalClear = rawActiveProfileId === '';
+    const normalizedActiveProfileId = normalizeBrandProfileId(rawActiveProfileId);
+    const validActiveProfileId = typeof rawActiveProfileId === 'string'
+        && rawActiveProfileId.length > 0
+        && normalizedActiveProfileId === rawActiveProfileId;
     const theme = normalizeTheme(value.theme);
+    const retainedActiveProfileId = normalizeBrandProfileId(local.settings?.activeProfileId) || '';
+    let activeProfileId = retainedActiveProfileId;
     let skipped = 0;
-    if (activeProfileId && !mergedProfiles.some((profile) => profile?.id === activeProfileId))
-        skipped++;
+    let reason = '';
+    if (!intentionalClear && !validActiveProfileId) {
+        skipped = 1;
+        reason = 'The imported active Brand Profile preference is missing or malformed. Existing active-profile context is preserved.';
+    }
+    else if (validActiveProfileId && !mergedProfiles.some((profile) => profile?.id === normalizedActiveProfileId)) {
+        skipped = 1;
+        reason = 'The imported active Brand Profile preference will be skipped because its identifier is not available in the selected Profile data or the current browser. Existing active-profile context is preserved.';
+    }
+    else {
+        activeProfileId = intentionalClear ? '' : normalizedActiveProfileId ?? retainedActiveProfileId;
+    }
     const updated = Number(theme !== normalizeTheme(local.settings?.theme)
-        || (Boolean(activeProfileId) && activeProfileId !== local.settings?.activeProfileId && skipped === 0));
-    return { added: 0, updated, skipped, settings: { activeProfileId: skipped ? '' : activeProfileId, theme } };
+        || (skipped === 0 && activeProfileId !== retainedActiveProfileId));
+    return { added: 0, updated, skipped, reason, settings: { activeProfileId, theme } };
 }
 /** Preview section-specific non-destructive merge outcomes without writing. */
 export async function previewWorkspaceArchive(raw, localInput, options = {}) {
@@ -422,6 +476,9 @@ export async function previewWorkspaceArchive(raw, localInput, options = {}) {
     const local = normalizedInput(localInput);
     const results = [];
     let mergedProfiles = local.brandProfiles;
+    const selectedIds = options.selectedSectionIds
+        ? new Set(options.selectedSectionIds.slice(0, MAX_WORKSPACE_ARCHIVE_SECTIONS))
+        : null;
     for (const section of archive.sections) {
         if (section.status !== 'ready') {
             results.push({ ...section, added: 0, updated: 0, skipped: section.recordCount, selected: false });
@@ -436,17 +493,21 @@ export async function previewWorkspaceArchive(raw, localInput, options = {}) {
                 : definition.merge
                     ? definition.merge(local, section.data, archive.generatedAt)
                     : { added: 0, updated: 0, skipped: section.recordCount };
-            if (definition.id === 'brandProfiles' && result.profiles)
+            const selected = selectedIds ? selectedIds.has(section.id) : true;
+            if (definition.id === 'brandProfiles' && selected && result.profiles)
                 mergedProfiles = result.profiles;
             results.push({
                 ...section,
                 status: 'ready',
-                reason: '',
+                reason: definition.id === 'settings' && selected && (result.skipped ?? 0) > 0
+                    ? result.reason ?? 'The imported workspace preference was skipped. Existing browser-local context is preserved.'
+                    : '',
                 added: result.added ?? 0,
                 updated: result.updated ?? 0,
                 skipped: result.skipped ?? 0,
                 pruned: result.pruned ?? 0,
-                selected: true,
+                brandProfileReferencesOmitted: result.brandProfileReferencesOmitted ?? 0,
+                selected,
                 normalizedSettings: result.settings || null,
             });
         }
@@ -465,6 +526,31 @@ export async function previewWorkspaceArchive(raw, localInput, options = {}) {
             });
         }
     }
+    const profileCollision = results.find((section) => section.id === 'brandProfiles'
+        && section.status === 'blocked'
+        && /reuses one exact identifier for different normalised profile names/iu.test(section.reason));
+    if (profileCollision) {
+        for (const dependentId of ['cases', 'settings']) {
+            const dependentIndex = results.findIndex((section) => section.id === dependentId && section.status === 'ready');
+            const dependentSection = results[dependentIndex];
+            if (dependentIndex < 0 || !dependentSection)
+                continue;
+            results[dependentIndex] = {
+                ...dependentSection,
+                status: 'blocked',
+                reason: dependentId === 'cases'
+                    ? 'Cases were not selected because a Brand Profile identifier collision must be resolved before their opaque references can be imported safely.'
+                    : 'Workspace settings were not selected because an active Brand Profile preference could otherwise bind to a different local profile that reuses the same identifier.',
+                added: 0,
+                updated: 0,
+                skipped: dependentSection.recordCount,
+                pruned: 0,
+                brandProfileReferencesOmitted: 0,
+                selected: false,
+                normalizedSettings: dependentId === 'settings' ? null : dependentSection.normalizedSettings ?? null,
+            };
+        }
+    }
     return {
         ...archive,
         sections: results,

package/lib/application-version.mjs

@@ -0,0 +1,3 @@
+import packageDocument from '../package.json' with { type: 'json' };
+import { normalizeBoundedSemanticVersion } from "./semantic-version.mjs";
+export const WHOISLEUTH_APPLICATION_VERSION = normalizeBoundedSemanticVersion(packageDocument.version, 'Application manifest');