@riddledc/riddle-proof 0.7.26 → 0.7.28

package/dist/cli.cjs

@@ -6895,6 +6895,9 @@ var RIDDLE_PROOF_PROFILE_CHECK_TYPES = [
 ];
 var RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES = [
   "click",
+  "fill",
+  "set_input_value",
+  "local_storage",
   "wait",
   "wait_for_selector",
   "wait_for_text"
@@ -6908,6 +6911,18 @@ function isRecord(value) {
 function stringValue2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function stringFromOwn(input, ...keys) {
+  for (const key of keys) {
+    if (hasOwn(input, key)) {
+      const value = input[key];
+      if (value !== void 0 && value !== null) return String(value);
+    }
+  }
+  return void 0;
+}
 function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -6992,6 +7007,11 @@ function jsonRecord(value) {
   if (!isRecord(value)) return void 0;
   return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJsonValue(child)]));
 }
+function stringRecord(value) {
+  if (!isRecord(value)) return void 0;
+  const entries = Object.entries(value).map(([key, child]) => [key, String(child)]).filter(([key]) => key.trim());
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
 function toJsonValue(value) {
   if (value === null || value === void 0) return null;
   if (typeof value === "string" || typeof value === "boolean") return value;
@@ -7039,15 +7059,30 @@ function normalizeSetupAction(input, index) {
   if (!isRecord(input)) throw new Error(`target.setup_actions[${index}] must be an object.`);
   const type = normalizeSetupActionType(stringValue2(input.type), index);
   const selector = stringValue2(input.selector);
-  if ((type === "click" || type === "wait_for_selector" || type === "wait_for_text") && !selector) {
+  if ((type === "click" || type === "fill" || type === "set_input_value" || type === "wait_for_selector" || type === "wait_for_text") && !selector) {
     throw new Error(`target.setup_actions[${index}] ${type} requires selector.`);
   }
   if (type === "wait_for_text" && !stringValue2(input.text) && !stringValue2(input.pattern)) {
     throw new Error(`target.setup_actions[${index}] wait_for_text requires text or pattern.`);
   }
+  const value = stringFromOwn(input, "value", "input_value", "inputValue");
+  const hasJsonValue = hasOwn(input, "value_json") || hasOwn(input, "valueJson") || hasOwn(input, "json");
+  if ((type === "fill" || type === "set_input_value") && value === void 0 && !hasJsonValue) {
+    throw new Error(`target.setup_actions[${index}] ${type} requires value.`);
+  }
+  const key = stringValue2(input.key);
+  if (type === "local_storage" && !key) {
+    throw new Error(`target.setup_actions[${index}] local_storage requires key.`);
+  }
+  if (type === "local_storage" && value === void 0 && !hasJsonValue) {
+    throw new Error(`target.setup_actions[${index}] local_storage requires value.`);
+  }
   return {
     type,
     selector,
+    key,
+    value,
+    value_json: hasJsonValue ? toJsonValue(input.value_json ?? input.valueJson ?? input.json) : void 0,
     text: stringValue2(input.text),
     pattern: stringValue2(input.pattern),
     flags: stringValue2(input.flags),
@@ -7055,6 +7090,7 @@ function normalizeSetupAction(input, index) {
     ms: numberValue(input.ms) ?? numberValue(input.wait_ms) ?? numberValue(input.waitMs),
     timeout_ms: numberValue(input.timeout_ms) ?? numberValue(input.timeoutMs),
     after_ms: numberValue(input.after_ms) ?? numberValue(input.afterMs),
+    reload: input.reload === true,
     continue_on_failure: input.continue_on_failure === true || input.continueOnFailure === true
   };
 }
@@ -7063,6 +7099,33 @@ function normalizeSetupActions(value) {
   if (!Array.isArray(value)) throw new Error("target.setup_actions must be an array.");
   return value.map(normalizeSetupAction);
 }
+function normalizeNetworkMock(input, index) {
+  if (!isRecord(input)) throw new Error(`target.network_mocks[${index}] must be an object.`);
+  const url = stringValue2(input.url) || stringValue2(input.glob) || stringValue2(input.pattern);
+  if (!url) throw new Error(`target.network_mocks[${index}] requires url.`);
+  const status = numberValue(input.status) ?? 200;
+  if (!Number.isInteger(status) || status < 100 || status > 599) {
+    throw new Error(`target.network_mocks[${index}].status must be an HTTP status code.`);
+  }
+  const body = stringValue2(input.body) ?? stringValue2(input.body_text) ?? stringValue2(input.bodyText);
+  const hasJsonBody = Object.prototype.hasOwnProperty.call(input, "body_json") || Object.prototype.hasOwnProperty.call(input, "bodyJson") || Object.prototype.hasOwnProperty.call(input, "json");
+  return {
+    label: normalizeName(input.label || input.name, `network-mock-${index + 1}`),
+    url,
+    method: stringValue2(input.method)?.toUpperCase(),
+    status,
+    content_type: stringValue2(input.content_type) || stringValue2(input.contentType),
+    headers: stringRecord(input.headers),
+    body,
+    body_json: hasJsonBody ? toJsonValue(input.body_json ?? input.bodyJson ?? input.json) : void 0,
+    required: input.required === false ? false : true
+  };
+}
+function normalizeNetworkMocks(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new Error("target.network_mocks must be an array.");
+  return value.map(normalizeNetworkMock);
+}
 function normalizeCheck(input, index) {
   if (!isRecord(input)) throw new Error(`checks[${index}] must be an object.`);
   const type = stringValue2(input.type);
@@ -7132,7 +7195,8 @@ function normalizeRiddleProofProfile(input, options = {}) {
       timeout_sec: timeoutSecValue(targetInput.timeout_sec) ?? timeoutSecValue(targetInput.timeoutSec) ?? timeoutSecValue(targetInput.riddle_timeout_sec) ?? timeoutSecValue(targetInput.riddleTimeoutSec),
       wait_for_selector: stringValue2(targetInput.wait_for_selector) || stringValue2(targetInput.waitForSelector),
       wait_ms: numberValue(targetInput.wait_ms) ?? numberValue(targetInput.waitMs),
-      setup_actions: normalizeSetupActions(targetInput.setup_actions ?? targetInput.setupActions)
+      setup_actions: normalizeSetupActions(targetInput.setup_actions ?? targetInput.setupActions),
+      network_mocks: normalizeNetworkMocks(targetInput.network_mocks ?? targetInput.networkMocks)
     },
     checks,
     artifacts: Array.isArray(input.artifacts) ? input.artifacts.map((item) => String(item)).filter(Boolean) : ["screenshot", "console", "dom_summary", "proof_json"],
@@ -7404,6 +7468,50 @@ function assessSetupActionsFromEvidence(profile, evidence) {
     message: failed.length ? `Setup actions failed in ${failed.length} viewport action(s).` : void 0
   };
 }
+function assessNetworkMocksFromEvidence(profile, evidence) {
+  const mocks = profile.target.network_mocks || [];
+  if (!mocks.length) return void 0;
+  const events = evidence.network_mocks || [];
+  const failed = [];
+  const requiredMocks = mocks.filter((mock) => mock.required !== false);
+  for (const mock of requiredMocks) {
+    const hits = events.filter((event) => event.label === mock.label && event.ok !== false).length;
+    if (hits < 1) {
+      failed.push({
+        label: mock.label,
+        url: mock.url,
+        method: mock.method || null,
+        reason: "required_mock_not_hit"
+      });
+    }
+  }
+  for (const event of events) {
+    if (event.ok === false) {
+      failed.push({
+        label: event.label ?? null,
+        url: event.url ?? null,
+        method: event.method ?? null,
+        reason: event.reason ?? event.error ?? "mock_failed"
+      });
+    }
+  }
+  return {
+    type: "network_mocks_succeeded",
+    label: "network mocks succeeded",
+    status: failed.length ? "failed" : "passed",
+    evidence: {
+      mock_count: mocks.length,
+      required_count: requiredMocks.length,
+      hit_count: events.filter((event) => event.ok !== false).length,
+      hits_by_label: Object.fromEntries(mocks.map((mock) => [
+        mock.label,
+        events.filter((event) => event.label === mock.label && event.ok !== false).length
+      ])),
+      failed
+    },
+    message: failed.length ? `Network mocks failed or were not hit for ${failed.length} mock(s).` : void 0
+  };
+}
 function profileStatusFromEvidence(profile, evidence, checks) {
   if (!evidence) return "proof_insufficient";
   const viewports = evidence.viewports || [];
@@ -7418,6 +7526,7 @@ function profileStatusFromEvidence(profile, evidence, checks) {
 function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
   const capturedAt = evidence?.captured_at || (/* @__PURE__ */ new Date()).toISOString();
   const checks = evidence ? [
+    assessNetworkMocksFromEvidence(profile, evidence),
     assessSetupActionsFromEvidence(profile, evidence),
     ...profile.checks.map((check) => assessCheckFromEvidence(check, evidence))
   ].filter((check) => Boolean(check)) : [];
@@ -7618,6 +7727,49 @@ function horizontalBoundsOverflowPx(value) {
 function assessProfile(profile, evidence) {
   const checks = [];
   const viewports = evidence.viewports || [];
+  if (profile.target && Array.isArray(profile.target.network_mocks) && profile.target.network_mocks.length) {
+    const events = evidence.network_mocks || [];
+    const requiredMocks = profile.target.network_mocks.filter((mock) => mock && mock.required !== false);
+    const failed = [];
+    for (const mock of requiredMocks) {
+      const hits = events.filter((event) => event && event.label === mock.label && event.ok !== false).length;
+      if (hits < 1) {
+        failed.push({
+          label: mock.label,
+          url: mock.url,
+          method: mock.method || null,
+          reason: "required_mock_not_hit",
+        });
+      }
+    }
+    for (const event of events) {
+      if (event && event.ok === false) {
+        failed.push({
+          label: event.label || null,
+          url: event.url || null,
+          method: event.method || null,
+          reason: event.reason || event.error || "mock_failed",
+        });
+      }
+    }
+    const hitsByLabel = {};
+    for (const mock of profile.target.network_mocks) {
+      hitsByLabel[mock.label] = events.filter((event) => event && event.label === mock.label && event.ok !== false).length;
+    }
+    checks.push({
+      type: "network_mocks_succeeded",
+      label: "network mocks succeeded",
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        mock_count: profile.target.network_mocks.length,
+        required_count: requiredMocks.length,
+        hit_count: events.filter((event) => event && event.ok !== false).length,
+        hits_by_label: hitsByLabel,
+        failed,
+      },
+      message: failed.length ? "Network mocks failed or were not hit for " + failed.length + " mock(s)." : undefined,
+    });
+  }
   if (profile.target && Array.isArray(profile.target.setup_actions) && profile.target.setup_actions.length) {
     const actionCount = profile.target.setup_actions.length;
     const failed = [];
@@ -7807,6 +7959,7 @@ const profileSlug = ${serializableSlug};
 const capturedAt = new Date().toISOString();
 const consoleEvents = [];
 const pageErrors = [];
+const networkMockEvents = [];
 page.on("console", (message) => {
   const type = message.type();
   if (type === "error" || type === "warning" || type === "assert") {
@@ -7842,6 +7995,14 @@ function setupTextMatches(sample, action) {
   }
   return String(sample || "").includes(action.text || "");
 }
+function setupHasOwn(action, key) {
+  return Boolean(action) && Object.keys(action).includes(key);
+}
+function setupActionValue(action) {
+  if (setupHasOwn(action, "value_json")) return JSON.stringify(action.value_json);
+  if (setupHasOwn(action, "value")) return String(action.value ?? "");
+  return "";
+}
 async function setupLocatorText(locator, index) {
   return await locator.nth(index).textContent({ timeout: 1000 }).catch(() => "");
 }
@@ -7853,6 +8014,49 @@ function compactSetupResultText(value) {
 async function setupLocatorVisible(locator, index) {
   return await locator.nth(index).isVisible({ timeout: 1000 }).catch(() => false);
 }
+async function registerNetworkMocks(mocks) {
+  for (const mock of mocks || []) {
+    await page.route(mock.url, async (route) => {
+      const request = route.request();
+      const method = request.method ? request.method() : "";
+      if (mock.method && method.toUpperCase() !== String(mock.method).toUpperCase()) {
+        await route.continue();
+        return;
+      }
+      try {
+        const headers = { ...(mock.headers || {}) };
+        let body = mock.body || "";
+        let contentType = mock.content_type || headers["content-type"] || headers["Content-Type"] || "text/plain";
+        if (mock.body_json !== undefined) {
+          body = JSON.stringify(mock.body_json);
+          contentType = mock.content_type || headers["content-type"] || headers["Content-Type"] || "application/json";
+        }
+        networkMockEvents.push({
+          ok: true,
+          label: mock.label,
+          url: request.url(),
+          method,
+          status: mock.status || 200,
+        });
+        await route.fulfill({
+          status: mock.status || 200,
+          headers,
+          contentType,
+          body,
+        });
+      } catch (error) {
+        networkMockEvents.push({
+          ok: false,
+          label: mock.label,
+          url: request.url(),
+          method,
+          error: String(error && error.message ? error.message : error).slice(0, 1000),
+        });
+        throw error;
+      }
+    });
+  }
+}
 async function executeSetupAction(action, ordinal) {
   const type = setupActionType(action);
   const base = { ok: false, action: type || "unknown", ordinal, selector: action.selector || null };
@@ -7867,6 +8071,16 @@ async function executeSetupAction(action, ordinal) {
       await page.waitForSelector(action.selector, { state: "visible", timeout });
       return { ...base, ok: true, timeout_ms: timeout };
     }
+    if (type === "local_storage") {
+      const value = setupActionValue(action);
+      await page.evaluate(({ key, value }) => {
+        window.localStorage.setItem(key, value);
+      }, { key: action.key, value });
+      if (action.reload === true) {
+        await page.reload({ waitUntil: "domcontentloaded", timeout: 45000 });
+      }
+      return { ...base, ok: true, key: action.key, value_length: value.length, reload: action.reload === true };
+    }
     if (type === "click") {
       const locator = page.locator(action.selector);
       const count = await locator.count();
@@ -7899,6 +8113,16 @@ async function executeSetupAction(action, ordinal) {
       await locator.nth(targetIndex).click({ timeout });
       return { ...base, ok: true, count, target_index: targetIndex, text: matchedText };
     }
+    if (type === "fill" || type === "set_input_value") {
+      const locator = page.locator(action.selector);
+      const count = await locator.count();
+      if (!count) return { ...base, reason: "selector_not_found", count };
+      const targetIndex = Number.isInteger(action.index) ? action.index : 0;
+      if (targetIndex < 0 || targetIndex >= count) return { ...base, reason: "index_out_of_range", count, target_index: targetIndex };
+      const value = setupActionValue(action);
+      await locator.nth(targetIndex).fill(value, { timeout });
+      return { ...base, ok: true, count, target_index: targetIndex, value_length: value.length };
+    }
     if (type === "wait_for_text") {
       const locator = page.locator(action.selector);
       const startedAt = Date.now();
@@ -8114,6 +8338,7 @@ function buildProfileEvidence(currentViewports) {
       fatal_count: consoleEvents.filter((event) => event.type === "error" || event.type === "assert").length,
     },
     page_errors: pageErrors,
+    network_mocks: networkMockEvents.slice(),
     dom_summary: {
       expected_viewport_count: expectedViewportCount,
       viewport_count: currentViewports.length,
@@ -8123,6 +8348,8 @@ function buildProfileEvidence(currentViewports) {
       overflow_px: currentViewports.map((viewport) => viewport.overflow_px),
       bounds_overflow_px: currentViewports.map((viewport) => viewport.bounds_overflow_px),
       overflow_offender_counts: currentViewports.map((viewport) => (viewport.overflow_offenders || []).length),
+      network_mock_count: (profile.target.network_mocks || []).length,
+      network_mock_hit_count: networkMockEvents.filter((event) => event.ok !== false).length,
     },
   };
 }
@@ -8136,6 +8363,9 @@ async function saveProfileArtifacts(currentViewports) {
   }
   return result;
 }
+await registerNetworkMocks(profile.target.network_mocks || []);
+consoleEvents.length = 0;
+pageErrors.length = 0;
 let result = await saveProfileArtifacts(viewports);
 for (const viewport of profile.target.viewports || []) {
   viewports.push(await captureViewport(viewport));

package/dist/cli.js

@@ -10,7 +10,7 @@ import {
   profileStatusExitCode,
   resolveRiddleProofProfileTargetUrl,
   resolveRiddleProofProfileTimeoutSec
-} from "./chunk-SDSBS64X.js";
+} from "./chunk-NUGGW7NX.js";
 import {
   createRiddleApiClient,
   parseRiddleViewport