@slicedearth/whoisleuth-cli 2.3.0 → 2.5.1

package/packages/cases/case-report.mjs

@@ -8,18 +8,23 @@
 // contains raw RDAP/WHOIS material. This module deliberately excludes all raw
 // registry/web responses, contacts, cookies, screenshots, and authentication
 // data. Reports contain only the normalized case record.
-import { caseEvidenceIncomparableReasons, compareCaseEvidence, latestCaseEvidence } from "./case-model.mjs";
+import { caseEvidenceTimeline, compareCaseEvidence, currentCaseEvidence, publishedCaseEvidenceTimelineForVerification } from "./case-evidence-model.mjs";
 import { httpSecurityHeaderLabel } from "./http-summary.mjs";
-import { analystInteroperabilityTags } from "../../lib/analyst-taxonomy.mjs";
-import { buildPortableGeneratorMetadata, portableGeneratorAttribution, } from "../../lib/portable-generator.mjs";
+import { webCollectionScoreLimitation } from "../evidence/collection-quality.mjs";
+import { analystInteroperabilityTags } from "../analysis/analyst-taxonomy.mjs";
+import { caseEvidenceLinkIssues } from "./case-evidence-links.mjs";
+import { caseTypeSummary } from "./case-workflow-metadata.mjs";
+import { buildPortableGeneratorMetadata, portableGeneratorAttribution, } from "../analysis/portable-generator.mjs";
 import { buildCaseResponseLifecycleSummary, CASE_EVIDENCE_RELATION_STANCES } from "./case-response-model.mjs";
 import { normalizeCaseBrandProfileIds } from "./case-brand-profile-references.mjs";
-import { CASE_REPORT_SCHEMA, CASE_REPORT_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
+import { CASE_RECHECK_CONDITIONS } from "./case-recheck-model.mjs";
+import { escapeCaseMarkdownInline as escapeMarkdownInline } from "./case-markdown.mjs";
+import { CASE_REPORT_SCHEMA, CASE_REPORT_SCHEMA_VERSION, LATEST_PUBLIC_CASE_REPORT_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_REPORT_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 export { CASE_REPORT_SCHEMA, CASE_REPORT_SCHEMA_VERSION };
-const LIMITATIONS_TEXT = [
+const PUBLISHED_V2_3_LIMITATIONS = Object.freeze([
     'This report contains normalised browser-local observations from WHOISleuth analyst cases.',
     'It is not a live lookup and does not contain raw WHOIS, RDAP, DNS, HTML, or responses collected during website checks.',
     'Absence of a signal (e.g. no MX record observed) does not prove nonexistence. It may not have been evaluated.',
@@ -28,17 +33,12 @@ const LIMITATIONS_TEXT = [
     'Brand Profile references record an explicit analyst-selected association only; they do not establish ownership, attribution, intent, safety, or maliciousness.',
     'Provider workflow outcomes and independently observed technical effects remain separately attributed. A provider outcome does not establish independent remediation, absence, or safety; neither evidence family establishes legal sufficiency or provider performance.',
     'Generated locally in the browser. Review the package before sharing it.',
+]);
+const LIMITATIONS_TEXT = [
+    ...PUBLISHED_V2_3_LIMITATIONS.slice(0, 2),
+    'Snapshot hostnames are excluded; supporting DNS, TLS and web observations need not concern the Case registration domain.',
+    ...PUBLISHED_V2_3_LIMITATIONS.slice(2),
 ].join(' ');
-function escapeMarkdownInline(text) {
-    return String(text)
-        .replace(/[\r\n\u2028\u2029]+/g, ' ')
-        .replace(/([\\`*_{}\[\]<>()#+!|~])/g, '\\$1')
-        // GFM autolinks bare URLs independently of ordinary link syntax. Break
-        // the scheme or the first `www.` separator without making normal domains,
-        // dates, and prose noisy in the report source.
-        .replace(/\b([a-z][a-z0-9+.-]{1,31}):(?=\/\/)/gi, '$1\\:')
-        .replace(/\bwww\.(?=\S)/gi, 'www\\.');
-}
 /**
  * Escapes a multiline note body for safe inclusion in a Markdown blockquote.
  * Each line is individually escaped and prefixed with `> `.
@@ -84,6 +84,12 @@ function formatReportValue(value, field) {
         return String(value);
     return String(value);
 }
+function readableRiskScore(snapshot) {
+    const value = escapeMarkdownInline(formatReportValue(snapshot.riskScore));
+    const limitation = snapshot.riskScore === null ? null
+        : webCollectionScoreLimitation(snapshot.webCollectionQuality, snapshot.scanDepth);
+    return limitation ? `${value} — ${escapeMarkdownInline(limitation)}` : value;
+}
 /**
  * Returns a shallow clone of a snapshot containing only known schema fields.
  * Unknown/imported keys are never included.
@@ -100,10 +106,12 @@ function pickKnownSnapshotFields(snapshot) {
     return {
         id: snapshot.id,
         fingerprint: snapshot.fingerprint,
+        ...(snapshot.factorOrder ? { factorOrder: snapshot.factorOrder } : {}),
         firstCapturedAt: snapshot.firstCapturedAt,
         capturedAt: snapshot.capturedAt,
         source: snapshot.source,
         scanDepth: snapshot.scanDepth,
+        ...(snapshot.webCollectionQuality ? { webCollectionQuality: { ...snapshot.webCollectionQuality } } : {}),
         availability: snapshot.availability,
         confidence: snapshot.confidence,
         riskModelVersion: snapshot.riskModelVersion,
@@ -165,51 +173,10 @@ export function buildCaseReport(caseRecord, options = {}) {
     const now = generatedAt || new Date().toISOString();
     const generator = buildPortableGeneratorMetadata(options.applicationVersion);
     // --- Build JSON report ---
-    const timelineEntries = [];
-    if (Array.isArray(caseRecord.evidenceHistory) && caseRecord.evidenceHistory.length > 0) {
-        const chronological = [...caseRecord.evidenceHistory];
-        for (let i = 0; i < chronological.length; i++) {
-            const snapshot = chronological[i];
-            if (!snapshot)
-                continue;
-            const isBaseline = i === 0;
-            const hasRepeatedObservation = snapshot.firstCapturedAt !== snapshot.capturedAt;
-            let changes = null;
-            let hasIncomparableChange = false;
-            let incomparableReasons = [];
-            if (!isBaseline) {
-                const previous = chronological[i - 1];
-                if (!previous)
-                    continue;
-                const rawChanges = compareCaseEvidence(previous, snapshot);
-                incomparableReasons = caseEvidenceIncomparableReasons(previous, snapshot);
-                const hostnameContextChanged = incomparableReasons.includes('observation-context');
-                if (rawChanges.length > 0 && !hostnameContextChanged) {
-                    changes = rawChanges.map((change) => ({
-                        field: change.field,
-                        label: change.label,
-                        before: change.before,
-                        after: change.after,
-                        tone: change.tone,
-                    }));
-                }
-                else if (snapshot.fingerprint !== previous.fingerprint
-                    && incomparableReasons.length === 0) {
-                    incomparableReasons = ['other'];
-                }
-                hasIncomparableChange = incomparableReasons.length > 0;
-            }
-            timelineEntries.push({
-                snapshot: pickKnownSnapshotFields(snapshot),
-                isBaseline,
-                hasRepeatedObservation,
-                changes,
-                hasIncomparableChange,
-                incomparableReasons,
-            });
-        }
-    }
-    const latest = latestCaseEvidence({ evidenceHistory: caseRecord.evidenceHistory ?? undefined });
+    const timeline = caseEvidenceTimeline(caseRecord.evidenceHistory);
+    const timelineEntries = projectReportTimeline(timeline);
+    const selection = currentCaseEvidence(caseRecord);
+    const latest = selection.snapshot;
     const currentAssessment = latest ? pickKnownSnapshotFields(latest) : null;
     const responseLifecycle = buildCaseResponseLifecycleSummary(caseRecord);
     const observedEffects = caseRecord.observedEffects ?? {
@@ -231,6 +198,7 @@ export function buildCaseReport(caseRecord, options = {}) {
         application: generator,
         case: {
             id: caseRecord.id,
+            title: caseRecord.title ?? '',
             domain: caseRecord.domain,
             status: caseRecord.status,
             disposition: caseRecord.disposition,
@@ -247,7 +215,9 @@ export function buildCaseReport(caseRecord, options = {}) {
         currentAssessment,
         evidenceTimeline: timelineEntries,
         analystResponse: {
+            ...(caseRecord.workflowMetadata === undefined ? {} : { workflowMetadata: structuredClone(caseRecord.workflowMetadata) }),
             evidencePins: caseRecord.evidencePins.map((item) => ({ ...item, limitations: [...item.limitations] })),
+            ...(caseRecord.evidenceLinks === undefined ? {} : { evidenceLinks: structuredClone(caseRecord.evidenceLinks) }),
             decisions: caseRecord.decisions.map((item) => ({ ...item, evidencePinIds: [...item.evidencePinIds] })),
             actions: caseRecord.actions.map((item) => ({
                 ...item,
@@ -290,12 +260,42 @@ export function buildCaseReport(caseRecord, options = {}) {
             })),
         },
         responseLifecycle,
-        limitations: LIMITATIONS_TEXT,
+        limitations: [LIMITATIONS_TEXT, selection.limitation, ...new Set(timeline.map((entry) => entry.orderingLimitation))].filter(Boolean).join(' '),
     };
     // --- Build Markdown ---
     const md = buildMarkdown(json, options.includeAttribution !== false);
     return { json, markdown: md };
 }
+function projectReportTimeline(timeline) {
+    return timeline.map(entry => ({
+        snapshot: pickKnownSnapshotFields(entry.snapshot), isBaseline: entry.isBaseline,
+        hasRepeatedObservation: entry.hasRepeatedObservation,
+        changes: entry.changes?.map(({ field, label, before, after, tone }) => ({ field, label, before, after, tone })) ?? null,
+        hasIncomparableChange: entry.hasIncomparableChange, incomparableReasons: [...entry.incomparableReasons],
+    }));
+}
+/** Expected strict reader projection; historical disclosure wording is immutable. */
+export function buildCaseReportVerificationProjection(caseRecord, options, schemaVersion) {
+    const generated = buildCaseReport(caseRecord, options).json;
+    if (schemaVersion === CASE_REPORT_SCHEMA_VERSION)
+        return generated;
+    if (caseRecord.evidenceHistory.some(snapshot => snapshot.webCollectionQuality !== undefined)) {
+        throw new TypeError('Published report formats cannot declare newer collection-quality fields.');
+    }
+    const current = { ...generated, evidenceTimeline: projectReportTimeline(publishedCaseEvidenceTimelineForVerification(caseRecord.evidenceHistory)) };
+    if (schemaVersion === LATEST_PUBLIC_CASE_REPORT_SCHEMA_VERSION)
+        return { ...current, schemaVersion };
+    if (schemaVersion !== PUBLISHED_V2_3_CASE_REPORT_SCHEMA_VERSION) {
+        throw new TypeError('No strict Case report projection is defined for this version.');
+    }
+    const { title: _title, ...publishedCase } = current.case;
+    return {
+        ...current,
+        case: publishedCase,
+        schemaVersion,
+        limitations: PUBLISHED_V2_3_LIMITATIONS.join(' ') + current.limitations.slice(LIMITATIONS_TEXT.length),
+    };
+}
 // ---------------------------------------------------------------------------
 // Markdown generation
 // ---------------------------------------------------------------------------
@@ -310,6 +310,11 @@ function buildMarkdown(report, includeAttribution) {
     const domain = escapeMarkdownInline(report.case.domain || 'unknown');
     lines.push(`# Case Report: ${domain}`);
     lines.push('');
+    if (report.case.title) {
+        lines.push(`**Incident:** ${escapeMarkdownInline(report.case.title)}`);
+        lines.push('');
+    }
+    lines.push(`**Case ID:** ${escapeMarkdownInline(report.case.id)}`);
     // Metadata
     lines.push(`**Generated:** ${escapeMarkdownInline(report.generatedAt)}`);
     lines.push(`**Report schema:** ${escapeMarkdownInline(report.schema)} v${report.schemaVersion}`);
@@ -330,6 +335,17 @@ function buildMarkdown(report, includeAttribution) {
     if (report.case.tags.length > 0) {
         lines.push(`| Tags | ${escapeMarkdownInline(report.case.tags.join(', '))} |`);
     }
+    const caseTypes = caseTypeSummary(report.analystResponse.workflowMetadata ? { workflowMetadata: report.analystResponse.workflowMetadata } : {});
+    if (caseTypes)
+        lines.push(`| Case types | ${escapeMarkdownInline(caseTypes)} |`);
+    const context = report.analystResponse.workflowMetadata?.investigationContext;
+    if (context) {
+        lines.push(`| Investigation objective | ${escapeMarkdownInline(context.objective)} |`);
+        lines.push(`| Incident URL (${context.urlRetention === 'exact' ? 'exact' : 'origin only'}) | ${escapeMarkdownInline(context.incidentUrl)} |`);
+    }
+    for (const target of report.analystResponse.workflowMetadata?.incidentTargets ?? []) {
+        lines.push(`| Incident link (${target.state}) | ${escapeMarkdownInline(target.url)} |`);
+    }
     lines.push(`| Notes included | ${report.case.notesIncluded ? 'Yes' : 'No'} |`);
     lines.push('');
     // Current assessment
@@ -338,7 +354,7 @@ function buildMarkdown(report, includeAttribution) {
     if (report.currentAssessment) {
         const a = report.currentAssessment;
         lines.push(`- **Availability:** ${escapeMarkdownInline(formatReportValue(a.availability))}`);
-        lines.push(`- **Risk score:** ${escapeMarkdownInline(formatReportValue(a.riskScore))}`);
+        lines.push(`- **Risk score:** ${readableRiskScore(a)}`);
         lines.push(`- **Risk model:** ${a.riskModelVersion === null ? 'Unversioned' : `v${escapeMarkdownInline(formatReportValue(a.riskModelVersion))}`}`);
         lines.push(`- **Brand Profile context:** ${escapeMarkdownInline(formatReportValue(a.profileContextState))}`);
         if (a.profileContextLimitation)
@@ -355,7 +371,9 @@ function buildMarkdown(report, includeAttribution) {
         lines.push(`- **Source:** ${escapeMarkdownInline(formatReportValue(a.source))}`);
     }
     else {
-        lines.push('No evidence captured.');
+        lines.push(report.evidenceTimeline.length
+            ? 'Retained snapshots have no unique latest assessment. Review the timeline and limitations.'
+            : 'No evidence captured.');
     }
     lines.push('');
     // Evidence timeline
@@ -391,7 +409,7 @@ function buildMarkdown(report, includeAttribution) {
             lines.push('**Key evidence:**');
             lines.push('');
             lines.push(`- Availability: ${escapeMarkdownInline(formatReportValue(snap.availability))}`);
-            lines.push(`- Risk score: ${escapeMarkdownInline(formatReportValue(snap.riskScore))}`);
+            lines.push(`- Risk score: ${readableRiskScore(snap)}`);
             lines.push(`- Risk model: ${snap.riskModelVersion === null ? 'Unversioned' : `v${escapeMarkdownInline(formatReportValue(snap.riskModelVersion))}`}`);
             lines.push(`- Brand Profile context: ${escapeMarkdownInline(formatReportValue(snap.profileContextState))}`);
             if (snap.profileContextLimitation)
@@ -458,6 +476,8 @@ function buildMarkdown(report, includeAttribution) {
                     lines.push('> Opportunity scores and factors use different or unversioned models, so their numeric difference is not treated as a domain change.');
                 if (reasons.includes('scan-depth'))
                     lines.push('> Capture depths differ, so unevaluated deep signals are not treated as additions or removals.');
+                if (reasons.includes('collection-quality'))
+                    lines.push('> Missing or incomplete observations prevent comparison of affected registration, page, favicon or score fields.');
                 if (reasons.length === 0 || reasons.includes('other'))
                     lines.push('> The observations differ materially, but no reliable field-level comparison is available.');
                 lines.push('');
@@ -467,7 +487,7 @@ function buildMarkdown(report, includeAttribution) {
     lines.push('## Analyst Decision Packet');
     lines.push('');
     const response = report.analystResponse;
-    if (!response.evidencePins.length && !response.sightings.length && !response.decisions.length && !response.actions.length && !response.assertions.length && !response.manualTrail.length && !response.observedEffects.reviews.length && !response.closures.records.length && !response.branches.length) {
+    if (!response.evidencePins.length && !response.evidenceLinks?.length && !response.sightings.length && !response.decisions.length && !response.actions.length && !response.assertions.length && !response.manualTrail.length && !response.observedEffects.reviews.length && !response.closures.records.length && !response.branches.length) {
         lines.push('No evidence pins, source-qualified sightings, structured assertions, decision records, response actions, independent effect reviews, closures, or manual investigation steps recorded.');
         lines.push('');
     }
@@ -478,7 +498,7 @@ function buildMarkdown(report, includeAttribution) {
             lines.push('No evidence pins recorded.');
         for (const pin of response.evidencePins) {
             lines.push(`- **${escapeMarkdownInline(pin.label)}:** ${escapeMarkdownInline(pin.value)}`);
-            lines.push(`  Source: ${escapeMarkdownInline(pin.source)}; observed ${escapeMarkdownInline(pin.observedAt)}; completeness ${escapeMarkdownInline(pin.completeness)}.`);
+            lines.push(`  Source: ${escapeMarkdownInline(pin.source)}; observed ${escapeMarkdownInline(pin.observedAt ?? 'Time unavailable')}; completeness ${escapeMarkdownInline(pin.completeness)}.`);
             if (pin.limitations.length)
                 lines.push(`  Limitations: ${escapeMarkdownInline(pin.limitations.join('; '))}`);
         }
@@ -488,7 +508,7 @@ function buildMarkdown(report, includeAttribution) {
         if (!response.sightings.length)
             lines.push('No source-qualified sightings recorded.');
         for (const sighting of response.sightings) {
-            lines.push(`- **${escapeMarkdownInline(sighting.state.replaceAll('_', ' '))}:** ${escapeMarkdownInline(sighting.category)} (${escapeMarkdownInline(sighting.observedAt)})`);
+            lines.push(`- **${escapeMarkdownInline(sighting.state.replaceAll('_', ' '))}:** ${escapeMarkdownInline(sighting.category)} (${escapeMarkdownInline(sighting.observedAt ?? 'Observation time unavailable')})`);
             lines.push(`  Source: ${escapeMarkdownInline(sighting.source)}; class ${escapeMarkdownInline(sighting.sourceClass)}; completeness ${escapeMarkdownInline(sighting.completeness)}.`);
             if (sighting.evidencePinId)
                 lines.push(`  Evidence pin: ${escapeMarkdownInline(sighting.evidencePinId)}`);
@@ -512,6 +532,11 @@ function buildMarkdown(report, includeAttribution) {
                 lines.push(`- **${escapeMarkdownInline(assertion.state)}:** ${escapeMarkdownInline(assertion.statement)}`);
                 if (assertion.rationale)
                     lines.push(`  ${escapeMarkdownInline(assertion.rationale)}`);
+                if (assertion.recheck) {
+                    lines.push(`  Recheck target: ${escapeMarkdownInline(assertion.recheck.targetHostname)}; comparison conditions: ${escapeMarkdownInline(assertion.recheck.conditions)}`);
+                    if (assertion.recheck.baselinePinId)
+                        lines.push(`  Baseline evidence pin: ${escapeMarkdownInline(assertion.recheck.baselinePinId)}`);
+                }
                 if (assertion.provenance) {
                     lines.push(`  External provenance: ${escapeMarkdownInline(assertion.provenance.format.toUpperCase())}; source ${escapeMarkdownInline(assertion.provenance.sourceName)}; file SHA-256 ${escapeMarkdownInline(assertion.provenance.sourceDigestSha256)}.`);
                     if (assertion.provenance.publisher)
@@ -537,6 +562,12 @@ function buildMarkdown(report, includeAttribution) {
             }
             lines.push('');
         }
+        if (response.evidenceLinks?.length) {
+            lines.push('### Analyst-declared evidence relationships', '');
+            for (const { link, missingPinIds, cyclic } of caseEvidenceLinkIssues(response.evidenceLinks, response.evidencePins))
+                lines.push(`- ${escapeMarkdownInline(link.fromPinId)} ${link.kind === 'derived_from' ? 'derived from' : 'shares a source with'} ${escapeMarkdownInline(link.toPinId)} · recorded ${link.createdAt}`, `  Basis: ${escapeMarkdownInline(link.basis)}`, ...(link.withdrawal ? [`  Withdrawn ${link.withdrawal.at}: ${escapeMarkdownInline(link.withdrawal.reason)}`] : []), ...(missingPinIds.length ? [`  Referenced pins not retained: ${missingPinIds.map(escapeMarkdownInline).join(', ')}`] : []), ...(cyclic ? ['  Conflicting imported derivation cycle; no order is inferred.'] : []));
+            lines.push('These relationships record analyst attribution, not independent corroboration or added confidence.', '');
+        }
         lines.push('### Decisions');
         lines.push('');
         if (!response.decisions.length)
@@ -562,6 +593,13 @@ function buildMarkdown(report, includeAttribution) {
                 lines.push(`  Route review due: ${escapeMarkdownInline(action.routeReviewAfter)}`);
             if (action.originActionId)
                 lines.push(`  Originating action: ${escapeMarkdownInline(action.originActionId)}`);
+            if (action.amendment)
+                lines.push(`  Amendment of submitted packet SHA-256: ${action.amendment.packetDigestSha256}; request events: ${action.amendment.requestEventIds.map(escapeMarkdownInline).join(', ')}`);
+            for (const event of action.history)
+                if (event.evidenceRequest) {
+                    const request = event.evidenceRequest;
+                    lines.push(`  Requested evidence [${request.state}]: ${escapeMarkdownInline(request.summary)}; deadline: ${request.dueAt ?? 'not stated'}; original packet: ${request.packetDigestSha256}${event.applied ? '' : ' (retained conflict)'}`, `  Prepared pins: ${request.evidencePinIds.map(escapeMarkdownInline).join(', ') || 'none'}${request.rationale ? `; ${escapeMarkdownInline(request.rationale)}` : ''}`);
+                }
             if (action.dueAt)
                 lines.push(`  Due: ${escapeMarkdownInline(action.dueAt)}`);
             if (action.followUpAt)
@@ -623,10 +661,19 @@ function buildMarkdown(report, includeAttribution) {
         : `- Latest independently observed change time: Withheld because the independent change state is ${escapeMarkdownInline(report.responseLifecycle.observedChangeState)}.`);
     if (observedEffect)
         lines.push(`- Latest independent review: ${escapeMarkdownInline(observedEffect.state.replaceAll('_', ' '))} at ${escapeMarkdownInline(observedEffect.observedAt)} from ${escapeMarkdownInline(observedEffect.source)}.`);
+    else if (response.observedEffects.reviews.length)
+        lines.push('- A single latest independent review cannot be selected from the retained observation times. Review the individual records below.');
     if (!response.observedEffects.reviews.length)
         lines.push('- No independent observed-effect review recorded.');
     for (const review of response.observedEffects.reviews) {
         lines.push(`- **${escapeMarkdownInline(review.state.replaceAll('_', ' '))}** (${escapeMarkdownInline(review.observedAt)}): ${escapeMarkdownInline(review.source)}; class ${escapeMarkdownInline(review.sourceClass)}; completeness ${escapeMarkdownInline(review.completeness)}.`);
+        if (review.recheck) {
+            lines.push(`  Question ${escapeMarkdownInline(review.recheck.questionId)}: ${escapeMarkdownInline(review.recheck.question)}`);
+            lines.push(`  Recheck target: ${escapeMarkdownInline(review.recheck.targetHostname)}; retained comparison conditions: ${escapeMarkdownInline(review.recheck.conditions)}`);
+            lines.push(`  Condition comparison: ${escapeMarkdownInline(CASE_RECHECK_CONDITIONS[review.recheck.conditionsMatch])}`);
+            if (review.recheck.baselinePinId)
+                lines.push(`  Baseline evidence pin: ${escapeMarkdownInline(review.recheck.baselinePinId)}`);
+        }
         if (review.evidencePinId)
             lines.push(`  Evidence pin: ${escapeMarkdownInline(review.evidencePinId)}`);
         if (review.sightingId)

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

@@ -0,0 +1,146 @@
+import { array, enumeration, exact, HEX_DIGEST_RE, iso, text } from "../evidence/artifact-structure.mjs";
+import { assertWorkspaceInputGraph } from "../workspace/hostile-input.mjs";
+import { MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_VALUE_LENGTH } from "../contracts/case-portability.mjs";
+import { SAFE_ID_RE } from "./case-response-values.mjs";
+function identifier(value, label) {
+    const result = text(value, label, 64);
+    if (!SAFE_ID_RE.test(result))
+        throw new TypeError(`${label} is invalid.`);
+    return result;
+}
+function identifiers(value, label) {
+    const result = array(value, label, MAX_DECISION_PIN_REFERENCES).map(item => identifier(item, label));
+    if (new Set(result).size !== result.length)
+        throw new TypeError(`${label} contains duplicate identities.`);
+    return result;
+}
+function packetDigest(value) {
+    if (typeof value !== 'string' || !HEX_DIGEST_RE.test(value))
+        throw new TypeError('Select a recorded submitted-packet digest.');
+    return value;
+}
+export function readCaseEvidenceRequest(raw) {
+    if (raw === undefined)
+        return undefined;
+    assertWorkspaceInputGraph(raw, 'Requested evidence');
+    const row = exact(raw, ['id', 'packetDigestSha256', 'summary', 'dueAt', 'state', 'evidencePinIds', 'rationale', 'previousEventIds'], 'Requested evidence');
+    iso(row.dueAt, 'Requested evidence deadline', true);
+    const summary = text(row.summary, 'Requested evidence summary', MAX_RESPONSE_VALUE_LENGTH).trim();
+    const rationale = text(row.rationale, 'Requested evidence rationale', MAX_RESPONSE_RATIONALE_LENGTH, true).trim();
+    const state = enumeration(row.state, ['requested', 'prepared', 'unavailable'], 'Requested evidence state');
+    const evidencePinIds = identifiers(row.evidencePinIds, 'Requested evidence pins');
+    if (!summary || (state === 'prepared' && !evidencePinIds.length) || (state === 'unavailable' && !rationale)) {
+        throw new TypeError('Prepared evidence needs retained pins; unavailable evidence needs an explanation.');
+    }
+    return { id: identifier(row.id, 'Evidence request identity'), packetDigestSha256: packetDigest(row.packetDigestSha256),
+        summary, dueAt: row.dueAt, state, evidencePinIds, rationale,
+        previousEventIds: identifiers(row.previousEventIds, 'Prior evidence request events') };
+}
+export function readCasePacketAmendment(raw) {
+    if (raw === undefined)
+        return undefined;
+    assertWorkspaceInputGraph(raw, 'Packet amendment');
+    const row = exact(raw, ['packetDigestSha256', 'requestEventIds'], 'Packet amendment');
+    const requestEventIds = identifiers(row.requestEventIds, 'Amendment request events');
+    if (!requestEventIds.length)
+        throw new TypeError('Select at least one prepared evidence request.');
+    return { packetDigestSha256: packetDigest(row.packetDigestSha256), requestEventIds };
+}
+export function assertEvidenceRequestEvent(request, event) {
+    if (request && (event.nextState !== 'acknowledged' || !['submitted', 'acknowledged'].includes(String(event.previousState))
+        || (request.state === 'requested'
+            ? event.sourceClass !== 'provider' || event.providerOutcome !== 'more_information_requested' || request.evidencePinIds.length > 0 || Boolean(request.rationale) || request.previousEventIds.length > 0
+            : event.sourceClass !== 'analyst' || request.previousEventIds.length === 0)))
+        throw new TypeError('Requested evidence has incompatible event provenance.');
+}
+/** A digest belongs to the explicit delivery event, never the latest mutable reference. */
+export function submittedPacketReceipts(action) {
+    return action.history.flatMap(event => {
+        const match = /^response-packet-sha256:([a-f0-9]{64})$/u.exec(event.reference ?? '');
+        return event.applied && event.previousState === 'authorised' && event.nextState === 'submitted'
+            && event.sourceClass === 'analyst' && match
+            ? [{ eventId: event.id, digestSha256: match[1], occurredAt: event.occurredAt }] : [];
+    });
+}
+export function latestEvidenceRequests(action) {
+    const events = action.history.filter((event) => event.applied && Boolean(event.evidenceRequest));
+    const replaced = new Set(events.flatMap(event => event.evidenceRequest.previousEventIds
+        .filter(id => events.some(parent => parent.id === id && parent.evidenceRequest.id === event.evidenceRequest.id))));
+    return events.filter(event => !replaced.has(event.id));
+}
+/** Causal links order same-time reviews and retain concurrent branches for explicit reconciliation. */
+export function assertEvidenceRequestHistory(events, missingHistory) {
+    const byId = new Map(events.map(event => [event.id, event]));
+    const complete = new Set(), visiting = new Set();
+    const visit = (id) => {
+        if (complete.has(id))
+            return;
+        if (visiting.has(id))
+            throw new TypeError('Requested evidence history contains a cycle.');
+        visiting.add(id);
+        const request = byId.get(id)?.evidenceRequest;
+        for (const parentId of request?.previousEventIds ?? []) {
+            const parent = byId.get(parentId);
+            if (!parent && missingHistory)
+                continue;
+            if (!parent?.evidenceRequest || parent.evidenceRequest.id !== request.id
+                || parent.evidenceRequest.summary !== request.summary || parent.evidenceRequest.dueAt !== request.dueAt
+                || parent.evidenceRequest.packetDigestSha256 !== request.packetDigestSha256)
+                throw new TypeError('Requested evidence history does not preserve its original request.');
+            visit(parentId);
+        }
+        visiting.delete(id);
+        complete.add(id);
+    };
+    for (const event of events)
+        visit(event.id);
+}
+export function assertEvidenceRequestTransition(action, request, sourceClass, providerOutcome, validPinIds) {
+    if (!['submitted', 'acknowledged'].includes(action.state)
+        || !submittedPacketReceipts(action).some(receipt => receipt.digestSha256 === request.packetDigestSha256)) {
+        throw new Error('Requested evidence must refer to an explicitly recorded packet delivery on an open action.');
+    }
+    const previousEvents = latestEvidenceRequests(action).filter(event => event.evidenceRequest.id === request.id);
+    if (!previousEvents.length) {
+        if (request.state !== 'requested' || sourceClass !== 'provider' || providerOutcome !== 'more_information_requested'
+            || request.evidencePinIds.length || request.rationale || request.previousEventIds.length)
+            throw new Error('A new evidence request must record the provider request before preparation.');
+    }
+    else if (sourceClass !== 'analyst' || request.state === 'requested'
+        || previousEvents.some(({ evidenceRequest: previous }) => request.summary !== previous.summary
+            || request.dueAt !== previous.dueAt || request.packetDigestSha256 !== previous.packetDigestSha256)) {
+        throw new Error('Keep the original provider request unchanged; append a separate request for changed requirements.');
+    }
+    if (JSON.stringify(request.previousEventIds.slice().sort()) !== JSON.stringify(previousEvents.map(event => event.id).sort())) {
+        throw new Error('The evidence preparation changed. Review all current request events before saving.');
+    }
+    if (validPinIds && request.evidencePinIds.some(id => !validPinIds.has(id)))
+        throw new Error('Requested evidence refers to a pin no longer retained in this Case.');
+}
+export function assertPacketAmendment(actions, originActionId, amendment) {
+    const original = actions.find(action => action.id === originActionId);
+    if (!original || !submittedPacketReceipts(original).some(receipt => receipt.digestSha256 === amendment.packetDigestSha256)) {
+        throw new Error('An amendment requires the exact recorded packet delivery from its originating action.');
+    }
+    const latest = latestEvidenceRequests(original);
+    if (amendment.requestEventIds.some(id => !latest.some(event => event.id === id
+        && latest.filter(other => other.evidenceRequest.id === event.evidenceRequest.id).length === 1
+        && event.evidenceRequest.state === 'prepared' && event.evidenceRequest.packetDigestSha256 === amendment.packetDigestSha256))) {
+        throw new Error('Review the current prepared evidence requests before creating or submitting an amendment.');
+    }
+}
+export function assertPacketAmendmentSelection(actions, selectedActionId, selectedPinIds) {
+    const action = actions.find(item => item.id === selectedActionId);
+    if (!action?.amendment)
+        return;
+    assertPacketAmendment(actions, action.originActionId, action.amendment);
+    const original = actions.find(item => item.id === action.originActionId);
+    const required = latestEvidenceRequests(original).filter(event => action.amendment.requestEventIds.includes(event.id))
+        .flatMap(event => event.evidenceRequest.evidencePinIds);
+    if (required.some(id => !selectedPinIds.has(id)))
+        throw new TypeError('Select every prepared request pin for this amendment; the original packet is not regenerated.');
+}
+export function evidenceRequestDelivery(actions, actionId, eventId) {
+    return actions.flatMap(action => action.originActionId === actionId && action.amendment?.requestEventIds.includes(eventId)
+        ? submittedPacketReceipts(action).map(receipt => ({ actionId: action.id, ...receipt })) : []);
+}