@riddledc/riddle-proof 0.7.10 → 0.7.12

package/dist/{chunk-3CVGVQTQ.js → chunk-5KOHSE4V.js}

@@ -186,6 +186,7 @@ async function runRiddleScript(config, input) {
   };
   if (input.viewport) payload.viewport = input.viewport;
   if (input.include) payload.include = input.include;
+  if (typeof input.strict === "boolean") payload.strict = input.strict;
   if (input.options) payload.options = input.options;
   return riddleRequestJson(config, "/v1/run", {
     method: "POST",

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

@@ -193,16 +193,16 @@ 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) {
+function routeForViewport(viewport, targetUrl) {
   if (viewport?.route) {
     return {
       ...viewport.route,
-      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path)
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
     };
   }
   return {
@@ -236,11 +236,48 @@ function normalizeRoutePath(path) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
+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 successfulRoute(route) {
-  const matched = route.matched || routePathMatches(route.observed, route.expected_path);
+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) {
@@ -259,8 +296,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: routePathMatches(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),
@@ -435,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",
@@ -532,11 +569,32 @@ function normalizeRoutePath(path) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
+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) {
-  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path)) && !route.error && (route.http_status == null || route.http_status < 400));
+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) {
@@ -593,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 = routePathMatches(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,
@@ -935,7 +993,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: routePathMatches(dom.pathname, expectedPath),
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },
@@ -1051,6 +1109,7 @@ export {
   slugifyRiddleProofProfileName,
   normalizeRiddleProofProfile,
   resolveRiddleProofProfileTargetUrl,
+  resolveRiddleProofProfileRouteUrl,
   assessRiddleProofProfileEvidence,
   summarizeRiddleProofProfileResult,
   profileStatusExitCode,

package/dist/cli.cjs

@@ -6733,6 +6733,7 @@ async function runRiddleScript(config, input) {
   };
   if (input.viewport) payload.viewport = input.viewport;
   if (input.include) payload.include = input.include;
+  if (typeof input.strict === "boolean") payload.strict = input.strict;
   if (input.options) payload.options = input.options;
   return riddleRequestJson(config, "/v1/run", {
     method: "POST",
@@ -6972,16 +6973,16 @@ 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) {
+function routeForViewport(viewport, targetUrl) {
   if (viewport?.route) {
     return {
       ...viewport.route,
-      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path)
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
     };
   }
   return {
@@ -7015,11 +7016,48 @@ function normalizeRoutePath(path7) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
+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 successfulRoute(route) {
-  const matched = route.matched || routePathMatches(route.observed, route.expected_path);
+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) {
@@ -7038,8 +7076,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: routePathMatches(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),
@@ -7214,7 +7252,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",
@@ -7295,11 +7333,32 @@ function normalizeRoutePath(path) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
-}
-function routeOk(route) {
-  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path)) && !route.error && (route.http_status == null || route.http_status < 400));
+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) {
@@ -7356,8 +7415,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 = routePathMatches(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,
@@ -7698,7 +7757,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: routePathMatches(dom.pathname, expectedPath),
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },

package/dist/cli.js

@@ -9,11 +9,11 @@ import {
   normalizeRiddleProofProfile,
   profileStatusExitCode,
   resolveRiddleProofProfileTargetUrl
-} from "./chunk-A7RJZD4I.js";
+} from "./chunk-PZYQGRQ5.js";
 import {
   createRiddleApiClient,
   parseRiddleViewport
-} from "./chunk-3CVGVQTQ.js";
+} from "./chunk-5KOHSE4V.js";
 import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,

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,16 +8700,16 @@ 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) {
+function routeForViewport(viewport, targetUrl) {
   if (viewport?.route) {
     return {
       ...viewport.route,
-      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path)
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
     };
   }
   return {
@@ -8742,11 +8743,48 @@ function normalizeRoutePath(path6) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
+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 successfulRoute(route) {
-  const matched = route.matched || routePathMatches(route.observed, route.expected_path);
+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) {
@@ -8765,8 +8803,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: routePathMatches(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),
@@ -8941,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",
@@ -9038,11 +9076,32 @@ function normalizeRoutePath(path) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
-}
-function routeOk(route) {
-  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path)) && !route.error && (route.http_status == null || route.http_status < 400));
+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) {
@@ -9099,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 = routePathMatches(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,
@@ -9441,7 +9500,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: routePathMatches(dom.pathname, expectedPath),
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },
@@ -9735,6 +9794,7 @@ async function runRiddleScript(config, input) {
   };
   if (input.viewport) payload.viewport = input.viewport;
   if (input.include) payload.include = input.include;
+  if (typeof input.strict === "boolean") payload.strict = input.strict;
   if (input.options) payload.options = input.options;
   return riddleRequestJson(config, "/v1/run", {
     method: "POST",
@@ -9876,6 +9936,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-A7RJZD4I.js";
+} from "./chunk-PZYQGRQ5.js";
 import {
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,
@@ -70,7 +71,7 @@ import {
   riddleRequestJson,
   runRiddleScript,
   runRiddleServerPreview
-} from "./chunk-3CVGVQTQ.js";
+} from "./chunk-5KOHSE4V.js";
 import {
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
@@ -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,16 +235,16 @@ 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) {
+function routeForViewport(viewport, targetUrl) {
   if (viewport?.route) {
     return {
       ...viewport.route,
-      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path)
+      matched: viewport.route.matched || routePathMatches(viewport.route.observed, viewport.route.expected_path, targetUrl)
     };
   }
   return {
@@ -277,11 +278,48 @@ function normalizeRoutePath(path) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
+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 successfulRoute(route) {
-  const matched = route.matched || routePathMatches(route.observed, route.expected_path);
+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) {
@@ -300,8 +338,8 @@ function assessCheckFromEvidence(check, evidence) {
     const failed = viewports.filter((viewport) => !successfulRoute({
       ...viewport.route,
       expected_path: expectedPath,
-      matched: routePathMatches(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),
@@ -476,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",
@@ -573,11 +611,32 @@ function normalizeRoutePath(path) {
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
 }
-function routePathMatches(observed, expected) {
-  return normalizeRoutePath(observed) === normalizeRoutePath(expected);
+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) {
-  return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path)) && !route.error && (route.http_status == null || route.http_status < 400));
+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) {
@@ -634,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 = routePathMatches(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,
@@ -976,7 +1035,7 @@ async function captureViewport(viewport) {
       requested: targetUrl,
       observed: dom.pathname,
       expected_path: expectedPath,
-      matched: routePathMatches(dom.pathname, expectedPath),
+      matched: routePathMatches(dom.pathname, expectedPath, targetUrl),
       http_status: httpStatus,
       error: navigationError || waitError || undefined,
     },
@@ -1098,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-A7RJZD4I.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: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "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: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "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: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "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: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "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: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "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: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;

package/dist/riddle-client.cjs

@@ -231,6 +231,7 @@ async function runRiddleScript(config, input) {
   };
   if (input.viewport) payload.viewport = input.viewport;
   if (input.include) payload.include = input.include;
+  if (typeof input.strict === "boolean") payload.strict = input.strict;
   if (input.options) payload.options = input.options;
   return riddleRequestJson(config, "/v1/run", {
     method: "POST",

package/dist/riddle-client.d.cts

@@ -26,6 +26,7 @@ interface RiddleRunScriptInput {
     };
     timeoutSec?: number;
     sync?: boolean;
+    strict?: boolean;
     include?: string[];
     options?: Record<string, unknown>;
 }

package/dist/riddle-client.d.ts

@@ -26,6 +26,7 @@ interface RiddleRunScriptInput {
     };
     timeoutSec?: number;
     sync?: boolean;
+    strict?: boolean;
     include?: string[];
     options?: Record<string, unknown>;
 }

package/dist/riddle-client.js

@@ -11,7 +11,7 @@ import {
   riddleRequestJson,
   runRiddleScript,
   runRiddleServerPreview
-} from "./chunk-3CVGVQTQ.js";
+} from "./chunk-5KOHSE4V.js";
 export {
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,

package/package.json

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