@riddledc/riddle-proof 0.7.21 → 0.7.23

package/dist/index.cjs

@@ -7889,7 +7889,8 @@ function assessBasicGameplayEvidence(evidence, options = {}) {
   }
   const routeResults = (run.results || []).map((route) => augmentRouteAssessmentWithProgressionChecks(
     assessBasicGameplayRoute(route, options),
-    route
+    route,
+    options
   ));
   const failingRoutes = routeResults.filter((result) => !result.ok).map((result) => ({
     name: result.name,
@@ -7950,7 +7951,7 @@ function assessBasicGameplayRoute(route, options = {}) {
   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);
+  const mobileOverflowPx = horizontalBoundsOverflowPx(mobile);
   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) {
@@ -8093,11 +8094,11 @@ function assessBasicGameplayProgressionCheck(check) {
 function assessBasicGameplayProgressionChecks(route) {
   return progressionChecksForRoute(route).map((check) => assessBasicGameplayProgressionCheck(check));
 }
-function augmentBasicGameplayAssessmentWithProgressionChecks(assessment, evidence) {
+function augmentBasicGameplayAssessmentWithProgressionChecks(assessment, evidence, options = {}) {
   const run = extractBasicGameplayEvidence(evidence);
   if (!run?.results?.length) return assessment;
   const routeResults = assessment.route_results.map(
-    (result, index) => augmentRouteAssessmentWithProgressionChecks(result, run.results?.[index] || {})
+    (result, index) => augmentRouteAssessmentWithProgressionChecks(result, run.results?.[index] || {}, options)
   );
   const failingRoutes = routeResults.filter((result) => !result.ok).map((result) => ({
     name: result.name,
@@ -8159,7 +8160,7 @@ function attachBasicGameplayArtifactScreenshotHashes(evidence, routesOrOptions =
   }
   return evidence;
 }
-function createBasicGameplayCatchRecords(assessment, evidence) {
+function createBasicGameplayCatchRecords(assessment, evidence, options = {}) {
   const run = extractBasicGameplayEvidence(evidence);
   if (!run?.results?.length) return [];
   const catches = [];
@@ -8233,6 +8234,24 @@ function createBasicGameplayCatchRecords(assessment, evidence) {
         summary: `${route.name || route.path || "Route"}: responsive setup failed on ${failure.viewport?.label || "viewport"} (${failure.reason || "responsive_setup_failed"})`
       });
     }
+    for (const failure of responsiveBoundsFailures(route, options.maxMobileOverflowPx ?? 4)) {
+      catches.push({
+        site: run.site || null,
+        route: route.name,
+        path: route.path,
+        code: failure.code,
+        label: failure.label,
+        type: "responsive_bounds",
+        selector: null,
+        reason: failure.reason || "responsive_bounds_clipped",
+        phase: failure.viewport?.phase || void 0,
+        viewport: failure.viewport,
+        overflow_px: failure.overflow_px,
+        max_allowed_px: failure.max_allowed_px,
+        offenders: failure.offenders,
+        summary: `${route.name || route.path || "Route"}: responsive bounds exceeded ${failure.max_allowed_px}px on ${failure.viewport?.label || "viewport"} (${failure.overflow_px}px)`
+      });
+    }
     for (const check of assessBasicGameplayProgressionChecks(route).filter((item) => item.ok === false)) {
       catches.push({
         site: run.site || null,
@@ -8387,13 +8406,15 @@ function changed(before, after) {
 function canvasHashes(canvases) {
   return (canvases || []).map((canvas) => canvas.hash).filter(Boolean).join("|");
 }
-function augmentRouteAssessmentWithProgressionChecks(result, route) {
+function augmentRouteAssessmentWithProgressionChecks(result, route, options = {}) {
   const progressionFailures = assessBasicGameplayProgressionChecks(route).filter((check) => check.ok === false);
   const responsiveFailures = responsiveSetupFailures(route);
-  if (!progressionFailures.length && !responsiveFailures.length) return result;
+  const responsiveBounds = responsiveBoundsFailures(route, options.maxMobileOverflowPx ?? 4);
+  if (!progressionFailures.length && !responsiveFailures.length && !responsiveBounds.length) return result;
   const failures = new Set(result.failures);
   if (progressionFailures.length) failures.add("progression_assertion_failed");
   for (const failure of responsiveFailures) failures.add(failure.code);
+  for (const failure of responsiveBounds) failures.add(failure.code);
   return {
     ...result,
     ok: false,
@@ -8409,7 +8430,8 @@ function augmentRouteAssessmentWithProgressionChecks(result, route) {
         state_call: check.state_call || null,
         property_path: check.property_path || null
       })),
-      ...responsiveFailures
+      ...responsiveFailures,
+      ...responsiveBounds
     ]
   };
 }
@@ -8435,6 +8457,28 @@ function responsiveSetupFailures(route) {
   }
   return failures;
 }
+function responsiveBoundsFailures(route, maxOverflowPx) {
+  const failures = [];
+  for (const viewport of responsiveViewportsForRoute(route)) {
+    const overflowPx = horizontalBoundsOverflowPx(viewport);
+    if (overflowPx <= maxOverflowPx) continue;
+    failures.push({
+      code: "responsive_bounds_clipped",
+      label: `${viewport.label || "responsive"} horizontal bounds`,
+      reason: `horizontal bounds overflow ${overflowPx}px exceeded ${maxOverflowPx}px`,
+      overflow_px: overflowPx,
+      max_allowed_px: maxOverflowPx,
+      offenders: boundsOffendersForEvidence(viewport).slice(0, 10),
+      viewport: {
+        label: viewport.label || null,
+        width: numberValue2(viewport.width) || null,
+        height: numberValue2(viewport.height) || null,
+        phase: viewport.phase || null
+      }
+    });
+  }
+  return failures;
+}
 function responsiveViewportsForRoute(route) {
   return listValue2(route.responsive_viewports || route.responsiveViewports).filter((item) => Boolean(recordValue3(item)));
 }
@@ -8444,6 +8488,82 @@ function progressionChecksForRoute(route) {
 function metricValue(value) {
   return recordValue3(value);
 }
+function horizontalBoundsOverflowPx(value) {
+  const record = recordValue3(value);
+  if (!record) return 0;
+  let max = maxPositiveNumber(
+    record.overflow_px,
+    record.overflow,
+    record.bounds_overflow_px,
+    record.horizontal_overflow_px,
+    record.left_overflow_px,
+    record.right_overflow_px
+  );
+  for (const offender of boundsOffendersForEvidence(record)) {
+    max = Math.max(max, horizontalOffenderOverflowPx(offender));
+  }
+  return roundPixels(max);
+}
+function horizontalOffenderOverflowPx(value) {
+  const record = recordValue3(value);
+  if (!record) return 0;
+  let max = maxPositiveNumber(
+    record.overflow,
+    record.overflow_px,
+    record.bounds_overflow_px,
+    record.horizontal_overflow_px,
+    record.left_overflow_px,
+    record.right_overflow_px,
+    record.leftOverflowPx,
+    record.rightOverflowPx
+  );
+  const clipped = recordValue3(record.clipped || record.clip || record.clipping);
+  if (clipped) {
+    max = Math.max(max, maxPositiveNumber(
+      clipped.left,
+      clipped.right,
+      clipped.left_px,
+      clipped.right_px,
+      clipped.leftPx,
+      clipped.rightPx
+    ));
+  }
+  const rect = recordValue3(record.rect || record.bounds || record.bounding_rect || record.boundingRect);
+  const viewportWidth = numericValue3(record.viewport_width ?? record.viewportWidth);
+  if (rect && viewportWidth !== null) {
+    const left = numericValue3(rect.left);
+    const right = numericValue3(rect.right);
+    if (left !== null && left < 0) max = Math.max(max, Math.abs(left));
+    if (right !== null && right > viewportWidth) max = Math.max(max, right - viewportWidth);
+  }
+  return roundPixels(max);
+}
+function boundsOffendersForEvidence(value) {
+  const record = recordValue3(value);
+  if (!record) return [];
+  const offenders = [
+    ...listValue2(record.overflow_offenders),
+    ...listValue2(record.overflowOffenders),
+    ...listValue2(record.bounds_offenders),
+    ...listValue2(record.boundsOffenders),
+    ...listValue2(record.clipped_elements),
+    ...listValue2(record.clippedElements),
+    ...listValue2(record.clipping_offenders),
+    ...listValue2(record.clippingOffenders)
+  ];
+  return offenders.filter((item) => Boolean(recordValue3(item))).sort((a, b) => horizontalOffenderOverflowPx(b) - horizontalOffenderOverflowPx(a));
+}
+function maxPositiveNumber(...values) {
+  let max = 0;
+  for (const value of values) {
+    const number = numericValue3(value);
+    if (number !== null && number > max) max = number;
+  }
+  return max;
+}
+function roundPixels(value) {
+  return Math.round(value * 100) / 100;
+}
 function textMatches(text, pattern, flags) {
   if (!pattern) return Boolean(text);
   try {
@@ -8632,6 +8752,79 @@ function stringValue5(value) {
 function numberValue3(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function horizontalBoundsOverflowPx2(value) {
+  if (!isRecord2(value)) return 0;
+  let max = maxPositiveNumber2(
+    value.overflow_px,
+    value.overflow,
+    value.bounds_overflow_px,
+    value.horizontal_overflow_px,
+    value.left_overflow_px,
+    value.right_overflow_px
+  );
+  for (const offender of boundsOffendersForEvidence2(value)) {
+    max = Math.max(max, horizontalOffenderOverflowPx2(offender));
+  }
+  return roundPixels2(max);
+}
+function horizontalOffenderOverflowPx2(value) {
+  if (!isRecord2(value)) return 0;
+  let max = maxPositiveNumber2(
+    value.overflow,
+    value.overflow_px,
+    value.bounds_overflow_px,
+    value.horizontal_overflow_px,
+    value.left_overflow_px,
+    value.right_overflow_px,
+    value.leftOverflowPx,
+    value.rightOverflowPx
+  );
+  const clipped = isRecord2(value.clipped || value.clip || value.clipping) ? value.clipped || value.clip || value.clipping : void 0;
+  if (isRecord2(clipped)) {
+    max = Math.max(max, maxPositiveNumber2(
+      clipped.left,
+      clipped.right,
+      clipped.left_px,
+      clipped.right_px,
+      clipped.leftPx,
+      clipped.rightPx
+    ));
+  }
+  const rect = isRecord2(value.rect || value.bounds || value.bounding_rect || value.boundingRect) ? value.rect || value.bounds || value.bounding_rect || value.boundingRect : void 0;
+  const viewportWidth = numberValue3(value.viewport_width ?? value.viewportWidth);
+  if (isRecord2(rect) && viewportWidth !== void 0) {
+    const left = numberValue3(rect.left);
+    const right = numberValue3(rect.right);
+    if (left !== void 0 && left < 0) max = Math.max(max, Math.abs(left));
+    if (right !== void 0 && right > viewportWidth) max = Math.max(max, right - viewportWidth);
+  }
+  return roundPixels2(max);
+}
+function boundsOffendersForEvidence2(value) {
+  if (!isRecord2(value)) return [];
+  const offenders = [
+    ...Array.isArray(value.overflow_offenders) ? value.overflow_offenders : [],
+    ...Array.isArray(value.overflowOffenders) ? value.overflowOffenders : [],
+    ...Array.isArray(value.bounds_offenders) ? value.bounds_offenders : [],
+    ...Array.isArray(value.boundsOffenders) ? value.boundsOffenders : [],
+    ...Array.isArray(value.clipped_elements) ? value.clipped_elements : [],
+    ...Array.isArray(value.clippedElements) ? value.clippedElements : [],
+    ...Array.isArray(value.clipping_offenders) ? value.clipping_offenders : [],
+    ...Array.isArray(value.clippingOffenders) ? value.clippingOffenders : []
+  ];
+  return offenders.filter((item) => isRecord2(item)).sort((a, b) => horizontalOffenderOverflowPx2(b) - horizontalOffenderOverflowPx2(a));
+}
+function maxPositiveNumber2(...values) {
+  let max = 0;
+  for (const value of values) {
+    const number = numberValue3(value);
+    if (number !== void 0 && number > max) max = number;
+  }
+  return max;
+}
+function roundPixels2(value) {
+  return Math.round(value * 100) / 100;
+}
 function timeoutSecValue(value) {
   const number = numberValue3(value);
   return number && number > 0 ? Math.ceil(number) : void 0;
@@ -8974,7 +9167,7 @@ function assessCheckFromEvidence(check, evidence) {
         message: "No applicable viewport evidence was captured for overflow check."
       };
     }
-    const failed = applicable.filter((viewport) => (viewport.overflow_px ?? 0) > maxOverflow);
+    const failed = applicable.filter((viewport) => horizontalBoundsOverflowPx2(viewport) > maxOverflow);
     return {
       type: check.type,
       label: checkLabel(check),
@@ -8982,9 +9175,11 @@ function assessCheckFromEvidence(check, evidence) {
       evidence: {
         max_overflow_px: maxOverflow,
         overflow_px: applicable.map((viewport) => viewport.overflow_px ?? null),
+        bounds_overflow_px: applicable.map((viewport) => horizontalBoundsOverflowPx2(viewport)),
+        overflow_offender_counts: applicable.map((viewport) => boundsOffendersForEvidence2(viewport).length),
         viewports: applicable.map((viewport) => viewport.name)
       },
-      message: failed.length ? `Horizontal overflow exceeded ${maxOverflow}px in ${failed.length} viewport(s).` : void 0
+      message: failed.length ? `Horizontal bounds overflow exceeded ${maxOverflow}px in ${failed.length} viewport(s).` : void 0
     };
   }
   if (check.type === "no_fatal_console_errors") {
@@ -9206,6 +9401,77 @@ function textMatches(sample, check) {
   }
   return String(sample || "").includes(check.text || "");
 }
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function maxPositiveNumber() {
+  let max = 0;
+  for (const value of arguments) {
+    const number = numberValue(value);
+    if (number !== undefined && number > max) max = number;
+  }
+  return max;
+}
+function roundPixels(value) {
+  return Math.round(value * 100) / 100;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function boundsOffendersForEvidence(value) {
+  if (!isRecord(value)) return [];
+  const offenders = []
+    .concat(Array.isArray(value.overflow_offenders) ? value.overflow_offenders : [])
+    .concat(Array.isArray(value.overflowOffenders) ? value.overflowOffenders : [])
+    .concat(Array.isArray(value.bounds_offenders) ? value.bounds_offenders : [])
+    .concat(Array.isArray(value.boundsOffenders) ? value.boundsOffenders : [])
+    .concat(Array.isArray(value.clipped_elements) ? value.clipped_elements : [])
+    .concat(Array.isArray(value.clippedElements) ? value.clippedElements : [])
+    .concat(Array.isArray(value.clipping_offenders) ? value.clipping_offenders : [])
+    .concat(Array.isArray(value.clippingOffenders) ? value.clippingOffenders : []);
+  return offenders.filter(isRecord).sort((a, b) => horizontalOffenderOverflowPx(b) - horizontalOffenderOverflowPx(a));
+}
+function horizontalOffenderOverflowPx(value) {
+  if (!isRecord(value)) return 0;
+  let max = maxPositiveNumber(
+    value.overflow,
+    value.overflow_px,
+    value.bounds_overflow_px,
+    value.horizontal_overflow_px,
+    value.left_overflow_px,
+    value.right_overflow_px,
+    value.leftOverflowPx,
+    value.rightOverflowPx
+  );
+  const clipped = value.clipped || value.clip || value.clipping;
+  if (isRecord(clipped)) {
+    max = Math.max(max, maxPositiveNumber(clipped.left, clipped.right, clipped.left_px, clipped.right_px, clipped.leftPx, clipped.rightPx));
+  }
+  const rect = value.rect || value.bounds || value.bounding_rect || value.boundingRect;
+  const viewportWidth = numberValue(value.viewport_width != null ? value.viewport_width : value.viewportWidth);
+  if (isRecord(rect) && viewportWidth !== undefined) {
+    const left = numberValue(rect.left);
+    const right = numberValue(rect.right);
+    if (left !== undefined && left < 0) max = Math.max(max, Math.abs(left));
+    if (right !== undefined && right > viewportWidth) max = Math.max(max, right - viewportWidth);
+  }
+  return roundPixels(max);
+}
+function horizontalBoundsOverflowPx(value) {
+  if (!isRecord(value)) return 0;
+  let max = maxPositiveNumber(
+    value.overflow_px,
+    value.overflow,
+    value.bounds_overflow_px,
+    value.horizontal_overflow_px,
+    value.left_overflow_px,
+    value.right_overflow_px
+  );
+  for (const offender of boundsOffendersForEvidence(value)) {
+    max = Math.max(max, horizontalOffenderOverflowPx(offender));
+  }
+  return roundPixels(max);
+}
 function assessProfile(profile, evidence) {
   const checks = [];
   const viewports = evidence.viewports || [];
@@ -9323,13 +9589,19 @@ function assessProfile(profile, evidence) {
         });
         continue;
       }
-      const failed = applicable.filter((viewport) => (viewport.overflow_px || 0) > maxOverflow);
+      const failed = applicable.filter((viewport) => horizontalBoundsOverflowPx(viewport) > maxOverflow);
       checks.push({
         type: check.type,
         label: check.label || check.type,
         status: failed.length ? "failed" : "passed",
-        evidence: { max_overflow_px: maxOverflow, overflow_px: applicable.map((viewport) => viewport.overflow_px ?? null), viewports: applicable.map((viewport) => viewport.name) },
-        message: failed.length ? "Horizontal overflow exceeded " + maxOverflow + "px in " + failed.length + " viewport(s)." : undefined,
+        evidence: {
+          max_overflow_px: maxOverflow,
+          overflow_px: applicable.map((viewport) => viewport.overflow_px ?? null),
+          bounds_overflow_px: applicable.map((viewport) => horizontalBoundsOverflowPx(viewport)),
+          overflow_offender_counts: applicable.map((viewport) => boundsOffendersForEvidence(viewport).length),
+          viewports: applicable.map((viewport) => viewport.name)
+        },
+        message: failed.length ? "Horizontal bounds overflow exceeded " + maxOverflow + "px in " + failed.length + " viewport(s)." : undefined,
       });
       continue;
     }
@@ -9559,14 +9831,55 @@ async function captureViewport(viewport) {
     const body = document.body;
     const documentElement = document.documentElement;
     const text = (body ? body.innerText : "").replace(/\s+/g, " ").trim();
+    const clientWidth = documentElement ? documentElement.clientWidth : window.innerWidth;
+    const scrollWidth = documentElement ? documentElement.scrollWidth : 0;
+    const viewportWidth = clientWidth || window.innerWidth;
+    const overflowOffenders = [];
+    for (const element of Array.from(body ? body.querySelectorAll("*") : [])) {
+      const rect = element.getBoundingClientRect();
+      if (!rect || rect.width < 1 || rect.height < 1) continue;
+      const style = window.getComputedStyle(element);
+      if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") continue;
+      const leftOverflow = Math.max(0, -rect.left);
+      const rightOverflow = Math.max(0, rect.right - viewportWidth);
+      const overflow = Math.max(leftOverflow, rightOverflow);
+      if (overflow <= 0.5) continue;
+      const tag = element.tagName ? element.tagName.toLowerCase() : "element";
+      const id = element.id ? "#" + element.id : "";
+      const className = typeof element.className === "string"
+        ? element.className.trim().split(/\s+/).filter(Boolean).slice(0, 2).join(".")
+        : "";
+      overflowOffenders.push({
+        selector: tag + id + (className ? "." + className : ""),
+        tag,
+        text: (element.textContent || "").replace(/\s+/g, " ").trim().slice(0, 120),
+        overflow,
+        left_overflow_px: leftOverflow,
+        right_overflow_px: rightOverflow,
+        viewport_width: viewportWidth,
+        rect: {
+          left: rect.left,
+          right: rect.right,
+          width: rect.width,
+        },
+      });
+    }
+    overflowOffenders.sort((a, b) => b.overflow - a.overflow);
+    const boundsOverflowPx = Math.max(
+      0,
+      scrollWidth - (clientWidth || viewportWidth),
+      ...overflowOffenders.map((offender) => offender.overflow),
+    );
     return {
       url: location.href,
       pathname: location.pathname,
       title: document.title,
       body_text_length: text.length,
       body_text_sample: text.slice(0, 8000),
-      scroll_width: documentElement ? documentElement.scrollWidth : 0,
-      client_width: documentElement ? documentElement.clientWidth : window.innerWidth,
+      scroll_width: scrollWidth,
+      client_width: clientWidth,
+      bounds_overflow_px: Math.round(boundsOverflowPx * 100) / 100,
+      overflow_offenders: overflowOffenders.slice(0, 10),
     };
   }).catch((error) => ({
     url: page.url(),
@@ -9576,6 +9889,8 @@ async function captureViewport(viewport) {
     body_text_sample: "",
     scroll_width: 0,
     client_width: viewport.width,
+    bounds_overflow_px: 0,
+    overflow_offenders: [],
     evaluation_error: String(error && error.message ? error.message : error).slice(0, 1000),
   }));
   const selectors = {};
@@ -9614,6 +9929,8 @@ async function captureViewport(viewport) {
     scroll_width: dom.scroll_width,
     client_width: dom.client_width,
     overflow_px: Math.max(0, (dom.scroll_width || 0) - (dom.client_width || viewport.width)),
+    bounds_overflow_px: dom.bounds_overflow_px,
+    overflow_offenders: dom.overflow_offenders || [],
     selectors,
     text_matches,
     setup_action_results: setupActionResults,
@@ -9645,6 +9962,8 @@ function buildProfileEvidence(currentViewports) {
       routes: currentViewports.map((viewport) => viewport.route),
       titles: currentViewports.map((viewport) => viewport.title),
       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),
     },
   };
 }
@@ -9668,24 +9987,36 @@ return result;
 }
 function collectRiddleProfileArtifactRefs(input) {
   const refs = [];
-  const seen = /* @__PURE__ */ new Set();
+  const indexes = /* @__PURE__ */ new Map();
+  const priorities = /* @__PURE__ */ new Map();
   function add(item, source) {
     if (!isRecord2(item)) return;
-    const name = stringValue5(item.name) || stringValue5(item.filename) || "";
     const url = stringValue5(item.url);
     const path6 = stringValue5(item.path);
+    const rawName = stringValue5(item.name) || stringValue5(item.filename) || artifactNameFromPath(url || path6) || "";
+    const name = normalizeRiddleProfileArtifactName(rawName);
     if (!name && !url && !path6) return;
-    const key = `${name}:${url || path6 || ""}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    refs.push({
+    const key = profileArtifactDedupeKey(name, url || path6 || "");
+    const priority = profileArtifactPriority(rawName, name);
+    const ref = {
       name,
       url,
       path: path6,
       kind: stringValue5(item.kind) || stringValue5(item.type),
       content_type: stringValue5(item.content_type) || stringValue5(item.contentType),
       source
-    });
+    };
+    const existingIndex = indexes.get(key);
+    if (existingIndex !== void 0) {
+      if (priority > (priorities.get(key) || 0)) {
+        refs[existingIndex] = ref;
+        priorities.set(key, priority);
+      }
+      return;
+    }
+    indexes.set(key, refs.length);
+    priorities.set(key, priority);
+    refs.push(ref);
   }
   function visit(value, source) {
     if (Array.isArray(value)) {
@@ -9700,6 +10031,31 @@ function collectRiddleProfileArtifactRefs(input) {
   visit(input, "artifacts");
   return refs;
 }
+function normalizeRiddleProfileArtifactName(name) {
+  return name.replace(/\.json\.json$/i, ".json");
+}
+function profileArtifactDedupeKey(name, location) {
+  if (PROFILE_SINGLETON_ARTIFACT_NAMES.has(name.toLowerCase())) return name.toLowerCase();
+  return `${name}:${location}`;
+}
+function profileArtifactPriority(rawName, normalizedName) {
+  const lower = normalizedName.toLowerCase();
+  if (!PROFILE_SINGLETON_ARTIFACT_NAMES.has(lower)) return 1;
+  return /\.json\.json$/i.test(rawName) ? 2 : 1;
+}
+function artifactNameFromPath(value) {
+  if (!value) return "";
+  try {
+    return new URL(value).pathname.split("/").filter(Boolean).pop() || "";
+  } catch {
+    return value.split(/[\\/]/).filter(Boolean).pop() || "";
+  }
+}
+var PROFILE_SINGLETON_ARTIFACT_NAMES = /* @__PURE__ */ new Set([
+  "proof.json",
+  "console.json",
+  "dom-summary.json"
+]);
 function extractRiddleProofProfileResult(input) {
   if (!isRecord2(input)) return void 0;
   if (input.version === RIDDLE_PROOF_PROFILE_RESULT_VERSION) return input;

package/dist/index.d.cts

@@ -9,6 +9,6 @@ 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, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayResponsiveViewportEvidence, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.cjs';
-export { NormalizeRiddleProofProfileOptions, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, RiddleProofProfile, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileResult, RiddleProofProfileRouteEvidence, RiddleProofProfileRunner, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.cjs';
+export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayBoundsOffender, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayResponsiveViewportEvidence, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.cjs';
+export { NormalizeRiddleProofProfileOptions, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, RiddleProofProfile, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileBoundsOffender, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileResult, RiddleProofProfileRouteEvidence, RiddleProofProfileRunner, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.cjs';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, RiddleServerPreviewInput, RiddleServerPreviewResult, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript, runRiddleServerPreview } from './riddle-client.cjs';

package/dist/index.d.ts

@@ -9,6 +9,6 @@ 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, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayResponsiveViewportEvidence, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.js';
-export { NormalizeRiddleProofProfileOptions, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, RiddleProofProfile, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileResult, RiddleProofProfileRouteEvidence, RiddleProofProfileRunner, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.js';
+export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayBoundsOffender, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayResponsiveViewportEvidence, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.js';
+export { NormalizeRiddleProofProfileOptions, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, RiddleProofProfile, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileBoundsOffender, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileResult, RiddleProofProfileRouteEvidence, RiddleProofProfileRunner, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.js';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, RiddleServerPreviewInput, RiddleServerPreviewResult, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript, runRiddleServerPreview } from './riddle-client.js';

package/dist/index.js

@@ -36,7 +36,7 @@ import {
   extractBasicGameplayEvidence,
   resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   sanitizeBasicGameplayJsonString
-} from "./chunk-E6O3EOEI.js";
+} from "./chunk-ELZSPOWV.js";
 import {
   RIDDLE_PROOF_PROFILE_CHECK_TYPES,
   RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,
@@ -58,7 +58,7 @@ import {
   resolveRiddleProofProfileTimeoutSec,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult
-} from "./chunk-TPUR67H5.js";
+} from "./chunk-XOM2OYAB.js";
 import {
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,