@riddledc/riddle-proof 0.5.57 → 0.7.0

package/dist/index.cjs

@@ -2773,6 +2773,8 @@ var init_proof_run_engine = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BASIC_GAMEPLAY_ACTION_TYPES: () => BASIC_GAMEPLAY_ACTION_TYPES,
+  BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES: () => BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES,
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT: () => DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT: () => DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
   DEFAULT_DIAGNOSTIC_STRING_LIMIT: () => DEFAULT_DIAGNOSTIC_STRING_LIMIT,
@@ -2786,6 +2788,11 @@ __export(index_exports, {
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION: () => RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION: () => RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
   RIDDLE_PROOF_PLAYABILITY_VERSION: () => RIDDLE_PROOF_PLAYABILITY_VERSION,
+  RIDDLE_PROOF_PROFILE_CHECK_TYPES: () => RIDDLE_PROOF_PROFILE_CHECK_TYPES,
+  RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION: () => RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,
+  RIDDLE_PROOF_PROFILE_RESULT_VERSION: () => RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+  RIDDLE_PROOF_PROFILE_STATUSES: () => RIDDLE_PROOF_PROFILE_STATUSES,
+  RIDDLE_PROOF_PROFILE_VERSION: () => RIDDLE_PROOF_PROFILE_VERSION,
   RIDDLE_PROOF_RUN_CARD_VERSION: () => RIDDLE_PROOF_RUN_CARD_VERSION,
   RIDDLE_PROOF_RUN_STATE_VERSION: () => RIDDLE_PROOF_RUN_STATE_VERSION,
   RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION: () => RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION,
@@ -2797,18 +2804,27 @@ __export(index_exports, {
   applyPrLifecycleState: () => applyPrLifecycleState,
   applyTerminalMetadata: () => applyTerminalMetadata,
   assessBasicGameplayEvidence: () => assessBasicGameplayEvidence,
+  assessBasicGameplayProgressionCheck: () => assessBasicGameplayProgressionCheck,
+  assessBasicGameplayProgressionChecks: () => assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute: () => assessBasicGameplayRoute,
   assessPlayabilityEvidence: () => assessPlayabilityEvidence,
+  assessRiddleProofProfileEvidence: () => assessRiddleProofProfileEvidence,
+  attachBasicGameplayArtifactScreenshotHashes: () => attachBasicGameplayArtifactScreenshotHashes,
+  augmentBasicGameplayAssessmentWithProgressionChecks: () => augmentBasicGameplayAssessmentWithProgressionChecks,
   authorPacketPayloadFromCheckpointResponse: () => authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket: () => buildAuthorCheckpointPacket,
   buildCheckpointPacketForEngineResult: () => buildCheckpointPacketForEngineResult,
   buildProofAssessmentCheckpointPacket: () => buildProofAssessmentCheckpointPacket,
+  buildRiddleProofProfileScript: () => buildRiddleProofProfileScript,
   buildStageCheckpointPacket: () => buildStageCheckpointPacket,
   buildVisualProofSession: () => buildVisualProofSession,
   checkpointResponseIdentity: () => checkpointResponseIdentity,
   checkpointSummaryFromState: () => checkpointSummaryFromState,
+  collectRiddleProfileArtifactRefs: () => collectRiddleProfileArtifactRefs,
+  compactBasicGameplayText: () => compactBasicGameplayText,
   compactRecord: () => compactRecord,
   compareVisualProofSessionFingerprint: () => compareVisualProofSessionFingerprint,
+  createBasicGameplayCatchRecords: () => createBasicGameplayCatchRecords,
   createBasicGameplayCatchSummary: () => createBasicGameplayCatchSummary,
   createCaptureDiagnostic: () => createCaptureDiagnostic,
   createCheckpointResponseTemplate: () => createCheckpointResponseTemplate,
@@ -2818,6 +2834,9 @@ __export(index_exports, {
   createLocalAgentAdapter: () => createCodexExecAgentAdapter,
   createLocalAgentJsonRunner: () => createCodexExecJsonRunner,
   createRiddleApiClient: () => createRiddleApiClient,
+  createRiddleProofProfileConfigurationError: () => createRiddleProofProfileConfigurationError,
+  createRiddleProofProfileEnvironmentBlockedResult: () => createRiddleProofProfileEnvironmentBlockedResult,
+  createRiddleProofProfileInsufficientResult: () => createRiddleProofProfileInsufficientResult,
   createRiddleProofRunCard: () => createRiddleProofRunCard,
   createRunResult: () => createRunResult,
   createRunState: () => createRunState,
@@ -2825,6 +2844,7 @@ __export(index_exports, {
   deployRiddleStaticPreview: () => deployRiddleStaticPreview,
   extractBasicGameplayEvidence: () => extractBasicGameplayEvidence,
   extractPlayabilityEvidence: () => extractPlayabilityEvidence,
+  extractRiddleProofProfileResult: () => extractRiddleProofProfileResult,
   isDuplicateCheckpointResponse: () => isDuplicateCheckpointResponse,
   isRiddleProofPlayabilityMode: () => isRiddleProofPlayabilityMode,
   isSuccessfulStatus: () => isSuccessfulStatus,
@@ -2834,16 +2854,20 @@ __export(index_exports, {
   normalizeCheckpointResponse: () => normalizeCheckpointResponse,
   normalizeIntegrationContext: () => normalizeIntegrationContext,
   normalizePrLifecycleState: () => normalizePrLifecycleState,
+  normalizeRiddleProofProfile: () => normalizeRiddleProofProfile,
   normalizeRunParams: () => normalizeRunParams,
   normalizeTerminalMetadata: () => normalizeTerminalMetadata,
   parseRiddleViewport: () => parseRiddleViewport,
   parseVisualProofSession: () => parseVisualProofSession,
   pollRiddleJob: () => pollRiddleJob,
+  profileStatusExitCode: () => profileStatusExitCode,
   proofContractFromAuthorCheckpointResponse: () => proofContractFromAuthorCheckpointResponse,
   readRiddleProofRunStatus: () => readRiddleProofRunStatus,
   recordValue: () => recordValue,
   redactForProofDiagnostics: () => redactForProofDiagnostics,
+  resolveBasicGameplayProgressionCheckWithArtifactScreenshots: () => resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey: () => resolveRiddleApiKey,
+  resolveRiddleProofProfileTargetUrl: () => resolveRiddleProofProfileTargetUrl,
   riddleRequestJson: () => riddleRequestJson,
   runCodexExecAgentDoctor: () => runCodexExecAgentDoctor,
   runLocalAgentDoctor: () => runCodexExecAgentDoctor,
@@ -2851,9 +2875,12 @@ __export(index_exports, {
   runRiddleProofEngineHarness: () => runRiddleProofEngineHarness,
   runRiddleScript: () => runRiddleScript,
   runRiddleServerPreview: () => runRiddleServerPreview,
+  sanitizeBasicGameplayJsonString: () => sanitizeBasicGameplayJsonString,
   setRunStatus: () => setRunStatus,
+  slugifyRiddleProofProfileName: () => slugifyRiddleProofProfileName,
   statePathsForRunState: () => statePathsForRunState,
   summarizeCaptureArtifacts: () => summarizeCaptureArtifacts,
+  summarizeRiddleProofProfileResult: () => summarizeRiddleProofProfileResult,
   visualSessionFingerprint: () => visualSessionFingerprint,
   visualSessionFingerprintBasis: () => visualSessionFingerprintBasis
 });
@@ -7623,6 +7650,34 @@ function parseJson(value) {
 var RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION = "riddle-proof.basic-gameplay.v1";
 var RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION = "riddle-proof.basic-gameplay.assessment.v1";
 var RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION = "riddle-proof.basic-gameplay.catch.v1";
+var BASIC_GAMEPLAY_ACTION_TYPES = [
+  "wait",
+  "key",
+  "key-down",
+  "key-up",
+  "hold-key",
+  "repeat",
+  "click",
+  "click-by-text",
+  "wait-for-text",
+  "window-call",
+  "evaluate"
+];
+var BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES = [
+  "selector_count_increases",
+  "selector_count_at_least",
+  "selector_absent",
+  "selector_text_matches",
+  "number_increases",
+  "number_decreases",
+  "number_unchanged",
+  "number_stays_equal",
+  "number_equals",
+  "canvas_hash_changes",
+  "screenshot_hash_changes",
+  "visual_hash_changes",
+  "state_changes"
+];
 var BASIC_GAMEPLAY_CONTAINER_KEYS = [
   "basic_gameplay",
   "basicGameplay",
@@ -7631,6 +7686,19 @@ var BASIC_GAMEPLAY_CONTAINER_KEYS = [
   "gameplay_proof",
   "gameplayProof"
 ];
+var ARTIFACT_VISUAL_CHANGE_CHECKS = /* @__PURE__ */ new Set([
+  "canvas_hash_changes",
+  "screenshot_hash_changes",
+  "state_changes",
+  "visual_hash_changes"
+]);
+var PHASE_SCREENSHOT_SUFFIXES = {
+  initial: "before",
+  after_action: "after",
+  after_continue: "after-continue",
+  after_restart: "after-restart",
+  revisit: "revisit"
+};
 function assessBasicGameplayEvidence(evidence, options = {}) {
   const run = extractBasicGameplayEvidence(evidence);
   if (!run) {
@@ -7646,12 +7714,16 @@ function assessBasicGameplayEvidence(evidence, options = {}) {
       route_results: []
     };
   }
-  const routeResults = (run.results || []).map((route) => assessBasicGameplayRoute(route, options));
+  const routeResults = (run.results || []).map((route) => augmentRouteAssessmentWithProgressionChecks(
+    assessBasicGameplayRoute(route, options),
+    route
+  ));
   const failingRoutes = routeResults.filter((result) => !result.ok).map((result) => ({
     name: result.name,
     path: result.path,
     failures: result.failures,
-    warnings: result.warnings
+    warnings: result.warnings,
+    suite_failures: result.suite_failures
   }));
   return {
     version: RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
@@ -7732,6 +7804,255 @@ function assessBasicGameplayRoute(route, options = {}) {
     }
   };
 }
+function sanitizeBasicGameplayJsonString(value) {
+  const text = String(value ?? "");
+  let output = "";
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = text.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        output += text[index] + text[index + 1];
+        index += 1;
+      }
+      continue;
+    }
+    if (code >= 56320 && code <= 57343) continue;
+    output += text[index];
+  }
+  return output;
+}
+function compactBasicGameplayText(value, max = 160) {
+  const compacted = sanitizeBasicGameplayJsonString(value).replace(/\s+/g, " ").trim();
+  return Array.from(compacted).slice(0, max).join("");
+}
+function assessBasicGameplayProgressionCheck(check) {
+  const before = metricValue(check.before);
+  const after = metricValue(check.after);
+  const type = String(check.type || "");
+  const hasExplicitResult = typeof check.ok === "boolean";
+  let ok = hasExplicitResult ? check.ok === true : true;
+  let reason = check.reason ?? null;
+  if (type === "selector_count_increases") {
+    ok = numberValue2(after?.count) > numberValue2(before?.count);
+    reason = ok ? null : "selector_count_did_not_increase";
+  } else if (type === "selector_count_at_least") {
+    if (numericValue3(check.min) === null && hasExplicitResult) return resolveBasicGameplayProgressionCheckWithArtifactScreenshots({ ...check, ok, reason });
+    ok = numberValue2(after?.count) >= numberValue2(check.min);
+    reason = ok ? null : "selector_count_below_min";
+  } else if (type === "selector_absent") {
+    ok = !after?.present || numberValue2(after?.count) === 0;
+    reason = ok ? null : "selector_still_present";
+  } else if (type === "selector_text_matches") {
+    if (!check.pattern && hasExplicitResult) return resolveBasicGameplayProgressionCheckWithArtifactScreenshots({ ...check, ok, reason });
+    ok = textMatches(after?.text, check.pattern, check.flags);
+    reason = ok ? null : "selector_text_did_not_match";
+  } else if (type === "number_increases") {
+    ok = numericValue3(before?.number) !== null && numericValue3(after?.number) !== null && numberValue2(after?.number) > numberValue2(before?.number);
+    reason = ok ? null : "number_did_not_increase";
+  } else if (type === "number_decreases") {
+    ok = numericValue3(before?.number) !== null && numericValue3(after?.number) !== null && numberValue2(after?.number) < numberValue2(before?.number);
+    reason = ok ? null : "number_did_not_decrease";
+  } else if (type === "number_unchanged" || type === "number_stays_equal") {
+    ok = numericValue3(before?.number) !== null && numericValue3(after?.number) !== null && numberValue2(after?.number) === numberValue2(before?.number);
+    reason = ok ? null : "number_changed";
+  } else if (type === "number_equals") {
+    const expected = numericValue3(check.expected ?? check.value);
+    if (expected === null && hasExplicitResult) return resolveBasicGameplayProgressionCheckWithArtifactScreenshots({ ...check, ok, reason });
+    ok = numericValue3(after?.number) !== null && expected !== null && numberValue2(after?.number) === expected;
+    reason = ok ? null : "number_did_not_equal_expected";
+  } else if (type === "canvas_hash_changes") {
+    ok = hashChanged(before, after, ["first_canvas_hash", "first_canvas_visual_sample_hash", "visual_sample_hash"]);
+    reason = ok ? null : "canvas_or_visual_sample_hash_did_not_change";
+  } else if (type === "screenshot_hash_changes") {
+    ok = hashChanged(before, after, ["screenshot_hash", "visual_sample_hash", "artifact_screenshot_hash"]);
+    reason = ok ? null : "screenshot_hash_did_not_change";
+  } else if (type === "visual_hash_changes") {
+    ok = hashChanged(before, after, ["visual_sample_hash", "screenshot_hash", "artifact_screenshot_hash"]);
+    reason = ok ? null : "visual_hash_did_not_change";
+  } else if (type === "state_changes") {
+    ok = hashChanged(before, after, [
+      "dom_signature_hash",
+      "body_text_hash",
+      "screenshot_hash",
+      "visual_sample_hash",
+      "artifact_screenshot_hash",
+      "first_canvas_hash",
+      "first_canvas_visual_sample_hash"
+    ]);
+    reason = ok ? null : "state_hash_did_not_change";
+  }
+  const assessed = {
+    ...check,
+    ok,
+    reason
+  };
+  return resolveBasicGameplayProgressionCheckWithArtifactScreenshots(assessed);
+}
+function assessBasicGameplayProgressionChecks(route) {
+  return progressionChecksForRoute(route).map((check) => assessBasicGameplayProgressionCheck(check));
+}
+function augmentBasicGameplayAssessmentWithProgressionChecks(assessment, evidence) {
+  const run = extractBasicGameplayEvidence(evidence);
+  if (!run?.results?.length) return assessment;
+  const routeResults = assessment.route_results.map(
+    (result, index) => augmentRouteAssessmentWithProgressionChecks(result, run.results?.[index] || {})
+  );
+  const failingRoutes = routeResults.filter((result) => !result.ok).map((result) => ({
+    name: result.name,
+    path: result.path,
+    failures: result.failures,
+    warnings: result.warnings,
+    suite_failures: result.suite_failures
+  }));
+  return {
+    ...assessment,
+    passed: failingRoutes.length === 0,
+    passing_routes: routeResults.filter((result) => result.ok).length,
+    failing_routes: failingRoutes,
+    failure_counts: countCodes(routeResults.flatMap((result) => result.failures)),
+    warning_counts: countCodes(routeResults.flatMap((result) => result.warnings)),
+    route_results: routeResults
+  };
+}
+function resolveBasicGameplayProgressionCheckWithArtifactScreenshots(check) {
+  if (check.ok !== false) return check;
+  if (!ARTIFACT_VISUAL_CHANGE_CHECKS.has(String(check.type || ""))) return check;
+  const beforeHash = stringValue4(metricValue(check.before)?.artifact_screenshot_hash);
+  const afterHash = stringValue4(metricValue(check.after)?.artifact_screenshot_hash);
+  if (!beforeHash || !afterHash || beforeHash === afterHash) return check;
+  return {
+    ...check,
+    ok: true,
+    reason: null,
+    artifact_resolution: {
+      source: "riddle_screenshot_artifacts",
+      before_hash: beforeHash,
+      after_hash: afterHash
+    }
+  };
+}
+function attachBasicGameplayArtifactScreenshotHashes(evidence, routesOrOptions = {}, maybeArtifacts = []) {
+  const routes = Array.isArray(routesOrOptions) ? routesOrOptions : routesOrOptions.routes || [];
+  const artifacts = Array.isArray(routesOrOptions) ? maybeArtifacts : routesOrOptions.artifacts || [];
+  if (!evidence?.results?.length || !artifacts.length) return evidence;
+  const artifactsByName = screenshotArtifactIndex(artifacts);
+  if (!artifactsByName.size) return evidence;
+  for (const [index, routeEvidence] of evidence.results.entries()) {
+    const routeContract = routes[index] || {};
+    for (const phase of Object.keys(PHASE_SCREENSHOT_SUFFIXES)) {
+      attachPhaseArtifactHash(routeEvidence, routeContract, phase, artifactsByName);
+    }
+    const checks = progressionChecksForRoute(routeEvidence);
+    const resolvedChecks = checks.map((check) => {
+      const fromPhase = check.from_phase || "initial";
+      const toPhase = check.to_phase || "after_action";
+      if (check.before) attachPhaseArtifactHash({ ...routeEvidence, [fromPhase]: check.before }, routeContract, fromPhase, artifactsByName);
+      if (check.after) attachPhaseArtifactHash({ ...routeEvidence, [toPhase]: check.after }, routeContract, toPhase, artifactsByName);
+      return resolveBasicGameplayProgressionCheckWithArtifactScreenshots(check);
+    });
+    if (routeEvidence.progression_checks) routeEvidence.progression_checks = resolvedChecks;
+    else if (routeEvidence.progressionChecks) routeEvidence.progressionChecks = resolvedChecks;
+    routeEvidence.progression_failure_count = resolvedChecks.filter((check) => check.ok === false).length;
+  }
+  return evidence;
+}
+function createBasicGameplayCatchRecords(assessment, evidence) {
+  const run = extractBasicGameplayEvidence(evidence);
+  if (!run?.results?.length) return [];
+  const catches = [];
+  for (const route of run.results) {
+    if (numberValue2(route.page_error_count) > 0) {
+      catches.push({
+        site: run.site || null,
+        route: route.name,
+        path: route.path,
+        code: "fatal_page_error",
+        label: "page runtime error",
+        type: "page_error",
+        selector: null,
+        reason: stringValue4(route.first_page_error) || "page_error",
+        page_errors: listValue2(route.page_errors),
+        summary: `${route.name || route.path || "Route"}: page runtime error (${stringValue4(route.first_page_error) || "page_error"})`
+      });
+    }
+    if (numberValue2(route.console_error_count) > 0) {
+      catches.push({
+        site: run.site || null,
+        route: route.name,
+        path: route.path,
+        code: "critical_console_error",
+        label: "console error",
+        type: "console_error",
+        selector: null,
+        reason: stringValue4(route.first_console_error) || "console_error",
+        console_errors: listValue2(route.console_errors),
+        summary: `${route.name || route.path || "Route"}: console error (${stringValue4(route.first_console_error) || "console_error"})`
+      });
+    }
+    for (const [group, phase] of [
+      ["action_results", "after_action"],
+      ["continued_action_results", "after_continue"],
+      ["restart_action_results", "after_restart"]
+    ]) {
+      for (const actionResult of listValue2(route[group])) {
+        if (!actionResult || actionResult.ok !== false) continue;
+        const action = stringValue4(actionResult.action) || group;
+        const reason = stringValue4(actionResult.reason) || "action_failed";
+        catches.push({
+          site: run.site || null,
+          route: route.name,
+          path: route.path,
+          code: "action_failed",
+          label: action,
+          type: action,
+          selector: stringValue4(actionResult.selector),
+          reason,
+          phase,
+          action_result: actionResult,
+          summary: `${route.name || route.path || "Route"}: ${action} failed (${reason})`
+        });
+      }
+    }
+    for (const check of assessBasicGameplayProgressionChecks(route).filter((item) => item.ok === false)) {
+      catches.push({
+        site: run.site || null,
+        route: route.name,
+        path: route.path,
+        code: "progression_assertion_failed",
+        label: check.label,
+        type: String(check.type || ""),
+        selector: check.selector || null,
+        state_path: check.state_path || null,
+        state_call: check.state_call || null,
+        property_path: check.property_path || null,
+        reason: check.reason || "progression_assertion_failed",
+        from_phase: check.from_phase,
+        to_phase: check.to_phase,
+        before: compactCatchMetric(check.before),
+        after: compactCatchMetric(check.after),
+        summary: `${route.name || route.path || "Route"}: ${check.label || check.type || "progression check"} failed (${check.reason || "progression_assertion_failed"})`
+      });
+    }
+  }
+  if (!catches.length && assessment.failing_routes.length) {
+    for (const route of assessment.failing_routes) {
+      for (const code of route.failures || []) {
+        catches.push({
+          site: run.site || null,
+          route: route.name,
+          path: route.path,
+          code,
+          label: code,
+          type: code,
+          reason: code,
+          summary: `${route.name || route.path || "Route"}: ${code}`
+        });
+      }
+    }
+  }
+  return catches;
+}
 function createBasicGameplayCatchSummary(input, options = {}) {
   const before = summarizeAssessment(assessBasicGameplayEvidence(input.before, options));
   const after = input.after === void 0 ? void 0 : summarizeAssessment(assessBasicGameplayEvidence(input.after, options));
@@ -7847,6 +8168,122 @@ function changed(before, after) {
 function canvasHashes(canvases) {
   return (canvases || []).map((canvas) => canvas.hash).filter(Boolean).join("|");
 }
+function augmentRouteAssessmentWithProgressionChecks(result, route) {
+  const progressionFailures = assessBasicGameplayProgressionChecks(route).filter((check) => check.ok === false);
+  if (!progressionFailures.length) return result;
+  const failures = result.failures.includes("progression_assertion_failed") ? result.failures : [...result.failures, "progression_assertion_failed"];
+  return {
+    ...result,
+    ok: false,
+    failures,
+    suite_failures: [
+      ...result.suite_failures || [],
+      ...progressionFailures.map((check) => ({
+        code: "progression_assertion_failed",
+        label: check.label,
+        reason: check.reason,
+        selector: check.selector || null,
+        state_path: check.state_path || null,
+        state_call: check.state_call || null,
+        property_path: check.property_path || null
+      }))
+    ]
+  };
+}
+function progressionChecksForRoute(route) {
+  return listValue2(route.progression_checks || route.progressionChecks).filter((item) => Boolean(recordValue3(item)));
+}
+function metricValue(value) {
+  return recordValue3(value);
+}
+function textMatches(text, pattern, flags) {
+  if (!pattern) return Boolean(text);
+  try {
+    return new RegExp(String(pattern), typeof flags === "string" ? flags : "i").test(String(text ?? ""));
+  } catch {
+    return false;
+  }
+}
+function hashChanged(before, after, keys) {
+  if (!before || !after) return false;
+  return keys.some((key) => {
+    const beforeValue = stringValue4(before[key]);
+    const afterValue = stringValue4(after[key]);
+    return Boolean(beforeValue && afterValue && beforeValue !== afterValue);
+  });
+}
+function screenshotArtifactIndex(artifacts) {
+  const index = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts || []) {
+    const hash = stringValue4(artifact.sha256 || artifact.hash);
+    if (!hash) continue;
+    if (String(artifact.kind || "").toLowerCase() !== "screenshot" && !/\.png($|\?)/i.test(`${artifact.name || ""} ${artifact.path || ""} ${artifact.url || ""}`)) continue;
+    const filename = artifactBasename(artifact.path || artifact.name || artifact.url);
+    if (!filename) continue;
+    index.set(filename.toLowerCase(), {
+      ...artifact,
+      sha256: hash
+    });
+  }
+  return index;
+}
+function attachPhaseArtifactHash(routeEvidence, routeContract, phase, artifactsByName) {
+  const suffix = PHASE_SCREENSHOT_SUFFIXES[phase];
+  if (!suffix) return null;
+  const metric = metricValue(routeEvidence[phase]);
+  if (!metric) return null;
+  const filename = `${routeArtifactSlug(routeEvidence, routeContract)}-${suffix}.png`.toLowerCase();
+  const artifact = artifactsByName.get(filename);
+  if (!artifact?.sha256) return null;
+  metric.artifact_screenshot_hash = artifact.sha256;
+  metric.artifact_screenshot = {
+    name: artifact.name || artifactBasename(artifact.path || filename),
+    path: artifact.path,
+    url: artifact.url,
+    kind: artifact.kind,
+    sha256: artifact.sha256
+  };
+  return artifact.sha256;
+}
+function routeArtifactSlug(routeEvidence, routeContract) {
+  return slug(routeContract.name || routeEvidence.name || routeContract.path || routeEvidence.path || "route");
+}
+function artifactBasename(value) {
+  const raw = stringValue4(value);
+  if (!raw) return "";
+  try {
+    const url = new URL(raw);
+    return url.pathname.split("/").filter(Boolean).pop() || "";
+  } catch {
+    return raw.split(/[\\/]/).filter(Boolean).pop() || raw;
+  }
+}
+function compactCatchMetric(metric) {
+  const value = metricValue(metric);
+  if (!value) return null;
+  return {
+    phase: value.phase,
+    text: value.text,
+    number: value.number,
+    count: value.count,
+    present: value.present,
+    state_path: value.state_path,
+    state_call: value.state_call,
+    property_path: value.property_path,
+    screenshot_hash: value.screenshot_hash,
+    visual_sample_hash: value.visual_sample_hash,
+    viewport_screenshot_hash: value.viewport_screenshot_hash,
+    artifact_screenshot_hash: value.artifact_screenshot_hash,
+    dom_signature_hash: value.dom_signature_hash,
+    body_text_hash: value.body_text_hash,
+    first_canvas_hash: value.first_canvas_hash,
+    first_canvas_visual_sample_hash: value.first_canvas_visual_sample_hash,
+    visible_canvas_count: value.visible_canvas_count
+  };
+}
+function slug(value) {
+  return String(value || "artifact").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96) || "artifact";
+}
 function countCodes(codes) {
   const counts = {};
   for (const code of codes) counts[code] = (counts[code] || 0) + 1;
@@ -7870,6 +8307,9 @@ function numericValue3(value) {
   }
   return null;
 }
+function stringValue4(value) {
+  return typeof value === "string" && value.length ? value : null;
+}
 function recordValue3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -7886,6 +8326,795 @@ function parseJson2(value) {
   }
 }
 
+// src/profile.ts
+var RIDDLE_PROOF_PROFILE_VERSION = "riddle-proof.profile.v1";
+var RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION = "riddle-proof.profile-evidence.v1";
+var RIDDLE_PROOF_PROFILE_RESULT_VERSION = "riddle-proof.profile-result.v1";
+var RIDDLE_PROOF_PROFILE_STATUSES = [
+  "passed",
+  "product_regression",
+  "proof_insufficient",
+  "environment_blocked",
+  "configuration_error",
+  "needs_human_review"
+];
+var RIDDLE_PROOF_PROFILE_CHECK_TYPES = [
+  "route_loaded",
+  "selector_visible",
+  "selector_count_at_least",
+  "text_visible",
+  "text_absent",
+  "no_horizontal_overflow",
+  "no_mobile_horizontal_overflow",
+  "no_fatal_console_errors"
+];
+var DEFAULT_VIEWPORTS = [
+  { name: "desktop", width: 1280, height: 800 }
+];
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue5(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberValue3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function jsonRecord(value) {
+  if (!isRecord2(value)) return void 0;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJsonValue(child)]));
+}
+function toJsonValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (Array.isArray(value)) return value.map(toJsonValue);
+  if (isRecord2(value)) return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJsonValue(child)]));
+  return String(value);
+}
+function normalizeName(value, fallback) {
+  const name = stringValue5(value) || fallback;
+  return name.replace(/\s+/g, " ").trim();
+}
+function slugifyRiddleProofProfileName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "profile";
+}
+function normalizeViewport(input, index) {
+  if (!isRecord2(input)) throw new Error(`target.viewports[${index}] must be an object.`);
+  const width = numberValue3(input.width);
+  const height = numberValue3(input.height);
+  if (!width || !height || width < 100 || height < 100) {
+    throw new Error(`target.viewports[${index}] requires numeric width and height >= 100.`);
+  }
+  return {
+    name: normalizeName(input.name || input.label, `viewport-${index + 1}`),
+    width: Math.round(width),
+    height: Math.round(height)
+  };
+}
+function normalizeViewports(value) {
+  if (value === void 0) return [...DEFAULT_VIEWPORTS];
+  if (!Array.isArray(value) || value.length === 0) throw new Error("target.viewports must be a non-empty array.");
+  return value.map(normalizeViewport);
+}
+function isSupportedCheckType(value) {
+  return RIDDLE_PROOF_PROFILE_CHECK_TYPES.includes(value);
+}
+function normalizeCheck(input, index) {
+  if (!isRecord2(input)) throw new Error(`checks[${index}] must be an object.`);
+  const type = stringValue5(input.type);
+  if (!type) throw new Error(`checks[${index}].type is required.`);
+  if (!isSupportedCheckType(type)) {
+    throw new Error(`checks[${index}].type ${type} is not supported. Supported checks: ${RIDDLE_PROOF_PROFILE_CHECK_TYPES.join(", ")}`);
+  }
+  if ((type === "selector_visible" || type === "selector_count_at_least") && !stringValue5(input.selector)) {
+    throw new Error(`checks[${index}] ${type} requires selector.`);
+  }
+  if ((type === "text_visible" || type === "text_absent") && !stringValue5(input.text) && !stringValue5(input.pattern)) {
+    throw new Error(`checks[${index}] ${type} requires text or pattern.`);
+  }
+  if (type === "selector_count_at_least" && numberValue3(input.min_count) === void 0) {
+    throw new Error(`checks[${index}] selector_count_at_least requires min_count.`);
+  }
+  return {
+    type,
+    label: stringValue5(input.label),
+    expected_path: stringValue5(input.expected_path),
+    selector: stringValue5(input.selector),
+    text: stringValue5(input.text),
+    pattern: stringValue5(input.pattern),
+    flags: stringValue5(input.flags),
+    min_count: numberValue3(input.min_count),
+    max_overflow_px: numberValue3(input.max_overflow_px)
+  };
+}
+function normalizeFailurePolicy(input) {
+  const defaults = {
+    product_regression: "fail",
+    proof_insufficient: "fail",
+    environment_blocked: "neutral",
+    configuration_error: "fail",
+    needs_human_review: "fail"
+  };
+  if (!isRecord2(input)) return defaults;
+  const next = { ...defaults };
+  for (const [key, value] of Object.entries(input)) {
+    if (!RIDDLE_PROOF_PROFILE_STATUSES.includes(key)) continue;
+    if (value === "fail" || value === "neutral" || value === "review") {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+function normalizeRiddleProofProfile(input, options = {}) {
+  if (!isRecord2(input)) throw new Error("profile must be a JSON object.");
+  const version = stringValue5(input.version) || RIDDLE_PROOF_PROFILE_VERSION;
+  if (version !== RIDDLE_PROOF_PROFILE_VERSION) {
+    throw new Error(`Unsupported profile version ${version}. Expected ${RIDDLE_PROOF_PROFILE_VERSION}.`);
+  }
+  const targetInput = isRecord2(input.target) ? input.target : {};
+  const checks = Array.isArray(input.checks) ? input.checks.map(normalizeCheck) : [];
+  if (!checks.length) throw new Error("profile.checks must contain at least one check.");
+  const targetUrl = stringValue5(options.url) || stringValue5(targetInput.url);
+  const route = stringValue5(options.route) || stringValue5(targetInput.route);
+  if (!targetUrl && !route) throw new Error("profile.target requires url or route, or pass --url.");
+  return {
+    version: RIDDLE_PROOF_PROFILE_VERSION,
+    name: normalizeName(input.name, "riddle-proof-profile"),
+    target: {
+      url: targetUrl,
+      route,
+      viewports: options.viewports?.length ? options.viewports : normalizeViewports(targetInput.viewports),
+      auth: stringValue5(targetInput.auth) || "none",
+      wait_for_selector: stringValue5(targetInput.wait_for_selector) || stringValue5(targetInput.waitForSelector),
+      wait_ms: numberValue3(targetInput.wait_ms) ?? numberValue3(targetInput.waitMs)
+    },
+    checks,
+    artifacts: Array.isArray(input.artifacts) ? input.artifacts.map((item) => String(item)).filter(Boolean) : ["screenshot", "console", "dom_summary", "proof_json"],
+    baseline_policy: stringValue5(input.baseline_policy) || stringValue5(input.baselinePolicy) || "invariant_only",
+    failure_policy: normalizeFailurePolicy(input.failure_policy || input.failurePolicy),
+    metadata: jsonRecord(input.metadata)
+  };
+}
+function resolveRiddleProofProfileTargetUrl(profile) {
+  const route = profile.target.route || "";
+  const targetUrl = profile.target.url || "";
+  if (/^https?:\/\//i.test(route)) return route;
+  if (targetUrl && route) return new URL(route, targetUrl).href;
+  if (targetUrl) return targetUrl;
+  throw new Error("profile target URL could not be resolved.");
+}
+function routeForViewport(viewport) {
+  return viewport?.route || {
+    requested: "",
+    observed: "",
+    matched: false,
+    error: "missing viewport evidence"
+  };
+}
+function checkLabel(check) {
+  return check.label || check.type;
+}
+function selectorKey(check) {
+  return check.selector || "";
+}
+function textKey(check) {
+  return check.pattern ? `pattern:${check.pattern}/${check.flags || ""}` : `text:${check.text || ""}`;
+}
+function matchText(sample, check) {
+  if (check.pattern) {
+    try {
+      return new RegExp(check.pattern, check.flags || "").test(sample);
+    } catch {
+      return false;
+    }
+  }
+  return sample.includes(check.text || "");
+}
+function successfulRoute(route) {
+  return route.matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
+}
+function assessCheckFromEvidence(check, evidence) {
+  const viewports = evidence.viewports || [];
+  if (!viewports.length) {
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: "failed",
+      evidence: {},
+      message: "No viewport evidence was captured."
+    };
+  }
+  if (check.type === "route_loaded") {
+    const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
+    const failed = viewports.filter((viewport) => !successfulRoute({
+      ...viewport.route,
+      expected_path: expectedPath,
+      matched: viewport.route.observed === expectedPath || viewport.route.matched
+    }));
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        expected_path: expectedPath,
+        observed_paths: viewports.map((viewport) => viewport.route.observed),
+        http_statuses: viewports.map((viewport) => viewport.route.http_status ?? null)
+      },
+      message: failed.length ? `Route did not load as ${expectedPath} in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "selector_visible") {
+    const key = selectorKey(check);
+    const failed = viewports.filter((viewport) => (viewport.selectors?.[key]?.visible_count || 0) < 1);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        selector: key,
+        visible_counts: viewports.map((viewport) => viewport.selectors?.[key]?.visible_count || 0)
+      },
+      message: failed.length ? `Selector ${key} was not visible in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "selector_count_at_least") {
+    const key = selectorKey(check);
+    const minCount = check.min_count ?? 1;
+    const failed = viewports.filter((viewport) => (viewport.selectors?.[key]?.count || 0) < minCount);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        selector: key,
+        min_count: minCount,
+        counts: viewports.map((viewport) => viewport.selectors?.[key]?.count || 0)
+      },
+      message: failed.length ? `Selector ${key} count was below ${minCount} in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "text_visible" || check.type === "text_absent") {
+    const key = textKey(check);
+    const expectedVisible = check.type === "text_visible";
+    const matches = viewports.map((viewport) => {
+      const fromEvidence = viewport.text_matches?.[key];
+      return typeof fromEvidence === "boolean" ? fromEvidence : matchText(viewport.body_text_sample || "", check);
+    });
+    const failed = matches.filter((matched) => matched !== expectedVisible).length;
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed ? "failed" : "passed",
+      evidence: {
+        text: check.text || null,
+        pattern: check.pattern || null,
+        matches
+      },
+      message: failed ? `Text assertion failed in ${failed} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "no_horizontal_overflow" || check.type === "no_mobile_horizontal_overflow") {
+    const maxOverflow = check.max_overflow_px ?? 4;
+    const applicable = check.type === "no_mobile_horizontal_overflow" ? viewports.filter((viewport) => viewport.width <= 820) : viewports;
+    if (!applicable.length) {
+      return {
+        type: check.type,
+        label: checkLabel(check),
+        status: "failed",
+        evidence: { max_overflow_px: maxOverflow },
+        message: "No applicable viewport evidence was captured for overflow check."
+      };
+    }
+    const failed = applicable.filter((viewport) => (viewport.overflow_px ?? 0) > maxOverflow);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        max_overflow_px: maxOverflow,
+        overflow_px: applicable.map((viewport) => viewport.overflow_px ?? null),
+        viewports: applicable.map((viewport) => viewport.name)
+      },
+      message: failed.length ? `Horizontal overflow exceeded ${maxOverflow}px in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "no_fatal_console_errors") {
+    const fatalCount = (evidence.console?.fatal_count || 0) + (evidence.page_errors?.length || 0);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: fatalCount ? "failed" : "passed",
+      evidence: {
+        console_fatal_count: evidence.console?.fatal_count || 0,
+        page_error_count: evidence.page_errors?.length || 0
+      },
+      message: fatalCount ? `${fatalCount} fatal browser error(s) were captured.` : void 0
+    };
+  }
+  return {
+    type: check.type,
+    label: checkLabel(check),
+    status: "needs_human_review",
+    evidence: {},
+    message: "Unsupported check type."
+  };
+}
+function profileStatusFromEvidence(evidence, checks) {
+  if (!evidence) return "proof_insufficient";
+  const viewports = evidence.viewports || [];
+  if (!viewports.length || !checks.length) return "proof_insufficient";
+  if (viewports.some((viewport) => viewport.navigation_error)) return "environment_blocked";
+  if (checks.some((check) => check.status === "needs_human_review")) return "needs_human_review";
+  if (checks.some((check) => check.status === "failed")) return "product_regression";
+  return "passed";
+}
+function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
+  const capturedAt = evidence?.captured_at || (/* @__PURE__ */ new Date()).toISOString();
+  const checks = evidence ? profile.checks.map((check) => assessCheckFromEvidence(check, evidence)) : [];
+  const status = profileStatusFromEvidence(evidence, checks);
+  const firstViewport = evidence?.viewports?.[0];
+  const screenshots = (evidence?.viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => Boolean(label));
+  return {
+    version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+    profile_name: profile.name,
+    runner: options.runner || "riddle",
+    status,
+    baseline_policy: profile.baseline_policy,
+    route: routeForViewport(firstViewport),
+    artifacts: {
+      screenshots,
+      console: "console.json",
+      proof_json: "proof.json",
+      dom_summary: "dom-summary.json",
+      riddle_artifacts: options.artifacts
+    },
+    checks,
+    summary: summarizeRiddleProofProfileResult({ profile_name: profile.name, status, checks, viewports: evidence?.viewports || [] }),
+    captured_at: capturedAt,
+    evidence,
+    riddle: options.riddle
+  };
+}
+function summarizeRiddleProofProfileResult(input) {
+  const passedChecks = input.checks.filter((check) => check.status === "passed").length;
+  const failedChecks = input.checks.filter((check) => check.status === "failed").length;
+  const viewportNames = input.viewports.map((viewport) => viewport.name).join(", ");
+  if (input.status === "passed") {
+    return `${input.profile_name} passed ${passedChecks} check(s) across ${input.viewports.length} viewport(s)${viewportNames ? ` (${viewportNames})` : ""}.`;
+  }
+  if (input.status === "product_regression") {
+    return `${input.profile_name} failed ${failedChecks} product invariant(s) across ${input.viewports.length} viewport(s).`;
+  }
+  if (input.status === "environment_blocked") {
+    return `${input.profile_name} could not collect reliable evidence because navigation or the browser environment was blocked.`;
+  }
+  if (input.status === "proof_insufficient") {
+    return `${input.profile_name} did not produce enough evidence for a profile judgment.`;
+  }
+  if (input.status === "configuration_error") {
+    return `${input.profile_name} has a profile configuration error.`;
+  }
+  return `${input.profile_name} collected artifacts but needs human review.`;
+}
+function profileStatusExitCode(profile, status) {
+  if (status === "passed") return 0;
+  return profile.failure_policy[status] === "neutral" ? 0 : 1;
+}
+function createRiddleProofProfileConfigurationError(name, error, runner = "riddle") {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+    profile_name: name,
+    runner,
+    status: "configuration_error",
+    baseline_policy: "invariant_only",
+    route: { requested: "", observed: "", matched: false, error: message },
+    artifacts: { screenshots: [], proof_json: "proof.json" },
+    checks: [],
+    summary: `${name} has a profile configuration error.`,
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    error: message
+  };
+}
+function createRiddleProofProfileEnvironmentBlockedResult(input) {
+  const message = input.error instanceof Error ? input.error.message : input.error ? String(input.error) : "Riddle runner did not complete successfully.";
+  return {
+    version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+    profile_name: input.profile.name,
+    runner: input.runner || "riddle",
+    status: "environment_blocked",
+    baseline_policy: input.profile.baseline_policy,
+    route: { requested: resolveRiddleProofProfileTargetUrl(input.profile), observed: "", matched: false, error: message },
+    artifacts: { screenshots: [], proof_json: "proof.json", riddle_artifacts: input.artifacts },
+    checks: [],
+    summary: `${input.profile.name} could not collect reliable evidence because the runner was blocked.`,
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    riddle: input.riddle,
+    error: message
+  };
+}
+function createRiddleProofProfileInsufficientResult(input) {
+  const message = input.error instanceof Error ? input.error.message : input.error ? String(input.error) : "No proof.json profile result artifact was found.";
+  return {
+    version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+    profile_name: input.profile.name,
+    runner: input.runner || "riddle",
+    status: "proof_insufficient",
+    baseline_policy: input.profile.baseline_policy,
+    route: { requested: resolveRiddleProofProfileTargetUrl(input.profile), observed: "", matched: false, error: message },
+    artifacts: { screenshots: [], proof_json: "proof.json", riddle_artifacts: input.artifacts },
+    checks: [],
+    summary: `${input.profile.name} did not produce enough evidence for a profile judgment.`,
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    riddle: input.riddle,
+    error: message
+  };
+}
+function runtimeScriptAssessmentSource() {
+  return String.raw`
+function routeOk(route) {
+  return Boolean(route && route.matched && !route.error && (route.http_status == null || route.http_status < 400));
+}
+function textMatches(sample, check) {
+  if (check.pattern) {
+    try { return new RegExp(check.pattern, check.flags || "").test(sample || ""); } catch { return false; }
+  }
+  return String(sample || "").includes(check.text || "");
+}
+function assessProfile(profile, evidence) {
+  const checks = [];
+  const viewports = evidence.viewports || [];
+  for (const check of profile.checks || []) {
+    if (check.type === "route_loaded") {
+      const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
+      const failed = viewports.filter((viewport) => {
+        const route = { ...(viewport.route || {}), expected_path: expectedPath };
+        route.matched = route.observed === expectedPath || route.matched;
+        return !routeOk(route);
+      });
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: {
+          expected_path: expectedPath,
+          observed_paths: viewports.map((viewport) => viewport.route && viewport.route.observed),
+          http_statuses: viewports.map((viewport) => viewport.route ? viewport.route.http_status ?? null : null),
+        },
+        message: failed.length ? "Route did not load as " + expectedPath + " in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "selector_visible") {
+      const selector = check.selector || "";
+      const failed = viewports.filter((viewport) => !viewport.selectors || !viewport.selectors[selector] || viewport.selectors[selector].visible_count < 1);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: { selector, visible_counts: viewports.map((viewport) => viewport.selectors && viewport.selectors[selector] ? viewport.selectors[selector].visible_count : 0) },
+        message: failed.length ? "Selector " + selector + " was not visible in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "selector_count_at_least") {
+      const selector = check.selector || "";
+      const minCount = check.min_count == null ? 1 : check.min_count;
+      const failed = viewports.filter((viewport) => !viewport.selectors || !viewport.selectors[selector] || viewport.selectors[selector].count < minCount);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: { selector, min_count: minCount, counts: viewports.map((viewport) => viewport.selectors && viewport.selectors[selector] ? viewport.selectors[selector].count : 0) },
+        message: failed.length ? "Selector " + selector + " count was below " + minCount + " in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "text_visible" || check.type === "text_absent") {
+      const key = check.pattern ? "pattern:" + check.pattern + "/" + (check.flags || "") : "text:" + (check.text || "");
+      const expectedVisible = check.type === "text_visible";
+      const matches = viewports.map((viewport) => viewport.text_matches && typeof viewport.text_matches[key] === "boolean" ? viewport.text_matches[key] : textMatches(viewport.body_text_sample || "", check));
+      const failed = matches.filter((matched) => matched !== expectedVisible).length;
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed ? "failed" : "passed",
+        evidence: { text: check.text, pattern: check.pattern, matches },
+        message: failed ? "Text assertion failed in " + failed + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "no_horizontal_overflow" || check.type === "no_mobile_horizontal_overflow") {
+      const maxOverflow = check.max_overflow_px == null ? 4 : check.max_overflow_px;
+      const applicable = check.type === "no_mobile_horizontal_overflow" ? viewports.filter((viewport) => viewport.width <= 820) : viewports;
+      if (!applicable.length) {
+        checks.push({
+          type: check.type,
+          label: check.label || check.type,
+          status: "failed",
+          evidence: { max_overflow_px: maxOverflow },
+          message: "No applicable viewport evidence was captured for overflow check.",
+        });
+        continue;
+      }
+      const failed = applicable.filter((viewport) => (viewport.overflow_px || 0) > maxOverflow);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: { max_overflow_px: maxOverflow, overflow_px: applicable.map((viewport) => viewport.overflow_px ?? null), viewports: applicable.map((viewport) => viewport.name) },
+        message: failed.length ? "Horizontal overflow exceeded " + maxOverflow + "px in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "no_fatal_console_errors") {
+      const fatalCount = ((evidence.console && evidence.console.fatal_count) || 0) + ((evidence.page_errors || []).length);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: fatalCount ? "failed" : "passed",
+        evidence: { console_fatal_count: (evidence.console && evidence.console.fatal_count) || 0, page_error_count: (evidence.page_errors || []).length },
+        message: fatalCount ? String(fatalCount) + " fatal browser error(s) were captured." : undefined,
+      });
+      continue;
+    }
+    checks.push({ type: check.type, label: check.label || check.type, status: "needs_human_review", evidence: {}, message: "Unsupported check type." });
+  }
+  let status = "passed";
+  if (!viewports.length || !checks.length) status = "proof_insufficient";
+  else if (viewports.some((viewport) => viewport.navigation_error)) status = "environment_blocked";
+  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 = viewports.map((viewport) => viewport.screenshot_label).filter(Boolean);
+  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;
+  const viewportNames = viewports.map((viewport) => viewport.name).join(", ");
+  let summary = profile.name + " collected artifacts but needs human review.";
+  if (status === "passed") summary = profile.name + " passed " + passedChecks + " check(s) across " + viewports.length + " viewport(s)" + (viewportNames ? " (" + viewportNames + ")." : ".");
+  if (status === "product_regression") summary = profile.name + " failed " + failedChecks + " product invariant(s) across " + viewports.length + " viewport(s).";
+  if (status === "environment_blocked") summary = profile.name + " could not collect reliable evidence because navigation or the browser environment was blocked.";
+  if (status === "proof_insufficient") summary = profile.name + " did not produce enough evidence for a profile judgment.";
+  return {
+    version: "riddle-proof.profile-result.v1",
+    profile_name: profile.name,
+    runner: "riddle",
+    status,
+    baseline_policy: profile.baseline_policy || "invariant_only",
+    route,
+    artifacts: { screenshots: screenshotLabels, console: "console.json", proof_json: "proof.json", dom_summary: "dom-summary.json" },
+    checks,
+    summary,
+    captured_at: evidence.captured_at,
+    evidence,
+  };
+}
+`;
+}
+function buildRiddleProofProfileScript(profile) {
+  const targetUrl = resolveRiddleProofProfileTargetUrl(profile);
+  const slug2 = slugifyRiddleProofProfileName(profile.name);
+  const serializableProfile = JSON.stringify(profile);
+  const serializableTargetUrl = JSON.stringify(targetUrl);
+  const serializableSlug = JSON.stringify(slug2);
+  return String.raw`
+const profile = ${serializableProfile};
+const targetUrl = ${serializableTargetUrl};
+const profileSlug = ${serializableSlug};
+const capturedAt = new Date().toISOString();
+const consoleEvents = [];
+const pageErrors = [];
+page.on("console", (message) => {
+  const type = message.type();
+  if (type === "error" || type === "warning" || type === "assert") {
+    consoleEvents.push({
+      type,
+      text: message.text().slice(0, 1000),
+      location: message.location ? message.location() : undefined,
+    });
+  }
+});
+page.on("pageerror", (error) => {
+  pageErrors.push({ message: String(error && error.message ? error.message : error).slice(0, 1000) });
+});
+function textKey(check) {
+  return check.pattern ? "pattern:" + check.pattern + "/" + (check.flags || "") : "text:" + (check.text || "");
+}
+function textMatches(sample, check) {
+  if (check.pattern) {
+    try { return new RegExp(check.pattern, check.flags || "").test(sample || ""); } catch { return false; }
+  }
+  return String(sample || "").includes(check.text || "");
+}
+function expectedPathFor(check) {
+  return check.expected_path || new URL(targetUrl).pathname || "/";
+}
+async function selectorStats(selector) {
+  return page.locator(selector).evaluateAll((elements) => {
+    const isVisible = (element) => {
+      const style = window.getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return style && style.visibility !== "hidden" && style.display !== "none" && rect.width > 0 && rect.height > 0;
+    };
+    return { count: elements.length, visible_count: elements.filter(isVisible).length };
+  }).catch((error) => ({ count: 0, visible_count: 0, error: String(error && error.message ? error.message : error).slice(0, 500) }));
+}
+async function captureViewport(viewport) {
+  await page.setViewportSize({ width: viewport.width, height: viewport.height });
+  let httpStatus = null;
+  let navigationError;
+  let waitError;
+  try {
+    const response = await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 45000 });
+    httpStatus = response ? response.status() : null;
+  } catch (error) {
+    navigationError = String(error && error.message ? error.message : error).slice(0, 1000);
+  }
+  if (!navigationError && profile.target.wait_for_selector) {
+    try {
+      await page.waitForSelector(profile.target.wait_for_selector, { state: "visible", timeout: 15000 });
+    } catch (error) {
+      waitError = String(error && error.message ? error.message : error).slice(0, 1000);
+    }
+  }
+  if (!navigationError && profile.target.wait_ms) {
+    await page.waitForTimeout(profile.target.wait_ms);
+  }
+  const dom = await page.evaluate(() => {
+    const body = document.body;
+    const documentElement = document.documentElement;
+    const text = (body ? body.innerText : "").replace(/\s+/g, " ").trim();
+    return {
+      url: location.href,
+      pathname: location.pathname,
+      title: document.title,
+      body_text_length: text.length,
+      body_text_sample: text.slice(0, 8000),
+      scroll_width: documentElement ? documentElement.scrollWidth : 0,
+      client_width: documentElement ? documentElement.clientWidth : window.innerWidth,
+    };
+  }).catch((error) => ({
+    url: page.url(),
+    pathname: "",
+    title: "",
+    body_text_length: 0,
+    body_text_sample: "",
+    scroll_width: 0,
+    client_width: viewport.width,
+    evaluation_error: String(error && error.message ? error.message : error).slice(0, 1000),
+  }));
+  const selectors = {};
+  const text_matches = {};
+  for (const check of profile.checks || []) {
+    if ((check.type === "selector_visible" || check.type === "selector_count_at_least") && check.selector) {
+      selectors[check.selector] = await selectorStats(check.selector);
+    }
+    if ((check.type === "text_visible" || check.type === "text_absent") && (check.text || check.pattern)) {
+      text_matches[textKey(check)] = textMatches(dom.body_text_sample || "", check);
+    }
+  }
+  const screenshotLabel = profileSlug + "-" + viewport.name;
+  try {
+    if (typeof saveScreenshot === "function") await saveScreenshot(screenshotLabel);
+  } catch (error) {
+    pageErrors.push({ message: "saveScreenshot failed: " + String(error && error.message ? error.message : error).slice(0, 500) });
+  }
+  const expectedPath = profile.checks.find((check) => check.type === "route_loaded" && check.expected_path)?.expected_path || new URL(targetUrl).pathname || "/";
+  return {
+    name: viewport.name,
+    width: viewport.width,
+    height: viewport.height,
+    url: dom.url,
+    route: {
+      requested: targetUrl,
+      observed: dom.pathname,
+      expected_path: expectedPath,
+      matched: dom.pathname === expectedPath,
+      http_status: httpStatus,
+      error: navigationError || waitError || undefined,
+    },
+    title: dom.title,
+    body_text_length: dom.body_text_length,
+    body_text_sample: dom.body_text_sample,
+    scroll_width: dom.scroll_width,
+    client_width: dom.client_width,
+    overflow_px: Math.max(0, (dom.scroll_width || 0) - (dom.client_width || viewport.width)),
+    selectors,
+    text_matches,
+    screenshot_label: screenshotLabel,
+    navigation_error: navigationError,
+    wait_error: waitError,
+  };
+}
+${runtimeScriptAssessmentSource()}
+const viewports = [];
+for (const viewport of profile.target.viewports || []) {
+  viewports.push(await captureViewport(viewport));
+}
+const evidence = {
+  version: "riddle-proof.profile-evidence.v1",
+  profile_name: profile.name,
+  target_url: targetUrl,
+  baseline_policy: profile.baseline_policy || "invariant_only",
+  captured_at: capturedAt,
+  viewports,
+  console: {
+    events: consoleEvents,
+    fatal_count: consoleEvents.filter((event) => event.type === "error" || event.type === "assert").length,
+  },
+  page_errors: pageErrors,
+  dom_summary: {
+    viewport_count: viewports.length,
+    routes: viewports.map((viewport) => viewport.route),
+    titles: viewports.map((viewport) => viewport.title),
+    overflow_px: viewports.map((viewport) => viewport.overflow_px),
+  },
+};
+const result = assessProfile(profile, evidence);
+if (typeof saveJson === "function") {
+  await saveJson("proof.json", result);
+  await saveJson("console.json", { events: consoleEvents, page_errors: pageErrors });
+  await saveJson("dom-summary.json", evidence.dom_summary);
+}
+return result;
+`.trim();
+}
+function collectRiddleProfileArtifactRefs(input) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  function add(item, source) {
+    if (!isRecord2(item)) return;
+    const name = stringValue5(item.name) || stringValue5(item.filename) || "";
+    const url = stringValue5(item.url);
+    const path6 = stringValue5(item.path);
+    if (!name && !url && !path6) return;
+    const key = `${name}:${url || path6 || ""}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    refs.push({
+      name,
+      url,
+      path: path6,
+      kind: stringValue5(item.kind) || stringValue5(item.type),
+      content_type: stringValue5(item.content_type) || stringValue5(item.contentType),
+      source
+    });
+  }
+  function visit(value, source) {
+    if (Array.isArray(value)) {
+      for (const item of value) add(item, source);
+      return;
+    }
+    if (!isRecord2(value)) return;
+    for (const key of ["artifacts", "outputs", "screenshots", "files"]) {
+      if (Array.isArray(value[key])) visit(value[key], key);
+    }
+  }
+  visit(input, "artifacts");
+  return refs;
+}
+function extractRiddleProofProfileResult(input) {
+  if (!isRecord2(input)) return void 0;
+  if (input.version === RIDDLE_PROOF_PROFILE_RESULT_VERSION) return input;
+  const candidates = [
+    input.result,
+    input.return_value,
+    input.value,
+    input.profile_result,
+    isRecord2(input["proof.json"]) ? input["proof.json"] : void 0,
+    isRecord2(input._proof_json) ? input._proof_json : void 0
+  ];
+  for (const candidate of candidates) {
+    const result = extractRiddleProofProfileResult(candidate);
+    if (result) return result;
+  }
+  if (isRecord2(input._artifact_json)) {
+    return extractRiddleProofProfileResult(input._artifact_json["proof.json"]);
+  }
+  return void 0;
+}
+
 // src/riddle-client.ts
 var import_node_child_process4 = require("child_process");
 var import_node_fs5 = require("fs");
@@ -8120,6 +9349,8 @@ function createRiddleApiClient(config = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BASIC_GAMEPLAY_ACTION_TYPES,
+  BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES,
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
   DEFAULT_DIAGNOSTIC_STRING_LIMIT,
@@ -8133,6 +9364,11 @@ function createRiddleApiClient(config = {}) {
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
   RIDDLE_PROOF_PLAYABILITY_VERSION,
+  RIDDLE_PROOF_PROFILE_CHECK_TYPES,
+  RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,
+  RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+  RIDDLE_PROOF_PROFILE_STATUSES,
+  RIDDLE_PROOF_PROFILE_VERSION,
   RIDDLE_PROOF_RUN_CARD_VERSION,
   RIDDLE_PROOF_RUN_STATE_VERSION,
   RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION,
@@ -8144,18 +9380,27 @@ function createRiddleApiClient(config = {}) {
   applyPrLifecycleState,
   applyTerminalMetadata,
   assessBasicGameplayEvidence,
+  assessBasicGameplayProgressionCheck,
+  assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute,
   assessPlayabilityEvidence,
+  assessRiddleProofProfileEvidence,
+  attachBasicGameplayArtifactScreenshotHashes,
+  augmentBasicGameplayAssessmentWithProgressionChecks,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
   buildCheckpointPacketForEngineResult,
   buildProofAssessmentCheckpointPacket,
+  buildRiddleProofProfileScript,
   buildStageCheckpointPacket,
   buildVisualProofSession,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
+  collectRiddleProfileArtifactRefs,
+  compactBasicGameplayText,
   compactRecord,
   compareVisualProofSessionFingerprint,
+  createBasicGameplayCatchRecords,
   createBasicGameplayCatchSummary,
   createCaptureDiagnostic,
   createCheckpointResponseTemplate,
@@ -8165,6 +9410,9 @@ function createRiddleApiClient(config = {}) {
   createLocalAgentAdapter,
   createLocalAgentJsonRunner,
   createRiddleApiClient,
+  createRiddleProofProfileConfigurationError,
+  createRiddleProofProfileEnvironmentBlockedResult,
+  createRiddleProofProfileInsufficientResult,
   createRiddleProofRunCard,
   createRunResult,
   createRunState,
@@ -8172,6 +9420,7 @@ function createRiddleApiClient(config = {}) {
   deployRiddleStaticPreview,
   extractBasicGameplayEvidence,
   extractPlayabilityEvidence,
+  extractRiddleProofProfileResult,
   isDuplicateCheckpointResponse,
   isRiddleProofPlayabilityMode,
   isSuccessfulStatus,
@@ -8181,16 +9430,20 @@ function createRiddleApiClient(config = {}) {
   normalizeCheckpointResponse,
   normalizeIntegrationContext,
   normalizePrLifecycleState,
+  normalizeRiddleProofProfile,
   normalizeRunParams,
   normalizeTerminalMetadata,
   parseRiddleViewport,
   parseVisualProofSession,
   pollRiddleJob,
+  profileStatusExitCode,
   proofContractFromAuthorCheckpointResponse,
   readRiddleProofRunStatus,
   recordValue,
   redactForProofDiagnostics,
+  resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey,
+  resolveRiddleProofProfileTargetUrl,
   riddleRequestJson,
   runCodexExecAgentDoctor,
   runLocalAgentDoctor,
@@ -8198,9 +9451,12 @@ function createRiddleApiClient(config = {}) {
   runRiddleProofEngineHarness,
   runRiddleScript,
   runRiddleServerPreview,
+  sanitizeBasicGameplayJsonString,
   setRunStatus,
+  slugifyRiddleProofProfileName,
   statePathsForRunState,
   summarizeCaptureArtifacts,
+  summarizeRiddleProofProfileResult,
   visualSessionFingerprint,
   visualSessionFingerprintBasis
 });