@riddledc/riddle-proof 0.7.225 → 0.7.227

package/dist/chunk-BTN76IGW.js

@@ -0,0 +1,115 @@
+import {
+  normalizeIntegrationContext,
+  normalizeRunParams
+} from "./chunk-OHJQRDST.js";
+import {
+  compactRecord
+} from "./chunk-VY4Y5U57.js";
+
+// src/openclaw.ts
+function parseOpenClawAssertions(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return trimmed;
+  }
+}
+function parseOpenClawJsonObjectOrArray(value, name) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${name} is not valid JSON: ${message}`);
+  }
+  if (parsed === null || typeof parsed !== "object" && !Array.isArray(parsed)) {
+    throw new Error(`${name} must decode to a JSON object or array.`);
+  }
+  return parsed;
+}
+function normalizeOpenClawReference(value) {
+  if (value !== "prod" && value !== "before" && value !== "both") return void 0;
+  return value;
+}
+function ignoredOpenClawReference(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return normalizeOpenClawReference(value) ? void 0 : String(value);
+}
+function openClawIntegrationContext(params) {
+  const hasDiscordContext = Boolean(params.discord_channel || params.discord_thread_id || params.discord_message_id || params.discord_source_url);
+  return normalizeIntegrationContext({
+    source: hasDiscordContext ? "discord" : "openclaw",
+    channel_id: params.discord_channel,
+    thread_id: params.discord_thread_id,
+    message_id: params.discord_message_id,
+    source_url: params.discord_source_url,
+    metadata: compactRecord({
+      wrapper: "openclaw",
+      tool: "riddle_proof_change",
+      reference_input_ignored: ignoredOpenClawReference(params.reference)
+    })
+  }, "openclaw");
+}
+function toRiddleProofRunParams(params) {
+  return normalizeRunParams({
+    repo: params.repo,
+    branch: params.branch,
+    change_request: params.change_request,
+    commit_message: params.commit_message,
+    prod_url: params.prod_url,
+    capture_script: params.capture_script,
+    success_criteria: params.success_criteria,
+    assertions: parseOpenClawAssertions(params.assertions_json),
+    verification_mode: params.verification_mode,
+    resume_session: params.resume_session,
+    target_image_url: params.target_image_url,
+    target_image_hash: params.target_image_hash,
+    viewport_matrix: parseOpenClawJsonObjectOrArray(params.viewport_matrix_json, "viewport_matrix_json"),
+    deterministic_setup: parseOpenClawJsonObjectOrArray(params.deterministic_setup_json, "deterministic_setup_json"),
+    reference: normalizeOpenClawReference(params.reference),
+    base_branch: params.base_branch,
+    before_ref: params.before_ref,
+    allow_static_preview_fallback: params.allow_static_preview_fallback,
+    context: params.context,
+    reviewer: params.reviewer,
+    mode: params.mode,
+    implementation_mode: params.implementation_mode,
+    require_diff: params.require_diff,
+    allow_code_changes: params.allow_code_changes,
+    build_command: params.build_command,
+    build_output: params.build_output,
+    server_image: params.server_image,
+    server_command: params.server_command,
+    server_port: params.server_port,
+    server_path: params.server_path,
+    use_auth: params.use_auth,
+    auth_localStorage_json: params.auth_localStorage_json,
+    auth_cookies_json: params.auth_cookies_json,
+    auth_headers_json: params.auth_headers_json,
+    color_scheme: params.color_scheme,
+    wait_for_selector: params.wait_for_selector,
+    ship_mode: params.ship_mode || (params.ship_after_verify ? "ship" : void 0),
+    leave_draft: params.leave_draft,
+    engine_state_path: params.state_path,
+    harness_state_path: params.harness_state_path,
+    max_iterations: params.max_iterations,
+    auto_approve: params.auto_approve,
+    dry_run: params.dry_run,
+    integration_context: openClawIntegrationContext(params)
+  });
+}
+
+export {
+  parseOpenClawAssertions,
+  parseOpenClawJsonObjectOrArray,
+  openClawIntegrationContext,
+  toRiddleProofRunParams
+};

package/dist/{chunk-TGHTM66Z.js → chunk-COERZX63.js}

@@ -6,12 +6,19 @@ import {
 } from "./chunk-OHJQRDST.js";
 import {
   noImplementationModeFor
-} from "./chunk-GBVEQQIM.js";
+} from "./chunk-TJ63IE65.js";
 import {
   createRunResult
 } from "./chunk-VY4Y5U57.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
 
 // src/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  runRiddleProof: () => runRiddleProof
+});
 function errorDetails(error) {
   if (error instanceof Error) {
     return {
@@ -506,5 +513,6 @@ async function runRiddleProof(input) {
 }
 
 export {
-  runRiddleProof
+  runRiddleProof,
+  runner_exports
 };

package/dist/{chunk-4DRRIJDX.js → chunk-IWLQQ5S5.js}

@@ -14,7 +14,7 @@ import {
   visualDeltaForState,
   visualDeltaRequiredForState,
   visualDeltaShipGateReason
-} from "./chunk-GBVEQQIM.js";
+} from "./chunk-TJ63IE65.js";
 import {
   authorPacketPayloadFromCheckpointResponse,
   buildCheckpointPacketForEngineResult,
@@ -33,8 +33,17 @@ import {
   normalizeTerminalMetadata,
   recordValue
 } from "./chunk-VY4Y5U57.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
 
 // src/engine-harness.ts
+var engine_harness_exports = {};
+__export(engine_harness_exports, {
+  createDisabledRiddleProofAgentAdapter: () => createDisabledRiddleProofAgentAdapter,
+  readRiddleProofRunStatus: () => readRiddleProofRunStatus,
+  runRiddleProofEngineHarness: () => runRiddleProofEngineHarness
+});
 import { execFileSync } from "child_process";
 import {
   existsSync,
@@ -235,6 +244,16 @@ function baseContinuation(result) {
     continue_from_checkpoint: true
   };
 }
+function carryRequestControlFlags(params, request) {
+  if (!noImplementationModeFor(request)) return params;
+  return compactRecord({
+    ...params,
+    mode: request.mode,
+    implementation_mode: request.implementation_mode || "none",
+    require_diff: request.require_diff ?? false,
+    allow_code_changes: request.allow_code_changes ?? false
+  });
+}
 function initialRunParams(request, input, state) {
   return compactRecord({
     action: "run",
@@ -1389,7 +1408,10 @@ async function runRiddleProofEngineHarness(input) {
       message
     });
   }
-  let nextParams = input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state);
+  let nextParams = carryRequestControlFlags(
+    input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state),
+    request
+  );
   let lastResult = null;
   const stageIterations = {};
   for (let index = 0; index < maxIterations; index += 1) {
@@ -1502,7 +1524,7 @@ async function runRiddleProofEngineHarness(input) {
         message: "The harness route returned no next step."
       });
     }
-    nextParams = routed.next;
+    nextParams = carryRequestControlFlags(routed.next, request);
   }
   return blockerResult(state, lastResult, {
     code: "max_iterations_reached",
@@ -1519,5 +1541,6 @@ async function runRiddleProofEngineHarness(input) {
 export {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
-  runRiddleProofEngineHarness
+  runRiddleProofEngineHarness,
+  engine_harness_exports
 };

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/{chunk-GBVEQQIM.js → chunk-TJ63IE65.js}

@@ -1,4 +1,38 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
 // src/proof-run-core.ts
+var proof_run_core_exports = {};
+__export(proof_run_core_exports, {
+  BUNDLED_RIDDLE_PROOF_DIR: () => BUNDLED_RIDDLE_PROOF_DIR,
+  CHECKPOINT_CONTRACT_VERSION: () => CHECKPOINT_CONTRACT_VERSION,
+  RIDDLE_PROOF_DIR_CANDIDATES: () => RIDDLE_PROOF_DIR_CANDIDATES,
+  WORKFLOW_STAGE_ORDER: () => WORKFLOW_STAGE_ORDER,
+  buildCheckpointContract: () => buildCheckpointContract,
+  buildSetupArgs: () => buildSetupArgs,
+  checkpointContinueStage: () => checkpointContinueStage,
+  clearStageDecisionRequest: () => clearStageDecisionRequest,
+  ensureAction: () => ensureAction,
+  ensureStageLoopState: () => ensureStageLoopState,
+  invalidateVerifyEvidence: () => invalidateVerifyEvidence,
+  mergeStateFromParams: () => mergeStateFromParams,
+  noImplementationModeFor: () => noImplementationModeFor,
+  previewModeFromWorkflowMode: () => previewModeFromWorkflowMode,
+  readState: () => readState,
+  recordStageAttempt: () => recordStageAttempt,
+  requiredBaselineLabelsForState: () => requiredBaselineLabelsForState,
+  resolveConfig: () => resolveConfig,
+  resolveRiddleProofDir: () => resolveRiddleProofDir,
+  setStageDecisionRequest: () => setStageDecisionRequest,
+  summarizeState: () => summarizeState,
+  validateShipGate: () => validateShipGate,
+  visualDeltaForState: () => visualDeltaForState,
+  visualDeltaRequiredForState: () => visualDeltaRequiredForState,
+  visualDeltaShipGateReason: () => visualDeltaShipGateReason,
+  workflowFile: () => workflowFile,
+  writeState: () => writeState
+});
 import { readFileSync, existsSync, writeFileSync } from "fs";
 import { randomUUID } from "crypto";
 import path from "path";
@@ -1018,5 +1052,6 @@ export {
   validateShipGate,
   buildCheckpointContract,
   mergeStateFromParams,
-  summarizeState
+  summarizeState,
+  proof_run_core_exports
 };