@riddledc/riddle-proof 0.7.9 → 0.7.11

package/README.md

@@ -150,7 +150,9 @@ appears only after a picker, tab, login stub, transport control, or other
 bounded interaction. Supported setup actions are `click`, `wait`,
 `wait_for_selector`, and `wait_for_text`; a failed setup action is recorded as
 a failed `setup_actions_succeeded` check so the profile cannot pass without
-reaching the intended state.
+reaching the intended state. Text-matched `click` actions prefer visible
+matching elements, which keeps responsive layouts from selecting hidden desktop
+or mobile-only links.
 
 The result uses `riddle-proof.profile-result.v1` and separates product failures
 from weak proof and environment blockers:

package/dist/{chunk-NUSUGO2P.js → chunk-PZYQGRQ5.js}

@@ -193,13 +193,19 @@ function normalizeRiddleProofProfile(input, options = {}) {
 function resolveRiddleProofProfileTargetUrl(profile) {
   const route = profile.target.route || "";
   const targetUrl = profile.target.url || "";
+  if (targetUrl && route) return resolveRiddleProofProfileRouteUrl(targetUrl, route);
   if (/^https?:\/\//i.test(route)) return route;
-  if (targetUrl && route) return new URL(route, targetUrl).href;
   if (targetUrl) return targetUrl;
   throw new Error("profile target URL could not be resolved.");
 }
-function routeForViewport(viewport) {
-  return viewport?.route || {
+function routeForViewport(viewport, targetUrl) {
+  if (viewport?.route) {
+    return {
+      ...viewport.route,
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
+    };
+  }
+  return {
     requested: "",
     observed: "",
     matched: false,
@@ -225,8 +231,54 @@ function matchText(sample, check) {
   }
   return sample.includes(check.text || "");
 }
-function successfulRoute(route) {
-  return route.matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
+function normalizeRoutePath(path) {
+  const value = path || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(`${mountPrefix}/`)) return route;
+  return `${mountPrefix}${route}`;
+}
+function resolveRiddleProofProfileRouteUrl(targetUrl, route) {
+  if (/^https?:\/\//i.test(route)) return route;
+  if (!targetUrl) return route;
+  if (route.startsWith("/")) {
+    const base = new URL(targetUrl);
+    const mountPrefix = previewMountPrefix(base.pathname);
+    if (mountPrefix) {
+      const routeParts = new URL(route, base.origin);
+      base.pathname = joinMountedRoutePath(mountPrefix, routeParts.pathname);
+      base.search = routeParts.search;
+      base.hash = routeParts.hash;
+      return base.href;
+    }
+  }
+  return new URL(route, targetUrl).href;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function successfulRoute(route, targetUrl) {
+  const matched = route.matched || routePathMatches(route.observed, route.expected_path, targetUrl);
+  return matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
 }
 function assessCheckFromEvidence(check, evidence) {
   const viewports = evidence.viewports || [];
@@ -244,8 +296,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: viewport.route.observed === expectedPath || viewport.route.matched
-    }));
+      matched: routePathMatches(viewport.route.observed, expectedPath, evidence.target_url) || viewport.route.matched
+    }, evidence.target_url));
     return {
       type: check.type,
       label: checkLabel(check),
@@ -420,7 +472,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     runner: options.runner || "riddle",
     status,
     baseline_policy: profile.baseline_policy,
-    route: routeForViewport(firstViewport),
+    route: routeForViewport(firstViewport, evidence?.target_url),
     artifacts: {
       screenshots,
       console: "console.json",
@@ -512,8 +564,37 @@ function createRiddleProofProfileInsufficientResult(input) {
 }
 function runtimeScriptAssessmentSource() {
   return String.raw`
-function routeOk(route) {
-  return Boolean(route && route.matched && !route.error && (route.http_status == null || route.http_status < 400));
+function normalizeRoutePath(path) {
+  const value = path || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : "/" + routePath;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(mountPrefix + "/")) return route;
+  return mountPrefix + route;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function routeOk(route, targetUrl) {
+  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path, targetUrl)) && !route.error && (route.http_status == null || route.http_status < 400));
 }
 function textMatches(sample, check) {
   if (check.pattern) {
@@ -570,8 +651,8 @@ function assessProfile(profile, evidence) {
       const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
       const failed = viewports.filter((viewport) => {
         const route = { ...(viewport.route || {}), expected_path: expectedPath };
-        route.matched = route.observed === expectedPath || route.matched;
-        return !routeOk(route);
+        route.matched = routePathMatches(route.observed, expectedPath, evidence.target_url) || route.matched;
+        return !routeOk(route, evidence.target_url);
       });
       checks.push({
         type: check.type,
@@ -743,6 +824,9 @@ function setupTextMatches(sample, action) {
 async function setupLocatorText(locator, index) {
   return await locator.nth(index).textContent({ timeout: 1000 }).catch(() => "");
 }
+async function setupLocatorVisible(locator, index) {
+  return await locator.nth(index).isVisible({ timeout: 1000 }).catch(() => false);
+}
 async function executeSetupAction(action, ordinal) {
   const type = setupActionType(action);
   const base = { ok: false, action: type || "unknown", ordinal, selector: action.selector || null };
@@ -763,16 +847,26 @@ async function executeSetupAction(action, ordinal) {
       if (!count) return { ...base, reason: "selector_not_found", count };
       let targetIndex = Number.isInteger(action.index) ? action.index : 0;
       let matchedText = null;
+      let hiddenMatchIndex = -1;
+      let hiddenMatchedText = null;
       if (action.text || action.pattern) {
         targetIndex = -1;
         for (let index = 0; index < count; index += 1) {
           const text = await setupLocatorText(locator, index);
           if (setupTextMatches(text, action)) {
-            targetIndex = index;
-            matchedText = text;
-            break;
+            const visible = await setupLocatorVisible(locator, index);
+            if (visible) {
+              targetIndex = index;
+              matchedText = text;
+              break;
+            }
+            if (hiddenMatchIndex < 0) {
+              hiddenMatchIndex = index;
+              hiddenMatchedText = text;
+            }
           }
         }
+        if (targetIndex < 0 && hiddenMatchIndex >= 0) return { ...base, reason: "matching_element_not_visible", count, target_index: hiddenMatchIndex, text: hiddenMatchedText };
         if (targetIndex < 0) return { ...base, reason: "text_not_found", count };
       }
       if (targetIndex < 0 || targetIndex >= count) return { ...base, reason: "index_out_of_range", count, target_index: targetIndex };
@@ -899,7 +993,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: dom.pathname === expectedPath,
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },
@@ -1015,6 +1109,7 @@ export {
   slugifyRiddleProofProfileName,
   normalizeRiddleProofProfile,
   resolveRiddleProofProfileTargetUrl,
+  resolveRiddleProofProfileRouteUrl,
   assessRiddleProofProfileEvidence,
   summarizeRiddleProofProfileResult,
   profileStatusExitCode,

package/dist/cli.cjs

@@ -6972,13 +6972,19 @@ function normalizeRiddleProofProfile(input, options = {}) {
 function resolveRiddleProofProfileTargetUrl(profile) {
   const route = profile.target.route || "";
   const targetUrl = profile.target.url || "";
+  if (targetUrl && route) return resolveRiddleProofProfileRouteUrl(targetUrl, route);
   if (/^https?:\/\//i.test(route)) return route;
-  if (targetUrl && route) return new URL(route, targetUrl).href;
   if (targetUrl) return targetUrl;
   throw new Error("profile target URL could not be resolved.");
 }
-function routeForViewport(viewport) {
-  return viewport?.route || {
+function routeForViewport(viewport, targetUrl) {
+  if (viewport?.route) {
+    return {
+      ...viewport.route,
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
+    };
+  }
+  return {
     requested: "",
     observed: "",
     matched: false,
@@ -7004,8 +7010,54 @@ function matchText(sample, check) {
   }
   return sample.includes(check.text || "");
 }
-function successfulRoute(route) {
-  return route.matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
+function normalizeRoutePath(path7) {
+  const value = path7 || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(`${mountPrefix}/`)) return route;
+  return `${mountPrefix}${route}`;
+}
+function resolveRiddleProofProfileRouteUrl(targetUrl, route) {
+  if (/^https?:\/\//i.test(route)) return route;
+  if (!targetUrl) return route;
+  if (route.startsWith("/")) {
+    const base = new URL(targetUrl);
+    const mountPrefix = previewMountPrefix(base.pathname);
+    if (mountPrefix) {
+      const routeParts = new URL(route, base.origin);
+      base.pathname = joinMountedRoutePath(mountPrefix, routeParts.pathname);
+      base.search = routeParts.search;
+      base.hash = routeParts.hash;
+      return base.href;
+    }
+  }
+  return new URL(route, targetUrl).href;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function successfulRoute(route, targetUrl) {
+  const matched = route.matched || routePathMatches(route.observed, route.expected_path, targetUrl);
+  return matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
 }
 function assessCheckFromEvidence(check, evidence) {
   const viewports = evidence.viewports || [];
@@ -7023,8 +7075,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: viewport.route.observed === expectedPath || viewport.route.matched
-    }));
+      matched: routePathMatches(viewport.route.observed, expectedPath, evidence.target_url) || viewport.route.matched
+    }, evidence.target_url));
     return {
       type: check.type,
       label: checkLabel(check),
@@ -7199,7 +7251,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     runner: options.runner || "riddle",
     status,
     baseline_policy: profile.baseline_policy,
-    route: routeForViewport(firstViewport),
+    route: routeForViewport(firstViewport, evidence?.target_url),
     artifacts: {
       screenshots,
       console: "console.json",
@@ -7275,8 +7327,37 @@ function createRiddleProofProfileInsufficientResult(input) {
 }
 function runtimeScriptAssessmentSource() {
   return String.raw`
-function routeOk(route) {
-  return Boolean(route && route.matched && !route.error && (route.http_status == null || route.http_status < 400));
+function normalizeRoutePath(path) {
+  const value = path || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : "/" + routePath;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(mountPrefix + "/")) return route;
+  return mountPrefix + route;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function routeOk(route, targetUrl) {
+  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path, targetUrl)) && !route.error && (route.http_status == null || route.http_status < 400));
 }
 function textMatches(sample, check) {
   if (check.pattern) {
@@ -7333,8 +7414,8 @@ function assessProfile(profile, evidence) {
       const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
       const failed = viewports.filter((viewport) => {
         const route = { ...(viewport.route || {}), expected_path: expectedPath };
-        route.matched = route.observed === expectedPath || route.matched;
-        return !routeOk(route);
+        route.matched = routePathMatches(route.observed, expectedPath, evidence.target_url) || route.matched;
+        return !routeOk(route, evidence.target_url);
       });
       checks.push({
         type: check.type,
@@ -7506,6 +7587,9 @@ function setupTextMatches(sample, action) {
 async function setupLocatorText(locator, index) {
   return await locator.nth(index).textContent({ timeout: 1000 }).catch(() => "");
 }
+async function setupLocatorVisible(locator, index) {
+  return await locator.nth(index).isVisible({ timeout: 1000 }).catch(() => false);
+}
 async function executeSetupAction(action, ordinal) {
   const type = setupActionType(action);
   const base = { ok: false, action: type || "unknown", ordinal, selector: action.selector || null };
@@ -7526,16 +7610,26 @@ async function executeSetupAction(action, ordinal) {
       if (!count) return { ...base, reason: "selector_not_found", count };
       let targetIndex = Number.isInteger(action.index) ? action.index : 0;
       let matchedText = null;
+      let hiddenMatchIndex = -1;
+      let hiddenMatchedText = null;
       if (action.text || action.pattern) {
         targetIndex = -1;
         for (let index = 0; index < count; index += 1) {
           const text = await setupLocatorText(locator, index);
           if (setupTextMatches(text, action)) {
-            targetIndex = index;
-            matchedText = text;
-            break;
+            const visible = await setupLocatorVisible(locator, index);
+            if (visible) {
+              targetIndex = index;
+              matchedText = text;
+              break;
+            }
+            if (hiddenMatchIndex < 0) {
+              hiddenMatchIndex = index;
+              hiddenMatchedText = text;
+            }
           }
         }
+        if (targetIndex < 0 && hiddenMatchIndex >= 0) return { ...base, reason: "matching_element_not_visible", count, target_index: hiddenMatchIndex, text: hiddenMatchedText };
         if (targetIndex < 0) return { ...base, reason: "text_not_found", count };
       }
       if (targetIndex < 0 || targetIndex >= count) return { ...base, reason: "index_out_of_range", count, target_index: targetIndex };
@@ -7662,7 +7756,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: dom.pathname === expectedPath,
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
   normalizeRiddleProofProfile,
   profileStatusExitCode,
   resolveRiddleProofProfileTargetUrl
-} from "./chunk-NUSUGO2P.js";
+} from "./chunk-PZYQGRQ5.js";
 import {
   createRiddleApiClient,
   parseRiddleViewport

package/dist/index.cjs

@@ -2994,6 +2994,7 @@ __export(index_exports, {
   redactForProofDiagnostics: () => redactForProofDiagnostics,
   resolveBasicGameplayProgressionCheckWithArtifactScreenshots: () => resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey: () => resolveRiddleApiKey,
+  resolveRiddleProofProfileRouteUrl: () => resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl: () => resolveRiddleProofProfileTargetUrl,
   riddleRequestJson: () => riddleRequestJson,
   runCodexExecAgentDoctor: () => runCodexExecAgentDoctor,
@@ -8699,13 +8700,19 @@ function normalizeRiddleProofProfile(input, options = {}) {
 function resolveRiddleProofProfileTargetUrl(profile) {
   const route = profile.target.route || "";
   const targetUrl = profile.target.url || "";
+  if (targetUrl && route) return resolveRiddleProofProfileRouteUrl(targetUrl, route);
   if (/^https?:\/\//i.test(route)) return route;
-  if (targetUrl && route) return new URL(route, targetUrl).href;
   if (targetUrl) return targetUrl;
   throw new Error("profile target URL could not be resolved.");
 }
-function routeForViewport(viewport) {
-  return viewport?.route || {
+function routeForViewport(viewport, targetUrl) {
+  if (viewport?.route) {
+    return {
+      ...viewport.route,
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
+    };
+  }
+  return {
     requested: "",
     observed: "",
     matched: false,
@@ -8731,8 +8738,54 @@ function matchText(sample, check) {
   }
   return sample.includes(check.text || "");
 }
-function successfulRoute(route) {
-  return route.matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
+function normalizeRoutePath(path6) {
+  const value = path6 || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(`${mountPrefix}/`)) return route;
+  return `${mountPrefix}${route}`;
+}
+function resolveRiddleProofProfileRouteUrl(targetUrl, route) {
+  if (/^https?:\/\//i.test(route)) return route;
+  if (!targetUrl) return route;
+  if (route.startsWith("/")) {
+    const base = new URL(targetUrl);
+    const mountPrefix = previewMountPrefix(base.pathname);
+    if (mountPrefix) {
+      const routeParts = new URL(route, base.origin);
+      base.pathname = joinMountedRoutePath(mountPrefix, routeParts.pathname);
+      base.search = routeParts.search;
+      base.hash = routeParts.hash;
+      return base.href;
+    }
+  }
+  return new URL(route, targetUrl).href;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function successfulRoute(route, targetUrl) {
+  const matched = route.matched || routePathMatches(route.observed, route.expected_path, targetUrl);
+  return matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
 }
 function assessCheckFromEvidence(check, evidence) {
   const viewports = evidence.viewports || [];
@@ -8750,8 +8803,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: viewport.route.observed === expectedPath || viewport.route.matched
-    }));
+      matched: routePathMatches(viewport.route.observed, expectedPath, evidence.target_url) || viewport.route.matched
+    }, evidence.target_url));
     return {
       type: check.type,
       label: checkLabel(check),
@@ -8926,7 +8979,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     runner: options.runner || "riddle",
     status,
     baseline_policy: profile.baseline_policy,
-    route: routeForViewport(firstViewport),
+    route: routeForViewport(firstViewport, evidence?.target_url),
     artifacts: {
       screenshots,
       console: "console.json",
@@ -9018,8 +9071,37 @@ function createRiddleProofProfileInsufficientResult(input) {
 }
 function runtimeScriptAssessmentSource() {
   return String.raw`
-function routeOk(route) {
-  return Boolean(route && route.matched && !route.error && (route.http_status == null || route.http_status < 400));
+function normalizeRoutePath(path) {
+  const value = path || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : "/" + routePath;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(mountPrefix + "/")) return route;
+  return mountPrefix + route;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function routeOk(route, targetUrl) {
+  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path, targetUrl)) && !route.error && (route.http_status == null || route.http_status < 400));
 }
 function textMatches(sample, check) {
   if (check.pattern) {
@@ -9076,8 +9158,8 @@ function assessProfile(profile, evidence) {
       const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
       const failed = viewports.filter((viewport) => {
         const route = { ...(viewport.route || {}), expected_path: expectedPath };
-        route.matched = route.observed === expectedPath || route.matched;
-        return !routeOk(route);
+        route.matched = routePathMatches(route.observed, expectedPath, evidence.target_url) || route.matched;
+        return !routeOk(route, evidence.target_url);
       });
       checks.push({
         type: check.type,
@@ -9249,6 +9331,9 @@ function setupTextMatches(sample, action) {
 async function setupLocatorText(locator, index) {
   return await locator.nth(index).textContent({ timeout: 1000 }).catch(() => "");
 }
+async function setupLocatorVisible(locator, index) {
+  return await locator.nth(index).isVisible({ timeout: 1000 }).catch(() => false);
+}
 async function executeSetupAction(action, ordinal) {
   const type = setupActionType(action);
   const base = { ok: false, action: type || "unknown", ordinal, selector: action.selector || null };
@@ -9269,16 +9354,26 @@ async function executeSetupAction(action, ordinal) {
       if (!count) return { ...base, reason: "selector_not_found", count };
       let targetIndex = Number.isInteger(action.index) ? action.index : 0;
       let matchedText = null;
+      let hiddenMatchIndex = -1;
+      let hiddenMatchedText = null;
       if (action.text || action.pattern) {
         targetIndex = -1;
         for (let index = 0; index < count; index += 1) {
           const text = await setupLocatorText(locator, index);
           if (setupTextMatches(text, action)) {
-            targetIndex = index;
-            matchedText = text;
-            break;
+            const visible = await setupLocatorVisible(locator, index);
+            if (visible) {
+              targetIndex = index;
+              matchedText = text;
+              break;
+            }
+            if (hiddenMatchIndex < 0) {
+              hiddenMatchIndex = index;
+              hiddenMatchedText = text;
+            }
           }
         }
+        if (targetIndex < 0 && hiddenMatchIndex >= 0) return { ...base, reason: "matching_element_not_visible", count, target_index: hiddenMatchIndex, text: hiddenMatchedText };
         if (targetIndex < 0) return { ...base, reason: "text_not_found", count };
       }
       if (targetIndex < 0 || targetIndex >= count) return { ...base, reason: "index_out_of_range", count, target_index: targetIndex };
@@ -9405,7 +9500,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: dom.pathname === expectedPath,
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },
@@ -9840,6 +9935,7 @@ function createRiddleApiClient(config = {}) {
   redactForProofDiagnostics,
   resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey,
+  resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl,
   riddleRequestJson,
   runCodexExecAgentDoctor,

package/dist/index.d.cts

@@ -10,5 +10,5 @@ export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_D
 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, 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, resolveRiddleProofProfileTargetUrl, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.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, 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

@@ -10,5 +10,5 @@ export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_D
 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, 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, resolveRiddleProofProfileTargetUrl, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.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, 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

@@ -53,10 +53,11 @@ import {
   extractRiddleProofProfileResult,
   normalizeRiddleProofProfile,
   profileStatusExitCode,
+  resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult
-} from "./chunk-NUSUGO2P.js";
+} from "./chunk-PZYQGRQ5.js";
 import {
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,
@@ -231,6 +232,7 @@ export {
   redactForProofDiagnostics,
   resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   resolveRiddleApiKey,
+  resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl,
   riddleRequestJson,
   runCodexExecAgentDoctor,

package/dist/profile.cjs

@@ -35,6 +35,7 @@ __export(profile_exports, {
   extractRiddleProofProfileResult: () => extractRiddleProofProfileResult,
   normalizeRiddleProofProfile: () => normalizeRiddleProofProfile,
   profileStatusExitCode: () => profileStatusExitCode,
+  resolveRiddleProofProfileRouteUrl: () => resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl: () => resolveRiddleProofProfileTargetUrl,
   slugifyRiddleProofProfileName: () => slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult: () => summarizeRiddleProofProfileResult
@@ -234,13 +235,19 @@ function normalizeRiddleProofProfile(input, options = {}) {
 function resolveRiddleProofProfileTargetUrl(profile) {
   const route = profile.target.route || "";
   const targetUrl = profile.target.url || "";
+  if (targetUrl && route) return resolveRiddleProofProfileRouteUrl(targetUrl, route);
   if (/^https?:\/\//i.test(route)) return route;
-  if (targetUrl && route) return new URL(route, targetUrl).href;
   if (targetUrl) return targetUrl;
   throw new Error("profile target URL could not be resolved.");
 }
-function routeForViewport(viewport) {
-  return viewport?.route || {
+function routeForViewport(viewport, targetUrl) {
+  if (viewport?.route) {
+    return {
+      ...viewport.route,
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
+    };
+  }
+  return {
     requested: "",
     observed: "",
     matched: false,
@@ -266,8 +273,54 @@ function matchText(sample, check) {
   }
   return sample.includes(check.text || "");
 }
-function successfulRoute(route) {
-  return route.matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
+function normalizeRoutePath(path) {
+  const value = path || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(`${mountPrefix}/`)) return route;
+  return `${mountPrefix}${route}`;
+}
+function resolveRiddleProofProfileRouteUrl(targetUrl, route) {
+  if (/^https?:\/\//i.test(route)) return route;
+  if (!targetUrl) return route;
+  if (route.startsWith("/")) {
+    const base = new URL(targetUrl);
+    const mountPrefix = previewMountPrefix(base.pathname);
+    if (mountPrefix) {
+      const routeParts = new URL(route, base.origin);
+      base.pathname = joinMountedRoutePath(mountPrefix, routeParts.pathname);
+      base.search = routeParts.search;
+      base.hash = routeParts.hash;
+      return base.href;
+    }
+  }
+  return new URL(route, targetUrl).href;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function successfulRoute(route, targetUrl) {
+  const matched = route.matched || routePathMatches(route.observed, route.expected_path, targetUrl);
+  return matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
 }
 function assessCheckFromEvidence(check, evidence) {
   const viewports = evidence.viewports || [];
@@ -285,8 +338,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: viewport.route.observed === expectedPath || viewport.route.matched
-    }));
+      matched: routePathMatches(viewport.route.observed, expectedPath, evidence.target_url) || viewport.route.matched
+    }, evidence.target_url));
     return {
       type: check.type,
       label: checkLabel(check),
@@ -461,7 +514,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     runner: options.runner || "riddle",
     status,
     baseline_policy: profile.baseline_policy,
-    route: routeForViewport(firstViewport),
+    route: routeForViewport(firstViewport, evidence?.target_url),
     artifacts: {
       screenshots,
       console: "console.json",
@@ -553,8 +606,37 @@ function createRiddleProofProfileInsufficientResult(input) {
 }
 function runtimeScriptAssessmentSource() {
   return String.raw`
-function routeOk(route) {
-  return Boolean(route && route.matched && !route.error && (route.http_status == null || route.http_status < 400));
+function normalizeRoutePath(path) {
+  const value = path || "/";
+  if (value === "/") return "/";
+  return value.replace(/\/+$/, "") || "/";
+}
+function previewMountPrefix(pathname) {
+  const value = pathname || "/";
+  const apiPreview = value.match(/^(\/s\/[^/]+)(?:\/|$)/);
+  if (apiPreview) return apiPreview[1];
+  const internalPreview = value.match(/^(\/preview\/[^/]+\/[^/]+)(?:\/|$)/);
+  return internalPreview ? internalPreview[1] : "";
+}
+function joinMountedRoutePath(mountPrefix, routePath) {
+  const route = routePath.startsWith("/") ? routePath : "/" + routePath;
+  if (!mountPrefix) return route;
+  if (route === mountPrefix || route.startsWith(mountPrefix + "/")) return route;
+  return mountPrefix + route;
+}
+function mountedExpectedRoutePath(targetUrl, expected) {
+  if (!targetUrl || !expected || !expected.startsWith("/")) return expected;
+  const mountPrefix = previewMountPrefix(new URL(targetUrl).pathname);
+  return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
+}
+function routePathMatches(observed, expected, targetUrl) {
+  const normalizedObserved = normalizeRoutePath(observed);
+  const normalizedExpected = normalizeRoutePath(expected);
+  if (normalizedObserved === normalizedExpected) return true;
+  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+}
+function routeOk(route, targetUrl) {
+  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path, targetUrl)) && !route.error && (route.http_status == null || route.http_status < 400));
 }
 function textMatches(sample, check) {
   if (check.pattern) {
@@ -611,8 +693,8 @@ function assessProfile(profile, evidence) {
       const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
       const failed = viewports.filter((viewport) => {
         const route = { ...(viewport.route || {}), expected_path: expectedPath };
-        route.matched = route.observed === expectedPath || route.matched;
-        return !routeOk(route);
+        route.matched = routePathMatches(route.observed, expectedPath, evidence.target_url) || route.matched;
+        return !routeOk(route, evidence.target_url);
       });
       checks.push({
         type: check.type,
@@ -784,6 +866,9 @@ function setupTextMatches(sample, action) {
 async function setupLocatorText(locator, index) {
   return await locator.nth(index).textContent({ timeout: 1000 }).catch(() => "");
 }
+async function setupLocatorVisible(locator, index) {
+  return await locator.nth(index).isVisible({ timeout: 1000 }).catch(() => false);
+}
 async function executeSetupAction(action, ordinal) {
   const type = setupActionType(action);
   const base = { ok: false, action: type || "unknown", ordinal, selector: action.selector || null };
@@ -804,16 +889,26 @@ async function executeSetupAction(action, ordinal) {
       if (!count) return { ...base, reason: "selector_not_found", count };
       let targetIndex = Number.isInteger(action.index) ? action.index : 0;
       let matchedText = null;
+      let hiddenMatchIndex = -1;
+      let hiddenMatchedText = null;
       if (action.text || action.pattern) {
         targetIndex = -1;
         for (let index = 0; index < count; index += 1) {
           const text = await setupLocatorText(locator, index);
           if (setupTextMatches(text, action)) {
-            targetIndex = index;
-            matchedText = text;
-            break;
+            const visible = await setupLocatorVisible(locator, index);
+            if (visible) {
+              targetIndex = index;
+              matchedText = text;
+              break;
+            }
+            if (hiddenMatchIndex < 0) {
+              hiddenMatchIndex = index;
+              hiddenMatchedText = text;
+            }
           }
         }
+        if (targetIndex < 0 && hiddenMatchIndex >= 0) return { ...base, reason: "matching_element_not_visible", count, target_index: hiddenMatchIndex, text: hiddenMatchedText };
         if (targetIndex < 0) return { ...base, reason: "text_not_found", count };
       }
       if (targetIndex < 0 || targetIndex >= count) return { ...base, reason: "index_out_of_range", count, target_index: targetIndex };
@@ -940,7 +1035,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: dom.pathname === expectedPath,
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },
@@ -1062,6 +1157,7 @@ function extractRiddleProofProfileResult(input) {
   extractRiddleProofProfileResult,
   normalizeRiddleProofProfile,
   profileStatusExitCode,
+  resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult

package/dist/profile.d.cts

@@ -157,6 +157,7 @@ interface NormalizeRiddleProofProfileOptions {
 declare function slugifyRiddleProofProfileName(value: string): string;
 declare function normalizeRiddleProofProfile(input: unknown, options?: NormalizeRiddleProofProfileOptions): RiddleProofProfile;
 declare function resolveRiddleProofProfileTargetUrl(profile: RiddleProofProfile): string;
+declare function resolveRiddleProofProfileRouteUrl(targetUrl: string, route: string): string;
 declare function assessRiddleProofProfileEvidence(profile: RiddleProofProfile, evidence: RiddleProofProfileEvidence | undefined, options?: {
     runner?: RiddleProofProfileRunner;
     riddle?: RiddleProofProfileResult["riddle"];
@@ -188,4 +189,4 @@ declare function buildRiddleProofProfileScript(profile: RiddleProofProfile): str
 declare function collectRiddleProfileArtifactRefs(input: unknown): RiddleProofProfileArtifactRef[];
 declare function extractRiddleProofProfileResult(input: unknown): RiddleProofProfileResult | undefined;
 
-export { type 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, type RiddleProofProfile, type RiddleProofProfileArtifactRef, type RiddleProofProfileBaselinePolicy, type RiddleProofProfileCheck, type RiddleProofProfileCheckResult, type RiddleProofProfileCheckType, type RiddleProofProfileEvidence, type RiddleProofProfileFailureAction, type RiddleProofProfileResult, type RiddleProofProfileRouteEvidence, type RiddleProofProfileRunner, type RiddleProofProfileSetupAction, type RiddleProofProfileSetupActionType, type RiddleProofProfileStatus, type RiddleProofProfileTarget, type RiddleProofProfileViewport, type RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileTargetUrl, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult };
+export { type 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, type RiddleProofProfile, type RiddleProofProfileArtifactRef, type RiddleProofProfileBaselinePolicy, type RiddleProofProfileCheck, type RiddleProofProfileCheckResult, type RiddleProofProfileCheckType, type RiddleProofProfileEvidence, type RiddleProofProfileFailureAction, type RiddleProofProfileResult, type RiddleProofProfileRouteEvidence, type RiddleProofProfileRunner, type RiddleProofProfileSetupAction, type RiddleProofProfileSetupActionType, type RiddleProofProfileStatus, type RiddleProofProfileTarget, type RiddleProofProfileViewport, type RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult };

package/dist/profile.d.ts

@@ -157,6 +157,7 @@ interface NormalizeRiddleProofProfileOptions {
 declare function slugifyRiddleProofProfileName(value: string): string;
 declare function normalizeRiddleProofProfile(input: unknown, options?: NormalizeRiddleProofProfileOptions): RiddleProofProfile;
 declare function resolveRiddleProofProfileTargetUrl(profile: RiddleProofProfile): string;
+declare function resolveRiddleProofProfileRouteUrl(targetUrl: string, route: string): string;
 declare function assessRiddleProofProfileEvidence(profile: RiddleProofProfile, evidence: RiddleProofProfileEvidence | undefined, options?: {
     runner?: RiddleProofProfileRunner;
     riddle?: RiddleProofProfileResult["riddle"];
@@ -188,4 +189,4 @@ declare function buildRiddleProofProfileScript(profile: RiddleProofProfile): str
 declare function collectRiddleProfileArtifactRefs(input: unknown): RiddleProofProfileArtifactRef[];
 declare function extractRiddleProofProfileResult(input: unknown): RiddleProofProfileResult | undefined;
 
-export { type 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, type RiddleProofProfile, type RiddleProofProfileArtifactRef, type RiddleProofProfileBaselinePolicy, type RiddleProofProfileCheck, type RiddleProofProfileCheckResult, type RiddleProofProfileCheckType, type RiddleProofProfileEvidence, type RiddleProofProfileFailureAction, type RiddleProofProfileResult, type RiddleProofProfileRouteEvidence, type RiddleProofProfileRunner, type RiddleProofProfileSetupAction, type RiddleProofProfileSetupActionType, type RiddleProofProfileStatus, type RiddleProofProfileTarget, type RiddleProofProfileViewport, type RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileTargetUrl, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult };
+export { type 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, type RiddleProofProfile, type RiddleProofProfileArtifactRef, type RiddleProofProfileBaselinePolicy, type RiddleProofProfileCheck, type RiddleProofProfileCheckResult, type RiddleProofProfileCheckType, type RiddleProofProfileEvidence, type RiddleProofProfileFailureAction, type RiddleProofProfileResult, type RiddleProofProfileRouteEvidence, type RiddleProofProfileRunner, type RiddleProofProfileSetupAction, type RiddleProofProfileSetupActionType, type RiddleProofProfileStatus, type RiddleProofProfileTarget, type RiddleProofProfileViewport, type RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult };

package/dist/profile.js

@@ -14,10 +14,11 @@ import {
   extractRiddleProofProfileResult,
   normalizeRiddleProofProfile,
   profileStatusExitCode,
+  resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult
-} from "./chunk-NUSUGO2P.js";
+} from "./chunk-PZYQGRQ5.js";
 export {
   RIDDLE_PROOF_PROFILE_CHECK_TYPES,
   RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,
@@ -34,6 +35,7 @@ export {
   extractRiddleProofProfileResult,
   normalizeRiddleProofProfile,
   profileStatusExitCode,
+  resolveRiddleProofProfileRouteUrl,
   resolveRiddleProofProfileTargetUrl,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult

package/dist/proof-run-engine.d.cts

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;

package/dist/proof-run-engine.d.ts

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",