Files
reverse-engineering-anything/src/domain/comparisonEvidenceResult.ts
T
94cbae6d0c fix(reconstruction): verify visual screenshot comparisons (#12186)
* fix(reconstruction): admit visual screenshot comparisons

* fix(reconstruction): corroborate retained visual comparisons

* fix(reconstruction): bind visual claims to distinct captures

* fix(reconstruction): distinguish visual capture pairs

---------

Co-authored-by: Josh <joshuakrishna21@gmail.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
2026-11-19 06:57:15 -05:00

146 lines
5.1 KiB
TypeScript

import {
artifactComparisonResultSchema,
type ArtifactComparisonResult,
} from "./artifactComparison.js";
import type { ComparisonEvidenceOperation } from "./comparisonEvidenceIdentity.js";
import type { Evidence } from "./evidence.js";
import { EvidenceIntegrityError } from "./evidenceErrors.js";
import { readEvidencePayload } from "./evidenceValidation.js";
import {
functionComparisonResultSchema,
type FunctionComparisonResult,
} from "./functionComparisonSchemas.js";
import {
processCaptureComparisonSchema,
type ProcessCaptureComparison,
} from "./process/processComparison.js";
import {
webScreenshotDiffSchema,
type WebScreenshotDiff,
} from "./webScreenshot.js";
import { err, ok, type Result } from "./result.js";
import { comparisonSourceEvidenceSides } from "./comparisonSourceEvidence.js";
type ComparisonResults = {
readonly compare_artifacts: ArtifactComparisonResult;
readonly compare_functions: FunctionComparisonResult;
readonly compare_process_captures: ProcessCaptureComparison;
readonly compare_web_screenshots: WebScreenshotDiff;
};
/** One admitted comparison's envelope and its operation-specific parsed facts. */
export type ParsedComparisonEvidence<
Operation extends ComparisonEvidenceOperation = ComparisonEvidenceOperation,
> = {
[Kind in Operation]: {
readonly operation: Kind;
readonly evidence: Evidence;
readonly result: ComparisonResults[Kind];
};
}[Operation];
/** Decode an admitted comparison's payload and validate nested finding citations. */
export function readComparisonResult<
Operation extends ComparisonEvidenceOperation,
>(
evidence: Evidence,
operation: Operation,
): Result<ParsedComparisonEvidence<Operation>, EvidenceIntegrityError>;
export function readComparisonResult(
evidence: Evidence,
operation: ComparisonEvidenceOperation,
): Result<ParsedComparisonEvidence, EvidenceIntegrityError> {
if (operation === "compare_process_captures") {
const parsed = readEvidencePayload(
processCaptureComparisonSchema,
evidence.normalized_result,
{ within: ["normalized_result"] },
);
if (!parsed.ok) return parsed;
return ok({ operation, evidence, result: parsed.value });
}
if (operation === "compare_functions") {
const parsed = readEvidencePayload(
functionComparisonResultSchema,
evidence.normalized_result,
{ within: ["normalized_result"] },
);
if (!parsed.ok) return parsed;
if (parsed.value.function_match.method === "same-evidence") {
try {
const { left, right } = comparisonSourceEvidenceSides(evidence);
const sourceId = left[0];
const sameSource =
left.length === 1 &&
right.length === 1 &&
sourceId === right[0] &&
sourceId !== undefined &&
evidence.evidence_links.includes(sourceId) &&
parsed.value.dimensions.every(({ evidence_links }) =>
evidence_links.every((id) => id === sourceId),
);
const impossibleChange =
parsed.value.left_subject_sha256 !==
parsed.value.right_subject_sha256 ||
parsed.value.dimensions.some(
(dimension) =>
dimension.status === "changed" ||
(dimension.status === "unchanged" &&
dimension.left_digest !== dimension.right_digest),
);
if (!sameSource || impossibleChange)
return err(
new EvidenceIntegrityError(
"Same-Evidence function comparison must cite the same source on both sides",
),
);
} catch (cause) {
if (cause instanceof EvidenceIntegrityError) return err(cause);
throw cause;
}
}
const links = validateFindingLinks(
evidence,
parsed.value.dimensions.flatMap(({ evidence_links }) => evidence_links),
);
if (!links.ok) return links;
return ok({ operation, evidence, result: parsed.value });
}
if (operation === "compare_web_screenshots") {
const parsed = readEvidencePayload(
webScreenshotDiffSchema,
evidence.normalized_result,
{ within: ["normalized_result"] },
);
if (!parsed.ok) return parsed;
return ok({ operation, evidence, result: parsed.value });
}
const parsed = readEvidencePayload(
artifactComparisonResultSchema,
evidence.normalized_result,
{ within: ["normalized_result"] },
);
if (!parsed.ok) return parsed;
const links = validateFindingLinks(evidence, [
...parsed.value.changes.flatMap(({ evidence_links }) => evidence_links),
// optional-fact-default: only retained IDs are links to validate.
...(parsed.value.integrity_mismatch_evidence_ids ?? []),
]);
if (!links.ok) return links;
return ok({ operation, evidence, result: parsed.value });
}
const validateFindingLinks = (
evidence: Evidence,
nestedLinks: readonly string[],
): Result<void, EvidenceIntegrityError> => {
const closure = new Set(evidence.evidence_links);
return nestedLinks.some((id) => !closure.has(id))
? err(
new EvidenceIntegrityError(
"Comparison finding cites Evidence outside its top-level closure",
),
)
: ok(undefined);
};