reverseport 0.0.0-stage → 1.2.0

package/dist/domain/process/processCaptureValidation.js

@@ -0,0 +1,246 @@
+import { digestProcessCommitment } from "./processScenario.js";
+import { hasCaptureTruncation } from "./processCaptureCoverage.js";
+const orderedTimestamps = (values) => values.every((value, index) => {
+    const previous = values[index - 1];
+    return previous === undefined || value.at_ms >= previous.at_ms;
+});
+const validateCommitments = (capture, require) => {
+    const { manifest } = capture;
+    require(manifest.scenario.executable_sha256 ===
+        manifest.selected_executable_sha256, "manifest.selected_executable_sha256", "selected executable commitment does not match the scenario projection");
+    require(manifest.executable_identity.state === "path_metadata_unchanged"
+        ? manifest.executable_sha256 === manifest.selected_executable_sha256 &&
+            manifest.executable_identity.reason === null
+        : manifest.executable_sha256 === null &&
+            manifest.executable_identity.reason !==
+                null, "manifest.executable_identity", "launch identity and executable digest do not agree");
+    for (const [field, value] of [
+        ["full_scenario_sha256", manifest.scenario],
+        ["comparison_contract_sha256", manifest.comparison_contract],
+        ["normalization_sha256", capture.normalization],
+    ])
+        require(manifest[field] ===
+            digestProcessCommitment(value), `manifest.${field}`, "commitment does not match its canonical value");
+    require(Date.parse(manifest.started_at) <=
+        Date.parse(manifest.completed_at), "manifest.completed_at", "completion precedes start");
+};
+const validateOrdering = (capture, require) => {
+    for (const [name, values] of [
+        ["frames", capture.frames],
+        ["rendered_frames", capture.rendered_frames],
+        ["interaction_events", capture.interaction_events],
+    ])
+        require(values.every(({ sequence }, index) => sequence === index), name, "sequence values must be contiguous from zero");
+    for (const [name, values] of [
+        ["frames", capture.frames],
+        ["rendered_frames", capture.rendered_frames],
+        ["process_samples", capture.process_samples],
+    ])
+        require(orderedTimestamps(values), name, "timestamps must be ordered");
+};
+const validateEventJournal = (capture, require) => {
+    const journal = capture.event_journal;
+    if (journal.length === 0)
+        return;
+    const sizes = {
+        frames: capture.frames.length,
+        rendered_frames: capture.rendered_frames.length,
+        interaction_events: capture.interaction_events.length,
+        lifecycle: 2,
+        process_samples: capture.process_samples.length,
+        filesystem_checkpoints: capture.filesystem_checkpoints.length,
+    };
+    const references = new Set();
+    for (const [position, entry] of journal.entries()) {
+        require(entry.capture_order ===
+            position, `event_journal.${String(position)}.capture_order`, "capture order must be contiguous from zero");
+        require(entry.index <
+            sizes[entry.collection], `event_journal.${String(position)}.index`, "journal reference is outside its capture collection");
+        const reference = `${entry.collection}:${String(entry.index)}`;
+        require(!references.has(reference), `event_journal.${String(position)}`, "journal references must be unique");
+        references.add(reference);
+    }
+    const expectedSize = Object.values(sizes).reduce((total, size) => total + size, 0);
+    require(journal.length ===
+        expectedSize, "event_journal", "nonempty journal must reference every captured observation");
+};
+/**
+ * The committed comparison contract carries `finalization_ms` exactly when the
+ * committed scenario does, with the same value. Independent of the exit, so a
+ * partial capture with an unavailable exit is still checked.
+ */
+export const finalizationManifestIssue = (committedScenario, committedComparison) => committedScenario !== undefined &&
+    committedComparison !== undefined &&
+    committedScenario["finalization_ms"] !==
+        committedComparison["finalization_ms"]
+    ? "comparison_contract finalization_ms must match the committed scenario"
+    : undefined;
+/** Ensure incomplete exit and sibling finalization observations preserve one fact. */
+export const finalizationAgreementIssue = (exitFinalization, observedFinalization) => exitFinalization !== undefined &&
+    observedFinalization !== undefined &&
+    JSON.stringify(exitFinalization) !== JSON.stringify(observedFinalization)
+    ? "exit finalization and finalization observation must agree"
+    : undefined;
+/**
+ * Cross-field rule for `exit.finalization`, shared by complete and partial
+ * captures. Returns the violated rule, or undefined when the record is
+ * consistent.
+ */
+export const finalizationConsistencyIssue = (exit, committedScenario, committedComparison, options) => {
+    const manifestIssue = finalizationManifestIssue(committedScenario, committedComparison);
+    if (manifestIssue !== undefined)
+        return manifestIssue;
+    const finalization = exit?.finalization ?? options?.finalization;
+    if (finalization === undefined) {
+        // A deadline that fired under a committed interval must have attempted
+        // finalization; cancellation before the deadline legitimately has none.
+        const committed = committedScenario?.["finalization_ms"];
+        return (exit?.reason === "timeout" || exit?.reason === "idle_timeout") &&
+            typeof committed === "number" &&
+            committed > 0
+            ? "a deadline exit under a committed finalization_ms requires finalization evidence"
+            : undefined;
+    }
+    if (exit?.reason === "exited")
+        return "finalization requires a deadline exit reason";
+    const first = finalization.signals[0];
+    if (first?.signal !== "SIGTERM")
+        return "finalization signals must start with SIGTERM";
+    const killIndexes = finalization.signals.flatMap(({ signal }, index) => signal === "SIGKILL" ? [index] : []);
+    if (killIndexes.length > 1 ||
+        (killIndexes[0] !== undefined &&
+            killIndexes[0] !== finalization.signals.length - 1))
+        return "finalization may contain at most one final SIGKILL";
+    if (!finalization.signals.every(({ sent_at_ms }, index) => {
+        const previous = finalization.signals[index - 1];
+        return previous === undefined || sent_at_ms >= previous.sent_at_ms;
+    }))
+        return "finalization signal attempt times must not decrease";
+    if (finalization.signals.filter(({ signal }) => signal === "SIGTERM").length !==
+        1)
+        return "finalization must attempt SIGTERM exactly once";
+    const kill = finalization.signals.find(({ signal }) => signal === "SIGKILL");
+    if (kill !== undefined &&
+        kill.sent_at_ms < finalization.requested_ms &&
+        exit !== undefined &&
+        exit.reason !== "cancelled")
+        return "finalization SIGKILL cannot precede the requested interval";
+    if (finalization.elapsed_ms === null && options?.allowNullElapsedMs !== true)
+        return "finalization requires an observed elapsed_ms";
+    if (finalization.exit_code !== null &&
+        exit?.signal !== undefined &&
+        exit.signal !== null &&
+        exit.signal !== 0)
+        return "finalization exit_code requires an exit not caused by a signal";
+    if (finalization.elapsed_ms !== null &&
+        finalization.elapsed_ms <
+            (finalization.signals.at(-1)?.sent_at_ms ?? first.sent_at_ms))
+        return "finalization elapsed_ms cannot precede the last signal attempt";
+    if (committedScenario !== undefined &&
+        committedScenario["finalization_ms"] !== finalization.requested_ms)
+        return "finalization must match the committed finalization_ms";
+    return undefined;
+};
+const validateLifecycle = (capture, require) => {
+    require(capture.filesystem_checkpoints.map(({ name }) => name).join(",") ===
+        "before,after_settlement", "filesystem_checkpoints", "capture must include initial and final filesystem snapshots");
+    require(orderedTimestamps(capture.filesystem_checkpoints), "filesystem_checkpoints", "filesystem snapshot times must be ordered");
+    require(!capture.filesystem_checkpoints.some(({ truncated }) => truncated) ||
+        capture.truncated, "truncated", "filesystem snapshot truncation must propagate to the capture");
+    require(capture.exit.reason === "exited" ||
+        capture.exit.code ===
+            null, "exit", "deadline termination cannot declare a normal exit code");
+    const finalizationIssue = finalizationConsistencyIssue(capture.exit, capture.manifest.scenario, capture.manifest.comparison_contract);
+    require(finalizationIssue === undefined, "exit", finalizationIssue ?? "");
+};
+const validateCoverage = (capture, require) => {
+    const details = capture.truncation_details;
+    require(details.process.retained_samples === capture.process_samples.length &&
+        details.process.retained_samples <= details.process.sample_limit &&
+        details.process.sampling_partial ===
+            (details.process.sample_limit_reached ||
+                details.process.sampling_failures > 0) &&
+        (details.process.sampling_failures === 0) ===
+            (details.process.first_sampling_failure ===
+                null), "truncation_details.process", "sampling coverage must agree with retained samples and observed failures");
+    require(capture.truncated ===
+        hasCaptureTruncation(details), "truncation_details", "aggregate truncation must match producer coverage");
+    for (const [name, retention, count, bytes] of [
+        [
+            "raw_terminal",
+            details.raw_terminal,
+            capture.frames.length,
+            capture.frames.reduce((total, frame) => total + Buffer.byteLength(frame.raw_data ?? frame.data), 0),
+        ],
+        [
+            "rendered_terminal",
+            details.rendered_terminal,
+            capture.rendered_frames.length,
+            capture.rendered_frames.reduce((total, frame) => frame.lines.reduce((sum, line) => sum + Buffer.byteLength(line), total + Buffer.byteLength(frame.serialized_state)), 0),
+        ],
+    ]) {
+        // Whole frames are retained or omitted, so retained bytes are exactly the
+        // retained frames' bytes, and nothing is unretained when no frame was omitted.
+        require(retention.retained_frames === count &&
+            retention.observed_frames >= count &&
+            retention.retained_bytes === bytes &&
+            retention.observed_bytes >= retention.retained_bytes &&
+            (retention.observed_frames > count ||
+                retention.observed_bytes === retention.retained_bytes) &&
+            retention.retained_bytes <=
+                retention.budget_bytes, `truncation_details.${name}`, "retained observations and budget accounting do not agree");
+    }
+    for (const [name, coverage, files, checkpoint] of [
+        [
+            "filesystem_before",
+            details.filesystem_before,
+            capture.files_before,
+            capture.filesystem_checkpoints[0],
+        ],
+        [
+            "filesystem_after",
+            details.filesystem_after,
+            capture.files_after,
+            capture.filesystem_checkpoints[1],
+        ],
+    ]) {
+        const unhashedFiles = new Map(files
+            .filter((file) => file.type === "file" && file.sha256 === null)
+            .map((file) => [file.path, file]));
+        require(coverage.hash_omissions.length === unhashedFiles.size &&
+            new Set(coverage.hash_omissions.map(({ path }) => path)).size ===
+                unhashedFiles.size &&
+            coverage.hash_omissions.every((omission) => unhashedFiles.get(omission.path)?.size === omission.size_bytes &&
+                omission.remaining_budget_bytes <= coverage.hash_budget_bytes &&
+                (omission.reason === "file_unavailable"
+                    ? omission.system_code !== null
+                    : omission.system_code === null)), `truncation_details.${name}.hash_omissions`, "every retained regular file without a digest must have one matching omission reason");
+        require(coverage.hashed_bytes ===
+            files
+                .filter((file) => file.type === "file" && file.sha256 !== null)
+                .reduce((sum, file) => sum + file.size, 0) &&
+            coverage.hashed_bytes <= coverage.hash_budget_bytes &&
+            files.length <=
+                coverage.files_limit, `truncation_details.${name}`, "filesystem budget accounting does not match retained observations");
+        require(coverage.enumeration_truncated ===
+            coverage.enumeration_reasons.length > 0 &&
+            checkpoint?.truncated ===
+                (coverage.enumeration_truncated ||
+                    coverage.hash_omissions.length >
+                        0), `truncation_details.${name}`, "filesystem checkpoint truncation must match enumeration and digest coverage");
+    }
+};
+/** Recompute commitments and cross-field invariants without side effects. */
+export const collectProcessCaptureIssues = (capture) => {
+    const issues = [];
+    const require = (condition, path, message) => {
+        if (!condition)
+            issues.push({ path, message });
+    };
+    validateCommitments(capture, require);
+    validateOrdering(capture, require);
+    validateEventJournal(capture, require);
+    validateLifecycle(capture, require);
+    validateCoverage(capture, require);
+    return issues;
+};

package/dist/domain/process/processComparison.js

@@ -0,0 +1,315 @@
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { processSourceTruncated } from "./processCaptureCoverage.js";
+import { comparableTerminalFrame } from "./processObservation.js";
+import { AnalysisInputError } from "../analysisErrorCore.js";
+import { jsonValueSchema } from "../jsonValue.js";
+import { processTraceComparisonResultSchema } from "./processTraceEvaluation.js";
+import { dimensionsForTraceSources, traceCoversObservedDimension, } from "./processTraceDimensionProjection.js";
+import { compareProcessTraces, processTraceOutcomesDiffer, } from "./processTraceComparison.js";
+const OPERATION = "compare_process_captures";
+/** Comparison classification that never equates incomplete evidence. */
+export const comparisonStatusSchema = z.enum([
+    "unchanged",
+    "added",
+    "removed",
+    "changed",
+    "truncated",
+    "unknown",
+    "contradiction",
+]);
+/** Canonical ordered dimensions that contribute to an overall process status. */
+export const PROCESS_COMPARISON_DIMENSIONS = [
+    "terminal",
+    "interaction",
+    "exit",
+    "filesystem",
+    "process",
+];
+/** Derive the overall comparison status from every process dimension. */
+export const deriveProcessComparisonStatus = (dimensions) => {
+    if (dimensions.includes("truncated"))
+        return "truncated";
+    if (dimensions.some((status) => ["changed", "added", "removed"].includes(status)))
+        return "changed";
+    return dimensions.includes("unknown") ? "unknown" : "unchanged";
+};
+/** Pure normalized comparison between two captures. */
+export const processCaptureComparisonSchema = z
+    .object({
+    status: comparisonStatusSchema,
+    terminal: comparisonStatusSchema,
+    interaction: comparisonStatusSchema,
+    exit: comparisonStatusSchema,
+    filesystem: comparisonStatusSchema,
+    process: comparisonStatusSchema,
+    first_divergence: z.discriminatedUnion("status", [
+        z.object({ status: z.literal("none") }),
+        z.object({ status: z.literal("unknown"), reason: z.string() }),
+        z.object({
+            status: z.literal("found"),
+            dimension: z.enum([
+                "terminal",
+                "interaction",
+                "exit",
+                "filesystem",
+                "process",
+            ]),
+            index: z.number().int().nonnegative(),
+            left_at_ms: z.number().int().nonnegative().nullable(),
+            right_at_ms: z.number().int().nonnegative().nullable(),
+            left: jsonValueSchema.nullable(),
+            right: jsonValueSchema.nullable(),
+        }),
+    ]),
+    trace: processTraceComparisonResultSchema.optional(),
+    limitations: z.array(z.string()),
+})
+    .superRefine((comparison, context) => {
+    const expected = deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => comparison[dimension]));
+    if (comparison.status !== expected)
+        context.addIssue({
+            code: "custom",
+            message: "Process comparison status contradicts its dimensions",
+            path: ["status"],
+        });
+});
+const terminalObservations = (capture) => [
+    ...capture.frames.map((frame) => ({
+        kind: "raw",
+        ...comparableTerminalFrame(frame),
+    })),
+    ...capture.rendered_frames.map((frame) => ({
+        kind: "rendered",
+        ...frame,
+    })),
+].sort((left, right) => {
+    const time = left.at_ms - right.at_ms;
+    if (time !== 0)
+        return time;
+    if (left.kind !== right.kind)
+        return left.kind === "raw" ? -1 : 1;
+    return left.sequence - right.sequence;
+});
+const filesystemObservations = (capture) => capture.filesystem_checkpoints;
+const sameJsonValue = (left, right) => {
+    const encodedLeft = canonicalize(left);
+    return encodedLeft !== undefined && encodedLeft === canonicalize(right);
+};
+/** Canonical observations for one process-comparison dimension. */
+export const processDimensionObservations = (capture, dimension) => {
+    switch (dimension) {
+        case "terminal":
+            return terminalObservations(capture);
+        case "interaction":
+            return capture.interaction_events;
+        case "exit":
+            return [{ ...capture.exit, settlement: capture.settlement }];
+        case "filesystem":
+            return filesystemObservations(capture);
+        case "process":
+            return capture.process_samples;
+    }
+};
+const classifyCollection = (left, right) => {
+    if (sameJsonValue(left, right))
+        return "unchanged";
+    if (left.length === 0)
+        return "added";
+    if (right.length === 0)
+        return "removed";
+    return "changed";
+};
+const hasUnknown = (capture, scope) => capture.residual_unknowns.some((item) => item.scope === scope);
+const eventTime = (value) => {
+    if (typeof value === "object" &&
+        value !== null &&
+        "at_ms" in value &&
+        typeof value.at_ms === "number" &&
+        Number.isSafeInteger(value.at_ms) &&
+        value.at_ms >= 0)
+        return value.at_ms;
+    return null;
+};
+const firstCollectionDivergence = (dimension, left, right) => {
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = left[index] ?? null;
+        const rightValue = right[index] ?? null;
+        if (sameJsonValue(leftValue, rightValue))
+            continue;
+        return {
+            status: "found",
+            dimension,
+            index,
+            left_at_ms: eventTime(leftValue),
+            right_at_ms: eventTime(rightValue),
+            left: jsonValueSchema.parse(leftValue),
+            right: jsonValueSchema.parse(rightValue),
+        };
+    }
+    return null;
+};
+const chooseFirstDivergence = (candidates) => {
+    const found = candidates.filter((candidate) => candidate !== null);
+    return (found.sort((left, right) => {
+        const leftTime = Math.min(left.left_at_ms ?? Number.MAX_SAFE_INTEGER, left.right_at_ms ?? Number.MAX_SAFE_INTEGER);
+        const rightTime = Math.min(right.left_at_ms ?? Number.MAX_SAFE_INTEGER, right.right_at_ms ?? Number.MAX_SAFE_INTEGER);
+        return leftTime - rightTime;
+    })[0] ?? { status: "none" });
+};
+const assertComparable = (left, right, options) => {
+    if (left.manifest.comparison_contract_sha256 !==
+        right.manifest.comparison_contract_sha256) {
+        const fields = differingContractFields(left.manifest.comparison_contract, right.manifest.comparison_contract);
+        throw new AnalysisInputError(OPERATION, undefined, [
+            {
+                path: ["right"],
+                reason: "invalid_value",
+                message: `Process captures have incompatible comparison contracts${fields.length === 0 ? "" : `; these scenario fields differ: ${fields.join(", ")}`}. Capture both scenarios with the same values for these fields, then compare them.`,
+                expected: fields,
+            },
+        ]);
+    }
+    if (options.maxCaptureAgeMs === undefined)
+        return;
+    const maxCaptureAgeMs = options.maxCaptureAgeMs;
+    const now = (options.now ?? Date.now)();
+    const stale = [
+        ["left", left],
+        ["right", right],
+    ].flatMap(([side, { manifest }]) => {
+        const age = now - Date.parse(manifest.completed_at);
+        return age > maxCaptureAgeMs
+            ? [
+                `${side} completed at ${manifest.completed_at} (${String(age)} ms ago)`,
+            ]
+            : [];
+    });
+    if (stale.length > 0)
+        throw new AnalysisInputError(OPERATION, undefined, [
+            {
+                path: ["max_capture_age_ms"],
+                reason: "out_of_range",
+                message: `Process capture exceeds max_capture_age_ms ${String(maxCaptureAgeMs)}: ${stale.join("; ")}. Recapture the stale scenario or raise max_capture_age_ms.`,
+            },
+        ]);
+};
+/** Name top-level contract fields whose canonical values differ. */
+const differingContractFields = (left, right) => [...new Set([...Object.keys(left), ...Object.keys(right)])]
+    .filter((field) => !Object.hasOwn(left, field) ||
+    !Object.hasOwn(right, field) ||
+    canonicalize(left[field]) !== canonicalize(right[field]))
+    .sort();
+const applyTraceVerdict = (dimensions, specification, trace, captures) => {
+    const traceShowsDifference = processTraceOutcomesDiffer(trace);
+    const traceStatus = trace.verdict === "unknown"
+        ? "unknown"
+        : trace.verdict === "equivalent" || !traceShowsDifference
+            ? "unchanged"
+            : "changed";
+    const sources = new Set(specification.events.map(({ source }) => source));
+    const covered = dimensionsForTraceSources(sources);
+    const statusFor = (dimension) => {
+        const exact = dimensions[dimension];
+        if (!covered.has(dimension))
+            return exact;
+        if (trace.verdict === "nonconforming")
+            return exact;
+        if (trace.verdict === "different")
+            return traceShowsDifference ? "changed" : exact;
+        if (trace.verdict === "unknown" &&
+            ["changed", "added", "removed"].includes(exact))
+            return exact;
+        return traceCoversObservedDimension(dimension, sources, captures[0], captures[1])
+            ? traceStatus
+            : exact;
+    };
+    return {
+        terminal: statusFor("terminal"),
+        interaction: statusFor("interaction"),
+        exit: statusFor("exit"),
+        filesystem: statusFor("filesystem"),
+        process: statusFor("process"),
+    };
+};
+const compareDimensions = (left, right, sameNormalization) => {
+    const classify = (scope, leftValues, rightValues, source) => !sameNormalization ||
+        hasUnknown(left, scope) ||
+        hasUnknown(right, scope) ||
+        processSourceTruncated(left, source) ||
+        processSourceTruncated(right, source)
+        ? "unknown"
+        : classifyCollection(leftValues, rightValues);
+    return {
+        terminal: classify("terminal", terminalObservations(left), terminalObservations(right), "terminal_rendered"),
+        interaction: classify("interaction", left.interaction_events, right.interaction_events, "interaction"),
+        exit: hasUnknown(left, "exit") || hasUnknown(right, "exit")
+            ? "unknown"
+            : sameJsonValue({ exit: left.exit, settlement: left.settlement }, { exit: right.exit, settlement: right.settlement })
+                ? "unchanged"
+                : "changed",
+        filesystem: classify("filesystem", filesystemObservations(left), filesystemObservations(right), "filesystem"),
+        process: classify("process", left.process_samples, right.process_samples, "process"),
+    };
+};
+/**
+ * Compare two process capture observations without treating absence as proof.
+ *
+ * Observed differences outrank residual unknowns. A capture may therefore be
+ * definitively changed in one dimension while completeness remains unknown.
+ */
+export const compareProcessCaptures = (left, right, options = {}) => {
+    assertComparable(left, right, options);
+    const sameNormalization = sameJsonValue(left.normalization, right.normalization);
+    const exactDimensions = compareDimensions(left, right, sameNormalization);
+    const trace = options.traceSpecification === undefined
+        ? undefined
+        : compareProcessTraces(left, right, options.traceSpecification);
+    const dimensions = trace === undefined || options.traceSpecification === undefined
+        ? exactDimensions
+        : applyTraceVerdict(exactDimensions, options.traceSpecification, trace, [
+            left,
+            right,
+        ]);
+    const divergenceCandidates = PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension] === "unknown"
+        ? null
+        : firstCollectionDivergence(dimension, processDimensionObservations(left, dimension), processDimensionObservations(right, dimension)));
+    const observedFirstDivergence = chooseFirstDivergence(divergenceCandidates.map((candidate) => candidate !== null &&
+        trace?.verdict === "equivalent" &&
+        dimensions[candidate.dimension] === "unchanged"
+        ? null
+        : candidate));
+    const firstDivergence = left.truncated || right.truncated
+        ? {
+            status: "unknown",
+            reason: "Incomplete observations prevent locating the first divergence; unaffected dimensions retain their comparisons.",
+        }
+        : trace?.verdict === "equivalent" &&
+            deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension])) === "unchanged"
+            ? { status: "none" }
+            : observedFirstDivergence.status === "found"
+                ? observedFirstDivergence
+                : !sameNormalization ||
+                    left.residual_unknowns.length > 0 ||
+                    right.residual_unknowns.length > 0
+                    ? {
+                        status: "unknown",
+                        reason: "Residual unknowns prevent proving that no divergence occurred.",
+                    }
+                    : observedFirstDivergence;
+    const observedStatus = deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension]));
+    return {
+        status: observedStatus,
+        ...dimensions,
+        first_divergence: firstDivergence,
+        ...(trace === undefined ? {} : { trace }),
+        limitations: [
+            ...left.limitations,
+            ...right.limitations,
+            ...left.residual_unknowns.map(({ reason }) => reason),
+            ...right.residual_unknowns.map(({ reason }) => reason),
+            ...(sameNormalization ? [] : ["Capture normalization rules differ."]),
+        ],
+    };
+};

package/dist/domain/process/processEvidenceProvider.js

@@ -0,0 +1,11 @@
+/** Canonical provider identity for controlled process capture Evidence. */
+export const PROCESS_PROVIDER = {
+    id: "rea-process",
+    name: "REA process capture",
+    version: "3",
+};
+/** Admit current and previously emitted names for the same v3 process provider. */
+export const isProcessEvidenceProvider = (provider) => provider.id === PROCESS_PROVIDER.id &&
+    provider.version === PROCESS_PROVIDER.version &&
+    (provider.name === PROCESS_PROVIDER.name ||
+        provider.name === "REA deterministic process harness");