@riddledc/riddle-proof 0.5.56 → 0.6.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,
@@ -2797,8 +2799,12 @@ __export(index_exports, {
   applyPrLifecycleState: () => applyPrLifecycleState,
   applyTerminalMetadata: () => applyTerminalMetadata,
   assessBasicGameplayEvidence: () => assessBasicGameplayEvidence,
+  assessBasicGameplayProgressionCheck: () => assessBasicGameplayProgressionCheck,
+  assessBasicGameplayProgressionChecks: () => assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute: () => assessBasicGameplayRoute,
   assessPlayabilityEvidence: () => assessPlayabilityEvidence,
+  attachBasicGameplayArtifactScreenshotHashes: () => attachBasicGameplayArtifactScreenshotHashes,
+  augmentBasicGameplayAssessmentWithProgressionChecks: () => augmentBasicGameplayAssessmentWithProgressionChecks,
   authorPacketPayloadFromCheckpointResponse: () => authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket: () => buildAuthorCheckpointPacket,
   buildCheckpointPacketForEngineResult: () => buildCheckpointPacketForEngineResult,
@@ -2807,8 +2813,10 @@ __export(index_exports, {
   buildVisualProofSession: () => buildVisualProofSession,
   checkpointResponseIdentity: () => checkpointResponseIdentity,
   checkpointSummaryFromState: () => checkpointSummaryFromState,
+  compactBasicGameplayText: () => compactBasicGameplayText,
   compactRecord: () => compactRecord,
   compareVisualProofSessionFingerprint: () => compareVisualProofSessionFingerprint,
+  createBasicGameplayCatchRecords: () => createBasicGameplayCatchRecords,
   createBasicGameplayCatchSummary: () => createBasicGameplayCatchSummary,
   createCaptureDiagnostic: () => createCaptureDiagnostic,
   createCheckpointResponseTemplate: () => createCheckpointResponseTemplate,
@@ -2843,6 +2851,7 @@ __export(index_exports, {
   readRiddleProofRunStatus: () => readRiddleProofRunStatus,
   recordValue: () => recordValue,
   redactForProofDiagnostics: () => redactForProofDiagnostics,
+  resolveBasicGameplayProgressionCheckWithArtifactScreenshots: () => resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey: () => resolveRiddleApiKey,
   riddleRequestJson: () => riddleRequestJson,
   runCodexExecAgentDoctor: () => runCodexExecAgentDoctor,
@@ -2851,6 +2860,7 @@ __export(index_exports, {
   runRiddleProofEngineHarness: () => runRiddleProofEngineHarness,
   runRiddleScript: () => runRiddleScript,
   runRiddleServerPreview: () => runRiddleServerPreview,
+  sanitizeBasicGameplayJsonString: () => sanitizeBasicGameplayJsonString,
   setRunStatus: () => setRunStatus,
   statePathsForRunState: () => statePathsForRunState,
   summarizeCaptureArtifacts: () => summarizeCaptureArtifacts,
@@ -7623,6 +7633,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 +7669,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 +7697,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 +7787,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 +8151,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 +8290,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;
 }
@@ -8120,6 +8543,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,
@@ -8144,8 +8569,12 @@ function createRiddleApiClient(config = {}) {
   applyPrLifecycleState,
   applyTerminalMetadata,
   assessBasicGameplayEvidence,
+  assessBasicGameplayProgressionCheck,
+  assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute,
   assessPlayabilityEvidence,
+  attachBasicGameplayArtifactScreenshotHashes,
+  augmentBasicGameplayAssessmentWithProgressionChecks,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
   buildCheckpointPacketForEngineResult,
@@ -8154,8 +8583,10 @@ function createRiddleApiClient(config = {}) {
   buildVisualProofSession,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
+  compactBasicGameplayText,
   compactRecord,
   compareVisualProofSessionFingerprint,
+  createBasicGameplayCatchRecords,
   createBasicGameplayCatchSummary,
   createCaptureDiagnostic,
   createCheckpointResponseTemplate,
@@ -8190,6 +8621,7 @@ function createRiddleApiClient(config = {}) {
   readRiddleProofRunStatus,
   recordValue,
   redactForProofDiagnostics,
+  resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey,
   riddleRequestJson,
   runCodexExecAgentDoctor,
@@ -8198,6 +8630,7 @@ function createRiddleApiClient(config = {}) {
   runRiddleProofEngineHarness,
   runRiddleScript,
   runRiddleServerPreview,
+  sanitizeBasicGameplayJsonString,
   setRunStatus,
   statePathsForRunState,
   summarizeCaptureArtifacts,

package/dist/index.d.cts

@@ -9,5 +9,5 @@ export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunne
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.cjs';
 export { BuildVisualProofSessionInput, RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION, RIDDLE_PROOF_VISUAL_SESSION_VERSION, VisualProofSessionMismatch, buildVisualProofSession, compareVisualProofSessionFingerprint, parseVisualProofSession, visualSessionFingerprint, visualSessionFingerprintBasis } from './proof-session.cjs';
 export { AssessPlayabilityOptions, RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION, RIDDLE_PROOF_PLAYABILITY_VERSION, RiddleProofPlayabilityAssessment, RiddleProofPlayabilityEvidence, assessPlayabilityEvidence, extractPlayabilityEvidence, isRiddleProofPlayabilityMode } from './playability.cjs';
-export { AssessBasicGameplayOptions, BasicGameplayActionResult, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMobileEvidence, BasicGameplayProofArtifact, BasicGameplaySnapshot, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayRoute, createBasicGameplayCatchSummary, extractBasicGameplayEvidence } from './basic-gameplay.cjs';
+export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.cjs';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, RiddleServerPreviewInput, RiddleServerPreviewResult, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript, runRiddleServerPreview } from './riddle-client.cjs';

package/dist/index.d.ts

@@ -9,5 +9,5 @@ export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunne
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.js';
 export { BuildVisualProofSessionInput, RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION, RIDDLE_PROOF_VISUAL_SESSION_VERSION, VisualProofSessionMismatch, buildVisualProofSession, compareVisualProofSessionFingerprint, parseVisualProofSession, visualSessionFingerprint, visualSessionFingerprintBasis } from './proof-session.js';
 export { AssessPlayabilityOptions, RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION, RIDDLE_PROOF_PLAYABILITY_VERSION, RiddleProofPlayabilityAssessment, RiddleProofPlayabilityEvidence, assessPlayabilityEvidence, extractPlayabilityEvidence, isRiddleProofPlayabilityMode } from './playability.js';
-export { AssessBasicGameplayOptions, BasicGameplayActionResult, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMobileEvidence, BasicGameplayProofArtifact, BasicGameplaySnapshot, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayRoute, createBasicGameplayCatchSummary, extractBasicGameplayEvidence } from './basic-gameplay.js';
+export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.js';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, RiddleServerPreviewInput, RiddleServerPreviewResult, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript, runRiddleServerPreview } from './riddle-client.js';

package/dist/index.js

@@ -19,14 +19,24 @@ import {
   visualSessionFingerprintBasis
 } from "./chunk-ODORKNSO.js";
 import {
+  BASIC_GAMEPLAY_ACTION_TYPES,
+  BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES,
   RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
   RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION,
   RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
   assessBasicGameplayEvidence,
+  assessBasicGameplayProgressionCheck,
+  assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute,
+  attachBasicGameplayArtifactScreenshotHashes,
+  augmentBasicGameplayAssessmentWithProgressionChecks,
+  compactBasicGameplayText,
+  createBasicGameplayCatchRecords,
   createBasicGameplayCatchSummary,
-  extractBasicGameplayEvidence
-} from "./chunk-53DJMNQ6.js";
+  extractBasicGameplayEvidence,
+  resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
+  sanitizeBasicGameplayJsonString
+} from "./chunk-AAIASO2C.js";
 import {
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,
@@ -106,6 +116,8 @@ import {
   recordValue
 } from "./chunk-DUFDZJOF.js";
 export {
+  BASIC_GAMEPLAY_ACTION_TYPES,
+  BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES,
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
   DEFAULT_DIAGNOSTIC_STRING_LIMIT,
@@ -130,8 +142,12 @@ export {
   applyPrLifecycleState,
   applyTerminalMetadata,
   assessBasicGameplayEvidence,
+  assessBasicGameplayProgressionCheck,
+  assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute,
   assessPlayabilityEvidence,
+  attachBasicGameplayArtifactScreenshotHashes,
+  augmentBasicGameplayAssessmentWithProgressionChecks,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
   buildCheckpointPacketForEngineResult,
@@ -140,8 +156,10 @@ export {
   buildVisualProofSession,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
+  compactBasicGameplayText,
   compactRecord,
   compareVisualProofSessionFingerprint,
+  createBasicGameplayCatchRecords,
   createBasicGameplayCatchSummary,
   createCaptureDiagnostic,
   createCheckpointResponseTemplate,
@@ -176,6 +194,7 @@ export {
   readRiddleProofRunStatus,
   recordValue,
   redactForProofDiagnostics,
+  resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey,
   riddleRequestJson,
   runCodexExecAgentDoctor,
@@ -184,6 +203,7 @@ export {
   runRiddleProofEngineHarness,
   runRiddleScript,
   runRiddleServerPreview,
+  sanitizeBasicGameplayJsonString,
   setRunStatus,
   statePathsForRunState,
   summarizeCaptureArtifacts,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.56",
+  "version": "0.6.0",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",