@riddledc/riddle-proof 0.7.132 → 0.7.134

package/README.md

@@ -401,7 +401,7 @@ transport control, or other bounded interaction. Supported setup actions are
 `assert_text_absent`, `assert_selector_count`, `assert_window_value`,
 `assert_window_number`, `local_storage`, `session_storage`, `clear_storage`,
 `clear_console`, `screenshot`, `wait`, `wait_for_selector`, `wait_for_text`,
-and `window_call`;
+`window_call`, and `window_call_until`;
 a failed setup action is recorded as a failed `setup_actions_succeeded` check so
 the profile cannot pass without reaching the intended state. Text-matched `click` actions prefer
 visible matching elements, which keeps responsive layouts from selecting hidden
@@ -447,6 +447,11 @@ errors, but keeps network mock hit evidence intact. Any setup action can include
 with `repeat_index` and `repeat_count`, and `after_ms` runs after each
 repetition. Use it for bounded game proof helpers, retry controls, or other
 workflows where one declarative action needs to advance the app several times.
+Use `window_call_until` when a proof helper needs to advance randomized or
+progressive state until a window-state receipt is true. It accepts `path` plus
+optional `args`, `until_path`, `until_expected_value`, `max_calls` from 1 to
+100, and optional `interval_ms`; the action stops early when the predicate is
+met and records `call_count`, final `returned`, and final `until_value`.
 Use `screenshot` with an optional `label` to capture durable Riddle screenshots
 at important setup milestones, such as after a route switch, terminal state, or
 reset. These labels are recorded in setup evidence and included in profile

package/dist/{chunk-PKE223TX.js → chunk-TALHK3NV.js}

@@ -61,7 +61,8 @@ var RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES = [
   "wait",
   "wait_for_selector",
   "wait_for_text",
-  "window_call"
+  "window_call",
+  "window_call_until"
 ];
 var RIDDLE_PROOF_PROFILE_NETWORK_ABORT_ERROR_CODES = [
   "aborted",
@@ -451,6 +452,19 @@ function profileSetupActionCounts(results) {
 function profileSetupScreenshotLabels(results) {
   return results.filter((result) => profileSetupResultAction(result) === "screenshot" && result.ok !== false && typeof result.screenshot_label === "string").map((result) => result.screenshot_label).filter(Boolean);
 }
+function profileSetupWindowCallUntilReceipts(results) {
+  return results.filter((result) => profileSetupResultAction(result) === "window_call_until").map((result) => ({
+    ordinal: result.ordinal ?? null,
+    ok: result.ok !== false,
+    path: result.path ?? null,
+    until_path: result.until_path ?? null,
+    until_value: result.until_value ?? null,
+    until_expected_value: result.until_expected_value ?? null,
+    call_count: result.call_count ?? null,
+    max_calls: result.max_calls ?? null,
+    reason: result.reason ?? result.error ?? null
+  }));
+}
 function sampleProfileSetupSummaryItems(items, limit) {
   if (items.length <= limit) return items;
   const firstCount = Math.floor(limit / 2);
@@ -476,6 +490,9 @@ function profileSetupSummary(viewports, actionCount, expectedActionCountByViewpo
       const optionalFailed = results.filter((result) => result.ok === false && result.optional === true);
       const successfulClicks = results.filter((result) => profileSetupResultAction(result) === "click" && result.ok !== false);
       const clickCountValues = successfulClicks.map((result) => typeof result.click_count === "number" && Number.isFinite(result.click_count) && result.click_count > 1 ? result.click_count : void 0).filter((value) => value !== void 0);
+      const windowCallUntilReceipts = profileSetupWindowCallUntilReceipts(results);
+      const windowCallUntilCallCounts = windowCallUntilReceipts.map((result) => typeof result.call_count === "number" && Number.isFinite(result.call_count) ? result.call_count : void 0).filter((value) => value !== void 0);
+      const sampledWindowCallUntilReceipts = sampleProfileSetupSummaryItems(windowCallUntilReceipts, 8);
       const clickedItems = results.filter((result) => profileSetupResultAction(result) === "click" && result.ok !== false).map((result) => {
         const clickCount = typeof result.click_count === "number" && Number.isFinite(result.click_count) && result.click_count > 1 ? result.click_count : void 0;
         return {
@@ -508,6 +525,10 @@ function profileSetupSummary(viewports, actionCount, expectedActionCountByViewpo
         clicked_truncated: clickedItems.length > clicked.length,
         click_count_action_total: clickCountValues.length,
         click_count_value_total: clickCountValues.reduce((sum, value) => sum + value, 0),
+        window_call_until_total: windowCallUntilReceipts.length,
+        window_call_until_call_total: windowCallUntilCallCounts.reduce((sum, value) => sum + value, 0),
+        window_call_until_truncated: windowCallUntilReceipts.length > sampledWindowCallUntilReceipts.length,
+        window_call_until: sampledWindowCallUntilReceipts,
         clicked,
         text_samples,
         failed: failed.map((result) => ({
@@ -560,7 +581,7 @@ function isSupportedCheckType(value) {
 }
 function normalizeSetupActionType(value, index) {
   const normalizedInput = String(value || "").trim().replace(/-/g, "_");
-  const normalized = normalizedInput === "clear_browser_storage" ? "clear_storage" : normalizedInput === "reset_console" || normalizedInput === "clear_browser_console" || normalizedInput === "reset_browser_console" ? "clear_console" : normalizedInput === "pointer_drag" || normalizedInput === "mouse_drag" || normalizedInput === "drag_to" ? "drag" : normalizedInput === "keyboard_press" || normalizedInput === "key_press" ? "press" : normalizedInput === "capture_screenshot" || normalizedInput === "save_screenshot" || normalizedInput === "setup_screenshot" ? "screenshot" : normalizedInput === "accept_dialog" || normalizedInput === "accept_dialogs" || normalizedInput === "confirm_dialog" || normalizedInput === "set_dialog_response" ? "dialog_response" : normalizedInput === "dismiss_dialog" || normalizedInput === "dismiss_dialogs" || normalizedInput === "cancel_dialog" ? "dialog_response" : normalizedInput;
+  const normalized = normalizedInput === "clear_browser_storage" ? "clear_storage" : normalizedInput === "reset_console" || normalizedInput === "clear_browser_console" || normalizedInput === "reset_browser_console" ? "clear_console" : normalizedInput === "pointer_drag" || normalizedInput === "mouse_drag" || normalizedInput === "drag_to" ? "drag" : normalizedInput === "keyboard_press" || normalizedInput === "key_press" ? "press" : normalizedInput === "capture_screenshot" || normalizedInput === "save_screenshot" || normalizedInput === "setup_screenshot" ? "screenshot" : normalizedInput === "accept_dialog" || normalizedInput === "accept_dialogs" || normalizedInput === "confirm_dialog" || normalizedInput === "set_dialog_response" ? "dialog_response" : normalizedInput === "dismiss_dialog" || normalizedInput === "dismiss_dialogs" || normalizedInput === "cancel_dialog" ? "dialog_response" : normalizedInput === "window_call_until" || normalizedInput === "call_until" || normalizedInput === "window_call_repeat_until" || normalizedInput === "repeat_window_call_until" ? "window_call_until" : normalizedInput;
   if (RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES.includes(normalized)) {
     return normalized;
   }
@@ -691,10 +712,10 @@ function normalizeSetupAction(input, index) {
     throw new Error(`target.setup_actions[${index}] ${type} requires value.`);
   }
   const path = stringFromOwn(input, "path", "function_path", "functionPath", "window_path", "windowPath", "state_path", "statePath");
-  if ((type === "window_call" || type === "assert_window_value" || type === "assert_window_number") && !path) {
+  if ((type === "window_call" || type === "window_call_until" || type === "assert_window_value" || type === "assert_window_number") && !path) {
     throw new Error(`target.setup_actions[${index}] ${type} requires path.`);
   }
-  const args = type === "window_call" ? normalizeSetupActionArgs(input, index) : void 0;
+  const args = type === "window_call" || type === "window_call_until" ? normalizeSetupActionArgs(input, index) : void 0;
   const hasExpectedValue = hasOwn(input, "expected_value") || hasOwn(input, "expectedValue") || hasOwn(input, "expected") || hasOwn(input, "expect_value") || hasOwn(input, "expectValue") || hasOwn(input, "expect");
   if (type === "assert_window_value" && !hasExpectedValue) {
     throw new Error(`target.setup_actions[${index}] ${type} requires expected_value.`);
@@ -711,6 +732,24 @@ function normalizeSetupAction(input, index) {
     }
   }
   const hasExpectedReturn = hasOwn(input, "expect_return") || hasOwn(input, "expectReturn") || hasOwn(input, "expected_return") || hasOwn(input, "expectedReturn");
+  const untilPath = stringFromOwn(input, "until_path", "untilPath", "until_state_path", "untilStatePath", "until_window_path", "untilWindowPath", "until");
+  const hasUntilExpectedValue = hasOwn(input, "until_expected_value") || hasOwn(input, "untilExpectedValue") || hasOwn(input, "until_expected") || hasOwn(input, "untilExpected") || hasOwn(input, "until_value") || hasOwn(input, "untilValue") || hasOwn(input, "expected_value") || hasOwn(input, "expectedValue") || hasOwn(input, "expected");
+  if (type === "window_call_until") {
+    if (!untilPath) {
+      throw new Error(`target.setup_actions[${index}] ${type} requires until_path.`);
+    }
+    if (!hasUntilExpectedValue) {
+      throw new Error(`target.setup_actions[${index}] ${type} requires until_expected_value.`);
+    }
+  }
+  const maxCalls = numberValue(valueFromOwn(input, "max_calls", "maxCalls", "max_attempts", "maxAttempts", "attempts"));
+  if (type === "window_call_until" && (maxCalls === void 0 || !Number.isInteger(maxCalls) || maxCalls < 1 || maxCalls > 100)) {
+    throw new Error(`target.setup_actions[${index}].max_calls must be an integer from 1 to 100.`);
+  }
+  const intervalMs = numberValue(valueFromOwn(input, "interval_ms", "intervalMs", "poll_ms", "pollMs", "call_interval_ms", "callIntervalMs"));
+  if (type === "window_call_until" && intervalMs !== void 0 && (!Number.isInteger(intervalMs) || intervalMs < 0 || intervalMs > 5e3)) {
+    throw new Error(`target.setup_actions[${index}].interval_ms must be an integer from 0 to 5000.`);
+  }
   const steps = numberValue(input.steps);
   if (type === "drag" && steps !== void 0 && (!Number.isInteger(steps) || steps < 1 || steps > 100)) {
     throw new Error(`target.setup_actions[${index}].steps must be an integer from 1 to 100.`);
@@ -737,6 +776,10 @@ function normalizeSetupAction(input, index) {
     path,
     args,
     expect_return: hasExpectedReturn ? toJsonValue(valueFromOwn(input, "expect_return", "expectReturn", "expected_return", "expectedReturn")) : void 0,
+    until_path: untilPath,
+    until_expected_value: hasUntilExpectedValue ? toJsonValue(valueFromOwn(input, "until_expected_value", "untilExpectedValue", "until_expected", "untilExpected", "until_value", "untilValue", "expected_value", "expectedValue", "expected")) : void 0,
+    max_calls: maxCalls,
+    interval_ms: intervalMs,
     expected_value: hasExpectedValue ? toJsonValue(rawExpectedValue) : void 0,
     min_value: minValue,
     max_value: maxValue,
@@ -4613,6 +4656,34 @@ async function setupReadWindowValue(context, path) {
     return { ok: true, value: toJsonValue(current) };
   }, { path });
 }
+async function setupCallWindowFunction(context, path, args) {
+  return await context.evaluate(async ({ path, args }) => {
+    const toJsonValue = (value) => {
+      if (value === null || value === undefined) return null;
+      if (typeof value === "string" || typeof value === "boolean") return value;
+      if (typeof value === "number") return Number.isFinite(value) ? value : null;
+      if (Array.isArray(value)) return value.map(toJsonValue);
+      if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJsonValue(child)]));
+      }
+      return String(value);
+    };
+    const pathParts = String(path || "").split(".").map((part) => part.trim()).filter(Boolean);
+    let parent = window;
+    let current = window;
+    for (const part of pathParts) {
+      parent = current;
+      current = current?.[part];
+    }
+    if (typeof current !== "function") return { ok: false, reason: "missing_function" };
+    try {
+      const returned = await current.apply(parent, Array.isArray(args) ? args : []);
+      return { ok: true, returned: toJsonValue(returned) };
+    } catch (error) {
+      return { ok: false, reason: "function_threw", error: String(error && error.message ? error.message : error).slice(0, 1000) };
+    }
+  }, { path, args });
+}
 function setupFrameSelector(action) {
   return String(action?.frame_selector || action?.frameSelector || action?.iframe_selector || action?.iframeSelector || "").trim();
 }
@@ -5130,32 +5201,7 @@ async function executeSetupAction(action, ordinal, viewport) {
       if (!path) return { ...base, path, reason: "missing_path" };
       const scope = await setupActionScope(action, timeout);
       if (!scope.ok) return setupScopeFailure(base, scope);
-      const result = await scope.context.evaluate(async ({ path, args }) => {
-        const toJsonValue = (value) => {
-          if (value === null || value === undefined) return null;
-          if (typeof value === "string" || typeof value === "boolean") return value;
-          if (typeof value === "number") return Number.isFinite(value) ? value : null;
-          if (Array.isArray(value)) return value.map(toJsonValue);
-          if (typeof value === "object") {
-            return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJsonValue(child)]));
-          }
-          return String(value);
-        };
-        const pathParts = String(path || "").split(".").map((part) => part.trim()).filter(Boolean);
-        let parent = window;
-        let current = window;
-        for (const part of pathParts) {
-          parent = current;
-          current = current?.[part];
-        }
-        if (typeof current !== "function") return { ok: false, reason: "missing_function" };
-        try {
-          const returned = await current.apply(parent, Array.isArray(args) ? args : []);
-          return { ok: true, returned: toJsonValue(returned) };
-        } catch (error) {
-          return { ok: false, reason: "function_threw", error: String(error && error.message ? error.message : error).slice(0, 1000) };
-        }
-      }, { path, args });
+      const result = await setupCallWindowFunction(scope.context, path, args);
       const hasExpectation = setupHasOwn(action, "expect_return")
         || setupHasOwn(action, "expectReturn")
         || setupHasOwn(action, "expected_return")
@@ -5180,6 +5226,126 @@ async function executeSetupAction(action, ordinal, viewport) {
         error: result.error || undefined,
       };
     }
+    if (type === "window_call_until") {
+      const path = String(action.path || action.function_path || action.functionPath || "");
+      const untilPath = String(action.until_path || action.untilPath || action.until_state_path || action.untilStatePath || action.until_window_path || action.untilWindowPath || action.until || "");
+      const args = Array.isArray(action.args) ? action.args : [];
+      if (!path) return { ...base, path, reason: "missing_path" };
+      if (!untilPath) return { ...base, path, reason: "missing_until_path" };
+      const hasUntilExpected = setupHasOwn(action, "until_expected_value")
+        || setupHasOwn(action, "untilExpectedValue")
+        || setupHasOwn(action, "until_expected")
+        || setupHasOwn(action, "untilExpected")
+        || setupHasOwn(action, "until_value")
+        || setupHasOwn(action, "untilValue")
+        || setupHasOwn(action, "expected_value")
+        || setupHasOwn(action, "expectedValue")
+        || setupHasOwn(action, "expected");
+      const untilExpected = setupHasOwn(action, "until_expected_value")
+        ? action.until_expected_value
+        : setupHasOwn(action, "untilExpectedValue")
+          ? action.untilExpectedValue
+          : setupHasOwn(action, "until_expected")
+            ? action.until_expected
+            : setupHasOwn(action, "untilExpected")
+              ? action.untilExpected
+              : setupHasOwn(action, "until_value")
+                ? action.until_value
+                : setupHasOwn(action, "untilValue")
+                  ? action.untilValue
+                  : setupHasOwn(action, "expected_value")
+                    ? action.expected_value
+                    : setupHasOwn(action, "expectedValue")
+                      ? action.expectedValue
+                      : action.expected;
+      if (!hasUntilExpected) return { ...base, path, until_path: untilPath, reason: "missing_until_expected_value" };
+      const maxCalls = Math.min(100, Math.max(1, Math.floor(setupNumber(action.max_calls ?? action.maxCalls ?? action.max_attempts ?? action.maxAttempts ?? action.attempts, 1) || 1)));
+      const intervalMs = Math.min(5000, Math.max(0, Math.floor(setupNumber(action.interval_ms ?? action.intervalMs ?? action.poll_ms ?? action.pollMs ?? action.call_interval_ms ?? action.callIntervalMs, 100) || 0)));
+      const hasReturnExpectation = setupHasOwn(action, "expect_return")
+        || setupHasOwn(action, "expectReturn")
+        || setupHasOwn(action, "expected_return")
+        || setupHasOwn(action, "expectedReturn");
+      const expectedReturn = setupHasOwn(action, "expect_return")
+        ? action.expect_return
+        : setupHasOwn(action, "expectReturn")
+          ? action.expectReturn
+          : setupHasOwn(action, "expected_return")
+            ? action.expected_return
+            : action.expectedReturn;
+      const scope = await setupActionScope(action, timeout);
+      if (!scope.ok) return setupScopeFailure(base, scope);
+      const startedAt = Date.now();
+      let callCount = 0;
+      let lastCallResult = null;
+      let lastPredicateResult = await setupReadWindowValue(scope.context, untilPath);
+      if (lastPredicateResult.ok && setupValuesEqual(lastPredicateResult.value, untilExpected)) {
+        return {
+          ...base,
+          ...setupScopeEvidence(scope),
+          ok: true,
+          path,
+          arg_count: args.length,
+          until_path: untilPath,
+          until_value: setupJsonValue(lastPredicateResult.value),
+          until_expected_value: setupJsonValue(untilExpected),
+          call_count: callCount,
+          max_calls: maxCalls,
+          interval_ms: intervalMs,
+          timeout_ms: timeout,
+        };
+      }
+      while (callCount < maxCalls && Date.now() - startedAt <= timeout) {
+        lastCallResult = await setupCallWindowFunction(scope.context, path, args);
+        callCount += 1;
+        if (!lastCallResult.ok) break;
+        if (hasReturnExpectation && !setupValuesEqual(lastCallResult.returned, expectedReturn)) break;
+        lastPredicateResult = await setupReadWindowValue(scope.context, untilPath);
+        if (lastPredicateResult.ok && setupValuesEqual(lastPredicateResult.value, untilExpected)) {
+          return {
+            ...base,
+            ...setupScopeEvidence(scope),
+            ok: true,
+            path,
+            arg_count: args.length,
+            returned: setupJsonValue(lastCallResult.returned),
+            expected_return: hasReturnExpectation ? setupJsonValue(expectedReturn) : undefined,
+            until_path: untilPath,
+            until_value: setupJsonValue(lastPredicateResult.value),
+            until_expected_value: setupJsonValue(untilExpected),
+            call_count: callCount,
+            max_calls: maxCalls,
+            interval_ms: intervalMs,
+            timeout_ms: timeout,
+          };
+        }
+        if (callCount < maxCalls && intervalMs) await page.waitForTimeout(intervalMs);
+      }
+      const returnExpectationMet = !hasReturnExpectation || setupValuesEqual(lastCallResult?.returned, expectedReturn);
+      return {
+        ...base,
+        ...setupScopeEvidence(scope),
+        path,
+        arg_count: args.length,
+        returned: setupJsonValue(lastCallResult?.returned),
+        expected_return: hasReturnExpectation ? setupJsonValue(expectedReturn) : undefined,
+        until_path: untilPath,
+        until_value: setupJsonValue(lastPredicateResult?.value),
+        until_expected_value: setupJsonValue(untilExpected),
+        call_count: callCount,
+        max_calls: maxCalls,
+        interval_ms: intervalMs,
+        timeout_ms: timeout,
+        reason: lastCallResult && !lastCallResult.ok
+          ? lastCallResult.reason
+          : hasReturnExpectation && !returnExpectationMet
+            ? "unexpected_return_value"
+            : Date.now() - startedAt > timeout
+              ? "timeout"
+              : "until_condition_not_met",
+        error: lastCallResult?.error || undefined,
+        missing_part: lastPredicateResult?.missing_part || undefined,
+      };
+    }
     if (type === "assert_window_value") {
       const path = String(action.path || action.window_path || action.windowPath || "");
       const hasExpected = setupHasOwn(action, "expected_value")