@slicedearth/whoisleuth-cli 1.47.4 → 2.0.1

package/{frontend/src/lib/analysis/detection-rule-model.js → packages/workspace/detection-rule-model.mjs}

@@ -1,19 +1,10 @@
 // Pure browser-local custom detection-rule model. Rules are deliberately a
 // small structured language: field names and operators come from allowlists,
 // so imported rules cannot execute code or reach outside bounded case evidence.
-import { latestCaseEvidence } from "./case-model.js";
-export const DETECTION_RULE_SCHEMA = 'whoisleuth.detection-rules';
-export const DETECTION_RULE_SCHEMA_VERSION = 1;
-export const MAX_DETECTION_RULES = 50;
-export const MAX_RULE_CONDITIONS = 8;
-export const MAX_RULE_INPUT_RECORDS = 250;
-export const MAX_RULE_IMPORT_BYTES = 2 * 1024 * 1024;
-export const MAX_RULE_STORE_BYTES = 256 * 1024;
-export const MAX_RULE_NAME_LENGTH = 100;
-export const MAX_RULE_TAG_LENGTH = 40;
-export const MAX_CONDITION_VALUE_LENGTH = 200;
-export const MAX_RULE_RISK_DELTA = 25;
-export const MAX_CUSTOM_RISK_TOTAL = 50;
+import { latestCaseEvidence } from "../cases/case-model.mjs";
+import { assertWorkspaceDeclaredVersion, assertWorkspaceInputGraph, assertWorkspacePortableVersion, ordinaryWorkspaceRecord } from "./hostile-input.mjs";
+import { DETECTION_RULE_SCHEMA, DETECTION_RULE_SCHEMA_VERSION, MAX_CONDITION_VALUE_LENGTH, MAX_CUSTOM_RISK_TOTAL, MAX_DETECTION_RULES, MAX_RULE_CONDITIONS, MAX_RULE_INPUT_RECORDS, MAX_RULE_NAME_LENGTH, MAX_RULE_RISK_DELTA, MAX_RULE_STORE_BYTES, MAX_RULE_TAG_LENGTH, } from "../contracts/workspace-portability.mjs";
+export { DETECTION_RULE_SCHEMA, DETECTION_RULE_SCHEMA_VERSION, MAX_CONDITION_VALUE_LENGTH, MAX_CUSTOM_RISK_TOTAL, MAX_DETECTION_RULES, MAX_RULE_CONDITIONS, MAX_RULE_IMPORT_BYTES, MAX_RULE_INPUT_RECORDS, MAX_RULE_NAME_LENGTH, MAX_RULE_RISK_DELTA, MAX_RULE_STORE_BYTES, MAX_RULE_TAG_LENGTH, } from "../contracts/workspace-portability.mjs";
 const SAFE_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
 const TEXT_CONTROL_RE = /[\x00-\x1f\x7f]/;
 export const RULE_FIELD_DEFINITIONS = Object.freeze([
@@ -41,9 +32,7 @@ export const RULE_FIELD_DEFINITIONS = Object.freeze([
 ]);
 const FIELD_BY_VALUE = new Map(RULE_FIELD_DEFINITIONS.map((field) => [field.value, field]));
 function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
+    return ordinaryWorkspaceRecord(value, 'Detection-rule input') ?? {};
 }
 export function operatorsForRuleField(field) {
     const definition = typeof field === 'string' ? FIELD_BY_VALUE.get(field) : undefined;
@@ -145,6 +134,8 @@ export function detectionRuleStoreVersion(raw) {
     return typeof item.version === 'number' && Number.isFinite(item.version) ? item.version : null;
 }
 export function normalizeDetectionRuleStore(raw) {
+    assertWorkspaceInputGraph(raw, 'Detection-rule store');
+    assertWorkspaceDeclaredVersion(raw, 'Detection-rule store');
     const byId = new Map();
     for (const item of ruleList(raw).slice(0, MAX_RULE_INPUT_RECORDS)) {
         const rule = normalizeDetectionRule(item);
@@ -282,14 +273,21 @@ export function previewDetectionRule(records, existingRules, rawCandidate) {
     });
 }
 export function mergeDetectionRules(localRaw, importedRaw) {
+    assertWorkspaceInputGraph(localRaw, 'Local detection-rule store');
+    assertWorkspaceInputGraph(importedRaw, 'Imported detection-rule document');
+    assertWorkspacePortableVersion(importedRaw, DETECTION_RULE_SCHEMA_VERSION, 'Imported detection-rule document');
     const importedRecord = record(importedRaw);
-    if (typeof importedRecord.schema === 'string' && importedRecord.schema !== DETECTION_RULE_SCHEMA) {
+    if (importedRecord.schema !== DETECTION_RULE_SCHEMA
+        || !Array.isArray(importedRecord.rules)) {
         throw new Error('This JSON file is not a WHOISleuth custom-rule export.');
     }
     const version = detectionRuleStoreVersion(importedRaw);
     if (version !== null && version > DETECTION_RULE_SCHEMA_VERSION) {
         throw new Error(`This custom-rule file uses newer schema ${version}. Update the app before importing it.`);
     }
+    if (version !== DETECTION_RULE_SCHEMA_VERSION) {
+        throw new Error(`Expected custom-rule schema ${DETECTION_RULE_SCHEMA_VERSION}.`);
+    }
     const local = normalizeDetectionRuleStore(localRaw).rules;
     const byId = new Map(local.map((rule) => [rule.id, rule]));
     const importedList = ruleList(importedRaw);

package/packages/workspace/hostile-input.mjs

@@ -0,0 +1,172 @@
+import { MAX_WORKSPACE_INPUT_ARRAY_LENGTH, MAX_WORKSPACE_INPUT_GRAPH_DEPTH, MAX_WORKSPACE_INPUT_GRAPH_NODES, MAX_WORKSPACE_INPUT_OBJECT_KEYS, MAX_WORKSPACE_INPUT_STRING_CODE_UNITS, } from "../contracts/workspace-portability.mjs";
+function inputError(label, detail) {
+    return new TypeError(`${label} must be bounded ordinary JSON data; ${detail}.`);
+}
+function ownDataDescriptors(value, label) {
+    let keys;
+    try {
+        keys = Reflect.ownKeys(value);
+    }
+    catch {
+        throw inputError(label, 'its property keys could not be inspected safely');
+    }
+    if (keys.some((key) => typeof key !== 'string')) {
+        throw inputError(label, 'symbol keys are not supported');
+    }
+    return keys.map((key) => {
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(value, key);
+        }
+        catch {
+            throw inputError(label, 'a property descriptor could not be inspected safely');
+        }
+        if (!descriptor || !('value' in descriptor)) {
+            throw inputError(label, 'accessor properties are not supported');
+        }
+        return [key, descriptor];
+    });
+}
+export function ordinaryWorkspaceRecord(value, label = 'Workspace input') {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    let prototype;
+    try {
+        prototype = Object.getPrototypeOf(value);
+    }
+    catch {
+        throw inputError(label, 'its prototype could not be inspected safely');
+    }
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw inputError(label, 'custom object prototypes are not supported');
+    }
+    const descriptors = ownDataDescriptors(value, label);
+    if (descriptors.length > MAX_WORKSPACE_INPUT_OBJECT_KEYS) {
+        throw inputError(label, 'an object exceeds the key ceiling');
+    }
+    if (descriptors.some(([, descriptor]) => !descriptor.enumerable)) {
+        throw inputError(label, 'non-enumerable object fields are not supported');
+    }
+    return value;
+}
+export function assertWorkspaceInputGraph(value, label = 'Workspace input') {
+    const pending = [{ value, depth: 0, label }];
+    const seen = new WeakSet();
+    let nodes = 0;
+    let stringCodeUnits = 0;
+    while (pending.length) {
+        const current = pending.pop();
+        const candidate = current.value;
+        if (typeof candidate === 'string') {
+            stringCodeUnits += candidate.length;
+            if (stringCodeUnits > MAX_WORKSPACE_INPUT_STRING_CODE_UNITS) {
+                throw inputError(label, 'aggregate text exceeds the string ceiling');
+            }
+            continue;
+        }
+        if (candidate === null
+            || candidate === undefined
+            || typeof candidate === 'boolean'
+            || typeof candidate === 'number')
+            continue;
+        if (typeof candidate !== 'object') {
+            throw inputError(current.label, 'non-JSON values are not supported');
+        }
+        if (current.depth > MAX_WORKSPACE_INPUT_GRAPH_DEPTH) {
+            throw inputError(label, 'the nesting depth exceeds the graph ceiling');
+        }
+        nodes += 1;
+        if (nodes > MAX_WORKSPACE_INPUT_GRAPH_NODES) {
+            throw inputError(label, 'the graph exceeds the node ceiling');
+        }
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        if (Array.isArray(candidate)) {
+            let prototype;
+            try {
+                prototype = Object.getPrototypeOf(candidate);
+            }
+            catch {
+                throw inputError(current.label, 'its array prototype could not be inspected safely');
+            }
+            if (prototype !== Array.prototype) {
+                throw inputError(current.label, 'custom array prototypes are not supported');
+            }
+            const descriptors = ownDataDescriptors(candidate, current.label);
+            const lengthDescriptor = descriptors.find(([key]) => key === 'length')?.[1];
+            const length = lengthDescriptor?.value;
+            if (!Number.isSafeInteger(length)
+                || Number(length) < 0
+                || Number(length) > MAX_WORKSPACE_INPUT_ARRAY_LENGTH) {
+                throw inputError(current.label, 'an array exceeds the length ceiling');
+            }
+            if (descriptors.length !== Number(length) + 1) {
+                throw inputError(current.label, 'sparse arrays and custom array fields are not supported');
+            }
+            const byKey = new Map(descriptors);
+            for (let index = 0; index < Number(length); index += 1) {
+                const descriptor = byKey.get(String(index));
+                if (!descriptor?.enumerable) {
+                    throw inputError(current.label, 'sparse or non-enumerable array entries are not supported');
+                }
+                pending.push({
+                    value: descriptor.value,
+                    depth: current.depth + 1,
+                    label: `${current.label}[${index}]`,
+                });
+            }
+            continue;
+        }
+        const record = ordinaryWorkspaceRecord(candidate, current.label);
+        const descriptors = ownDataDescriptors(record, current.label);
+        for (const [key, descriptor] of descriptors) {
+            pending.push({
+                value: descriptor.value,
+                depth: current.depth + 1,
+                label: `${current.label}.${key}`,
+            });
+        }
+    }
+}
+export function assertWorkspacePortableVersion(value, currentVersion, label) {
+    if (!Number.isSafeInteger(currentVersion) || currentVersion < 1) {
+        throw new TypeError(`${label} current version is invalid.`);
+    }
+    if (Array.isArray(value)) {
+        return null;
+    }
+    const record = ordinaryWorkspaceRecord(value, label);
+    if (!record)
+        throw inputError(label, 'the root must be an object');
+    const descriptor = Object.getOwnPropertyDescriptor(record, 'version');
+    if (!descriptor)
+        return null;
+    if (!('value' in descriptor))
+        throw inputError(label, 'the version must be a positive safe integer');
+    if (typeof descriptor.value === 'number'
+        && Number.isFinite(descriptor.value)
+        && descriptor.value > currentVersion) {
+        return descriptor.value;
+    }
+    if (!Number.isSafeInteger(descriptor.value) || Number(descriptor.value) < 1) {
+        throw inputError(label, 'the version must be a positive safe integer');
+    }
+    const version = Number(descriptor.value);
+    return version;
+}
+export function assertWorkspaceDeclaredVersion(value, label) {
+    if (Array.isArray(value) || value === null || value === undefined)
+        return;
+    const record = ordinaryWorkspaceRecord(value, label);
+    if (!record)
+        return;
+    const descriptor = Object.getOwnPropertyDescriptor(record, 'version');
+    if (!descriptor)
+        return;
+    if (!('value' in descriptor)
+        || !Number.isSafeInteger(descriptor.value)
+        || Number(descriptor.value) < 1) {
+        throw inputError(label, 'a declared version must be a positive safe integer');
+    }
+}

package/{frontend/src/lib/analysis/investigation-guide.js → packages/workspace/investigation-guide.mjs}

@@ -1,10 +1,10 @@
-import { normalizeDomain } from "./case-model.js";
+import { normalizeDomain } from "../cases/case-model.mjs";
 import { parse } from 'tldts';
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
 export const INVESTIGATION_GUIDE_SCHEMA = 'whoisleuth.investigation-recipe';
 export const INVESTIGATION_GUIDE_VERSION = 5;
-export const INVESTIGATION_GUIDE_LEGACY_VERSION = 1;
 export const INVESTIGATION_GUIDE_EXPORT_VERSION = 4;
-export const INVESTIGATION_GUIDE_SUPPORTED_VERSIONS = [2, 3, 4, INVESTIGATION_GUIDE_VERSION];
+export const INVESTIGATION_GUIDE_SUPPORTED_VERSIONS = [INVESTIGATION_GUIDE_VERSION];
 export const INVESTIGATION_GUIDE_EXPORT_SCHEMA = 'whoisleuth.investigation-recipe-summary';
 export const MAX_INVESTIGATION_GUIDE_DOMAIN_LENGTH = 253;
 export const MAX_INVESTIGATION_GUIDE_REVIEW_DOMAINS = 25;
@@ -16,7 +16,6 @@ const CONTROL_RE = /[\x00-\x1f\x7f]/u;
 const SAFE_TEMPLATE_ID_RE = /^[A-Za-z0-9_-]{1,128}$/u;
 const GUIDE_STATUSES = new Set(['active', 'paused']);
 const GUIDE_OUTCOMES = new Set(['pending', 'complete', 'partial', 'skipped']);
-const PRE_RESPONSE_RECIPE_IDS = new Set(['brand_sweep', 'infrastructure_pivot', 'new_domain_triage']);
 function stage(id, workspace, label, detail, expectedEvidence, requestImpact, prerequisite, completionCriteria, instructions, requiresApproval) {
     return Object.freeze({
         id,
@@ -130,10 +129,7 @@ function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
 function timestamp(value) {
-    if (typeof value !== 'string' || value.length > MAX_INVESTIGATION_GUIDE_TIMESTAMP_LENGTH || CONTROL_RE.test(value))
-        return '';
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : '';
+    return normalizeExplicitIsoTimestamp(value) ?? '';
 }
 function nullableTimestamp(value) {
     if (value === null || value === undefined || value === '')
@@ -324,53 +320,22 @@ export function createInvestigationGuide(domain, recipeId = 'new_domain_triage',
         stages: stages.map((stageDefinition) => createStageProgress(stageDefinition, createdAt)),
     };
 }
-function parseLegacyGuide(input) {
-    const domain = normalizeInvestigationGuideDomain(input.domain);
-    const createdAt = timestamp(input.createdAt);
-    const updatedAt = timestamp(input.updatedAt);
-    const recipe = investigationGuideRecipe('new_domain_triage');
-    if (!domain || !createdAt || !updatedAt || !recipe)
-        return null;
-    const opened = new Set((Array.isArray(input.visitedStages) ? input.visitedStages : [])
-        .slice(0, recipe.stages.length * 2)
-        .filter((value) => typeof value === 'string'));
-    return {
-        version: INVESTIGATION_GUIDE_VERSION,
-        recipeId: recipe.id,
-        template: null,
-        domain,
-        focusDomain: null,
-        reviewDomains: [domain],
-        reviewDomainsTruncated: false,
-        status: 'active',
-        createdAt,
-        updatedAt,
-        stages: recipe.stages.map((stageDefinition) => ({
-            ...createStageProgress(stageDefinition, updatedAt),
-            openedAt: opened.has(stageDefinition.id) ? updatedAt : null,
-        })),
-    };
-}
 export function parseInvestigationGuide(value) {
     const input = record(value);
     if (!input)
         return null;
-    if (input.version === INVESTIGATION_GUIDE_LEGACY_VERSION)
-        return parseLegacyGuide(input);
     if (!INVESTIGATION_GUIDE_SUPPORTED_VERSIONS.includes(input.version))
         return null;
     const recipe = investigationGuideRecipe(input.recipeId);
     const domain = normalizeInvestigationGuideDomain(input.domain);
     const createdAt = timestamp(input.createdAt);
     const updatedAt = timestamp(input.updatedAt);
-    if (!recipe || !domain || !createdAt || !updatedAt
-        || (input.version !== INVESTIGATION_GUIDE_VERSION && !PRE_RESPONSE_RECIPE_IDS.has(recipe.id)))
+    if (!recipe || !domain || !createdAt || !updatedAt)
         return null;
-    const supportsTemplate = input.version === 3 || input.version === 4 || input.version === INVESTIGATION_GUIDE_VERSION;
-    const template = supportsTemplate && input.template !== null && input.template !== undefined
+    const template = input.template !== null && input.template !== undefined
         ? normalizeInvestigationGuideTemplateSnapshot(input.template, recipe.id)
         : null;
-    if (supportsTemplate && input.template !== null && input.template !== undefined && !template)
+    if (input.template !== null && input.template !== undefined && !template)
         return null;
     const stageDefinitions = template?.stages || recipe.stages;
     const normalizedReview = normalizeReviewDomains(input.reviewDomains);
@@ -401,9 +366,7 @@ export function parseInvestigationGuide(value) {
                 outcome: guideOutcome(item?.outcome),
                 approvedAt: nullableTimestamp(item?.approvedAt),
                 openedAt: nullableTimestamp(item?.openedAt),
-                reviewNote: input.version === 4 || input.version === INVESTIGATION_GUIDE_VERSION
-                    ? boundedReviewNote(item?.reviewNote)
-                    : null,
+                reviewNote: boundedReviewNote(item?.reviewNote),
                 updatedAt: timestamp(item?.updatedAt) || updatedAt,
             };
         }),

package/{frontend/src/lib/analysis/investigation-template-model.js → packages/workspace/investigation-template-model.mjs}

@@ -1,30 +1,23 @@
-import { INVESTIGATION_RECIPES, normalizeInvestigationGuideTemplateSnapshot, } from "./investigation-guide.js";
-export const INVESTIGATION_TEMPLATE_SCHEMA = 'whoisleuth.investigation-templates';
-export const INVESTIGATION_TEMPLATE_VERSION = 2;
-export const INVESTIGATION_TEMPLATE_SUPPORTED_VERSIONS = [1, INVESTIGATION_TEMPLATE_VERSION];
-export const MAX_INVESTIGATION_TEMPLATES = 20;
-export const MAX_INVESTIGATION_TEMPLATE_STORE_BYTES = 256 * 1024;
-export const MAX_INVESTIGATION_TEMPLATE_IMPORT_BYTES = 384 * 1024;
-const CONTROL_RE = /[\x00-\x1f\x7f]/u;
-const LEGACY_RECIPE_IDS = new Set(['brand_sweep', 'infrastructure_pivot', 'new_domain_triage']);
+import { INVESTIGATION_RECIPES, normalizeInvestigationGuideTemplateSnapshot, } from "./investigation-guide.mjs";
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
+import { assertWorkspaceDeclaredVersion, assertWorkspaceInputGraph, assertWorkspacePortableVersion, ordinaryWorkspaceRecord } from "./hostile-input.mjs";
+import { INVESTIGATION_TEMPLATE_SCHEMA, INVESTIGATION_TEMPLATE_SUPPORTED_VERSIONS, INVESTIGATION_TEMPLATE_VERSION, MAX_INVESTIGATION_TEMPLATES, MAX_INVESTIGATION_TEMPLATE_STORE_BYTES, } from "../contracts/workspace-portability.mjs";
+export { INVESTIGATION_TEMPLATE_SCHEMA, INVESTIGATION_TEMPLATE_SUPPORTED_VERSIONS, INVESTIGATION_TEMPLATE_VERSION, MAX_INVESTIGATION_TEMPLATES, MAX_INVESTIGATION_TEMPLATE_IMPORT_BYTES, MAX_INVESTIGATION_TEMPLATE_STORE_BYTES, } from "../contracts/workspace-portability.mjs";
 function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    return ordinaryWorkspaceRecord(value, 'Investigation-template input');
 }
 function timestamp(value) {
-    if (typeof value !== 'string' || value.length > 64 || CONTROL_RE.test(value))
-        return '';
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : '';
+    return normalizeExplicitIsoTimestamp(value) ?? '';
 }
 function byteLength(value) {
     return new TextEncoder().encode(value).byteLength;
 }
-function template(raw, sourceVersion = INVESTIGATION_TEMPLATE_VERSION) {
+function template(raw) {
     const value = record(raw);
     const snapshot = normalizeInvestigationGuideTemplateSnapshot(value);
     const createdAt = timestamp(value?.createdAt);
     const updatedAt = timestamp(value?.updatedAt);
-    return snapshot && createdAt && updatedAt && (sourceVersion !== 1 || LEGACY_RECIPE_IDS.has(snapshot.recipeId))
+    return snapshot && createdAt && updatedAt
         ? { ...snapshot, createdAt, updatedAt }
         : null;
 }
@@ -32,17 +25,18 @@ export function normalizeInvestigationTemplate(raw) {
     return template(raw);
 }
 export function normalizeInvestigationTemplateStore(raw) {
+    assertWorkspaceInputGraph(raw, 'Investigation-template store');
+    assertWorkspaceDeclaredVersion(raw, 'Investigation-template store');
     const value = record(raw);
     if (value?.schema === INVESTIGATION_TEMPLATE_SCHEMA
-        && Number(value.version) > INVESTIGATION_TEMPLATE_VERSION) {
-        throw new Error('This investigation-template collection uses a newer schema and cannot be read safely.');
+        && !INVESTIGATION_TEMPLATE_SUPPORTED_VERSIONS.includes(Number(value.version))) {
+        throw new Error(`Investigation-template schema ${String(value.version)} is unsupported; no data was changed.`);
     }
-    const sourceVersion = Array.isArray(raw) ? INVESTIGATION_TEMPLATE_VERSION : Number(value?.version) || INVESTIGATION_TEMPLATE_VERSION;
     const source = Array.isArray(raw) ? raw : Array.isArray(value?.templates) ? value.templates : [];
     const templates = [];
     const seen = new Set();
     for (const candidate of source.slice(0, MAX_INVESTIGATION_TEMPLATES * 2)) {
-        const normalized = template(candidate, sourceVersion);
+        const normalized = template(candidate);
         if (!normalized || seen.has(normalized.id))
             continue;
         seen.add(normalized.id);
@@ -119,11 +113,14 @@ function strictImport(raw) {
         throw new Error('This investigation-template export uses a newer schema and cannot be imported safely.');
     }
     if (!INVESTIGATION_TEMPLATE_SUPPORTED_VERSIONS.includes(Number(value.version))) {
-        throw new Error(`Expected investigation-template schema 1 or ${INVESTIGATION_TEMPLATE_VERSION}.`);
+        throw new Error(`Expected investigation-template schema ${INVESTIGATION_TEMPLATE_VERSION}.`);
     }
     return normalizeInvestigationTemplateStore(value).templates;
 }
 export function mergeInvestigationTemplates(localRaw, incomingRaw) {
+    assertWorkspaceInputGraph(localRaw, 'Local investigation-template store');
+    assertWorkspaceInputGraph(incomingRaw, 'Imported investigation-template document');
+    assertWorkspacePortableVersion(incomingRaw, INVESTIGATION_TEMPLATE_VERSION, 'Imported investigation-template document');
     const local = normalizeInvestigationTemplateStore(localRaw).templates;
     const incoming = strictImport(incomingRaw);
     const byId = new Map(local.map((item) => [item.id, item]));

package/{frontend/src/lib/analysis/page-baseline.js → packages/workspace/page-baseline.mjs}

@@ -2,18 +2,14 @@
 // deliberately accepts only bounded, normalized page-identity fields. Raw
 // HTML, URLs, headers, redirect inventories, and parser diagnostics never
 // cross this storage boundary.
-import { normalizeDomain } from "./case-model.js";
-import { isInformativeFaviconHash } from "./utils.js";
-export const PAGE_BASELINE_VERSION = 1;
-export const PAGE_IDENTITY_VERSION = 3;
-export const PAGE_FINGERPRINT_VERSION = 1;
-export const MAX_BASELINE_TITLE_LENGTH = 200;
-export const MAX_BASELINE_RESOURCE_HOSTS = 30;
-export const MAX_BASELINE_IDENTIFIERS = 30;
+import { normalizeDomain } from "../cases/case-model.mjs";
+import { isInformativePerceptualHash as isInformativeFaviconHash } from "../../lib/perceptual-hash-comparison.mjs";
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
+import { MAX_BASELINE_IDENTIFIERS, MAX_BASELINE_RESOURCE_HOSTS, MAX_BASELINE_TITLE_LENGTH, PAGE_BASELINE_VERSION, PAGE_FINGERPRINT_VERSION, PAGE_IDENTITY_VERSION, } from "../contracts/workspace-portability.mjs";
+export { MAX_BASELINE_IDENTIFIERS, MAX_BASELINE_RESOURCE_HOSTS, MAX_BASELINE_TITLE_LENGTH, PAGE_BASELINE_VERSION, PAGE_FINGERPRINT_VERSION, PAGE_IDENTITY_VERSION, } from "../contracts/workspace-portability.mjs";
 const SHA256_RE = /^[a-f0-9]{64}$/i;
 const SIMHASH_RE = /^[a-f0-9]{16}$/i;
 const CONTROL_RE = /[\x00-\x1f\x7f]/;
-const MAX_TIMESTAMP_LENGTH = 64;
 const MAX_HTML_TOKENS = 4096;
 const MAX_TEXT_TOKENS = 8192;
 const MAX_FORMS = 50;
@@ -24,10 +20,7 @@ function record(value) {
         : null;
 }
 function timestamp(value) {
-    if (typeof value !== 'string' || value.length > MAX_TIMESTAMP_LENGTH || CONTROL_RE.test(value))
-        return null;
-    const parsed = new Date(value);
-    return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+    return normalizeExplicitIsoTimestamp(value);
 }
 function count(value, maximum) {
     return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= maximum

package/{frontend/src/lib/analysis/relationship-observation-model.js → packages/workspace/relationship-observation-model.mjs}

@@ -1,12 +1,8 @@
-import { normalizeDomain } from "./case-model.js";
-export const RELATIONSHIP_OBSERVATION_SCHEMA = 'whoisleuth.relationship-observations';
-export const RELATIONSHIP_OBSERVATION_SCHEMA_VERSION = 1;
-export const MAX_RELATIONSHIP_OBSERVATIONS = 300;
-export const MAX_RELATIONSHIP_OBSERVATION_INPUTS = 1_200;
-export const MAX_RELATIONSHIP_OBSERVATION_DOMAINS = 50;
-export const MAX_RELATIONSHIP_OBSERVATION_LIMITATIONS = 8;
-export const MAX_RELATIONSHIP_OBSERVATION_VALUE_LENGTH = 20_000;
-export const MAX_RELATIONSHIP_OBSERVATION_STORE_BYTES = 768 * 1024;
+import { normalizeDomain } from "../cases/case-model.mjs";
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
+import { assertWorkspaceDeclaredVersion, assertWorkspaceInputGraph, assertWorkspacePortableVersion, ordinaryWorkspaceRecord } from "./hostile-input.mjs";
+import { MAX_RELATIONSHIP_OBSERVATIONS, MAX_RELATIONSHIP_OBSERVATION_DOMAINS, MAX_RELATIONSHIP_OBSERVATION_INPUTS, MAX_RELATIONSHIP_OBSERVATION_LIMITATIONS, MAX_RELATIONSHIP_OBSERVATION_STORE_BYTES, MAX_RELATIONSHIP_OBSERVATION_VALUE_LENGTH, RELATIONSHIP_OBSERVATION_SCHEMA, RELATIONSHIP_OBSERVATION_SCHEMA_VERSION, } from "../contracts/workspace-portability.mjs";
+export { MAX_RELATIONSHIP_OBSERVATIONS, MAX_RELATIONSHIP_OBSERVATION_DOMAINS, MAX_RELATIONSHIP_OBSERVATION_INPUTS, MAX_RELATIONSHIP_OBSERVATION_LIMITATIONS, MAX_RELATIONSHIP_OBSERVATION_STORE_BYTES, MAX_RELATIONSHIP_OBSERVATION_VALUE_LENGTH, RELATIONSHIP_OBSERVATION_SCHEMA, RELATIONSHIP_OBSERVATION_SCHEMA_VERSION, } from "../contracts/workspace-portability.mjs";
 export const RELATIONSHIP_OBSERVATION_TYPES = Object.freeze([
     'nameserver_set',
     'ip_address',
@@ -48,7 +44,7 @@ const TYPE_METADATA = Object.freeze({
         description: 'These domains used an identical or perceptually similar favicon in the retained scan.',
     }),
     official_asset: Object.freeze({
-        label: 'Official asset relationship',
+        label: 'Official asset host match',
         method: 'Configured-domain host match',
         description: 'One or more pages loaded an asset from this configured official domain or its subdomain.',
     }),
@@ -58,9 +54,7 @@ const FIXED_LIMITATIONS = Object.freeze([
     'A shared observation does not prove ownership, coordination, intent, or maliciousness.',
 ]);
 function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
+    return ordinaryWorkspaceRecord(value, 'Relationship-observation input');
 }
 function text(value, maximum) {
     if (typeof value !== 'string' || value.length > maximum * 4 || CONTROL_RE.test(value))
@@ -68,10 +62,7 @@ function text(value, maximum) {
     return value.replace(/\s+/gu, ' ').trim().slice(0, maximum).trim();
 }
 function timestamp(value) {
-    if (typeof value !== 'string' || value.length > 64 || CONTROL_RE.test(value))
-        return '';
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : '';
+    return normalizeExplicitIsoTimestamp(value) ?? '';
 }
 function positiveInteger(value) {
     return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 && value <= 1_000
@@ -262,6 +253,8 @@ export function normalizeRelationshipObservation(raw) {
     };
 }
 export function normalizeRelationshipObservationStore(raw) {
+    assertWorkspaceInputGraph(raw, 'Relationship-observation store');
+    assertWorkspaceDeclaredVersion(raw, 'Relationship-observation store');
     const byId = new Map();
     for (const candidate of observationList(raw).slice(0, MAX_RELATIONSHIP_OBSERVATION_INPUTS)) {
         const observation = normalizeRelationshipObservation(candidate);
@@ -361,6 +354,9 @@ export function deleteRelationshipObservation(rawStore, id) {
     return normalizeRelationshipObservationStore(rawStore).observations.filter((item) => item.id !== safeId);
 }
 export function mergeRelationshipObservations(localRaw, importedRaw) {
+    assertWorkspaceInputGraph(localRaw, 'Local relationship-observation store');
+    assertWorkspaceInputGraph(importedRaw, 'Imported relationship-observation document');
+    assertWorkspacePortableVersion(importedRaw, RELATIONSHIP_OBSERVATION_SCHEMA_VERSION, 'Imported relationship-observation document');
     const importedRecord = record(importedRaw);
     if (importedRecord?.schema !== undefined && importedRecord.schema !== RELATIONSHIP_OBSERVATION_SCHEMA) {
         throw new Error('This JSON section is not a WHOISleuth relationship-observation export.');

package/{frontend/src/lib/analysis/shortlist-model.js → packages/workspace/shortlist-model.mjs}

@@ -1,23 +1,18 @@
 // Pure browser-local shortlist model. The browser wrapper owns persistence
 // and downloads; this module owns schema migration, record normalization,
 // import merging, and exact serialized-byte accounting.
-import { compactWatchlistResults } from "./watchlist-history.js";
-import { normalizeOpportunityModelVersion, normalizeRiskModelVersion } from "./scoring.js";
-export const SHORTLIST_SCHEMA = 'whoisleuth.shortlist';
-export const SHORTLIST_SCHEMA_VERSION = 3;
-export const SUPPORTED_SHORTLIST_SCHEMA_VERSIONS = Object.freeze([2, SHORTLIST_SCHEMA_VERSION]);
-export const MAX_SHORTLIST_ENTRIES = 500;
-export const MAX_SHORTLIST_INPUTS = MAX_SHORTLIST_ENTRIES * 4;
-export const MAX_SHORTLIST_STORE_BYTES = 1024 * 1024;
-export const MAX_SHORTLIST_FACTORS = 20;
+import { compactWatchlistResults } from "./watchlist-history.mjs";
+import { normalizeOpportunityModelVersion } from "../../lib/opportunity-scoring.mjs";
+import { normalizeRiskModelVersion } from "../../lib/risk-scoring.mjs";
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
+import { assertWorkspaceDeclaredVersion, assertWorkspaceInputGraph, assertWorkspacePortableVersion, ordinaryWorkspaceRecord } from "./hostile-input.mjs";
+import { MAX_SHORTLIST_ENTRIES, MAX_SHORTLIST_FACTORS, MAX_SHORTLIST_INPUTS, MAX_SHORTLIST_STORE_BYTES, SHORTLIST_SCHEMA, SHORTLIST_SCHEMA_VERSION, SUPPORTED_SHORTLIST_SCHEMA_VERSIONS, } from "../contracts/workspace-portability.mjs";
+export { MAX_SHORTLIST_ENTRIES, MAX_SHORTLIST_FACTORS, MAX_SHORTLIST_INPUTS, MAX_SHORTLIST_STORE_BYTES, SHORTLIST_SCHEMA, SHORTLIST_SCHEMA_VERSION, SUPPORTED_SHORTLIST_SCHEMA_VERSIONS, } from "../contracts/workspace-portability.mjs";
 const MAX_FACTOR_LABEL_LENGTH = 200;
-const MAX_TIMESTAMP_LENGTH = 64;
 const CONTROL_RE = /[\x00-\x1f\x7f]/;
 const EPOCH = new Date(0).toISOString();
 function plainRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
+    return ordinaryWorkspaceRecord(value, 'Shortlist input');
 }
 function isEnvelope(value) {
     return Boolean(value && value.schema === SHORTLIST_SCHEMA && Array.isArray(value.entries));
@@ -30,7 +25,7 @@ function entryList(raw) {
 }
 export function shortlistStoreVersion(raw) {
     if (Array.isArray(raw))
-        return 1;
+        return SHORTLIST_SCHEMA_VERSION;
     const value = plainRecord(raw);
     if (!value || !isEnvelope(value))
         return null;
@@ -44,10 +39,7 @@ function score(value) {
         : null;
 }
 function timestamp(value, fallback = EPOCH) {
-    if (typeof value !== 'string' || value.length > MAX_TIMESTAMP_LENGTH || CONTROL_RE.test(value))
-        return fallback;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : fallback;
+    return normalizeExplicitIsoTimestamp(value) ?? fallback;
 }
 function factors(value) {
     if (!Array.isArray(value))
@@ -93,7 +85,14 @@ export function normalizeShortlistRecord(raw, options = {}) {
 }
 /** Normalize an internal record collection or current stored envelope. */
 export function normalizeShortlistStore(raw) {
+    assertWorkspaceInputGraph(raw, 'Shortlist store');
+    assertWorkspaceDeclaredVersion(raw, 'Shortlist store');
     const source = entryList(raw);
+    const sourceVersion = shortlistStoreVersion(raw);
+    if (!Array.isArray(raw) && sourceVersion !== null
+        && !SUPPORTED_SHORTLIST_SCHEMA_VERSIONS.includes(sourceVersion)) {
+        throw new Error(`Shortlist schema ${sourceVersion} is unsupported; no data was changed.`);
+    }
     const byDomain = new Map();
     if (source) {
         for (const item of source.slice(0, MAX_SHORTLIST_INPUTS)) {
@@ -167,6 +166,9 @@ function validateImport(raw) {
     }
 }
 export function mergeShortlistStores(localRaw, importedRaw) {
+    assertWorkspaceInputGraph(localRaw, 'Local shortlist store');
+    assertWorkspaceInputGraph(importedRaw, 'Imported shortlist document');
+    assertWorkspacePortableVersion(importedRaw, SHORTLIST_SCHEMA_VERSION, 'Imported shortlist document');
     validateImport(importedRaw);
     const importedVersion = shortlistStoreVersion(importedRaw);
     if (importedVersion !== null && importedVersion > SHORTLIST_SCHEMA_VERSION) {