@riddledc/riddle-proof 0.8.73 → 0.8.75

package/README.md

@@ -49,6 +49,7 @@ import { createRunResult, createRunState } from "@riddledc/riddle-proof";
 import { runRiddleProof } from "@riddledc/riddle-proof/runner";
 import { createCaptureDiagnostic } from "@riddledc/riddle-proof/diagnostics";
 import { toRiddleProofRunParams } from "@riddledc/riddle-proof/openclaw";
+import { assessRiddleProofChange } from "@riddledc/riddle-proof/change-proof";
 ```
 
 The root export provides generic contracts and helpers. Integration-specific
@@ -56,6 +57,64 @@ adapters are exposed through subpaths such as
 `@riddledc/riddle-proof/openclaw`, so wrappers can reuse the mapping logic
 without depending on another plugin runtime.
 
+### Change Proof Contracts
+
+Use `assessRiddleProofChange` when one proof needs to compose two profile
+results: a before target and an after target. The profile contract remains the
+portable page-level sensor; the change contract binds that sensor to two
+environments and checks the expected delta.
+
+```ts
+const result = assessRiddleProofChange({
+  version: "riddle-proof.change-contract.v1",
+  name: "Hero art appears after change",
+  deltas: [{
+    type: "check_status_transition",
+    check_label: "hero-art-visible",
+    before_status: "failed",
+    after_status: "passed",
+  }],
+}, {
+  before_result: productionProfileResult,
+  after_result: previewProfileResult,
+});
+```
+
+The default group semantics are intentionally change-oriented: the before
+group may be `passed` or `product_regression`, while the after group must be
+`passed`. Environment blockers dominate, missing before/after evidence is
+`proof_insufficient`, and a missing or failed required delta cannot become a
+passing change proof.
+
+The CLI can collect the two sides against hosted Riddle targets and write one
+change receipt:
+
+```sh
+riddle-proof-loop run-change-proof \
+  --profile .riddle-proof/profiles/hero-art.json \
+  --change-contract .riddle-proof/change-contracts/hero-art-change.json \
+  --before-url https://example.com \
+  --after-url https://preview.example.com \
+  --output artifacts/riddle-proof/hero-art-change
+```
+
+It can also compare saved profile packets without starting new browser jobs:
+
+```sh
+riddle-proof-loop run-change-proof \
+  --profile .riddle-proof/profiles/hero-art.json \
+  --change-contract .riddle-proof/change-contracts/hero-art-change.json \
+  --before-result artifacts/before/profile-result.json \
+  --after-result artifacts/after/profile-result.json \
+  --result-format compact-json
+```
+
+When `--output` / `--output-dir` is set, the command writes
+`change-proof-result.json`, `summary.md`, and normalized copies of the
+`before/profile-result.json` and `after/profile-result.json` inputs. A
+non-passing change proof exits nonzero so CI and PR-comment automation can use
+the receipt as a gate.
+
 ## Durable Loop CLI
 
 The package publishes `riddle-proof-loop` as a host-agnostic runner surface for

package/dist/advanced/index.d.cts

@@ -1,6 +1,6 @@
 export { b as runner } from '../runner-4LJ5z0D-.cjs';
 export { l as engineHarness } from '../engine-harness-LBfqbFSe.cjs';
 export { p as proofRunCore } from '../proof-run-core-7Dqm7RKM.cjs';
-export { p as proofRunEngine } from '../proof-run-engine-DpChFR5H.cjs';
+export { p as proofRunEngine } from '../proof-run-engine-Baiv6l3A.cjs';
 import '../types.cjs';
 import '../public-state.cjs';

package/dist/advanced/index.d.ts

@@ -1,6 +1,6 @@
 export { b as runner } from '../runner-BdQpOkZD.js';
 export { l as engineHarness } from '../engine-harness-CMACHP6A.js';
 export { p as proofRunCore } from '../proof-run-core-7Dqm7RKM.js';
-export { p as proofRunEngine } from '../proof-run-engine-BqRoA3Do.js';
+export { p as proofRunEngine } from '../proof-run-engine-MiKZt9oY.js';
 import '../types.js';
 import '../public-state.js';

package/dist/advanced/proof-run-engine.d.cts

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-DpChFR5H.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-Baiv6l3A.cjs';
 import '../proof-run-core-7Dqm7RKM.cjs';

package/dist/advanced/proof-run-engine.d.ts

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-BqRoA3Do.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-MiKZt9oY.js';
 import '../proof-run-core-7Dqm7RKM.js';

package/dist/change-proof.cjs

@@ -0,0 +1,193 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/change-proof.ts
+var change_proof_exports = {};
+__export(change_proof_exports, {
+  RIDDLE_PROOF_CHANGE_CONTRACT_VERSION: () => RIDDLE_PROOF_CHANGE_CONTRACT_VERSION,
+  RIDDLE_PROOF_CHANGE_RESULT_VERSION: () => RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+  assessRiddleProofChange: () => assessRiddleProofChange
+});
+module.exports = __toCommonJS(change_proof_exports);
+var RIDDLE_PROOF_CHANGE_CONTRACT_VERSION = "riddle-proof.change-contract.v1";
+var RIDDLE_PROOF_CHANGE_RESULT_VERSION = "riddle-proof.change-result.v1";
+var DEFAULT_BEFORE_STATUSES = ["passed", "product_regression"];
+var DEFAULT_AFTER_STATUSES = ["passed"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE = ["product_regression"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_AFTER = ["passed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_BEFORE = ["failed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_AFTER = ["passed"];
+function listValue(value, fallback) {
+  if (Array.isArray(value)) return value;
+  if (value === void 0) return fallback;
+  return [value];
+}
+function includesValue(allowed, observed) {
+  return observed !== void 0 && allowed.includes(observed);
+}
+function groupResult(side, contract, result) {
+  const fallback = side === "before" ? DEFAULT_BEFORE_STATUSES : DEFAULT_AFTER_STATUSES;
+  const requiredStatus = listValue(contract?.required_status, fallback);
+  const label = contract?.label || side;
+  if (!result) {
+    return {
+      side,
+      label,
+      ok: false,
+      status: "missing",
+      required_status: requiredStatus,
+      message: `${label} profile result is missing.`
+    };
+  }
+  const ok = includesValue(requiredStatus, result.status);
+  return {
+    side,
+    label,
+    ok,
+    profile_name: result.profile_name,
+    status: result.status,
+    required_status: requiredStatus,
+    summary: result.summary,
+    message: ok ? void 0 : `${label} profile status ${result.status} did not match required status ${requiredStatus.join(", ")}.`
+  };
+}
+function findCheck(result, delta) {
+  return result.checks.find((check) => {
+    if (delta.check_label && check.label !== delta.check_label) return false;
+    if (delta.check_type && check.type !== delta.check_type) return false;
+    return Boolean(delta.check_label || delta.check_type);
+  });
+}
+function profileStatusTransitionResult(delta, before, after) {
+  const label = delta.label || "profile-status-transition";
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeAllowed = listValue(delta.before_status, DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue(delta.after_status, DEFAULT_PROFILE_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, before.status) && includesValue(afterAllowed, after.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: before.status,
+    after_observed: after.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${before.status} -> ${after.status}.`
+  };
+}
+function checkStatusTransitionResult(delta, before, after) {
+  const label = delta.label || delta.check_label || delta.check_type || "check-status-transition";
+  if (!delta.check_label && !delta.check_type) {
+    return {
+      type: delta.type,
+      label,
+      status: "configuration_error",
+      message: `${label} needs check_label or check_type.`
+    };
+  }
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeCheck = findCheck(before, delta);
+  const afterCheck = findCheck(after, delta);
+  if (!beforeCheck || !afterCheck) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: beforeCheck?.status,
+      after_observed: afterCheck?.status,
+      message: `${label} was not present in ${!beforeCheck && !afterCheck ? "before or after" : !beforeCheck ? "before" : "after"} profile checks.`
+    };
+  }
+  const beforeAllowed = listValue(delta.before_status, DEFAULT_CHECK_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue(delta.after_status, DEFAULT_CHECK_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, beforeCheck.status) && includesValue(afterAllowed, afterCheck.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: beforeCheck.status,
+    after_observed: afterCheck.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${beforeCheck.status} -> ${afterCheck.status}.`
+  };
+}
+function assessDelta(delta, before, after) {
+  if (delta.type === "profile_status_transition") {
+    return profileStatusTransitionResult(delta, before, after);
+  }
+  return checkStatusTransitionResult(delta, before, after);
+}
+function collapsedChangeStatus(groups, deltas) {
+  const groupResults = [groups.before, groups.after];
+  if (groupResults.some((group) => group.status === "environment_blocked")) return "environment_blocked";
+  if (groupResults.some((group) => group.status === "configuration_error")) return "configuration_error";
+  if (deltas.some((delta) => delta.status === "configuration_error")) return "configuration_error";
+  if (groupResults.some((group) => group.status === "needs_human_review")) return "needs_human_review";
+  if (groupResults.some((group) => group.status === "missing" || group.status === "proof_insufficient")) return "proof_insufficient";
+  if (!deltas.length || deltas.some((delta) => delta.status === "proof_insufficient")) return "proof_insufficient";
+  if (groupResults.some((group) => !group.ok)) return "product_regression";
+  if (deltas.some((delta) => delta.status === "failed")) return "product_regression";
+  return "passed";
+}
+function changeSummary(name, status, deltas) {
+  if (status === "passed") return `${name} passed ${deltas.length} change delta(s).`;
+  if (status === "environment_blocked") return `${name} could not compare reliable evidence because an environment was blocked.`;
+  if (status === "configuration_error") return `${name} has an invalid change proof contract.`;
+  if (status === "needs_human_review") return `${name} needs human review before the change proof can pass.`;
+  if (status === "proof_insufficient") return `${name} did not produce enough before/after evidence for a change proof.`;
+  return `${name} failed ${deltas.filter((delta) => delta.status === "failed").length} change delta(s).`;
+}
+function assessRiddleProofChange(contract, input) {
+  const groups = {
+    before: groupResult("before", contract.before, input.before_result),
+    after: groupResult("after", contract.after, input.after_result)
+  };
+  const deltas = (contract.deltas || []).map((delta) => assessDelta(delta, input.before_result, input.after_result));
+  const status = collapsedChangeStatus(groups, deltas);
+  return {
+    version: RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+    contract_name: contract.name,
+    status,
+    groups,
+    deltas,
+    summary: changeSummary(contract.name, status, deltas),
+    metadata: contract.metadata
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RIDDLE_PROOF_CHANGE_CONTRACT_VERSION,
+  RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+  assessRiddleProofChange
+});

package/dist/change-proof.d.cts

@@ -0,0 +1,74 @@
+import { RiddleProofProfileResult, RiddleProofProfileStatus, RiddleProofProfileCheckResult } from './profile.cjs';
+import { JsonValue } from './types.cjs';
+import './public-state.cjs';
+
+declare const RIDDLE_PROOF_CHANGE_CONTRACT_VERSION: "riddle-proof.change-contract.v1";
+declare const RIDDLE_PROOF_CHANGE_RESULT_VERSION: "riddle-proof.change-result.v1";
+type RiddleProofChangeSide = "before" | "after";
+type RiddleProofChangeStatus = RiddleProofProfileStatus;
+type RiddleProofChangeDeltaStatus = "passed" | "failed" | "proof_insufficient" | "configuration_error";
+type RiddleProofChangeProfileCheckStatus = RiddleProofProfileCheckResult["status"];
+interface RiddleProofChangeGroupContract {
+    label?: string;
+    required_status?: RiddleProofProfileStatus | RiddleProofProfileStatus[];
+}
+interface RiddleProofProfileStatusTransitionDelta {
+    type: "profile_status_transition";
+    label?: string;
+    before_status?: RiddleProofProfileStatus | RiddleProofProfileStatus[];
+    after_status?: RiddleProofProfileStatus | RiddleProofProfileStatus[];
+}
+interface RiddleProofCheckStatusTransitionDelta {
+    type: "check_status_transition";
+    label?: string;
+    check_label?: string;
+    check_type?: string;
+    before_status?: RiddleProofChangeProfileCheckStatus | RiddleProofChangeProfileCheckStatus[];
+    after_status?: RiddleProofChangeProfileCheckStatus | RiddleProofChangeProfileCheckStatus[];
+}
+type RiddleProofChangeDelta = RiddleProofProfileStatusTransitionDelta | RiddleProofCheckStatusTransitionDelta;
+interface RiddleProofChangeContract {
+    version?: typeof RIDDLE_PROOF_CHANGE_CONTRACT_VERSION;
+    name: string;
+    before?: RiddleProofChangeGroupContract;
+    after?: RiddleProofChangeGroupContract;
+    deltas: RiddleProofChangeDelta[];
+    metadata?: Record<string, JsonValue>;
+}
+interface RiddleProofChangeGroupResult {
+    side: RiddleProofChangeSide;
+    label: string;
+    ok: boolean;
+    profile_name?: string;
+    status: RiddleProofProfileStatus | "missing";
+    required_status: RiddleProofProfileStatus[];
+    summary?: string;
+    message?: string;
+}
+interface RiddleProofChangeDeltaResult {
+    type: RiddleProofChangeDelta["type"];
+    label: string;
+    status: RiddleProofChangeDeltaStatus;
+    before_observed?: JsonValue;
+    after_observed?: JsonValue;
+    message?: string;
+}
+interface RiddleProofChangeResult {
+    version: typeof RIDDLE_PROOF_CHANGE_RESULT_VERSION;
+    contract_name: string;
+    status: RiddleProofChangeStatus;
+    groups: {
+        before: RiddleProofChangeGroupResult;
+        after: RiddleProofChangeGroupResult;
+    };
+    deltas: RiddleProofChangeDeltaResult[];
+    summary: string;
+    metadata?: Record<string, JsonValue>;
+}
+interface AssessRiddleProofChangeInput {
+    before_result?: RiddleProofProfileResult;
+    after_result?: RiddleProofProfileResult;
+}
+declare function assessRiddleProofChange(contract: RiddleProofChangeContract, input: AssessRiddleProofChangeInput): RiddleProofChangeResult;
+
+export { type AssessRiddleProofChangeInput, RIDDLE_PROOF_CHANGE_CONTRACT_VERSION, RIDDLE_PROOF_CHANGE_RESULT_VERSION, type RiddleProofChangeContract, type RiddleProofChangeDelta, type RiddleProofChangeDeltaResult, type RiddleProofChangeDeltaStatus, type RiddleProofChangeGroupContract, type RiddleProofChangeGroupResult, type RiddleProofChangeProfileCheckStatus, type RiddleProofChangeResult, type RiddleProofChangeSide, type RiddleProofChangeStatus, type RiddleProofCheckStatusTransitionDelta, type RiddleProofProfileStatusTransitionDelta, assessRiddleProofChange };

package/dist/change-proof.d.ts

@@ -0,0 +1,74 @@
+import { RiddleProofProfileResult, RiddleProofProfileStatus, RiddleProofProfileCheckResult } from './profile.js';
+import { JsonValue } from './types.js';
+import './public-state.js';
+
+declare const RIDDLE_PROOF_CHANGE_CONTRACT_VERSION: "riddle-proof.change-contract.v1";
+declare const RIDDLE_PROOF_CHANGE_RESULT_VERSION: "riddle-proof.change-result.v1";
+type RiddleProofChangeSide = "before" | "after";
+type RiddleProofChangeStatus = RiddleProofProfileStatus;
+type RiddleProofChangeDeltaStatus = "passed" | "failed" | "proof_insufficient" | "configuration_error";
+type RiddleProofChangeProfileCheckStatus = RiddleProofProfileCheckResult["status"];
+interface RiddleProofChangeGroupContract {
+    label?: string;
+    required_status?: RiddleProofProfileStatus | RiddleProofProfileStatus[];
+}
+interface RiddleProofProfileStatusTransitionDelta {
+    type: "profile_status_transition";
+    label?: string;
+    before_status?: RiddleProofProfileStatus | RiddleProofProfileStatus[];
+    after_status?: RiddleProofProfileStatus | RiddleProofProfileStatus[];
+}
+interface RiddleProofCheckStatusTransitionDelta {
+    type: "check_status_transition";
+    label?: string;
+    check_label?: string;
+    check_type?: string;
+    before_status?: RiddleProofChangeProfileCheckStatus | RiddleProofChangeProfileCheckStatus[];
+    after_status?: RiddleProofChangeProfileCheckStatus | RiddleProofChangeProfileCheckStatus[];
+}
+type RiddleProofChangeDelta = RiddleProofProfileStatusTransitionDelta | RiddleProofCheckStatusTransitionDelta;
+interface RiddleProofChangeContract {
+    version?: typeof RIDDLE_PROOF_CHANGE_CONTRACT_VERSION;
+    name: string;
+    before?: RiddleProofChangeGroupContract;
+    after?: RiddleProofChangeGroupContract;
+    deltas: RiddleProofChangeDelta[];
+    metadata?: Record<string, JsonValue>;
+}
+interface RiddleProofChangeGroupResult {
+    side: RiddleProofChangeSide;
+    label: string;
+    ok: boolean;
+    profile_name?: string;
+    status: RiddleProofProfileStatus | "missing";
+    required_status: RiddleProofProfileStatus[];
+    summary?: string;
+    message?: string;
+}
+interface RiddleProofChangeDeltaResult {
+    type: RiddleProofChangeDelta["type"];
+    label: string;
+    status: RiddleProofChangeDeltaStatus;
+    before_observed?: JsonValue;
+    after_observed?: JsonValue;
+    message?: string;
+}
+interface RiddleProofChangeResult {
+    version: typeof RIDDLE_PROOF_CHANGE_RESULT_VERSION;
+    contract_name: string;
+    status: RiddleProofChangeStatus;
+    groups: {
+        before: RiddleProofChangeGroupResult;
+        after: RiddleProofChangeGroupResult;
+    };
+    deltas: RiddleProofChangeDeltaResult[];
+    summary: string;
+    metadata?: Record<string, JsonValue>;
+}
+interface AssessRiddleProofChangeInput {
+    before_result?: RiddleProofProfileResult;
+    after_result?: RiddleProofProfileResult;
+}
+declare function assessRiddleProofChange(contract: RiddleProofChangeContract, input: AssessRiddleProofChangeInput): RiddleProofChangeResult;
+
+export { type AssessRiddleProofChangeInput, RIDDLE_PROOF_CHANGE_CONTRACT_VERSION, RIDDLE_PROOF_CHANGE_RESULT_VERSION, type RiddleProofChangeContract, type RiddleProofChangeDelta, type RiddleProofChangeDeltaResult, type RiddleProofChangeDeltaStatus, type RiddleProofChangeGroupContract, type RiddleProofChangeGroupResult, type RiddleProofChangeProfileCheckStatus, type RiddleProofChangeResult, type RiddleProofChangeSide, type RiddleProofChangeStatus, type RiddleProofCheckStatusTransitionDelta, type RiddleProofProfileStatusTransitionDelta, assessRiddleProofChange };

package/dist/change-proof.js

@@ -0,0 +1,11 @@
+import {
+  RIDDLE_PROOF_CHANGE_CONTRACT_VERSION,
+  RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+  assessRiddleProofChange
+} from "./chunk-6S7DZWVC.js";
+import "./chunk-MLKGABMK.js";
+export {
+  RIDDLE_PROOF_CHANGE_CONTRACT_VERSION,
+  RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+  assessRiddleProofChange
+};

package/dist/chunk-6S7DZWVC.js

@@ -0,0 +1,167 @@
+// src/change-proof.ts
+var RIDDLE_PROOF_CHANGE_CONTRACT_VERSION = "riddle-proof.change-contract.v1";
+var RIDDLE_PROOF_CHANGE_RESULT_VERSION = "riddle-proof.change-result.v1";
+var DEFAULT_BEFORE_STATUSES = ["passed", "product_regression"];
+var DEFAULT_AFTER_STATUSES = ["passed"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE = ["product_regression"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_AFTER = ["passed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_BEFORE = ["failed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_AFTER = ["passed"];
+function listValue(value, fallback) {
+  if (Array.isArray(value)) return value;
+  if (value === void 0) return fallback;
+  return [value];
+}
+function includesValue(allowed, observed) {
+  return observed !== void 0 && allowed.includes(observed);
+}
+function groupResult(side, contract, result) {
+  const fallback = side === "before" ? DEFAULT_BEFORE_STATUSES : DEFAULT_AFTER_STATUSES;
+  const requiredStatus = listValue(contract?.required_status, fallback);
+  const label = contract?.label || side;
+  if (!result) {
+    return {
+      side,
+      label,
+      ok: false,
+      status: "missing",
+      required_status: requiredStatus,
+      message: `${label} profile result is missing.`
+    };
+  }
+  const ok = includesValue(requiredStatus, result.status);
+  return {
+    side,
+    label,
+    ok,
+    profile_name: result.profile_name,
+    status: result.status,
+    required_status: requiredStatus,
+    summary: result.summary,
+    message: ok ? void 0 : `${label} profile status ${result.status} did not match required status ${requiredStatus.join(", ")}.`
+  };
+}
+function findCheck(result, delta) {
+  return result.checks.find((check) => {
+    if (delta.check_label && check.label !== delta.check_label) return false;
+    if (delta.check_type && check.type !== delta.check_type) return false;
+    return Boolean(delta.check_label || delta.check_type);
+  });
+}
+function profileStatusTransitionResult(delta, before, after) {
+  const label = delta.label || "profile-status-transition";
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeAllowed = listValue(delta.before_status, DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue(delta.after_status, DEFAULT_PROFILE_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, before.status) && includesValue(afterAllowed, after.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: before.status,
+    after_observed: after.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${before.status} -> ${after.status}.`
+  };
+}
+function checkStatusTransitionResult(delta, before, after) {
+  const label = delta.label || delta.check_label || delta.check_type || "check-status-transition";
+  if (!delta.check_label && !delta.check_type) {
+    return {
+      type: delta.type,
+      label,
+      status: "configuration_error",
+      message: `${label} needs check_label or check_type.`
+    };
+  }
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeCheck = findCheck(before, delta);
+  const afterCheck = findCheck(after, delta);
+  if (!beforeCheck || !afterCheck) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: beforeCheck?.status,
+      after_observed: afterCheck?.status,
+      message: `${label} was not present in ${!beforeCheck && !afterCheck ? "before or after" : !beforeCheck ? "before" : "after"} profile checks.`
+    };
+  }
+  const beforeAllowed = listValue(delta.before_status, DEFAULT_CHECK_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue(delta.after_status, DEFAULT_CHECK_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, beforeCheck.status) && includesValue(afterAllowed, afterCheck.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: beforeCheck.status,
+    after_observed: afterCheck.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${beforeCheck.status} -> ${afterCheck.status}.`
+  };
+}
+function assessDelta(delta, before, after) {
+  if (delta.type === "profile_status_transition") {
+    return profileStatusTransitionResult(delta, before, after);
+  }
+  return checkStatusTransitionResult(delta, before, after);
+}
+function collapsedChangeStatus(groups, deltas) {
+  const groupResults = [groups.before, groups.after];
+  if (groupResults.some((group) => group.status === "environment_blocked")) return "environment_blocked";
+  if (groupResults.some((group) => group.status === "configuration_error")) return "configuration_error";
+  if (deltas.some((delta) => delta.status === "configuration_error")) return "configuration_error";
+  if (groupResults.some((group) => group.status === "needs_human_review")) return "needs_human_review";
+  if (groupResults.some((group) => group.status === "missing" || group.status === "proof_insufficient")) return "proof_insufficient";
+  if (!deltas.length || deltas.some((delta) => delta.status === "proof_insufficient")) return "proof_insufficient";
+  if (groupResults.some((group) => !group.ok)) return "product_regression";
+  if (deltas.some((delta) => delta.status === "failed")) return "product_regression";
+  return "passed";
+}
+function changeSummary(name, status, deltas) {
+  if (status === "passed") return `${name} passed ${deltas.length} change delta(s).`;
+  if (status === "environment_blocked") return `${name} could not compare reliable evidence because an environment was blocked.`;
+  if (status === "configuration_error") return `${name} has an invalid change proof contract.`;
+  if (status === "needs_human_review") return `${name} needs human review before the change proof can pass.`;
+  if (status === "proof_insufficient") return `${name} did not produce enough before/after evidence for a change proof.`;
+  return `${name} failed ${deltas.filter((delta) => delta.status === "failed").length} change delta(s).`;
+}
+function assessRiddleProofChange(contract, input) {
+  const groups = {
+    before: groupResult("before", contract.before, input.before_result),
+    after: groupResult("after", contract.after, input.after_result)
+  };
+  const deltas = (contract.deltas || []).map((delta) => assessDelta(delta, input.before_result, input.after_result));
+  const status = collapsedChangeStatus(groups, deltas);
+  return {
+    version: RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+    contract_name: contract.name,
+    status,
+    groups,
+    deltas,
+    summary: changeSummary(contract.name, status, deltas),
+    metadata: contract.metadata
+  };
+}
+
+export {
+  RIDDLE_PROOF_CHANGE_CONTRACT_VERSION,
+  RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+  assessRiddleProofChange
+};