@riddledc/riddle-proof 0.7.88 → 0.7.90

package/README.md

@@ -103,7 +103,9 @@ targeted copy or UI changes, the visual gate can use a lower targeted threshold
 only when route/text semantics match the requested change. When before/after
 image artifacts can be compared directly, the runtime also records the changed
 region bounding box and refuses the targeted threshold if that exact region is
-too broad for a localized UI change. Missing or unmeasured visual deltas
+too broad for a localized UI change. External visual-delta payloads can provide
+that region with common field names such as `changed_region`, `bounds`, `bbox`,
+`boundingBox`, `xMin`/`xMax`, or `x1`/`x2`. Missing or unmeasured visual deltas
 continue through evidence recovery instead of being treated as a passing proof.
 
 ## CI / Profile Mode
@@ -448,6 +450,29 @@ scroll width, client width, measured horizontal overflow, and top visible
 overflow offenders. This keeps embedded-player audits in profile mode instead
 of requiring bespoke iframe inspection scripts.
 
+Use `link_status` for public link or asset audits where selected `href` / `src`
+URLs must still resolve. This is useful for Good Catch pages, documentation
+indexes, saved-game galleries, and other public proof surfaces where stale
+artifact links should fail the profile:
+
+```json
+{
+  "type": "link_status",
+  "selector": "a[href*='/artifacts/'], img[src*='/artifacts/']",
+  "expected_count": 88,
+  "same_origin_only": true,
+  "require_nonzero_bytes": true,
+  "max_links": 150
+}
+```
+
+The check defaults to `a[href]`, deduplicates URLs, probes up to 100 selected
+URLs, and treats HTTP `2xx` / `3xx` responses as healthy. Use
+`allowed_statuses` or `expected_status` when a narrower status contract is
+intentional, `min_count` for lower-bound audits, and `max_links` when the
+selected set is intentionally larger than 100. `artifact_link_status` is an
+alias with the same behavior for profiles that want artifact-specific wording.
+
 Use the `route_inventory` check for source-page route coverage audits where a
 navigation surface must expose a known set of routes and each route must load
 both directly and through real link clicks:

package/dist/{chunk-CEBHV23V.js → chunk-4FMBHM4E.js}

@@ -27,6 +27,8 @@ var RIDDLE_PROOF_PROFILE_CHECK_TYPES = [
   "frame_no_horizontal_overflow",
   "text_visible",
   "text_absent",
+  "link_status",
+  "artifact_link_status",
   "route_inventory",
   "no_horizontal_overflow",
   "no_mobile_horizontal_overflow",
@@ -691,6 +693,29 @@ function normalizeStringList(value, label) {
   if (!values.length) throw new Error(`${label} must contain non-empty strings.`);
   return values;
 }
+function normalizeHttpStatus(value, label) {
+  if (value === void 0) return void 0;
+  const status = numberValue(value);
+  if (status === void 0 || !Number.isInteger(status) || status < 100 || status > 599) {
+    throw new Error(`${label} must be an HTTP status code.`);
+  }
+  return status;
+}
+function normalizeHttpStatuses(value, label) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new Error(`${label} must be an array.`);
+  if (!value.length) throw new Error(`${label} must not be empty.`);
+  const statuses = value.map((item, index) => normalizeHttpStatus(item, `${label}[${index}]`));
+  return Array.from(new Set(statuses));
+}
+function normalizePositiveInteger(value, label, max) {
+  if (value === void 0) return void 0;
+  const number = numberValue(value);
+  if (number === void 0 || !Number.isInteger(number) || number < 1 || max !== void 0 && number > max) {
+    throw new Error(`${label} must be an integer from 1 to ${max ?? "unbounded"}.`);
+  }
+  return number;
+}
 function validateRegexPatterns(patterns, label) {
   for (const pattern of patterns || []) {
     try {
@@ -734,7 +759,8 @@ function normalizeCheck(input, index) {
   if (type === "url_search_param_equals" && expectedValue === void 0) {
     throw new Error(`checks[${index}] url_search_param_equals requires expected_value.`);
   }
-  if (type === "selector_count_at_least" && numberValue(input.min_count) === void 0) {
+  const minCount = numberValue(input.min_count) ?? numberValue(input.minCount);
+  if (type === "selector_count_at_least" && minCount === void 0) {
     throw new Error(`checks[${index}] selector_count_at_least requires min_count.`);
   }
   const expectedCount = numberValue(input.expected_count) ?? numberValue(input.expectedCount) ?? numberValue(input.count);
@@ -750,6 +776,21 @@ function normalizeCheck(input, index) {
   if (type === "route_inventory" && !expectedRoutes?.length) {
     throw new Error(`checks[${index}] route_inventory requires expected_routes.`);
   }
+  const isLinkStatusCheck = type === "link_status" || type === "artifact_link_status";
+  const expectedStatus = isLinkStatusCheck ? normalizeHttpStatus(input.expected_status ?? input.expectedStatus ?? input.status, `checks[${index}] expected_status`) : void 0;
+  const allowedStatuses = isLinkStatusCheck ? normalizeHttpStatuses(
+    input.allowed_statuses ?? input.allowedStatuses ?? input.expected_statuses ?? input.expectedStatuses,
+    `checks[${index}] allowed_statuses`
+  ) : void 0;
+  const maxLinks = isLinkStatusCheck ? normalizePositiveInteger(input.max_links ?? input.maxLinks ?? input.limit, `checks[${index}] max_links`, 500) : void 0;
+  if (isLinkStatusCheck) {
+    if (minCount !== void 0 && (!Number.isInteger(minCount) || minCount < 0)) {
+      throw new Error(`checks[${index}] ${type} min_count must be a non-negative integer.`);
+    }
+    if (expectedCount !== void 0 && (!Number.isInteger(expectedCount) || expectedCount < 0)) {
+      throw new Error(`checks[${index}] ${type} expected_count must be a non-negative integer.`);
+    }
+  }
   return {
     type,
     label: stringValue(input.label),
@@ -775,8 +816,15 @@ function normalizeCheck(input, index) {
     allowed_console_patterns: normalizeStringList(input.allowed_console_patterns ?? input.allowedConsolePatterns ?? input.allow_console_patterns ?? input.allowConsolePatterns, `checks[${index}] allowed_console_patterns`),
     allowed_page_error_texts: normalizeStringList(input.allowed_page_error_texts ?? input.allowedPageErrorTexts ?? input.allow_page_error_texts ?? input.allowPageErrorTexts, `checks[${index}] allowed_page_error_texts`),
     allowed_page_error_patterns: normalizeStringList(input.allowed_page_error_patterns ?? input.allowedPageErrorPatterns ?? input.allow_page_error_patterns ?? input.allowPageErrorPatterns, `checks[${index}] allowed_page_error_patterns`),
-    min_count: numberValue(input.min_count),
+    min_count: minCount,
     expected_count: expectedCount,
+    expected_status: expectedStatus,
+    allowed_statuses: allowedStatuses,
+    max_links: maxLinks,
+    same_origin_only: isLinkStatusCheck ? input.same_origin_only === true || input.sameOriginOnly === true : void 0,
+    dedupe: isLinkStatusCheck ? input.dedupe === false ? false : true : void 0,
+    require_nonzero_bytes: isLinkStatusCheck ? input.require_nonzero_bytes === true || input.requireNonzeroBytes === true : void 0,
+    allow_get_fallback: isLinkStatusCheck ? input.allow_get_fallback === false || input.allowGetFallback === false ? false : true : void 0,
     max_overflow_px: numberValue(input.max_overflow_px),
     timeout_ms: numberValue(input.timeout_ms) ?? numberValue(input.timeoutMs),
     run_direct_routes: input.run_direct_routes === false || input.runDirectRoutes === false ? false : true,
@@ -869,6 +917,97 @@ function checkLabel(check) {
 function selectorKey(check) {
   return check.selector || "";
 }
+function linkStatusSelector(check) {
+  return check.selector || check.link_selector || "a[href]";
+}
+function linkStatusAllowedStatuses(check) {
+  if (check.allowed_statuses?.length) return check.allowed_statuses;
+  if (check.expected_status !== void 0) return [check.expected_status];
+  return void 0;
+}
+function linkStatusIsAllowed(status, check) {
+  if (status === void 0) return false;
+  const allowed = linkStatusAllowedStatuses(check);
+  return allowed?.length ? allowed.includes(status) : status >= 200 && status < 400;
+}
+function linkStatusResultOk(result, check) {
+  const status = numberValue(result.status);
+  if (!linkStatusIsAllowed(status, check)) return false;
+  if (stringValue(result.error)) return false;
+  if (result.ok === false) return false;
+  if (check.require_nonzero_bytes) {
+    const bytes = numberValue(result.bytes);
+    const contentLength = numberValue(result.content_length);
+    return bytes !== void 0 && bytes > 0 || contentLength !== void 0 && contentLength > 0;
+  }
+  return true;
+}
+function linkStatusEvidenceForCheck(viewport, check) {
+  const evidence = viewport.link_statuses?.[linkStatusSelector(check)];
+  return isRecord(evidence) ? evidence : void 0;
+}
+function summarizeLinkStatusEvidence(viewport, check) {
+  const linkEvidence = linkStatusEvidenceForCheck(viewport, check);
+  if (!linkEvidence) {
+    return {
+      viewport: viewport.name,
+      selector: linkStatusSelector(check),
+      total_count: 0,
+      ok_count: 0,
+      failed_count: 1,
+      failures: [{ code: "link_status_evidence_missing" }]
+    };
+  }
+  const results = Array.isArray(linkEvidence.results) ? linkEvidence.results.filter(isRecord) : [];
+  const totalCount = numberValue(linkEvidence.total_count) ?? results.length;
+  const okCount = results.filter((result) => linkStatusResultOk(result, check)).length;
+  const failures = results.filter((result) => !linkStatusResultOk(result, check)).map((result) => ({
+    code: "link_status_failed",
+    url: stringValue(result.url) ?? null,
+    status: numberValue(result.status) ?? null,
+    method: stringValue(result.method) ?? null,
+    error: stringValue(result.error) ?? null,
+    bytes: numberValue(result.bytes) ?? numberValue(result.content_length) ?? null
+  }));
+  if (stringValue(linkEvidence.error)) {
+    failures.push({ code: "link_status_capture_failed", error: stringValue(linkEvidence.error) ?? "" });
+  }
+  const recordedFailedCount = numberValue(linkEvidence.failed_count) ?? 0;
+  if (!failures.length && recordedFailedCount > 0) {
+    const recordedFailures = Array.isArray(linkEvidence.failures) ? linkEvidence.failures.slice(0, 20) : [];
+    failures.push({
+      code: "link_status_recorded_failures",
+      failed_count: recordedFailedCount,
+      failures: toJsonValue(recordedFailures)
+    });
+  }
+  if (linkEvidence.truncated === true) {
+    failures.push({
+      code: "link_status_probe_truncated",
+      discovered_count: numberValue(linkEvidence.discovered_count) ?? totalCount,
+      max_links: numberValue(linkEvidence.max_links) ?? check.max_links ?? 100
+    });
+  }
+  if (check.expected_count !== void 0 && totalCount !== check.expected_count) {
+    failures.push({ code: "link_status_count_mismatch", expected: check.expected_count, actual: totalCount });
+  }
+  if (check.min_count !== void 0 && totalCount < check.min_count) {
+    failures.push({ code: "link_status_count_below_minimum", min_count: check.min_count, actual: totalCount });
+  }
+  const statusCounts = isRecord(linkEvidence.status_counts) ? linkEvidence.status_counts : {};
+  return {
+    viewport: viewport.name,
+    selector: linkStatusSelector(check),
+    total_count: totalCount,
+    discovered_count: numberValue(linkEvidence.discovered_count) ?? totalCount,
+    ok_count: numberValue(linkEvidence.ok_count) ?? okCount,
+    failed_count: failures.length,
+    truncated: linkEvidence.truncated === true,
+    max_links: numberValue(linkEvidence.max_links) ?? check.max_links ?? 100,
+    status_counts: statusCounts,
+    failures: failures.slice(0, 20)
+  };
+}
 function textKey(check) {
   return check.pattern ? `pattern:${check.pattern}/${check.flags || ""}` : `text:${check.text || ""}`;
 }
@@ -1348,6 +1487,26 @@ function assessCheckFromEvidence(check, evidence) {
       message: failed ? `Text assertion failed in ${failed} viewport(s).` : void 0
     };
   }
+  if (check.type === "link_status" || check.type === "artifact_link_status") {
+    const selector = linkStatusSelector(check);
+    const summaries = viewports.map((viewport) => summarizeLinkStatusEvidence(viewport, check));
+    const failed = summaries.filter((summary) => (numberValue(summary.failed_count) ?? 0) > 0);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        selector,
+        expected_count: check.expected_count ?? null,
+        min_count: check.min_count ?? null,
+        allowed_statuses: linkStatusAllowedStatuses(check) || ["2xx", "3xx"],
+        require_nonzero_bytes: check.require_nonzero_bytes === true,
+        viewports: summaries.map((summary) => toJsonValue(summary)),
+        failures: failed.flatMap((summary) => Array.isArray(summary.failures) ? summary.failures.map((failure) => toJsonValue({ viewport: stringValue(summary.viewport) ?? null, failure })) : [])
+      },
+      message: failed.length ? `Link status failed in ${failed.length} viewport(s).` : void 0
+    };
+  }
   if (check.type === "route_inventory") {
     const inventories = viewports.map((viewport) => ({ viewport: viewport.name, inventory: viewport.route_inventory })).filter((item) => isRecord(item.inventory));
     if (!inventories.length) {
@@ -1930,6 +2089,98 @@ function textOrderMatch(texts, expectedTexts) {
   }
   return { matched: true, positions };
 }
+function linkStatusSelector(check) {
+  return check.selector || check.link_selector || "a[href]";
+}
+function linkStatusAllowedStatuses(check) {
+  if (Array.isArray(check.allowed_statuses) && check.allowed_statuses.length) return check.allowed_statuses;
+  if (typeof check.expected_status === "number" && Number.isFinite(check.expected_status)) return [check.expected_status];
+  return undefined;
+}
+function linkStatusIsAllowed(status, check) {
+  if (typeof status !== "number" || !Number.isFinite(status)) return false;
+  const allowed = linkStatusAllowedStatuses(check);
+  return Array.isArray(allowed) && allowed.length ? allowed.includes(status) : status >= 200 && status < 400;
+}
+function linkStatusResultOk(result, check) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return false;
+  if (!linkStatusIsAllowed(result.status, check)) return false;
+  if (typeof result.error === "string" && result.error.trim()) return false;
+  if (result.ok === false) return false;
+  if (check.require_nonzero_bytes === true) {
+    const bytes = typeof result.bytes === "number" && Number.isFinite(result.bytes) ? result.bytes : undefined;
+    const contentLength = typeof result.content_length === "number" && Number.isFinite(result.content_length) ? result.content_length : undefined;
+    return (bytes !== undefined && bytes > 0) || (contentLength !== undefined && contentLength > 0);
+  }
+  return true;
+}
+function summarizeLinkStatusEvidence(viewport, check) {
+  const selector = linkStatusSelector(check);
+  const linkEvidence = viewport && viewport.link_statuses && viewport.link_statuses[selector];
+  if (!linkEvidence || typeof linkEvidence !== "object" || Array.isArray(linkEvidence)) {
+    return {
+      viewport: viewport && viewport.name,
+      selector,
+      total_count: 0,
+      ok_count: 0,
+      failed_count: 1,
+      failures: [{ code: "link_status_evidence_missing" }],
+    };
+  }
+  const results = Array.isArray(linkEvidence.results) ? linkEvidence.results.filter((result) => result && typeof result === "object" && !Array.isArray(result)) : [];
+  const totalCount = typeof linkEvidence.total_count === "number" && Number.isFinite(linkEvidence.total_count) ? linkEvidence.total_count : results.length;
+  const okCount = results.filter((result) => linkStatusResultOk(result, check)).length;
+  const failures = results
+    .filter((result) => !linkStatusResultOk(result, check))
+    .map((result) => ({
+      code: "link_status_failed",
+      url: typeof result.url === "string" ? result.url : null,
+      status: typeof result.status === "number" && Number.isFinite(result.status) ? result.status : null,
+      method: typeof result.method === "string" ? result.method : null,
+      error: typeof result.error === "string" ? result.error : null,
+      bytes: typeof result.bytes === "number" && Number.isFinite(result.bytes)
+        ? result.bytes
+        : typeof result.content_length === "number" && Number.isFinite(result.content_length)
+          ? result.content_length
+          : null,
+    }));
+  if (typeof linkEvidence.error === "string" && linkEvidence.error.trim()) {
+    failures.push({ code: "link_status_capture_failed", error: linkEvidence.error });
+  }
+  const recordedFailedCount = typeof linkEvidence.failed_count === "number" && Number.isFinite(linkEvidence.failed_count) ? linkEvidence.failed_count : 0;
+  if (!failures.length && recordedFailedCount > 0) {
+    failures.push({
+      code: "link_status_recorded_failures",
+      failed_count: recordedFailedCount,
+      failures: Array.isArray(linkEvidence.failures) ? linkEvidence.failures.slice(0, 20) : [],
+    });
+  }
+  if (linkEvidence.truncated === true) {
+    failures.push({
+      code: "link_status_probe_truncated",
+      discovered_count: typeof linkEvidence.discovered_count === "number" ? linkEvidence.discovered_count : totalCount,
+      max_links: typeof linkEvidence.max_links === "number" ? linkEvidence.max_links : check.max_links || 100,
+    });
+  }
+  if (typeof check.expected_count === "number" && Number.isFinite(check.expected_count) && totalCount !== check.expected_count) {
+    failures.push({ code: "link_status_count_mismatch", expected: check.expected_count, actual: totalCount });
+  }
+  if (typeof check.min_count === "number" && Number.isFinite(check.min_count) && totalCount < check.min_count) {
+    failures.push({ code: "link_status_count_below_minimum", min_count: check.min_count, actual: totalCount });
+  }
+  return {
+    viewport: viewport && viewport.name,
+    selector,
+    total_count: totalCount,
+    discovered_count: typeof linkEvidence.discovered_count === "number" ? linkEvidence.discovered_count : totalCount,
+    ok_count: typeof linkEvidence.ok_count === "number" ? linkEvidence.ok_count : okCount,
+    failed_count: failures.length,
+    truncated: linkEvidence.truncated === true,
+    max_links: typeof linkEvidence.max_links === "number" ? linkEvidence.max_links : check.max_links || 100,
+    status_counts: linkEvidence.status_counts && typeof linkEvidence.status_counts === "object" && !Array.isArray(linkEvidence.status_counts) ? linkEvidence.status_counts : {},
+    failures: failures.slice(0, 20),
+  };
+}
 function frameEvidenceForSelector(viewport, selector) {
   const container = viewport.frames && viewport.frames[selector || ""];
   if (!container || typeof container !== "object" || Array.isArray(container)) return [];
@@ -2583,6 +2834,29 @@ function assessProfile(profile, evidence) {
       });
       continue;
     }
+    if (check.type === "link_status" || check.type === "artifact_link_status") {
+      const selector = linkStatusSelector(check);
+      const summaries = checkViewports.map((viewport) => summarizeLinkStatusEvidence(viewport, check));
+      const failed = summaries.filter((summary) => summary.failed_count > 0);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: {
+          selector,
+          expected_count: check.expected_count ?? null,
+          min_count: check.min_count ?? null,
+          allowed_statuses: linkStatusAllowedStatuses(check) || ["2xx", "3xx"],
+          require_nonzero_bytes: check.require_nonzero_bytes === true,
+          viewports: summaries,
+          failures: failed.flatMap((summary) => Array.isArray(summary.failures)
+            ? summary.failures.map((failure) => ({ viewport: summary.viewport || null, failure }))
+            : []),
+        },
+        message: failed.length ? "Link status failed in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
     if (check.type === "route_inventory") {
       const inventories = checkViewports
         .map((viewport) => ({ viewport: viewport.name, inventory: viewport.route_inventory }))
@@ -3641,6 +3915,196 @@ async function selectorTextSequence(selector) {
     };
   }).catch((error) => ({ count: 0, visible_count: 0, texts: [], visible_texts: [], error: String(error && error.message ? error.message : error).slice(0, 500) }));
 }
+function linkProbeMaxLinks(check) {
+  const value = Number(check.max_links || check.maxLinks || check.limit || 100);
+  return Number.isInteger(value) && value > 0 ? Math.min(value, 500) : 100;
+}
+function linkProbeDedupe(check) {
+  return check.dedupe !== false;
+}
+function linkProbeSameOriginOnly(check) {
+  return check.same_origin_only === true;
+}
+async function collectLinkCandidates(selector) {
+  return page.locator(selector).evaluateAll((elements) => {
+    const compact = (value, limit) => String(value || "").replace(/\s+/g, " ").trim().slice(0, limit || 160);
+    return elements.map((element, index) => {
+      const tag = element && element.tagName ? element.tagName.toLowerCase() : "element";
+      const href = element && typeof element.href === "string" ? element.href : "";
+      const src = element && typeof element.src === "string" ? element.src : "";
+      const currentSrc = element && typeof element.currentSrc === "string" ? element.currentSrc : "";
+      const attrHref = element && typeof element.getAttribute === "function" ? element.getAttribute("href") || "" : "";
+      const attrSrc = element && typeof element.getAttribute === "function" ? element.getAttribute("src") || "" : "";
+      const attrPoster = element && typeof element.getAttribute === "function" ? element.getAttribute("poster") || "" : "";
+      const raw = href || currentSrc || src || attrHref || attrSrc || attrPoster;
+      if (!raw) return null;
+      let url = "";
+      try {
+        url = new URL(raw, location.href).href;
+      } catch {}
+      if (!url) return null;
+      return {
+        index,
+        tag,
+        url,
+        raw,
+        text: compact(element.innerText || element.textContent || "", 160),
+        alt: compact(element.getAttribute && element.getAttribute("alt"), 80),
+      };
+    }).filter(Boolean);
+  }).catch((error) => ({ error: String(error && error.message ? error.message : error).slice(0, 500) }));
+}
+function linkProbeAllowed(status, check) {
+  if (typeof status !== "number" || !Number.isFinite(status)) return false;
+  const allowed = Array.isArray(check.allowed_statuses) && check.allowed_statuses.length
+    ? check.allowed_statuses
+    : typeof check.expected_status === "number" && Number.isFinite(check.expected_status)
+      ? [check.expected_status]
+      : null;
+  return allowed ? allowed.includes(status) : status >= 200 && status < 400;
+}
+function linkProbeResponseFields(response, method) {
+  const contentLengthHeader = response.headers && typeof response.headers.get === "function" ? response.headers.get("content-length") : null;
+  const contentLength = contentLengthHeader && /^\d+$/.test(contentLengthHeader) ? Number(contentLengthHeader) : null;
+  return {
+    method,
+    status: response.status,
+    redirected: Boolean(response.redirected),
+    final_url: response.url || null,
+    content_type: response.headers && typeof response.headers.get === "function" ? response.headers.get("content-type") : null,
+    content_length: contentLength,
+  };
+}
+async function probeLinkStatus(candidate, check) {
+  const requireNonzeroBytes = check.require_nonzero_bytes === true;
+  const allowGetFallback = check.allow_get_fallback !== false;
+  const result = {
+    url: candidate.url,
+    tag: candidate.tag,
+    text: candidate.text || null,
+    status: null,
+    method: null,
+    ok: false,
+    content_type: null,
+    content_length: null,
+    bytes: null,
+    redirected: false,
+    final_url: null,
+    error: null,
+  };
+  const applyResponse = async (response, method, readBytes) => {
+    Object.assign(result, linkProbeResponseFields(response, method));
+    if (readBytes || requireNonzeroBytes) {
+      try {
+        const buffer = await response.arrayBuffer();
+        result.bytes = buffer.byteLength;
+      } catch (error) {
+        result.error = String(error && error.message ? error.message : error).slice(0, 500);
+      }
+    }
+    result.ok = linkProbeAllowed(result.status, check)
+      && (!requireNonzeroBytes || (typeof result.bytes === "number" ? result.bytes > 0 : typeof result.content_length === "number" && result.content_length > 0))
+      && !result.error;
+  };
+  try {
+    const response = await fetch(candidate.url, { method: "HEAD", redirect: "follow", cache: "no-store" });
+    await applyResponse(response, "HEAD", false);
+    if (result.ok || !allowGetFallback) return result;
+  } catch (error) {
+    result.error = String(error && error.message ? error.message : error).slice(0, 500);
+    if (!allowGetFallback) return result;
+  }
+  try {
+    result.error = null;
+    const response = await fetch(candidate.url, {
+      method: "GET",
+      redirect: "follow",
+      cache: "no-store",
+      headers: { Range: "bytes=0-0" },
+    });
+    await applyResponse(response, "GET", requireNonzeroBytes);
+    return result;
+  } catch (error) {
+    result.error = String(error && error.message ? error.message : error).slice(0, 500);
+    result.ok = false;
+    return result;
+  }
+}
+async function collectLinkStatus(check) {
+  const selector = linkStatusSelector(check);
+  const candidateResult = await collectLinkCandidates(selector);
+  if (candidateResult && candidateResult.error) {
+    return {
+      version: "riddle-proof.link-status.v1",
+      selector,
+      total_count: 0,
+      discovered_count: 0,
+      ok_count: 0,
+      failed_count: 1,
+      failures: [{ code: "link_status_capture_failed", error: candidateResult.error }],
+      results: [],
+      status_counts: {},
+      error: candidateResult.error,
+    };
+  }
+  const baseUrl = page.url() || targetUrl;
+  let candidates = Array.isArray(candidateResult) ? candidateResult : [];
+  if (linkProbeSameOriginOnly(check)) {
+    const origin = new URL(baseUrl).origin;
+    candidates = candidates.filter((candidate) => {
+      try { return new URL(candidate.url).origin === origin; } catch { return false; }
+    });
+  }
+  const discoveredCount = candidates.length;
+  if (linkProbeDedupe(check)) {
+    const seen = new Set();
+    candidates = candidates.filter((candidate) => {
+      if (seen.has(candidate.url)) return false;
+      seen.add(candidate.url);
+      return true;
+    });
+  }
+  const maxLinks = linkProbeMaxLinks(check);
+  const selected = candidates.slice(0, maxLinks);
+  const results = [];
+  for (const candidate of selected) {
+    results.push(await probeLinkStatus(candidate, check));
+  }
+  const failures = results.filter((result) => !result.ok).map((result) => ({
+    code: "link_status_failed",
+    url: result.url,
+    status: result.status,
+    method: result.method,
+    error: result.error,
+    bytes: result.bytes == null ? result.content_length : result.bytes,
+  }));
+  const statusCounts = {};
+  for (const result of results) {
+    const key = result.status == null ? "error" : String(result.status);
+    statusCounts[key] = (statusCounts[key] || 0) + 1;
+  }
+  return {
+    version: "riddle-proof.link-status.v1",
+    selector,
+    max_links: maxLinks,
+    same_origin_only: linkProbeSameOriginOnly(check),
+    dedupe: linkProbeDedupe(check),
+    require_nonzero_bytes: check.require_nonzero_bytes === true,
+    allowed_statuses: Array.isArray(check.allowed_statuses) && check.allowed_statuses.length
+      ? check.allowed_statuses
+      : typeof check.expected_status === "number"
+        ? [check.expected_status]
+        : ["2xx", "3xx"],
+    discovered_count: discoveredCount,
+    total_count: selected.length,
+    truncated: candidates.length > selected.length,
+    ok_count: results.filter((result) => result.ok).length,
+    failed_count: failures.length,
+    status_counts: statusCounts,
+    failures: failures.slice(0, 20),
+    results,
+  };
+}
 async function frameEvidence(selector) {
   const result = { selector, count: 0, frame_count: 0, frames: [], errors: [] };
   let handles = [];
@@ -4160,6 +4624,7 @@ async function captureViewport(viewport) {
   const frames = {};
   const text_sequences = {};
   const text_matches = {};
+  const link_statuses = {};
   for (const check of profile.checks || []) {
     if (
       (
@@ -4184,6 +4649,10 @@ async function captureViewport(viewport) {
       selectors[check.selector] = selectors[check.selector] || await selectorStats(check.selector);
       frames[check.selector] = frames[check.selector] || await frameEvidence(check.selector);
     }
+    if (check.type === "link_status" || check.type === "artifact_link_status") {
+      const selector = linkStatusSelector(check);
+      link_statuses[selector] = link_statuses[selector] || await collectLinkStatus(check);
+    }
   }
   const screenshotLabel = profileSlug + "-" + viewport.name;
   try {
@@ -4247,6 +4716,7 @@ async function captureViewport(viewport) {
     frames,
     text_sequences,
     text_matches,
+    link_statuses,
     route_inventory: routeInventory,
     setup_action_results: setupActionResults,
     screenshot_label: screenshotLabel,
@@ -4295,6 +4765,18 @@ function buildProfileEvidence(currentViewports) {
             ),
           })),
         })),
+      link_status: currentViewports
+        .filter((viewport) => viewport.link_statuses)
+        .map((viewport) => ({
+          viewport: viewport.name,
+          selectors: Object.entries(viewport.link_statuses || {}).map(([selector, statusSet]) => ({
+            selector,
+            total_count: statusSet && statusSet.total_count,
+            ok_count: statusSet && statusSet.ok_count,
+            failed_count: statusSet && statusSet.failed_count,
+            truncated: statusSet && statusSet.truncated === true,
+          })),
+        })),
       route_inventory: currentViewports
         .filter((viewport) => viewport.route_inventory)
         .map((viewport) => ({