@riddledc/riddle-proof 0.8.77 → 0.8.79

package/dist/{chunk-IY4W6STC.js → chunk-7N6X54WG.js}

@@ -1,3 +1,11 @@
+import {
+  RIDDLE_PROOF_CHANGE_RECEIPT_V1_VERSION,
+  RIDDLE_PROOF_CHANGE_RECEIPT_VERSION,
+  RIDDLE_PROOF_HANDOFF_RECEIPT_VERSION,
+  createRiddleProofHandoffReceipt,
+  parseRiddleProofChangeReceipt,
+  parseRiddleProofHandoffReceipt
+} from "./chunk-6VFS2JFR.js";
 import {
   riddleProofPublicStateAllowsMergeRecommendation,
   riddleProofPublicStateMergeRecommendation,
@@ -84,9 +92,10 @@ function collectChangeReceiptArtifacts(result) {
   const seen = /* @__PURE__ */ new Set();
   const collectSide = (sideName, side) => {
     const candidates = [
+      side.canonical_screenshot,
       ...asArray(side.screenshots),
       ...asArray(side.artifacts)
-    ];
+    ].filter(Boolean);
     for (const [index, item] of candidates.entries()) {
       const artifact = asRecord(item);
       const url = stringValue(artifact.url) || stringValue(artifact.path);
@@ -178,9 +187,10 @@ function changeReceiptPageSummaries(result) {
   for (const sideName of ["before", "after"]) {
     const side = asRecord(result[sideName]);
     if (!Object.keys(side).length) continue;
-    const checks = asRecord(side.checks);
+    const profileSummary = asRecord(side.profile_summary);
+    const checks = Object.keys(asRecord(side.checks)).length ? asRecord(side.checks) : asRecord(profileSummary.checks);
     pages.push({
-      route: firstStringValue(side.source, side.profile_name) || sideName,
+      route: firstStringValue(asRecord(side.target).url, side.source, profileSummary.profile_name, side.profile_name) || sideName,
       passed: numberValue(checks.passed) ?? 0,
       failed: numberValue(checks.failed) ?? 0
     });
@@ -243,7 +253,11 @@ function isProfileResult(result) {
   return version === "riddle-proof.profile-result.v1" || version === "riddle-proof.profile-compact-result.v1";
 }
 function isChangeReceiptResult(result) {
-  return stringValue(result.version) === "riddle-proof.change-receipt.v1";
+  const version = stringValue(result.version);
+  return version === RIDDLE_PROOF_CHANGE_RECEIPT_V1_VERSION || version === RIDDLE_PROOF_CHANGE_RECEIPT_VERSION;
+}
+function isHandoffReceiptResult(result) {
+  return stringValue(result.version) === RIDDLE_PROOF_HANDOFF_RECEIPT_VERSION;
 }
 function isChangeResult(result) {
   const version = stringValue(result.version);
@@ -251,10 +265,13 @@ function isChangeResult(result) {
 }
 function summarizeRiddleProofPrComment(input) {
   const runResponse = asRecord(input.runResponse);
-  const result = asRecord(input.result);
+  const inputResult = asRecord(input.result);
+  const handoffReceipt = isHandoffReceiptResult(inputResult) ? parseRiddleProofHandoffReceipt(inputResult) : void 0;
+  const parsedChangeReceipt = handoffReceipt?.change || (isChangeReceiptResult(inputResult) ? parseRiddleProofChangeReceipt(inputResult) : void 0);
+  const result = parsedChangeReceipt ? asRecord(parsedChangeReceipt) : inputResult;
   const proofResult = asRecord(runResponse.proofResult);
   const profileResult = isProfileResult(result);
-  const changeReceiptResult = isChangeReceiptResult(result);
+  const changeReceiptResult = Boolean(parsedChangeReceipt);
   const changeResult = changeReceiptResult || isChangeResult(result);
   const profileRiddle = asRecord(result.riddle);
   const preview = asRecord(runResponse.preview);
@@ -275,7 +292,7 @@ function summarizeRiddleProofPrComment(input) {
   delete checkSource.ok;
   const nestedChecks = summarizeExplicitChecks(checkSource);
   const resultStatus = firstStringValue(result.status, stopCondition.status);
-  const ok = changeResult ? resultStatus === "passed" : booleanValue(result.ok) ?? booleanValue(runResponse.ok) ?? null;
+  const ok = changeReceiptResult ? parsedChangeReceipt?.recommendation.merge_recommended ?? false : changeResult ? resultStatus === "passed" : booleanValue(result.ok) ?? booleanValue(runResponse.ok) ?? null;
   const checkpointSummary = checkpointSummaryFrom(
     result.checkpoint_summary,
     stopCondition.checkpoint_summary,
@@ -283,19 +300,19 @@ function summarizeRiddleProofPrComment(input) {
     rawDetails.checkpoint_summary,
     proofResult.checkpoint_summary
   );
-  const publicState = summarizeRiddleProofPublicState({
+  const publicState = changeReceiptResult ? void 0 : summarizeRiddleProofPublicState({
     ...result,
     status: resultStatus,
     checkpoint_summary: checkpointSummary || result.checkpoint_summary
   });
-  const mergeRecommendation = riddleProofPublicStateMergeRecommendation(
+  const mergeRecommendation = publicState ? riddleProofPublicStateMergeRecommendation(
     publicState,
     firstStringValue(result.merge_recommendation, stopCondition.merge_recommendation, resultRaw.merge_recommendation)
-  );
+  ) : void 0;
   return {
     ok,
     status: firstStringValue(proofResult.status, profileRiddle.status),
-    result_status: changeResult ? resultStatus : publicState.status,
+    result_status: changeResult ? resultStatus : publicState?.status,
     job_id: firstStringValue(proofResult.job_id, profileRiddle.job_id),
     duration_ms: numberValue(proofResult.duration_ms) ?? numberValue(profileRiddle.elapsed_ms),
     proof_url: stringValue(runResponse.proofUrl),
@@ -303,13 +320,13 @@ function summarizeRiddleProofPrComment(input) {
     preview_url: stringValue(preview.preview_url) || stringValue(preview.url),
     preview_publish_recovered: booleanValue(preview.publish_recovered),
     preview_publish_error: stringValue(preview.publish_error),
-    ship_held: publicState.ship_held,
-    shipping_disabled: publicState.shipping_disabled,
-    ship_authorized: publicState.ship_authorized,
-    merge_ready: publicState.merge_ready,
-    sync_allowed: publicState.sync_allowed,
+    ship_held: publicState?.ship_held,
+    shipping_disabled: publicState?.shipping_disabled,
+    ship_authorized: changeReceiptResult ? parsedChangeReceipt?.shipping_authorization.authorized : publicState?.ship_authorized,
+    merge_ready: publicState?.merge_ready,
+    sync_allowed: publicState?.sync_allowed,
     proof_decision: firstStringValue(result.proof_decision, stopCondition.proof_decision, resultRaw.proof_decision),
-    merge_recommendation: changeReceiptResult && resultStatus ? stringValue(result.verdict) : mergeRecommendation,
+    merge_recommendation: changeReceiptResult ? parsedChangeReceipt?.recommendation.label : mergeRecommendation,
     checkpoint_summary: checkpointSummary,
     public_state: publicState,
     passed_checks: changeChecks?.passed ?? profileChecks?.passed ?? nestedChecks.passed,
@@ -377,7 +394,88 @@ function checkpointSummaryLine(summary) {
     summary.latest_decision ? `latest decision \`${summary.latest_decision}\`` : ""
   ].filter(Boolean).join("; ");
 }
+function markdownTableValue(value) {
+  return String(value ?? "").replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function observationArtifactTarget(artifact) {
+  return artifact?.url || artifact?.path;
+}
+function canonicalScreenshotCell(artifact, fallback) {
+  const target = observationArtifactTarget(artifact);
+  if (!artifact || !target) return fallback;
+  if (artifact.url) return `![${artifact.name.replace(/\]/g, "\\]")}](${artifact.url})`;
+  return markdownTableValue(artifact.path || artifact.name);
+}
+function shortRevision(value) {
+  return value ? value.slice(0, 12) : "not recorded";
+}
+function buildRiddleProofHandoffPrCommentMarkdown(handoff, input = {}) {
+  const receipt = parseRiddleProofHandoffReceipt(handoff);
+  const change = receipt.change;
+  const beforeStatus = change.before.profile_summary?.status || "not recorded";
+  const afterStatus = change.after.profile_summary?.status || "not recorded";
+  const beforeBaseline = change.groups.before.ok ? "matched baseline" : "baseline mismatch";
+  const lines = [
+    RIDDLE_PROOF_PR_COMMENT_MARKER,
+    `## ${input.title?.trim() || "Riddle Change Proof"}`,
+    "",
+    `**Result:** ${receipt.recommendation.label}`,
+    `**Evidence verdict:** \`${receipt.verdict}\``,
+    `**Shipping authorization:** ${receipt.shipping_authorization.status}`,
+    `**Contract:** ${change.contract_name}`
+  ];
+  if (input.goal?.trim()) lines.push(`**Goal:** ${input.goal.trim()}`);
+  if (input.successCriteria?.trim()) lines.push(`**Success criteria:** ${input.successCriteria.trim()}`);
+  lines.push("", change.summary, "", "### Canonical Before / After", "");
+  lines.push("| Before | After |");
+  lines.push("| --- | --- |");
+  lines.push(`| ${beforeBaseline}: \`${markdownTableValue(beforeStatus)}\` | \`${markdownTableValue(afterStatus)}\` |`);
+  lines.push(`| ${canonicalScreenshotCell(receipt.canonical_pair.before, "No canonical before screenshot")} | ${canonicalScreenshotCell(receipt.canonical_pair.after, "No canonical after screenshot")} |`);
+  lines.push("", "### Source Binding", "");
+  lines.push("| Side | Target | Git revision | Binding | Preview | Digest |");
+  lines.push("| --- | --- | --- | --- | --- | --- |");
+  for (const side of ["before", "after"]) {
+    const observation = change[side];
+    const binding = change.source_bindings[side];
+    lines.push(`| ${side} | ${markdownTableValue(observation.target.url)} | \`${shortRevision(binding.observed_git_revision || observation.source.git_revision)}\` | ${binding.status} | ${markdownTableValue(binding.preview_id || observation.target.preview?.preview_id || "not required")} | \`${markdownTableValue(binding.content_digest || observation.target.preview?.content_digest || "not required")}\` |`);
+  }
+  lines.push("", "### Declared Delta", "");
+  lines.push("| Measurement | Status | Before | After |");
+  lines.push("| --- | --- | --- | --- |");
+  for (const delta of change.deltas) {
+    lines.push(`| ${markdownTableValue(delta.label)} | ${delta.status} | ${markdownTableValue(delta.before_observed)} | ${markdownTableValue(delta.after_observed)} |`);
+  }
+  if (change.proves.length) {
+    lines.push("", "### What This Proves", "");
+    for (const claim of change.proves) lines.push(`- ${claim}`);
+  }
+  if (change.does_not_prove.length) {
+    lines.push("", "### Limits", "");
+    for (const claim of change.does_not_prove) lines.push(`- ${claim}`);
+  }
+  const linkedArtifacts = [
+    ...change.before.artifacts.map((artifact) => ({ side: "before", artifact })),
+    ...change.after.artifacts.map((artifact) => ({ side: "after", artifact }))
+  ].filter(({ artifact }) => Boolean(artifact.url));
+  if (linkedArtifacts.length) {
+    lines.push("", "### Artifacts", "");
+    for (const { side, artifact } of linkedArtifacts.slice(0, 24)) {
+      lines.push(`- ${side}: ${markdownLink(artifact.name, artifact.url || "")}`);
+    }
+  }
+  lines.push("", input.source?.trim() ? `_Source: ${input.source.trim()}_` : "_Rendered from the Handoff receipt without recomputing its verdict._");
+  return `${lines.join("\n").trim()}
+`;
+}
 function buildRiddleProofPrCommentMarkdown(input) {
+  const result = asRecord(input.result);
+  if (isHandoffReceiptResult(result)) {
+    return buildRiddleProofHandoffPrCommentMarkdown(parseRiddleProofHandoffReceipt(result), input);
+  }
+  if (isChangeReceiptResult(result)) {
+    const handoff = createRiddleProofHandoffReceipt(parseRiddleProofChangeReceipt(result));
+    return buildRiddleProofHandoffPrCommentMarkdown(handoff, input);
+  }
   const summary = summarizeRiddleProofPrComment(input);
   const title = input.title?.trim() || "Riddle Proof Evidence";
   const lines = [
@@ -448,5 +546,6 @@ function buildRiddleProofPrCommentMarkdown(input) {
 export {
   RIDDLE_PROOF_PR_COMMENT_MARKER,
   summarizeRiddleProofPrComment,
+  buildRiddleProofHandoffPrCommentMarkdown,
   buildRiddleProofPrCommentMarkdown
 };

package/dist/{chunk-GG2D3MFZ.js → chunk-FCSJZBC5.js}

@@ -781,6 +781,12 @@ function profileScreenshotLabels(viewports) {
   }
   return labels;
 }
+function profileFinalScreenshotLabels(viewports) {
+  return (viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => typeof label === "string" && Boolean(label.trim()));
+}
+function profileAllSetupScreenshotLabels(viewports) {
+  return (viewports || []).flatMap((viewport) => profileSetupScreenshotLabels(viewport.setup_action_results || []));
+}
 function profileSetupSummary(viewports, actionCount, expectedActionCountByViewport, finalScreenshotFullPage) {
   const normalizedFinalScreenshotFullPage = finalScreenshotFullPage === void 0 ? void 0 : finalScreenshotFullPage !== false;
   const finalScreenshotCount = viewports.filter((viewport) => typeof viewport.screenshot_label === "string" && viewport.screenshot_label.trim()).length;
@@ -3631,6 +3637,8 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
   const status = profileStatusFromEvidence(profile, evidence, checks);
   const firstViewport = evidence?.viewports?.[0];
   const screenshots = profileScreenshotLabels(evidence?.viewports);
+  const canonicalScreenshots = profileFinalScreenshotLabels(evidence?.viewports);
+  const setupScreenshots = profileAllSetupScreenshotLabels(evidence?.viewports);
   const result = {
     version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
     profile_name: profile.name,
@@ -3640,6 +3648,8 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     route: routeForViewport(firstViewport, evidence?.target_url),
     artifacts: {
       screenshots,
+      canonical_screenshots: canonicalScreenshots,
+      setup_screenshots: setupScreenshots,
       console: "console.json",
       proof_json: "proof.json",
       dom_summary: "dom-summary.json",
@@ -4958,6 +4968,12 @@ function profileScreenshotLabels(viewports) {
   }
   return labels;
 }
+function profileFinalScreenshotLabels(viewports) {
+  return (viewports || []).map((viewport) => viewport && viewport.screenshot_label).filter(Boolean);
+}
+function profileAllSetupScreenshotLabels(viewports) {
+  return (viewports || []).flatMap((viewport) => profileSetupScreenshotLabels(viewport && viewport.setup_action_results || []));
+}
 function profileSetupSummary(viewports, actionCount, expectedActionCountsByViewport, finalScreenshotFullPage) {
   const normalizedFinalScreenshotFullPage = finalScreenshotFullPage === undefined
     ? undefined
@@ -5826,6 +5842,8 @@ function assessProfile(profile, evidence) {
   else if (checks.some((check) => check.status === "needs_human_review")) status = "needs_human_review";
   else if (checks.some((check) => check.status === "failed")) status = "product_regression";
   const screenshotLabels = profileScreenshotLabels(viewports);
+  const canonicalScreenshotLabels = profileFinalScreenshotLabels(viewports);
+  const setupScreenshotLabels = profileAllSetupScreenshotLabels(viewports);
   const route = viewports[0] && viewports[0].route ? viewports[0].route : { requested: evidence.target_url, observed: "", matched: false, error: "missing viewport evidence" };
   const passedChecks = checks.filter((check) => check.status === "passed").length;
   const failedChecks = checks.filter((check) => check.status === "failed").length;
@@ -5842,7 +5860,14 @@ function assessProfile(profile, evidence) {
     status,
     baseline_policy: profile.baseline_policy || "invariant_only",
     route,
-    artifacts: { screenshots: screenshotLabels, console: "console.json", proof_json: "proof.json", dom_summary: "dom-summary.json" },
+    artifacts: {
+      screenshots: screenshotLabels,
+      canonical_screenshots: canonicalScreenshotLabels,
+      setup_screenshots: setupScreenshotLabels,
+      console: "console.json",
+      proof_json: "proof.json",
+      dom_summary: "dom-summary.json"
+    },
     checks,
     summary,
     captured_at: evidence.captured_at,

package/dist/chunk-MEVVL4TI.js

@@ -0,0 +1,258 @@
+// src/receipts.ts
+var RIDDLE_PREVIEW_RECEIPT_VERSION = "riddle.preview-receipt.v1";
+var RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION = "riddle-proof.observation-receipt.v1";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(record, key, context) {
+  const value = record[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${context}.${key} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function normalizedSourceIdentity(value) {
+  if (!isRecord(value)) return {};
+  return {
+    git_revision: typeof value.git_revision === "string" && value.git_revision.trim() ? value.git_revision.trim() : void 0,
+    repository: typeof value.repository === "string" && value.repository.trim() ? value.repository.trim() : void 0,
+    dirty: typeof value.dirty === "boolean" ? value.dirty : void 0,
+    label: typeof value.label === "string" && value.label.trim() ? value.label.trim() : void 0
+  };
+}
+function parseRiddlePreviewReceipt(value) {
+  if (!isRecord(value)) throw new Error("Preview receipt must be an object.");
+  if (value.version !== RIDDLE_PREVIEW_RECEIPT_VERSION) {
+    throw new Error(`Unsupported Preview receipt version ${String(value.version || "missing")}.`);
+  }
+  if (!isRecord(value.source)) throw new Error("Preview receipt source must be an object.");
+  const expiresAt = requiredString(value, "expires_at", "preview receipt");
+  const publishedAt = requiredString(value, "published_at", "preview receipt");
+  const contentDigest = requiredString(value, "content_digest", "preview receipt");
+  if (!contentDigest.startsWith("sha256:") || contentDigest.length <= "sha256:".length) {
+    throw new Error("preview receipt.content_digest must be a sha256 digest.");
+  }
+  if (!Number.isFinite(Date.parse(expiresAt)) || !Number.isFinite(Date.parse(publishedAt))) {
+    throw new Error("Preview receipt timestamps must be valid ISO date strings.");
+  }
+  return {
+    version: RIDDLE_PREVIEW_RECEIPT_VERSION,
+    preview_id: requiredString(value, "preview_id", "preview receipt"),
+    url: requiredString(value, "url", "preview receipt"),
+    expires_at: expiresAt,
+    content_digest: contentDigest,
+    source: normalizedSourceIdentity(value.source),
+    published_at: publishedAt
+  };
+}
+function comparableArtifactName(value) {
+  return (value || "").split(/[/?#]/).pop()?.toLowerCase().replace(/\.(png|jpe?g|gif|webp|avif|svg)$/u, "").replace(/[^a-z0-9_-]+/gu, "-").replace(/^-+|-+$/g, "") || "";
+}
+function artifactMatchesLabel(artifact, label) {
+  const expected = comparableArtifactName(label);
+  if (!expected) return false;
+  return [artifact.name, artifact.url, artifact.path].map(comparableArtifactName).some((name) => name === expected || name.endsWith(`-${expected}`));
+}
+function artifactLooksLikeScreenshot(ref) {
+  const text = [ref.name, ref.url, ref.path, ref.kind, ref.content_type].filter(Boolean).join(" ").toLowerCase();
+  return /screenshot|\bimage\b/.test(text) || /\.(png|jpe?g|gif|webp|avif|svg)(\?|#|$)/.test(text);
+}
+function finalScreenshotLabels(result) {
+  const explicit = result.artifacts.canonical_screenshots || [];
+  if (explicit.length) return explicit;
+  const fromEvidence = (result.evidence?.viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => typeof label === "string" && Boolean(label.trim()));
+  if (fromEvidence.length) return fromEvidence;
+  return (result.artifacts.screenshots || []).slice(0, 1);
+}
+function setupScreenshotLabels(result) {
+  const explicit = result.artifacts.setup_screenshots || [];
+  if (explicit.length) return explicit;
+  return (result.evidence?.viewports || []).flatMap(
+    (viewport) => (viewport.setup_action_results || []).filter((action) => action.action === "screenshot" && action.ok !== false && typeof action.screenshot_label === "string").map((action) => String(action.screenshot_label))
+  );
+}
+function observationArtifactFromRef(ref, canonicalLabels, setupLabels) {
+  const base = {
+    name: ref.name,
+    role: ref.role || "artifact",
+    url: ref.url,
+    path: ref.path,
+    kind: ref.kind,
+    content_type: ref.content_type,
+    source: ref.source
+  };
+  if (!artifactLooksLikeScreenshot(ref)) return base;
+  if (canonicalLabels.some((label) => artifactMatchesLabel(base, label))) {
+    return { ...base, role: "canonical_screenshot" };
+  }
+  if (setupLabels.some((label) => artifactMatchesLabel(base, label))) {
+    return { ...base, role: "setup_screenshot" };
+  }
+  return { ...base, role: "diagnostic" };
+}
+function profileObservationArtifacts(result) {
+  const canonicalLabels = finalScreenshotLabels(result);
+  const setupLabels = setupScreenshotLabels(result);
+  const artifacts = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (artifact) => {
+    const key = artifact.url || artifact.path || `${artifact.role}:${artifact.name}`;
+    if (!artifact.name || seen.has(key)) return;
+    seen.add(key);
+    artifacts.push(artifact);
+  };
+  for (const ref of result.artifacts.riddle_artifacts || []) {
+    add(observationArtifactFromRef(ref, canonicalLabels, setupLabels));
+  }
+  for (const label of canonicalLabels) {
+    if (!artifacts.some((artifact) => artifactMatchesLabel(artifact, label))) {
+      add({ name: label, path: label, role: "canonical_screenshot", kind: "image" });
+    }
+  }
+  for (const label of setupLabels) {
+    if (!artifacts.some((artifact) => artifactMatchesLabel(artifact, label))) {
+      add({ name: label, path: label, role: "setup_screenshot", kind: "image" });
+    }
+  }
+  for (const label of result.artifacts.screenshots || []) {
+    if (!artifacts.some((artifact) => artifactMatchesLabel(artifact, label))) {
+      add({ name: label, path: label, role: "diagnostic", kind: "image" });
+    }
+  }
+  return artifacts;
+}
+function mergeObservationArtifacts(profileArtifacts, suppliedArtifacts) {
+  const artifacts = [...profileArtifacts];
+  for (const supplied of suppliedArtifacts) {
+    const suppliedNames = [supplied.name, supplied.url, supplied.path].map(comparableArtifactName).filter(Boolean);
+    const existingIndex = artifacts.findIndex((artifact) => {
+      if (supplied.url && artifact.url === supplied.url) return true;
+      if (supplied.path && artifact.path === supplied.path) return true;
+      return [artifact.name, artifact.url, artifact.path].map(comparableArtifactName).some((name) => name && suppliedNames.includes(name));
+    });
+    if (existingIndex < 0) {
+      artifacts.push(supplied);
+      continue;
+    }
+    const existing = artifacts[existingIndex];
+    const role = supplied.role === "canonical_screenshot" || supplied.role === "setup_screenshot" ? supplied.role : existing.role === "canonical_screenshot" || existing.role === "setup_screenshot" ? existing.role : supplied.role === "artifact" ? existing.role : supplied.role;
+    artifacts[existingIndex] = {
+      ...existing,
+      ...supplied,
+      role
+    };
+  }
+  return artifacts;
+}
+function defaultObservationId(role, capturedAt) {
+  return `obs_${role}_${capturedAt.replace(/[^0-9]/g, "").slice(0, 17) || "unknown"}`;
+}
+function profileCheckCounts(result) {
+  const counts = { total: result.checks.length, passed: 0, failed: 0, skipped: 0, needs_human_review: 0 };
+  for (const check of result.checks) {
+    if (check.status === "passed") counts.passed += 1;
+    if (check.status === "failed") counts.failed += 1;
+    if (check.status === "skipped") counts.skipped += 1;
+    if (check.status === "needs_human_review") counts.needs_human_review += 1;
+  }
+  return counts;
+}
+function createRiddleProofObservationReceipt(input) {
+  const capturedAt = input.captured_at || input.profile_result?.captured_at || (/* @__PURE__ */ new Date()).toISOString();
+  const profileArtifacts = input.profile_result ? profileObservationArtifacts(input.profile_result) : [];
+  const requestedCanonical = input.canonical_screenshot ? { ...input.canonical_screenshot, role: "canonical_screenshot" } : void 0;
+  const artifacts = mergeObservationArtifacts(
+    profileArtifacts,
+    [...input.artifacts || [], ...requestedCanonical ? [requestedCanonical] : []]
+  );
+  const canonicalScreenshot = requestedCanonical ? artifacts.find((artifact) => artifact.role === "canonical_screenshot" && artifactMatchesLabel(artifact, requestedCanonical.name)) || requestedCanonical : artifacts.find((artifact) => artifact.role === "canonical_screenshot");
+  const target = input.target.kind === "preview" && input.target.preview ? { ...input.target, preview: parseRiddlePreviewReceipt(input.target.preview) } : input.target;
+  return {
+    version: RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION,
+    observation_id: input.observation_id || defaultObservationId(input.comparison_role, capturedAt),
+    comparison_role: input.comparison_role,
+    executor: input.executor,
+    target,
+    source: normalizedSourceIdentity(input.source || input.target.preview?.source),
+    captured_at: capturedAt,
+    artifacts,
+    canonical_screenshot: canonicalScreenshot,
+    profile_summary: input.profile_result ? {
+      profile_name: input.profile_result.profile_name,
+      status: input.profile_result.status,
+      summary: input.profile_result.summary,
+      route: input.profile_result.route,
+      checks: profileCheckCounts(input.profile_result)
+    } : void 0,
+    proof: input.profile_result ? {
+      profile_name: input.profile_result.profile_name,
+      result: input.profile_result
+    } : void 0,
+    publication: input.publication,
+    execution: input.execution,
+    metadata: input.metadata
+  };
+}
+function parseRiddleProofObservationReceipt(value) {
+  if (!isRecord(value)) throw new Error("Observation receipt must be an object.");
+  if (value.version !== RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION) {
+    throw new Error(`Unsupported Observation receipt version ${String(value.version || "missing")}.`);
+  }
+  if (!isRecord(value.executor)) throw new Error("Observation receipt executor must be an object.");
+  if (!isRecord(value.target)) throw new Error("Observation receipt target must be an object.");
+  if (!isRecord(value.source)) throw new Error("Observation receipt source must be an object.");
+  requiredString(value, "observation_id", "observation receipt");
+  requiredString(value, "captured_at", "observation receipt");
+  const executorKind = requiredString(value.executor, "kind", "observation receipt executor");
+  if (!"local_playwright,riddle_hosted,browser_api,other".split(",").includes(executorKind)) {
+    throw new Error(`Unsupported observation executor kind ${executorKind}.`);
+  }
+  if (value.executor.runner !== void 0) {
+    requiredString(value.executor, "runner", "observation receipt executor");
+  }
+  const role = requiredString(value, "comparison_role", "observation receipt");
+  if (!["before", "after", "standalone"].includes(role)) {
+    throw new Error(`Unsupported observation comparison role ${role}.`);
+  }
+  const targetKind = requiredString(value.target, "kind", "observation receipt target");
+  if (targetKind !== "url" && targetKind !== "preview") {
+    throw new Error(`Unsupported observation target kind ${targetKind}.`);
+  }
+  requiredString(value.target, "url", "observation receipt target");
+  if (targetKind === "preview") {
+    if (value.target.preview === void 0) {
+      throw new Error("Preview Observation target must include its Preview receipt.");
+    }
+    parseRiddlePreviewReceipt(value.target.preview);
+  }
+  if (!Array.isArray(value.artifacts)) throw new Error("Observation receipt artifacts must be an array.");
+  const artifactRoles = /* @__PURE__ */ new Set(["canonical_screenshot", "setup_screenshot", "data", "diagnostic", "artifact"]);
+  const artifacts = value.artifacts.map((artifact, index) => {
+    if (!isRecord(artifact)) throw new Error(`Observation receipt artifact ${index} must be an object.`);
+    requiredString(artifact, "name", `observation receipt artifact ${index}`);
+    const artifactRole = requiredString(artifact, "role", `observation receipt artifact ${index}`);
+    if (!artifactRoles.has(artifactRole)) {
+      throw new Error(`Unsupported observation artifact role ${artifactRole}.`);
+    }
+    return artifact;
+  });
+  if (value.canonical_screenshot !== void 0) {
+    if (!isRecord(value.canonical_screenshot) || value.canonical_screenshot.role !== "canonical_screenshot") {
+      throw new Error("Observation canonical_screenshot must have the canonical_screenshot role.");
+    }
+    const canonical = value.canonical_screenshot;
+    const included = artifacts.some((artifact) => artifact.role === "canonical_screenshot" && artifact.name === canonical.name && artifact.url === canonical.url && artifact.path === canonical.path);
+    if (!included) {
+      throw new Error("Observation canonical_screenshot must reference an artifact in the receipt.");
+    }
+  }
+  return value;
+}
+
+export {
+  RIDDLE_PREVIEW_RECEIPT_VERSION,
+  RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION,
+  parseRiddlePreviewReceipt,
+  createRiddleProofObservationReceipt,
+  parseRiddleProofObservationReceipt
+};