@riddledc/riddle-proof 0.5.54 → 0.5.55

package/dist/basic-gameplay.cjs

@@ -0,0 +1,255 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/basic-gameplay.ts
+var basic_gameplay_exports = {};
+__export(basic_gameplay_exports, {
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION: () => RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION: () => RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
+  assessBasicGameplayEvidence: () => assessBasicGameplayEvidence,
+  assessBasicGameplayRoute: () => assessBasicGameplayRoute,
+  extractBasicGameplayEvidence: () => extractBasicGameplayEvidence
+});
+module.exports = __toCommonJS(basic_gameplay_exports);
+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 BASIC_GAMEPLAY_CONTAINER_KEYS = [
+  "basic_gameplay",
+  "basicGameplay",
+  "basic_gameplay_evidence",
+  "basicGameplayEvidence",
+  "gameplay_proof",
+  "gameplayProof"
+];
+function assessBasicGameplayEvidence(evidence, options = {}) {
+  const run = extractBasicGameplayEvidence(evidence);
+  if (!run) {
+    return {
+      version: RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+      evidence_present: false,
+      passed: false,
+      checked_routes: 0,
+      passing_routes: 0,
+      failing_routes: [],
+      failure_counts: {},
+      warning_counts: {},
+      route_results: []
+    };
+  }
+  const routeResults = (run.results || []).map((route) => assessBasicGameplayRoute(route, options));
+  const failingRoutes = routeResults.filter((result) => !result.ok).map((result) => ({
+    name: result.name,
+    path: result.path,
+    failures: result.failures,
+    warnings: result.warnings
+  }));
+  return {
+    version: RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+    evidence_present: true,
+    passed: failingRoutes.length === 0,
+    checked_routes: routeResults.length,
+    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 assessBasicGameplayRoute(route, options = {}) {
+  const maxMobileOverflowPx = options.maxMobileOverflowPx ?? 4;
+  const minBodyTextLength = options.minBodyTextLength ?? 20;
+  const minVisibleLargeNodes = options.minVisibleLargeNodes ?? 3;
+  const minSurfaceLargeNodes = options.minSurfaceLargeNodes ?? 8;
+  const warnOnMissingResetPath = options.warnOnMissingResetPath ?? true;
+  const warnOnConsoleError = options.warnOnConsoleError ?? true;
+  const failOnConsoleError = options.failOnConsoleError ?? false;
+  const failures = [];
+  const warnings = [];
+  const initial = route.initial || {};
+  const timed = route.timed || {};
+  const afterAction = route.after_action || route.afterAction || {};
+  const mobile = route.mobile || {};
+  const timedChange = changed(initial, timed);
+  const actionChange = changed(timed, afterAction);
+  const surfaceVisible = numberValue(initial.visible_canvas_count) > 0 || numberValue(initial.enabled_clickable_count) > 0 || numberValue(initial.visible_large_node_count) >= minSurfaceLargeNodes;
+  const actionResults = listValue(route.action_results || route.actionResults);
+  const actionAttempted = actionResults.some((result) => result.ok === true && result.action !== "wait");
+  const actionFailed = actionResults.some((result) => result.ok === false && result.action !== "wait");
+  const stateChangeObserved = actionChange.changed || timedChange.changed;
+  const resetPathPresent = numberValue(initial.reset_control_count) > 0 || numberValue(timed.reset_control_count) > 0 || numberValue(afterAction.reset_control_count) > 0;
+  const responseStatus = firstNumber(route.http_status, route.response_status, route.status);
+  const pageErrorCount = numberValue(route.page_error_count);
+  const consoleErrorCount = numberValue(route.console_error_count);
+  const mobileOverflowPx = numberValue(mobile.overflow_px);
+  if (responseStatus !== null && responseStatus >= 400) failures.push("route_http_error");
+  if (pageErrorCount > 0) failures.push("fatal_page_error");
+  if (numberValue(initial.body_text_length) < minBodyTextLength && numberValue(initial.visible_large_node_count) < minVisibleLargeNodes) {
+    failures.push("route_blank_or_thin");
+  }
+  if (!surfaceVisible) failures.push("no_game_surface");
+  if (mobileOverflowPx > maxMobileOverflowPx) failures.push("mobile_horizontal_overflow");
+  if (!actionAttempted && !timedChange.changed) failures.push("primary_control_missing");
+  if (actionAttempted && !stateChangeObserved) failures.push("primary_control_inert");
+  if (failOnConsoleError && consoleErrorCount > 0) failures.push("fatal_page_error");
+  if (numberValue(initial.visible_canvas_count) > 0 && actionAttempted && !timedChange.canvas_changed && !actionChange.canvas_changed && !actionChange.screenshot_changed) {
+    warnings.push("canvas_inert");
+  }
+  if (actionFailed) warnings.push("some_actions_failed");
+  if (warnOnMissingResetPath && !resetPathPresent && route.requires_reset !== false && actionAttempted && stateChangeObserved) {
+    warnings.push("missing_reset_path");
+  }
+  if (warnOnConsoleError && consoleErrorCount > 0) warnings.push("critical_console_error");
+  return {
+    name: route.name,
+    path: route.path,
+    ok: failures.length === 0,
+    failures,
+    warnings,
+    signals: {
+      route_loaded: !failures.includes("route_http_error") && !failures.includes("route_blank_or_thin"),
+      surface_visible: surfaceVisible,
+      action_attempted: actionAttempted,
+      timed_progression_observed: timedChange.changed,
+      first_interaction_observed: actionChange.changed,
+      state_change_observed: stateChangeObserved,
+      mobile_overflow_absent: mobileOverflowPx <= maxMobileOverflowPx,
+      reset_path_present: resetPathPresent,
+      fatal_errors_absent: pageErrorCount === 0
+    },
+    diffs: {
+      timed: timedChange,
+      after_action: actionChange
+    }
+  };
+}
+function extractBasicGameplayEvidence(...sources) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    const found = findBasicGameplayEvidence(source, seen);
+    if (found) return found;
+  }
+  return null;
+}
+function findBasicGameplayEvidence(value, seen, depth = 0) {
+  if (depth > 6 || value === null || value === void 0) return null;
+  if (typeof value === "string") {
+    const parsed = parseJson(value);
+    return parsed === null ? null : findBasicGameplayEvidence(parsed, seen, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return null;
+    seen.add(value);
+    if (value.some((item) => hasRouteShape(recordValue(item)))) {
+      return { results: value.filter((item) => hasRouteShape(recordValue(item))) };
+    }
+    for (const item of value) {
+      const found = findBasicGameplayEvidence(item, seen, depth + 1);
+      if (found) return found;
+    }
+    return null;
+  }
+  const record = recordValue(value);
+  if (!record || seen.has(record)) return null;
+  seen.add(record);
+  if (record.version === RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION || Array.isArray(record.results)) {
+    return {
+      ...record,
+      results: listValue(record.results).filter((item) => Boolean(recordValue(item)))
+    };
+  }
+  if (hasRouteShape(record)) {
+    return { results: [record] };
+  }
+  for (const key of BASIC_GAMEPLAY_CONTAINER_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) {
+      const nested = findBasicGameplayEvidence(record[key], seen, depth + 1);
+      if (nested) return nested;
+    }
+  }
+  for (const item of Object.values(record)) {
+    const found = findBasicGameplayEvidence(item, seen, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+function hasRouteShape(record) {
+  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.action_results || record.actionResults) && (record.path || record.name));
+}
+function changed(before, after) {
+  const bodyTextChanged = Boolean(before.body_text_hash && after.body_text_hash && before.body_text_hash !== after.body_text_hash);
+  const screenshotChanged = Boolean(before.screenshot_hash && after.screenshot_hash && before.screenshot_hash !== after.screenshot_hash);
+  const beforeCanvasHashes = canvasHashes(before.canvases);
+  const afterCanvasHashes = canvasHashes(after.canvases);
+  const canvasChanged = Boolean(beforeCanvasHashes && afterCanvasHashes && beforeCanvasHashes !== afterCanvasHashes);
+  return {
+    body_text_changed: bodyTextChanged,
+    screenshot_changed: screenshotChanged,
+    canvas_changed: canvasChanged,
+    changed: bodyTextChanged || screenshotChanged || canvasChanged
+  };
+}
+function canvasHashes(canvases) {
+  return (canvases || []).map((canvas) => canvas.hash).filter(Boolean).join("|");
+}
+function countCodes(codes) {
+  const counts = {};
+  for (const code of codes) counts[code] = (counts[code] || 0) + 1;
+  return counts;
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    const number = numericValue(value);
+    if (number !== null) return number;
+  }
+  return null;
+}
+function numberValue(value) {
+  return numericValue(value) ?? 0;
+}
+function numericValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+function parseJson(value) {
+  const trimmed = value.trim();
+  if (!trimmed || !/^[{[]/.test(trimmed)) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
+  assessBasicGameplayEvidence,
+  assessBasicGameplayRoute,
+  extractBasicGameplayEvidence
+});

package/dist/basic-gameplay.d.cts

@@ -0,0 +1,117 @@
+declare const RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION = "riddle-proof.basic-gameplay.v1";
+declare const RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION = "riddle-proof.basic-gameplay.assessment.v1";
+type BasicGameplayFailureCode = "route_http_error" | "fatal_page_error" | "route_blank_or_thin" | "no_game_surface" | "mobile_horizontal_overflow" | "primary_control_missing" | "primary_control_inert";
+type BasicGameplayWarningCode = "canvas_inert" | "some_actions_failed" | "missing_reset_path" | "critical_console_error";
+interface BasicGameplayCanvasState {
+    index?: number;
+    width?: number;
+    height?: number;
+    css_width?: number;
+    css_height?: number;
+    visible?: boolean;
+    readable?: boolean;
+    hash?: string | null;
+}
+interface BasicGameplaySnapshot {
+    screenshot_hash?: string | null;
+    body_text_hash?: string | null;
+    body_text_length?: number;
+    visible_large_node_count?: number;
+    enabled_clickable_count?: number;
+    reset_control_count?: number;
+    visible_canvas_count?: number;
+    canvases?: BasicGameplayCanvasState[];
+    [key: string]: unknown;
+}
+interface BasicGameplayActionResult {
+    ok?: boolean;
+    action?: string;
+    [key: string]: unknown;
+}
+interface BasicGameplayMobileEvidence {
+    overflow_px?: number;
+    [key: string]: unknown;
+}
+interface RiddleProofBasicGameplayRouteEvidence {
+    name?: string;
+    path?: string;
+    http_status?: number | null;
+    response_status?: number | null;
+    status?: number | null;
+    console_error_count?: number;
+    page_error_count?: number;
+    initial?: BasicGameplaySnapshot;
+    timed?: BasicGameplaySnapshot;
+    after_action?: BasicGameplaySnapshot;
+    afterAction?: BasicGameplaySnapshot;
+    mobile?: BasicGameplayMobileEvidence;
+    action_results?: BasicGameplayActionResult[];
+    actionResults?: BasicGameplayActionResult[];
+    requires_reset?: boolean;
+    [key: string]: unknown;
+}
+interface RiddleProofBasicGameplayEvidence {
+    version?: typeof RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION | string;
+    site?: string | null;
+    base_url?: string;
+    results?: RiddleProofBasicGameplayRouteEvidence[];
+    [key: string]: unknown;
+}
+interface AssessBasicGameplayOptions {
+    maxMobileOverflowPx?: number;
+    minBodyTextLength?: number;
+    minVisibleLargeNodes?: number;
+    minSurfaceLargeNodes?: number;
+    warnOnMissingResetPath?: boolean;
+    warnOnConsoleError?: boolean;
+    failOnConsoleError?: boolean;
+}
+interface BasicGameplayChangeSummary {
+    body_text_changed: boolean;
+    screenshot_changed: boolean;
+    canvas_changed: boolean;
+    changed: boolean;
+}
+interface RiddleProofBasicGameplayRouteAssessment {
+    name?: string;
+    path?: string;
+    ok: boolean;
+    failures: BasicGameplayFailureCode[];
+    warnings: BasicGameplayWarningCode[];
+    signals: {
+        route_loaded: boolean;
+        surface_visible: boolean;
+        action_attempted: boolean;
+        timed_progression_observed: boolean;
+        first_interaction_observed: boolean;
+        state_change_observed: boolean;
+        mobile_overflow_absent: boolean;
+        reset_path_present: boolean;
+        fatal_errors_absent: boolean;
+    };
+    diffs: {
+        timed: BasicGameplayChangeSummary;
+        after_action: BasicGameplayChangeSummary;
+    };
+}
+interface RiddleProofBasicGameplayAssessment {
+    version: typeof RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION;
+    evidence_present: boolean;
+    passed: boolean;
+    checked_routes: number;
+    passing_routes: number;
+    failing_routes: Array<{
+        name?: string;
+        path?: string;
+        failures: BasicGameplayFailureCode[];
+        warnings: BasicGameplayWarningCode[];
+    }>;
+    failure_counts: Record<string, number>;
+    warning_counts: Record<string, number>;
+    route_results: RiddleProofBasicGameplayRouteAssessment[];
+}
+declare function assessBasicGameplayEvidence(evidence: unknown, options?: AssessBasicGameplayOptions): RiddleProofBasicGameplayAssessment;
+declare function assessBasicGameplayRoute(route: RiddleProofBasicGameplayRouteEvidence, options?: AssessBasicGameplayOptions): RiddleProofBasicGameplayRouteAssessment;
+declare function extractBasicGameplayEvidence(...sources: unknown[]): RiddleProofBasicGameplayEvidence | null;
+
+export { type AssessBasicGameplayOptions, type BasicGameplayActionResult, type BasicGameplayCanvasState, type BasicGameplayChangeSummary, type BasicGameplayFailureCode, type BasicGameplayMobileEvidence, type BasicGameplaySnapshot, type BasicGameplayWarningCode, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, type RiddleProofBasicGameplayAssessment, type RiddleProofBasicGameplayEvidence, type RiddleProofBasicGameplayRouteAssessment, type RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayRoute, extractBasicGameplayEvidence };

package/dist/basic-gameplay.d.ts

@@ -0,0 +1,117 @@
+declare const RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION = "riddle-proof.basic-gameplay.v1";
+declare const RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION = "riddle-proof.basic-gameplay.assessment.v1";
+type BasicGameplayFailureCode = "route_http_error" | "fatal_page_error" | "route_blank_or_thin" | "no_game_surface" | "mobile_horizontal_overflow" | "primary_control_missing" | "primary_control_inert";
+type BasicGameplayWarningCode = "canvas_inert" | "some_actions_failed" | "missing_reset_path" | "critical_console_error";
+interface BasicGameplayCanvasState {
+    index?: number;
+    width?: number;
+    height?: number;
+    css_width?: number;
+    css_height?: number;
+    visible?: boolean;
+    readable?: boolean;
+    hash?: string | null;
+}
+interface BasicGameplaySnapshot {
+    screenshot_hash?: string | null;
+    body_text_hash?: string | null;
+    body_text_length?: number;
+    visible_large_node_count?: number;
+    enabled_clickable_count?: number;
+    reset_control_count?: number;
+    visible_canvas_count?: number;
+    canvases?: BasicGameplayCanvasState[];
+    [key: string]: unknown;
+}
+interface BasicGameplayActionResult {
+    ok?: boolean;
+    action?: string;
+    [key: string]: unknown;
+}
+interface BasicGameplayMobileEvidence {
+    overflow_px?: number;
+    [key: string]: unknown;
+}
+interface RiddleProofBasicGameplayRouteEvidence {
+    name?: string;
+    path?: string;
+    http_status?: number | null;
+    response_status?: number | null;
+    status?: number | null;
+    console_error_count?: number;
+    page_error_count?: number;
+    initial?: BasicGameplaySnapshot;
+    timed?: BasicGameplaySnapshot;
+    after_action?: BasicGameplaySnapshot;
+    afterAction?: BasicGameplaySnapshot;
+    mobile?: BasicGameplayMobileEvidence;
+    action_results?: BasicGameplayActionResult[];
+    actionResults?: BasicGameplayActionResult[];
+    requires_reset?: boolean;
+    [key: string]: unknown;
+}
+interface RiddleProofBasicGameplayEvidence {
+    version?: typeof RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION | string;
+    site?: string | null;
+    base_url?: string;
+    results?: RiddleProofBasicGameplayRouteEvidence[];
+    [key: string]: unknown;
+}
+interface AssessBasicGameplayOptions {
+    maxMobileOverflowPx?: number;
+    minBodyTextLength?: number;
+    minVisibleLargeNodes?: number;
+    minSurfaceLargeNodes?: number;
+    warnOnMissingResetPath?: boolean;
+    warnOnConsoleError?: boolean;
+    failOnConsoleError?: boolean;
+}
+interface BasicGameplayChangeSummary {
+    body_text_changed: boolean;
+    screenshot_changed: boolean;
+    canvas_changed: boolean;
+    changed: boolean;
+}
+interface RiddleProofBasicGameplayRouteAssessment {
+    name?: string;
+    path?: string;
+    ok: boolean;
+    failures: BasicGameplayFailureCode[];
+    warnings: BasicGameplayWarningCode[];
+    signals: {
+        route_loaded: boolean;
+        surface_visible: boolean;
+        action_attempted: boolean;
+        timed_progression_observed: boolean;
+        first_interaction_observed: boolean;
+        state_change_observed: boolean;
+        mobile_overflow_absent: boolean;
+        reset_path_present: boolean;
+        fatal_errors_absent: boolean;
+    };
+    diffs: {
+        timed: BasicGameplayChangeSummary;
+        after_action: BasicGameplayChangeSummary;
+    };
+}
+interface RiddleProofBasicGameplayAssessment {
+    version: typeof RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION;
+    evidence_present: boolean;
+    passed: boolean;
+    checked_routes: number;
+    passing_routes: number;
+    failing_routes: Array<{
+        name?: string;
+        path?: string;
+        failures: BasicGameplayFailureCode[];
+        warnings: BasicGameplayWarningCode[];
+    }>;
+    failure_counts: Record<string, number>;
+    warning_counts: Record<string, number>;
+    route_results: RiddleProofBasicGameplayRouteAssessment[];
+}
+declare function assessBasicGameplayEvidence(evidence: unknown, options?: AssessBasicGameplayOptions): RiddleProofBasicGameplayAssessment;
+declare function assessBasicGameplayRoute(route: RiddleProofBasicGameplayRouteEvidence, options?: AssessBasicGameplayOptions): RiddleProofBasicGameplayRouteAssessment;
+declare function extractBasicGameplayEvidence(...sources: unknown[]): RiddleProofBasicGameplayEvidence | null;
+
+export { type AssessBasicGameplayOptions, type BasicGameplayActionResult, type BasicGameplayCanvasState, type BasicGameplayChangeSummary, type BasicGameplayFailureCode, type BasicGameplayMobileEvidence, type BasicGameplaySnapshot, type BasicGameplayWarningCode, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, type RiddleProofBasicGameplayAssessment, type RiddleProofBasicGameplayEvidence, type RiddleProofBasicGameplayRouteAssessment, type RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayRoute, extractBasicGameplayEvidence };

package/dist/basic-gameplay.js

@@ -0,0 +1,14 @@
+import {
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
+  assessBasicGameplayEvidence,
+  assessBasicGameplayRoute,
+  extractBasicGameplayEvidence
+} from "./chunk-RNGJX62B.js";
+export {
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
+  assessBasicGameplayEvidence,
+  assessBasicGameplayRoute,
+  extractBasicGameplayEvidence
+};

package/dist/chunk-RNGJX62B.js

@@ -0,0 +1,227 @@
+// src/basic-gameplay.ts
+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 BASIC_GAMEPLAY_CONTAINER_KEYS = [
+  "basic_gameplay",
+  "basicGameplay",
+  "basic_gameplay_evidence",
+  "basicGameplayEvidence",
+  "gameplay_proof",
+  "gameplayProof"
+];
+function assessBasicGameplayEvidence(evidence, options = {}) {
+  const run = extractBasicGameplayEvidence(evidence);
+  if (!run) {
+    return {
+      version: RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+      evidence_present: false,
+      passed: false,
+      checked_routes: 0,
+      passing_routes: 0,
+      failing_routes: [],
+      failure_counts: {},
+      warning_counts: {},
+      route_results: []
+    };
+  }
+  const routeResults = (run.results || []).map((route) => assessBasicGameplayRoute(route, options));
+  const failingRoutes = routeResults.filter((result) => !result.ok).map((result) => ({
+    name: result.name,
+    path: result.path,
+    failures: result.failures,
+    warnings: result.warnings
+  }));
+  return {
+    version: RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+    evidence_present: true,
+    passed: failingRoutes.length === 0,
+    checked_routes: routeResults.length,
+    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 assessBasicGameplayRoute(route, options = {}) {
+  const maxMobileOverflowPx = options.maxMobileOverflowPx ?? 4;
+  const minBodyTextLength = options.minBodyTextLength ?? 20;
+  const minVisibleLargeNodes = options.minVisibleLargeNodes ?? 3;
+  const minSurfaceLargeNodes = options.minSurfaceLargeNodes ?? 8;
+  const warnOnMissingResetPath = options.warnOnMissingResetPath ?? true;
+  const warnOnConsoleError = options.warnOnConsoleError ?? true;
+  const failOnConsoleError = options.failOnConsoleError ?? false;
+  const failures = [];
+  const warnings = [];
+  const initial = route.initial || {};
+  const timed = route.timed || {};
+  const afterAction = route.after_action || route.afterAction || {};
+  const mobile = route.mobile || {};
+  const timedChange = changed(initial, timed);
+  const actionChange = changed(timed, afterAction);
+  const surfaceVisible = numberValue(initial.visible_canvas_count) > 0 || numberValue(initial.enabled_clickable_count) > 0 || numberValue(initial.visible_large_node_count) >= minSurfaceLargeNodes;
+  const actionResults = listValue(route.action_results || route.actionResults);
+  const actionAttempted = actionResults.some((result) => result.ok === true && result.action !== "wait");
+  const actionFailed = actionResults.some((result) => result.ok === false && result.action !== "wait");
+  const stateChangeObserved = actionChange.changed || timedChange.changed;
+  const resetPathPresent = numberValue(initial.reset_control_count) > 0 || numberValue(timed.reset_control_count) > 0 || numberValue(afterAction.reset_control_count) > 0;
+  const responseStatus = firstNumber(route.http_status, route.response_status, route.status);
+  const pageErrorCount = numberValue(route.page_error_count);
+  const consoleErrorCount = numberValue(route.console_error_count);
+  const mobileOverflowPx = numberValue(mobile.overflow_px);
+  if (responseStatus !== null && responseStatus >= 400) failures.push("route_http_error");
+  if (pageErrorCount > 0) failures.push("fatal_page_error");
+  if (numberValue(initial.body_text_length) < minBodyTextLength && numberValue(initial.visible_large_node_count) < minVisibleLargeNodes) {
+    failures.push("route_blank_or_thin");
+  }
+  if (!surfaceVisible) failures.push("no_game_surface");
+  if (mobileOverflowPx > maxMobileOverflowPx) failures.push("mobile_horizontal_overflow");
+  if (!actionAttempted && !timedChange.changed) failures.push("primary_control_missing");
+  if (actionAttempted && !stateChangeObserved) failures.push("primary_control_inert");
+  if (failOnConsoleError && consoleErrorCount > 0) failures.push("fatal_page_error");
+  if (numberValue(initial.visible_canvas_count) > 0 && actionAttempted && !timedChange.canvas_changed && !actionChange.canvas_changed && !actionChange.screenshot_changed) {
+    warnings.push("canvas_inert");
+  }
+  if (actionFailed) warnings.push("some_actions_failed");
+  if (warnOnMissingResetPath && !resetPathPresent && route.requires_reset !== false && actionAttempted && stateChangeObserved) {
+    warnings.push("missing_reset_path");
+  }
+  if (warnOnConsoleError && consoleErrorCount > 0) warnings.push("critical_console_error");
+  return {
+    name: route.name,
+    path: route.path,
+    ok: failures.length === 0,
+    failures,
+    warnings,
+    signals: {
+      route_loaded: !failures.includes("route_http_error") && !failures.includes("route_blank_or_thin"),
+      surface_visible: surfaceVisible,
+      action_attempted: actionAttempted,
+      timed_progression_observed: timedChange.changed,
+      first_interaction_observed: actionChange.changed,
+      state_change_observed: stateChangeObserved,
+      mobile_overflow_absent: mobileOverflowPx <= maxMobileOverflowPx,
+      reset_path_present: resetPathPresent,
+      fatal_errors_absent: pageErrorCount === 0
+    },
+    diffs: {
+      timed: timedChange,
+      after_action: actionChange
+    }
+  };
+}
+function extractBasicGameplayEvidence(...sources) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    const found = findBasicGameplayEvidence(source, seen);
+    if (found) return found;
+  }
+  return null;
+}
+function findBasicGameplayEvidence(value, seen, depth = 0) {
+  if (depth > 6 || value === null || value === void 0) return null;
+  if (typeof value === "string") {
+    const parsed = parseJson(value);
+    return parsed === null ? null : findBasicGameplayEvidence(parsed, seen, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return null;
+    seen.add(value);
+    if (value.some((item) => hasRouteShape(recordValue(item)))) {
+      return { results: value.filter((item) => hasRouteShape(recordValue(item))) };
+    }
+    for (const item of value) {
+      const found = findBasicGameplayEvidence(item, seen, depth + 1);
+      if (found) return found;
+    }
+    return null;
+  }
+  const record = recordValue(value);
+  if (!record || seen.has(record)) return null;
+  seen.add(record);
+  if (record.version === RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION || Array.isArray(record.results)) {
+    return {
+      ...record,
+      results: listValue(record.results).filter((item) => Boolean(recordValue(item)))
+    };
+  }
+  if (hasRouteShape(record)) {
+    return { results: [record] };
+  }
+  for (const key of BASIC_GAMEPLAY_CONTAINER_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) {
+      const nested = findBasicGameplayEvidence(record[key], seen, depth + 1);
+      if (nested) return nested;
+    }
+  }
+  for (const item of Object.values(record)) {
+    const found = findBasicGameplayEvidence(item, seen, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+function hasRouteShape(record) {
+  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.action_results || record.actionResults) && (record.path || record.name));
+}
+function changed(before, after) {
+  const bodyTextChanged = Boolean(before.body_text_hash && after.body_text_hash && before.body_text_hash !== after.body_text_hash);
+  const screenshotChanged = Boolean(before.screenshot_hash && after.screenshot_hash && before.screenshot_hash !== after.screenshot_hash);
+  const beforeCanvasHashes = canvasHashes(before.canvases);
+  const afterCanvasHashes = canvasHashes(after.canvases);
+  const canvasChanged = Boolean(beforeCanvasHashes && afterCanvasHashes && beforeCanvasHashes !== afterCanvasHashes);
+  return {
+    body_text_changed: bodyTextChanged,
+    screenshot_changed: screenshotChanged,
+    canvas_changed: canvasChanged,
+    changed: bodyTextChanged || screenshotChanged || canvasChanged
+  };
+}
+function canvasHashes(canvases) {
+  return (canvases || []).map((canvas) => canvas.hash).filter(Boolean).join("|");
+}
+function countCodes(codes) {
+  const counts = {};
+  for (const code of codes) counts[code] = (counts[code] || 0) + 1;
+  return counts;
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    const number = numericValue(value);
+    if (number !== null) return number;
+  }
+  return null;
+}
+function numberValue(value) {
+  return numericValue(value) ?? 0;
+}
+function numericValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+function parseJson(value) {
+  const trimmed = value.trim();
+  if (!trimmed || !/^[{[]/.test(trimmed)) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  assessBasicGameplayEvidence,
+  assessBasicGameplayRoute,
+  extractBasicGameplayEvidence
+};

package/dist/cli.js

@@ -7,18 +7,18 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-A2AWRZ5B.js";
+} from "./chunk-2FBF2UDZ.js";
+import "./chunk-MO24D3PY.js";
 import "./chunk-RFJ5BQF6.js";
+import "./chunk-3UHWI3FO.js";
+import {
+  createCheckpointResponseTemplate
+} from "./chunk-33XO42CY.js";
 import "./chunk-JFQXAJH2.js";
 import {
   createCodexExecAgentAdapter,
   runCodexExecAgentDoctor
 } from "./chunk-3266V3MO.js";
-import "./chunk-MO24D3PY.js";
-import "./chunk-3UHWI3FO.js";
-import {
-  createCheckpointResponseTemplate
-} from "./chunk-33XO42CY.js";
 import "./chunk-DUFDZJOF.js";
 
 // src/cli.ts

package/dist/engine-harness.js

@@ -2,9 +2,9 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-A2AWRZ5B.js";
-import "./chunk-RFJ5BQF6.js";
+} from "./chunk-2FBF2UDZ.js";
 import "./chunk-MO24D3PY.js";
+import "./chunk-RFJ5BQF6.js";
 import "./chunk-3UHWI3FO.js";
 import "./chunk-33XO42CY.js";
 import "./chunk-DUFDZJOF.js";

package/dist/index.cjs

@@ -2778,6 +2778,8 @@ __export(index_exports, {
   DEFAULT_DIAGNOSTIC_STRING_LIMIT: () => DEFAULT_DIAGNOSTIC_STRING_LIMIT,
   DEFAULT_RIDDLE_API_BASE_URL: () => DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE: () => DEFAULT_RIDDLE_API_KEY_FILE,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION: () => RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION: () => RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
   RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION: () => RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION: () => RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION: () => RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -2793,6 +2795,8 @@ __export(index_exports, {
   appendStageHeartbeat: () => appendStageHeartbeat,
   applyPrLifecycleState: () => applyPrLifecycleState,
   applyTerminalMetadata: () => applyTerminalMetadata,
+  assessBasicGameplayEvidence: () => assessBasicGameplayEvidence,
+  assessBasicGameplayRoute: () => assessBasicGameplayRoute,
   assessPlayabilityEvidence: () => assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse: () => authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket: () => buildAuthorCheckpointPacket,
@@ -2817,6 +2821,7 @@ __export(index_exports, {
   createRunState: () => createRunState,
   createRunStatusSnapshot: () => createRunStatusSnapshot,
   deployRiddleStaticPreview: () => deployRiddleStaticPreview,
+  extractBasicGameplayEvidence: () => extractBasicGameplayEvidence,
   extractPlayabilityEvidence: () => extractPlayabilityEvidence,
   isDuplicateCheckpointResponse: () => isDuplicateCheckpointResponse,
   isRiddleProofPlayabilityMode: () => isRiddleProofPlayabilityMode,
@@ -7611,6 +7616,226 @@ function parseJson(value) {
   }
 }
 
+// src/basic-gameplay.ts
+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 BASIC_GAMEPLAY_CONTAINER_KEYS = [
+  "basic_gameplay",
+  "basicGameplay",
+  "basic_gameplay_evidence",
+  "basicGameplayEvidence",
+  "gameplay_proof",
+  "gameplayProof"
+];
+function assessBasicGameplayEvidence(evidence, options = {}) {
+  const run = extractBasicGameplayEvidence(evidence);
+  if (!run) {
+    return {
+      version: RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+      evidence_present: false,
+      passed: false,
+      checked_routes: 0,
+      passing_routes: 0,
+      failing_routes: [],
+      failure_counts: {},
+      warning_counts: {},
+      route_results: []
+    };
+  }
+  const routeResults = (run.results || []).map((route) => assessBasicGameplayRoute(route, options));
+  const failingRoutes = routeResults.filter((result) => !result.ok).map((result) => ({
+    name: result.name,
+    path: result.path,
+    failures: result.failures,
+    warnings: result.warnings
+  }));
+  return {
+    version: RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+    evidence_present: true,
+    passed: failingRoutes.length === 0,
+    checked_routes: routeResults.length,
+    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 assessBasicGameplayRoute(route, options = {}) {
+  const maxMobileOverflowPx = options.maxMobileOverflowPx ?? 4;
+  const minBodyTextLength = options.minBodyTextLength ?? 20;
+  const minVisibleLargeNodes = options.minVisibleLargeNodes ?? 3;
+  const minSurfaceLargeNodes = options.minSurfaceLargeNodes ?? 8;
+  const warnOnMissingResetPath = options.warnOnMissingResetPath ?? true;
+  const warnOnConsoleError = options.warnOnConsoleError ?? true;
+  const failOnConsoleError = options.failOnConsoleError ?? false;
+  const failures = [];
+  const warnings = [];
+  const initial = route.initial || {};
+  const timed = route.timed || {};
+  const afterAction = route.after_action || route.afterAction || {};
+  const mobile = route.mobile || {};
+  const timedChange = changed(initial, timed);
+  const actionChange = changed(timed, afterAction);
+  const surfaceVisible = numberValue2(initial.visible_canvas_count) > 0 || numberValue2(initial.enabled_clickable_count) > 0 || numberValue2(initial.visible_large_node_count) >= minSurfaceLargeNodes;
+  const actionResults = listValue2(route.action_results || route.actionResults);
+  const actionAttempted = actionResults.some((result) => result.ok === true && result.action !== "wait");
+  const actionFailed = actionResults.some((result) => result.ok === false && result.action !== "wait");
+  const stateChangeObserved = actionChange.changed || timedChange.changed;
+  const resetPathPresent = numberValue2(initial.reset_control_count) > 0 || numberValue2(timed.reset_control_count) > 0 || numberValue2(afterAction.reset_control_count) > 0;
+  const responseStatus = firstNumber(route.http_status, route.response_status, route.status);
+  const pageErrorCount = numberValue2(route.page_error_count);
+  const consoleErrorCount = numberValue2(route.console_error_count);
+  const mobileOverflowPx = numberValue2(mobile.overflow_px);
+  if (responseStatus !== null && responseStatus >= 400) failures.push("route_http_error");
+  if (pageErrorCount > 0) failures.push("fatal_page_error");
+  if (numberValue2(initial.body_text_length) < minBodyTextLength && numberValue2(initial.visible_large_node_count) < minVisibleLargeNodes) {
+    failures.push("route_blank_or_thin");
+  }
+  if (!surfaceVisible) failures.push("no_game_surface");
+  if (mobileOverflowPx > maxMobileOverflowPx) failures.push("mobile_horizontal_overflow");
+  if (!actionAttempted && !timedChange.changed) failures.push("primary_control_missing");
+  if (actionAttempted && !stateChangeObserved) failures.push("primary_control_inert");
+  if (failOnConsoleError && consoleErrorCount > 0) failures.push("fatal_page_error");
+  if (numberValue2(initial.visible_canvas_count) > 0 && actionAttempted && !timedChange.canvas_changed && !actionChange.canvas_changed && !actionChange.screenshot_changed) {
+    warnings.push("canvas_inert");
+  }
+  if (actionFailed) warnings.push("some_actions_failed");
+  if (warnOnMissingResetPath && !resetPathPresent && route.requires_reset !== false && actionAttempted && stateChangeObserved) {
+    warnings.push("missing_reset_path");
+  }
+  if (warnOnConsoleError && consoleErrorCount > 0) warnings.push("critical_console_error");
+  return {
+    name: route.name,
+    path: route.path,
+    ok: failures.length === 0,
+    failures,
+    warnings,
+    signals: {
+      route_loaded: !failures.includes("route_http_error") && !failures.includes("route_blank_or_thin"),
+      surface_visible: surfaceVisible,
+      action_attempted: actionAttempted,
+      timed_progression_observed: timedChange.changed,
+      first_interaction_observed: actionChange.changed,
+      state_change_observed: stateChangeObserved,
+      mobile_overflow_absent: mobileOverflowPx <= maxMobileOverflowPx,
+      reset_path_present: resetPathPresent,
+      fatal_errors_absent: pageErrorCount === 0
+    },
+    diffs: {
+      timed: timedChange,
+      after_action: actionChange
+    }
+  };
+}
+function extractBasicGameplayEvidence(...sources) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    const found = findBasicGameplayEvidence(source, seen);
+    if (found) return found;
+  }
+  return null;
+}
+function findBasicGameplayEvidence(value, seen, depth = 0) {
+  if (depth > 6 || value === null || value === void 0) return null;
+  if (typeof value === "string") {
+    const parsed = parseJson2(value);
+    return parsed === null ? null : findBasicGameplayEvidence(parsed, seen, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return null;
+    seen.add(value);
+    if (value.some((item) => hasRouteShape(recordValue3(item)))) {
+      return { results: value.filter((item) => hasRouteShape(recordValue3(item))) };
+    }
+    for (const item of value) {
+      const found = findBasicGameplayEvidence(item, seen, depth + 1);
+      if (found) return found;
+    }
+    return null;
+  }
+  const record = recordValue3(value);
+  if (!record || seen.has(record)) return null;
+  seen.add(record);
+  if (record.version === RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION || Array.isArray(record.results)) {
+    return {
+      ...record,
+      results: listValue2(record.results).filter((item) => Boolean(recordValue3(item)))
+    };
+  }
+  if (hasRouteShape(record)) {
+    return { results: [record] };
+  }
+  for (const key of BASIC_GAMEPLAY_CONTAINER_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) {
+      const nested = findBasicGameplayEvidence(record[key], seen, depth + 1);
+      if (nested) return nested;
+    }
+  }
+  for (const item of Object.values(record)) {
+    const found = findBasicGameplayEvidence(item, seen, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+function hasRouteShape(record) {
+  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.action_results || record.actionResults) && (record.path || record.name));
+}
+function changed(before, after) {
+  const bodyTextChanged = Boolean(before.body_text_hash && after.body_text_hash && before.body_text_hash !== after.body_text_hash);
+  const screenshotChanged = Boolean(before.screenshot_hash && after.screenshot_hash && before.screenshot_hash !== after.screenshot_hash);
+  const beforeCanvasHashes = canvasHashes(before.canvases);
+  const afterCanvasHashes = canvasHashes(after.canvases);
+  const canvasChanged = Boolean(beforeCanvasHashes && afterCanvasHashes && beforeCanvasHashes !== afterCanvasHashes);
+  return {
+    body_text_changed: bodyTextChanged,
+    screenshot_changed: screenshotChanged,
+    canvas_changed: canvasChanged,
+    changed: bodyTextChanged || screenshotChanged || canvasChanged
+  };
+}
+function canvasHashes(canvases) {
+  return (canvases || []).map((canvas) => canvas.hash).filter(Boolean).join("|");
+}
+function countCodes(codes) {
+  const counts = {};
+  for (const code of codes) counts[code] = (counts[code] || 0) + 1;
+  return counts;
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    const number = numericValue3(value);
+    if (number !== null) return number;
+  }
+  return null;
+}
+function numberValue2(value) {
+  return numericValue3(value) ?? 0;
+}
+function numericValue3(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function recordValue3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function listValue2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function parseJson2(value) {
+  const trimmed = value.trim();
+  if (!trimmed || !/^[{[]/.test(trimmed)) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+
 // src/riddle-client.ts
 var import_node_child_process4 = require("child_process");
 var import_node_fs5 = require("fs");
@@ -7767,6 +7992,8 @@ function createRiddleApiClient(config = {}) {
   DEFAULT_DIAGNOSTIC_STRING_LIMIT,
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
   RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -7782,6 +8009,8 @@ function createRiddleApiClient(config = {}) {
   appendStageHeartbeat,
   applyPrLifecycleState,
   applyTerminalMetadata,
+  assessBasicGameplayEvidence,
+  assessBasicGameplayRoute,
   assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
@@ -7806,6 +8035,7 @@ function createRiddleApiClient(config = {}) {
   createRunState,
   createRunStatusSnapshot,
   deployRiddleStaticPreview,
+  extractBasicGameplayEvidence,
   extractPlayabilityEvidence,
   isDuplicateCheckpointResponse,
   isRiddleProofPlayabilityMode,

package/dist/index.d.cts

@@ -9,4 +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, BasicGameplayCanvasState, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayMobileEvidence, BasicGameplaySnapshot, BasicGameplayWarningCode, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayRoute, extractBasicGameplayEvidence } from './basic-gameplay.cjs';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript } from './riddle-client.cjs';

package/dist/index.d.ts

@@ -9,4 +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, BasicGameplayCanvasState, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayMobileEvidence, BasicGameplaySnapshot, BasicGameplayWarningCode, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayRoute, extractBasicGameplayEvidence } from './basic-gameplay.js';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript } from './riddle-client.js';

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  runRiddleProof
+} from "./chunk-RXFKKYWA.js";
 import "./chunk-6F4PWJZI.js";
 import {
   RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
@@ -16,8 +19,12 @@ import {
   visualSessionFingerprintBasis
 } from "./chunk-ODORKNSO.js";
 import {
-  runRiddleProof
-} from "./chunk-RXFKKYWA.js";
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
+  assessBasicGameplayEvidence,
+  assessBasicGameplayRoute,
+  extractBasicGameplayEvidence
+} from "./chunk-RNGJX62B.js";
 import {
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,
@@ -45,14 +52,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-A2AWRZ5B.js";
-import "./chunk-RFJ5BQF6.js";
-import "./chunk-JFQXAJH2.js";
-import {
-  createCodexExecAgentAdapter,
-  createCodexExecJsonRunner,
-  runCodexExecAgentDoctor
-} from "./chunk-3266V3MO.js";
+} from "./chunk-2FBF2UDZ.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -65,6 +65,7 @@ import {
   normalizeRunParams,
   setRunStatus
 } from "./chunk-MO24D3PY.js";
+import "./chunk-RFJ5BQF6.js";
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
@@ -85,6 +86,12 @@ import {
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
 } from "./chunk-33XO42CY.js";
+import "./chunk-JFQXAJH2.js";
+import {
+  createCodexExecAgentAdapter,
+  createCodexExecJsonRunner,
+  runCodexExecAgentDoctor
+} from "./chunk-3266V3MO.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -101,6 +108,8 @@ export {
   DEFAULT_DIAGNOSTIC_STRING_LIMIT,
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
   RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -116,6 +125,8 @@ export {
   appendStageHeartbeat,
   applyPrLifecycleState,
   applyTerminalMetadata,
+  assessBasicGameplayEvidence,
+  assessBasicGameplayRoute,
   assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
@@ -140,6 +151,7 @@ export {
   createRunState,
   createRunStatusSnapshot,
   deployRiddleStaticPreview,
+  extractBasicGameplayEvidence,
   extractPlayabilityEvidence,
   isDuplicateCheckpointResponse,
   isRiddleProofPlayabilityMode,

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

@@ -277,7 +277,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -362,7 +362,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -624,7 +624,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;

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

@@ -277,7 +277,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -362,7 +362,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -624,7 +624,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.54",
+  "version": "0.5.55",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",
@@ -79,6 +79,11 @@
       "import": "./dist/playability.js",
       "require": "./dist/playability.cjs"
     },
+    "./basic-gameplay": {
+      "types": "./dist/basic-gameplay.d.ts",
+      "import": "./dist/basic-gameplay.js",
+      "require": "./dist/basic-gameplay.cjs"
+    },
     "./openclaw": {
       "types": "./dist/openclaw.d.ts",
       "import": "./dist/openclaw.js",
@@ -120,7 +125,7 @@
     "typescript": "^5.4.5"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/types.ts src/result.ts src/state.ts src/checkpoint.ts src/run-card.ts src/runner.ts src/engine-harness.ts src/codex-exec-agent.ts src/local-agent.ts src/cli.ts src/diagnostics.ts src/proof-session.ts src/playability.ts src/openclaw.ts src/proof-run-core.ts src/proof-run-engine.ts src/riddle-client.ts --format cjs,esm --dts --out-dir dist --clean",
+    "build": "tsup src/index.ts src/types.ts src/result.ts src/state.ts src/checkpoint.ts src/run-card.ts src/runner.ts src/engine-harness.ts src/codex-exec-agent.ts src/local-agent.ts src/cli.ts src/diagnostics.ts src/proof-session.ts src/playability.ts src/basic-gameplay.ts src/openclaw.ts src/proof-run-core.ts src/proof-run-engine.ts src/riddle-client.ts --format cjs,esm --dts --out-dir dist --clean",
     "clean": "rm -rf dist",
     "lint": "echo 'lint: (not configured)'",
     "test": "npm run build && node test.js && node proof-run.test.js"

package/dist/{chunk-A2AWRZ5B.js → chunk-2FBF2UDZ.js}

@@ -1,8 +1,3 @@
-import {
-  visualDeltaForState,
-  visualDeltaRequiredForState,
-  visualDeltaShipGateReason
-} from "./chunk-RFJ5BQF6.js";
 import {
   appendRunEvent,
   appendStageHeartbeat,
@@ -11,6 +6,11 @@ import {
   normalizeRunParams,
   setRunStatus
 } from "./chunk-MO24D3PY.js";
+import {
+  visualDeltaForState,
+  visualDeltaRequiredForState,
+  visualDeltaShipGateReason
+} from "./chunk-RFJ5BQF6.js";
 import {
   createRiddleProofRunCard
 } from "./chunk-3UHWI3FO.js";