@riddledc/riddle-proof 0.8.77 → 0.8.79

package/dist/profile-suggestions.js

@@ -1,8 +1,8 @@
 import {
   RIDDLE_PROOF_PROFILE_SUGGESTIONS_VERSION,
   suggestRiddleProofProfileChecks
-} from "./chunk-UE4I7RTI.js";
-import "./chunk-GG2D3MFZ.js";
+} from "./chunk-RQPCKRKT.js";
+import "./chunk-FCSJZBC5.js";
 import "./chunk-MLKGABMK.js";
 export {
   RIDDLE_PROOF_PROFILE_SUGGESTIONS_VERSION,

package/dist/profile.cjs

@@ -832,6 +832,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;
@@ -3682,6 +3688,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,
@@ -3691,6 +3699,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",
@@ -5009,6 +5019,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
@@ -5877,6 +5893,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;
@@ -5893,7 +5911,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/profile.d.cts

@@ -385,6 +385,8 @@ interface RiddleProofProfileResult {
     route: RiddleProofProfileRouteEvidence;
     artifacts: {
         screenshots: string[];
+        canonical_screenshots?: string[];
+        setup_screenshots?: string[];
         console?: string;
         proof_json?: string;
         dom_summary?: string;
@@ -401,6 +403,7 @@ interface RiddleProofProfileResult {
         job_id?: string;
         job_count?: number;
         status?: string | null;
+        phase?: string | null;
         terminal?: boolean;
         created_at?: string | null;
         submitted_at?: string | null;
@@ -414,10 +417,12 @@ interface RiddleProofProfileResult {
         retry_count?: number;
         stale_job_ids?: string[];
         artifact_recovery?: boolean;
+        execution?: Record<string, JsonValue>;
         split_jobs?: Array<{
             viewport: string;
             job_id?: string;
             status?: string | null;
+            phase?: string | null;
             terminal?: boolean;
             queue_elapsed_ms?: number | null;
             pre_submission_elapsed_ms?: number;
@@ -428,6 +433,7 @@ interface RiddleProofProfileResult {
             retry_count?: number;
             stale_job_ids?: string[];
             artifact_recovery?: boolean;
+            execution?: Record<string, JsonValue>;
         }>;
     };
     environment_blocker?: Record<string, JsonValue>;
@@ -441,6 +447,7 @@ interface RiddleProofProfileArtifactRef {
     kind?: string;
     content_type?: string;
     source?: string;
+    role?: "canonical_screenshot" | "setup_screenshot" | "data" | "diagnostic" | "artifact";
 }
 interface NormalizeRiddleProofProfileOptions {
     url?: string;

package/dist/profile.d.ts

@@ -385,6 +385,8 @@ interface RiddleProofProfileResult {
     route: RiddleProofProfileRouteEvidence;
     artifacts: {
         screenshots: string[];
+        canonical_screenshots?: string[];
+        setup_screenshots?: string[];
         console?: string;
         proof_json?: string;
         dom_summary?: string;
@@ -401,6 +403,7 @@ interface RiddleProofProfileResult {
         job_id?: string;
         job_count?: number;
         status?: string | null;
+        phase?: string | null;
         terminal?: boolean;
         created_at?: string | null;
         submitted_at?: string | null;
@@ -414,10 +417,12 @@ interface RiddleProofProfileResult {
         retry_count?: number;
         stale_job_ids?: string[];
         artifact_recovery?: boolean;
+        execution?: Record<string, JsonValue>;
         split_jobs?: Array<{
             viewport: string;
             job_id?: string;
             status?: string | null;
+            phase?: string | null;
             terminal?: boolean;
             queue_elapsed_ms?: number | null;
             pre_submission_elapsed_ms?: number;
@@ -428,6 +433,7 @@ interface RiddleProofProfileResult {
             retry_count?: number;
             stale_job_ids?: string[];
             artifact_recovery?: boolean;
+            execution?: Record<string, JsonValue>;
         }>;
     };
     environment_blocker?: Record<string, JsonValue>;
@@ -441,6 +447,7 @@ interface RiddleProofProfileArtifactRef {
     kind?: string;
     content_type?: string;
     source?: string;
+    role?: "canonical_screenshot" | "setup_screenshot" | "data" | "diagnostic" | "artifact";
 }
 interface NormalizeRiddleProofProfileOptions {
     url?: string;

package/dist/profile.js

@@ -27,7 +27,7 @@ import {
   resolveRiddleProofProfileTimeoutSec,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult
-} from "./chunk-GG2D3MFZ.js";
+} from "./chunk-FCSJZBC5.js";
 import "./chunk-MLKGABMK.js";
 export {
   RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS,

package/dist/receipts.cjs

@@ -0,0 +1,286 @@
+"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/receipts.ts
+var receipts_exports = {};
+__export(receipts_exports, {
+  RIDDLE_PREVIEW_RECEIPT_VERSION: () => RIDDLE_PREVIEW_RECEIPT_VERSION,
+  RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION: () => RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION,
+  createRiddleProofObservationReceipt: () => createRiddleProofObservationReceipt,
+  parseRiddlePreviewReceipt: () => parseRiddlePreviewReceipt,
+  parseRiddleProofObservationReceipt: () => parseRiddleProofObservationReceipt
+});
+module.exports = __toCommonJS(receipts_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RIDDLE_PREVIEW_RECEIPT_VERSION,
+  RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION,
+  createRiddleProofObservationReceipt,
+  parseRiddlePreviewReceipt,
+  parseRiddleProofObservationReceipt
+});

package/dist/receipts.d.cts

@@ -0,0 +1,115 @@
+import { RiddleProofProfileResult } from './profile.cjs';
+import { JsonValue } from './types.cjs';
+import './public-state.cjs';
+
+declare const RIDDLE_PREVIEW_RECEIPT_VERSION: "riddle.preview-receipt.v1";
+declare const RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION: "riddle-proof.observation-receipt.v1";
+type RiddleProofComparisonRole = "before" | "after" | "standalone";
+interface RiddleProofSourceIdentity {
+    git_revision?: string;
+    repository?: string;
+    dirty?: boolean;
+    label?: string;
+}
+interface RiddlePreviewReceipt {
+    version: typeof RIDDLE_PREVIEW_RECEIPT_VERSION;
+    preview_id: string;
+    url: string;
+    expires_at: string;
+    content_digest: string;
+    source: RiddleProofSourceIdentity;
+    published_at: string;
+}
+type RiddleProofObservationExecutorKind = "local_playwright" | "riddle_hosted" | "browser_api" | "other";
+interface RiddleProofObservationExecutor {
+    kind: RiddleProofObservationExecutorKind;
+    runner?: string;
+    job_id?: string;
+    worker_id?: string;
+}
+interface RiddleProofExecutionPhase {
+    phase: string;
+    at: string;
+}
+interface RiddleProofExecutionTelemetry {
+    enqueued_at?: string;
+    wake_requested_at?: string;
+    claimed_at?: string;
+    browser_started_at?: string;
+    artifacts_ready_at?: string;
+    completed_at?: string;
+    worker_id?: string;
+    cold_start?: boolean;
+    phases?: RiddleProofExecutionPhase[];
+    metadata?: Record<string, JsonValue>;
+}
+interface RiddleProofObservationTarget {
+    kind: "url" | "preview";
+    url: string;
+    preview?: RiddlePreviewReceipt;
+}
+type RiddleProofObservationArtifactRole = "canonical_screenshot" | "setup_screenshot" | "data" | "diagnostic" | "artifact";
+interface RiddleProofObservationArtifact {
+    name: string;
+    role: RiddleProofObservationArtifactRole;
+    url?: string;
+    path?: string;
+    kind?: string;
+    content_type?: string;
+    source?: string;
+}
+interface RiddleProofObservationPublication {
+    kind: "local" | "riddle_cdn" | "github" | "other";
+    url?: string;
+    path?: string;
+}
+interface RiddleProofObservationReceipt {
+    version: typeof RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION;
+    observation_id: string;
+    comparison_role: RiddleProofComparisonRole;
+    executor: RiddleProofObservationExecutor;
+    target: RiddleProofObservationTarget;
+    source: RiddleProofSourceIdentity;
+    captured_at: string;
+    artifacts: RiddleProofObservationArtifact[];
+    canonical_screenshot?: RiddleProofObservationArtifact;
+    profile_summary?: {
+        profile_name: string;
+        status: string;
+        summary: string;
+        route?: JsonValue;
+        checks: {
+            total: number;
+            passed: number;
+            failed: number;
+            skipped: number;
+            needs_human_review: number;
+        };
+    };
+    proof?: {
+        profile_name: string;
+        result: RiddleProofProfileResult;
+    };
+    publication?: RiddleProofObservationPublication;
+    execution?: RiddleProofExecutionTelemetry;
+    metadata?: Record<string, JsonValue>;
+}
+interface CreateRiddleProofObservationReceiptInput {
+    observation_id?: string;
+    comparison_role: RiddleProofComparisonRole;
+    executor: RiddleProofObservationExecutor;
+    target: RiddleProofObservationTarget;
+    source?: RiddleProofSourceIdentity;
+    profile_result?: RiddleProofProfileResult;
+    artifacts?: RiddleProofObservationArtifact[];
+    canonical_screenshot?: RiddleProofObservationArtifact;
+    publication?: RiddleProofObservationPublication;
+    execution?: RiddleProofExecutionTelemetry;
+    captured_at?: string;
+    metadata?: Record<string, JsonValue>;
+}
+declare function parseRiddlePreviewReceipt(value: unknown): RiddlePreviewReceipt;
+declare function createRiddleProofObservationReceipt(input: CreateRiddleProofObservationReceiptInput): RiddleProofObservationReceipt;
+declare function parseRiddleProofObservationReceipt(value: unknown): RiddleProofObservationReceipt;
+
+export { type CreateRiddleProofObservationReceiptInput, RIDDLE_PREVIEW_RECEIPT_VERSION, RIDDLE_PROOF_OBSERVATION_RECEIPT_VERSION, type RiddlePreviewReceipt, type RiddleProofComparisonRole, type RiddleProofExecutionPhase, type RiddleProofExecutionTelemetry, type RiddleProofObservationArtifact, type RiddleProofObservationArtifactRole, type RiddleProofObservationExecutor, type RiddleProofObservationExecutorKind, type RiddleProofObservationPublication, type RiddleProofObservationReceipt, type RiddleProofObservationTarget, type RiddleProofSourceIdentity, createRiddleProofObservationReceipt, parseRiddlePreviewReceipt, parseRiddleProofObservationReceipt };