@riddledc/riddle-proof 0.8.78 → 0.8.80

package/dist/profile.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var profile_exports = {};
 __export(profile_exports, {
   RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS: () => RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS,
+  RIDDLE_PROOF_ORDERED_TRACE_OPERATORS: () => RIDDLE_PROOF_ORDERED_TRACE_OPERATORS,
   RIDDLE_PROOF_PROFILE_CHECK_TYPES: () => RIDDLE_PROOF_PROFILE_CHECK_TYPES,
   RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION: () => RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,
   RIDDLE_PROOF_PROFILE_NETWORK_ABORT_ERROR_CODES: () => RIDDLE_PROOF_PROFILE_NETWORK_ABORT_ERROR_CODES,
@@ -29,6 +30,8 @@ __export(profile_exports, {
   RIDDLE_PROOF_PROFILE_STATUSES: () => RIDDLE_PROOF_PROFILE_STATUSES,
   RIDDLE_PROOF_PROFILE_VERSION: () => RIDDLE_PROOF_PROFILE_VERSION,
   applyRiddleProofProfileArtifactCompleteness: () => applyRiddleProofProfileArtifactCompleteness,
+  assessRiddleProofOrderedTrace: () => assessRiddleProofOrderedTrace,
+  assessRiddleProofOrderedTraceSetupResults: () => assessRiddleProofOrderedTraceSetupResults,
   assessRiddleProofProfileArtifactCompleteness: () => assessRiddleProofProfileArtifactCompleteness,
   assessRiddleProofProfileEvidence: () => assessRiddleProofProfileEvidence,
   buildRiddleProofProfileScript: () => buildRiddleProofProfileScript,
@@ -77,6 +80,7 @@ var RIDDLE_PROOF_PROFILE_CHECK_TYPES = [
   "selector_text_visible",
   "selector_text_absent",
   "selector_text_order",
+  "ordered_trace",
   "observe_within",
   "frame_text_visible",
   "frame_url_equals",
@@ -140,6 +144,21 @@ var RIDDLE_PROOF_PROFILE_NETWORK_ABORT_ERROR_CODES = [
   "timedout",
   "failed"
 ];
+var RIDDLE_PROOF_ORDERED_TRACE_OPERATORS = [
+  "exists",
+  "equals",
+  "not_equals",
+  "truthy",
+  "falsy",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "abs_gt",
+  "abs_gte",
+  "abs_lt",
+  "abs_lte"
+];
 function uniqueNonEmptyStrings(values) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -431,6 +450,185 @@ function resolveJsonPath(root, path) {
   }
   return { exists: true, value: current };
 }
+function assessRiddleProofOrderedTrace(trace, events) {
+  const insufficient = (reason, traceLength = Array.isArray(trace) ? trace.length : 0, witnesses2 = [], missingEvent, missingPaths) => ({
+    version: "riddle-proof.ordered-trace-assessment.v1",
+    status: "proof_insufficient",
+    trace_length: traceLength,
+    witnesses: witnesses2,
+    missing_event: missingEvent,
+    missing_paths: missingPaths,
+    reason
+  });
+  const parsePath = (path) => {
+    const segments = [];
+    let token = "";
+    const pushToken = () => {
+      const value = token.trim();
+      if (value) segments.push(value);
+      token = "";
+    };
+    for (let index = 0; index < path.length; index += 1) {
+      const char = path[index];
+      if (char === ".") {
+        pushToken();
+        continue;
+      }
+      if (char !== "[") {
+        token += char;
+        continue;
+      }
+      pushToken();
+      const closeIndex = path.indexOf("]", index + 1);
+      if (closeIndex === -1) throw new Error(`unterminated bracket at ${index}`);
+      const bracket = path.slice(index + 1, closeIndex).trim();
+      if (!bracket) throw new Error(`empty bracket at ${index}`);
+      if (/^\d+$/.test(bracket)) {
+        segments.push(Number(bracket));
+      } else {
+        segments.push(bracket.replace(/^['"]|['"]$/g, ""));
+      }
+      index = closeIndex;
+    }
+    pushToken();
+    return segments;
+  };
+  const resolve = (root, path) => {
+    let segments;
+    try {
+      segments = parsePath(path);
+    } catch {
+      return { exists: false };
+    }
+    let current = root;
+    for (const segment of segments) {
+      if (Array.isArray(current)) {
+        const index = typeof segment === "number" ? segment : /^\d+$/.test(segment) ? Number(segment) : -1;
+        if (index < 0 || index >= current.length) return { exists: false };
+        current = current[index];
+        continue;
+      }
+      if (typeof segment !== "string" || current === null || typeof current !== "object") return { exists: false };
+      if (!Object.hasOwn(current, segment)) return { exists: false };
+      current = current[segment];
+    }
+    return { exists: true, value: current };
+  };
+  const valuesEqual = (left, right) => {
+    if (Object.is(left, right)) return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+      return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => valuesEqual(value, right[index]));
+    }
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).sort();
+    const rightKeys = Object.keys(rightRecord).sort();
+    return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && valuesEqual(leftRecord[key], rightRecord[key]));
+  };
+  const numericOperator = (op) => [
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "abs_gt",
+    "abs_gte",
+    "abs_lt",
+    "abs_lte"
+  ].includes(op);
+  const matches = (value, predicate) => {
+    if (predicate.op === "exists") return true;
+    if (predicate.op === "equals") return valuesEqual(value, predicate.value);
+    if (predicate.op === "not_equals") return !valuesEqual(value, predicate.value);
+    if (predicate.op === "truthy") return Boolean(value);
+    if (predicate.op === "falsy") return !value;
+    const observed = typeof value === "number" ? value : Number.NaN;
+    const expected = typeof predicate.value === "number" ? predicate.value : Number.NaN;
+    if (!Number.isFinite(observed) || !Number.isFinite(expected)) return false;
+    const candidate = predicate.op.startsWith("abs_") ? Math.abs(observed) : observed;
+    if (predicate.op === "gt" || predicate.op === "abs_gt") return candidate > expected;
+    if (predicate.op === "gte" || predicate.op === "abs_gte") return candidate >= expected;
+    if (predicate.op === "lt" || predicate.op === "abs_lt") return candidate < expected;
+    return candidate <= expected;
+  };
+  if (!Array.isArray(trace) || trace.length === 0) return insufficient("trace_missing_or_empty");
+  if (!Array.isArray(events) || events.length === 0) return insufficient("events_missing", trace.length);
+  for (const event of events) {
+    const missingPaths = event.predicates.filter((predicate) => !trace.some((sample) => {
+      const resolved = resolve(sample, predicate.path);
+      return resolved.exists && (!numericOperator(predicate.op) || typeof resolved.value === "number" && Number.isFinite(resolved.value));
+    })).map((predicate) => predicate.path);
+    if (missingPaths.length) {
+      return insufficient("required_trace_field_missing", trace.length, [], event.label, Array.from(new Set(missingPaths)));
+    }
+  }
+  const witnesses = [];
+  let cursor = 0;
+  for (const event of events) {
+    let witnessIndex = -1;
+    for (let index = cursor; index < trace.length; index += 1) {
+      if (event.predicates.every((predicate) => {
+        const resolved = resolve(trace[index], predicate.path);
+        return resolved.exists && matches(resolved.value, predicate);
+      })) {
+        witnessIndex = index;
+        break;
+      }
+    }
+    if (witnessIndex < 0) {
+      return {
+        version: "riddle-proof.ordered-trace-assessment.v1",
+        status: "failed",
+        trace_length: trace.length,
+        witnesses,
+        missing_event: event.label,
+        reason: "ordered_event_not_observed"
+      };
+    }
+    witnesses.push({
+      label: event.label,
+      index: witnessIndex,
+      observations: event.predicates.map((predicate) => {
+        const observed = resolve(trace[witnessIndex], predicate.path).value;
+        return {
+          path: predicate.path,
+          op: predicate.op,
+          expected: predicate.value,
+          observed
+        };
+      })
+    });
+    cursor = witnessIndex + 1;
+  }
+  return {
+    version: "riddle-proof.ordered-trace-assessment.v1",
+    status: "passed",
+    trace_length: trace.length,
+    witnesses
+  };
+}
+function assessRiddleProofOrderedTraceSetupResults(results, setupActionLabel, tracePath, events) {
+  const insufficient = (reason) => ({
+    version: "riddle-proof.ordered-trace-assessment.v1",
+    status: "proof_insufficient",
+    trace_length: 0,
+    witnesses: [],
+    reason
+  });
+  if (!Array.isArray(results)) return insufficient("setup_results_missing");
+  const source = results.find((item) => item && typeof item === "object" && !Array.isArray(item) && item.label === setupActionLabel);
+  if (!source) return insufficient("setup_action_result_missing");
+  if (!Object.hasOwn(source, "returned")) return insufficient("setup_action_return_missing");
+  const segments = tracePath.split(".").map((segment) => segment.trim()).filter(Boolean);
+  let trace = source.returned;
+  for (const segment of segments) {
+    if (trace === null || typeof trace !== "object" || Array.isArray(trace) || !Object.hasOwn(trace, segment)) {
+      return insufficient("trace_path_missing");
+    }
+    trace = trace[segment];
+  }
+  return assessRiddleProofOrderedTrace(trace, events);
+}
 function evaluateHttpStatusBodyJsonAssertion(root, assertion) {
   const resolved = resolveJsonPath(root, assertion.path);
   const errors = [];
@@ -537,6 +735,7 @@ function profileSetupWindowCallReceipts(results) {
   return results.filter((result) => profileSetupResultAction(result) === "window_call").map((result) => {
     const receipt = {
       ordinal: result.ordinal ?? null,
+      label: result.label ?? null,
       ok: result.ok !== false,
       path: result.path ?? null,
       return_captured: result.return_captured ?? null,
@@ -555,6 +754,7 @@ function profileSetupWindowEvalReceipts(results) {
   return results.filter((result) => profileSetupResultAction(result) === "window_eval").map((result) => {
     const receipt = {
       ordinal: result.ordinal ?? null,
+      label: result.label ?? null,
       ok: result.ok !== false,
       script_length: result.script_length ?? null,
       return_captured: result.return_captured ?? null,
@@ -1827,6 +2027,51 @@ function dialogCountFieldForCheckType(type) {
   if (type === "dialog_dismiss_count_equals") return "dialog_dismiss_count";
   return "dialog_count";
 }
+function normalizeOrderedTraceEvents(value, label) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || !value.length) throw new Error(`${label} must be a non-empty array.`);
+  const seenLabels = /* @__PURE__ */ new Set();
+  return value.map((item, eventIndex) => {
+    const eventLabel = `${label}[${eventIndex}]`;
+    if (!isRecord(item)) throw new Error(`${eventLabel} must be an object.`);
+    const name = stringFromOwn(item, "label", "name", "event");
+    if (!name) throw new Error(`${eventLabel}.label is required.`);
+    if (seenLabels.has(name)) throw new Error(`${eventLabel}.label must be unique.`);
+    seenLabels.add(name);
+    const predicatesInput = item.predicates ?? item.all ?? item.where;
+    if (!Array.isArray(predicatesInput) || !predicatesInput.length) {
+      throw new Error(`${eventLabel}.predicates must be a non-empty array.`);
+    }
+    const predicates = predicatesInput.map((predicateInput, predicateIndex) => {
+      const predicateLabel = `${eventLabel}.predicates[${predicateIndex}]`;
+      if (!isRecord(predicateInput)) throw new Error(`${predicateLabel} must be an object.`);
+      const path = stringFromOwn(predicateInput, "path", "field", "key");
+      if (!path) throw new Error(`${predicateLabel}.path is required.`);
+      const op = stringFromOwn(predicateInput, "op", "operator");
+      if (!op || !RIDDLE_PROOF_ORDERED_TRACE_OPERATORS.includes(op)) {
+        throw new Error(`${predicateLabel}.op must be one of ${RIDDLE_PROOF_ORDERED_TRACE_OPERATORS.join(", ")}.`);
+      }
+      const requiresValue = !["exists", "truthy", "falsy"].includes(op);
+      const hasValue = hasOwn(predicateInput, "value") || hasOwn(predicateInput, "expected");
+      if (requiresValue && !hasValue) throw new Error(`${predicateLabel}.value is required for ${op}.`);
+      const value2 = hasOwn(predicateInput, "value") ? predicateInput.value : predicateInput.expected;
+      if (["gt", "gte", "lt", "lte", "abs_gt", "abs_gte", "abs_lt", "abs_lte"].includes(op)) {
+        if (typeof value2 !== "number" || !Number.isFinite(value2)) {
+          throw new Error(`${predicateLabel}.value must be a finite number for ${op}.`);
+        }
+        if (op.startsWith("abs_") && value2 < 0) {
+          throw new Error(`${predicateLabel}.value must be non-negative for ${op}.`);
+        }
+      }
+      return {
+        path,
+        op,
+        value: requiresValue ? toJsonValue(value2) : void 0
+      };
+    });
+    return { label: name, predicates };
+  });
+}
 function normalizeCheck(input, index) {
   if (!isRecord(input)) throw new Error(`checks[${index}] must be an object.`);
   const type = stringValue(input.type);
@@ -1877,6 +2122,17 @@ function normalizeCheck(input, index) {
     if (!stringValue(input.selector)) throw new Error(`checks[${index}] selector_text_order requires selector.`);
     if (!expectedTexts?.length) throw new Error(`checks[${index}] selector_text_order requires expected_texts.`);
   }
+  const setupActionLabel = stringFromOwn(input, "setup_action_label", "setupActionLabel", "source_action_label", "sourceActionLabel");
+  const tracePath = stringFromOwn(input, "trace_path", "tracePath", "path");
+  const orderedTraceEvents = normalizeOrderedTraceEvents(
+    input.events ?? input.sequence ?? input.ordered_events ?? input.orderedEvents,
+    `checks[${index}].events`
+  );
+  if (type === "ordered_trace") {
+    if (!setupActionLabel) throw new Error(`checks[${index}] ordered_trace requires setup_action_label.`);
+    if (!tracePath) throw new Error(`checks[${index}] ordered_trace requires trace_path.`);
+    if (!orderedTraceEvents?.length) throw new Error(`checks[${index}] ordered_trace requires events.`);
+  }
   const expectedRoutes = normalizeRouteInventoryRoutes(input.expected_routes ?? input.expectedRoutes, index);
   if (type === "route_inventory" && !expectedRoutes?.length) {
     throw new Error(`checks[${index}] route_inventory requires expected_routes.`);
@@ -1949,6 +2205,9 @@ function normalizeCheck(input, index) {
     body_not_patterns: bodyNotPatterns,
     body_json_assertions: bodyJsonAssertions,
     expected_texts: expectedTexts,
+    setup_action_label: type === "ordered_trace" ? setupActionLabel : void 0,
+    trace_path: type === "ordered_trace" ? tracePath : void 0,
+    events: type === "ordered_trace" ? orderedTraceEvents : void 0,
     link_selector: stringValue(input.link_selector) || stringValue(input.linkSelector),
     source_selector: stringValue(input.source_selector) || stringValue(input.sourceSelector),
     route_path_prefix: stringValue(input.route_path_prefix) || stringValue(input.routePathPrefix),
@@ -2015,6 +2274,20 @@ function normalizeRiddleProofProfile(input, options = {}) {
   const targetUrl = stringValue(options.url) || stringValue(targetInput.url);
   const route = stringValue(options.route) || stringValue(targetInput.route);
   if (!targetUrl && !route) throw new Error("profile.target requires url or route, or pass --url.");
+  const setupActions = normalizeSetupActions(targetInput.setup_actions ?? targetInput.setupActions);
+  for (const [index, check] of checks.entries()) {
+    if (check.type !== "ordered_trace") continue;
+    const matches = (setupActions || []).filter((action) => action.label === check.setup_action_label);
+    if (matches.length !== 1) {
+      throw new Error(`checks[${index}] ordered_trace setup_action_label must match exactly one target.setup_actions label.`);
+    }
+    if (!["window_eval", "window_call", "window_call_until"].includes(matches[0].type)) {
+      throw new Error(`checks[${index}] ordered_trace source action must capture a window_eval, window_call, or window_call_until return.`);
+    }
+    if (matches[0].capture_return === false) {
+      throw new Error(`checks[${index}] ordered_trace source action must not set capture_return to false.`);
+    }
+  }
   return {
     version: RIDDLE_PROOF_PROFILE_VERSION,
     name: normalizeName(input.name, "riddle-proof-profile"),
@@ -2027,7 +2300,7 @@ function normalizeRiddleProofProfile(input, options = {}) {
       wait_for_selector: stringValue(targetInput.wait_for_selector) || stringValue(targetInput.waitForSelector),
       wait_ms: numberValue(targetInput.wait_ms) ?? numberValue(targetInput.waitMs),
       screenshot_full_page: normalizeTargetScreenshotFullPage(targetInput),
-      setup_actions: normalizeSetupActions(targetInput.setup_actions ?? targetInput.setupActions),
+      setup_actions: setupActions,
       network_mocks: normalizeNetworkMocks(targetInput.network_mocks ?? targetInput.networkMocks)
     },
     checks,
@@ -3040,6 +3313,32 @@ function assessCheckFromEvidence(check, evidence) {
       message: failed ? `Selector ${key} text order failed in ${failed} viewport(s).` : void 0
     };
   }
+  if (check.type === "ordered_trace") {
+    const assessments = viewports.map((viewport) => ({
+      viewport: viewport.name,
+      assessment: assessRiddleProofOrderedTraceSetupResults(
+        viewport.setup_action_results,
+        check.setup_action_label || "",
+        check.trace_path || "",
+        check.events || []
+      )
+    }));
+    const insufficient = assessments.filter((item) => item.assessment.status === "proof_insufficient");
+    const failed = assessments.filter((item) => item.assessment.status === "failed");
+    const status = insufficient.length ? "proof_insufficient" : failed.length ? "failed" : "passed";
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status,
+      evidence: {
+        setup_action_label: check.setup_action_label || "",
+        trace_path: check.trace_path || "",
+        events: toJsonValue((check.events || []).map((event) => event.label)),
+        viewports: toJsonValue(assessments)
+      },
+      message: insufficient.length ? `Ordered trace evidence was insufficient in ${insufficient.length} viewport(s).` : failed.length ? `Ordered trace did not contain the required event sequence in ${failed.length} viewport(s).` : void 0
+    };
+  }
   if (check.type === "observe_within") {
     const key = observeWithinKey(check);
     const timeoutMs = observeWithinTimeoutMs(check);
@@ -3539,6 +3838,7 @@ function profileStatusFromEvidence(profile, evidence, checks) {
   if (!viewports.length || !checks.length) return "proof_insufficient";
   if (viewports.some((viewport) => viewport.navigation_error)) return "environment_blocked";
   if (expectedViewportCount && viewports.length < expectedViewportCount) return "proof_insufficient";
+  if (checks.some((check) => check.status === "proof_insufficient")) return "proof_insufficient";
   if (checks.some((check) => check.status === "needs_human_review")) return "needs_human_review";
   if (checks.some((check) => check.status === "failed")) return "product_regression";
   return "passed";
@@ -3868,8 +4168,12 @@ function createRiddleProofProfileInsufficientResult(input) {
     error: message
   };
 }
-function runtimeScriptAssessmentSource() {
+function runtimeScriptAssessmentSource(includeOrderedTrace = false) {
+  const orderedTraceSource = includeOrderedTrace ? String.raw`
+const assessRiddleProofOrderedTrace = ${assessRiddleProofOrderedTrace.toString()};
+const assessRiddleProofOrderedTraceSetupResults = ${assessRiddleProofOrderedTraceSetupResults.toString()};` : "";
   return String.raw`
+${orderedTraceSource}
 function normalizeRoutePath(path) {
   const value = path || "/";
   if (value === "/") return "/";
@@ -4699,6 +5003,7 @@ function profileSetupWindowCallReceipts(results) {
     .map((result) => {
       const receipt = {
         ordinal: result.ordinal ?? null,
+        label: result.label ?? null,
         ok: result.ok !== false,
         path: result.path ?? null,
         return_captured: result.return_captured ?? null,
@@ -4719,6 +5024,7 @@ function profileSetupWindowEvalReceipts(results) {
     .map((result) => {
       const receipt = {
         ordinal: result.ordinal ?? null,
+        label: result.label ?? null,
         ok: result.ok !== false,
         script_length: result.script_length ?? null,
         return_captured: result.return_captured ?? null,
@@ -5534,6 +5840,36 @@ function assessProfile(profile, evidence) {
       });
       continue;
     }
+    if (check.type === "ordered_trace") {
+      const assessments = checkViewports.map((viewport) => ({
+        viewport: viewport.name,
+        assessment: assessRiddleProofOrderedTraceSetupResults(
+          viewport.setup_action_results,
+          check.setup_action_label || "",
+          check.trace_path || "",
+          check.events || [],
+        ),
+      }));
+      const insufficient = assessments.filter((item) => item.assessment.status === "proof_insufficient");
+      const failed = assessments.filter((item) => item.assessment.status === "failed");
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: insufficient.length ? "proof_insufficient" : failed.length ? "failed" : "passed",
+        evidence: {
+          setup_action_label: check.setup_action_label || "",
+          trace_path: check.trace_path || "",
+          events: (check.events || []).map((event) => event.label),
+          viewports: assessments,
+        },
+        message: insufficient.length
+          ? "Ordered trace evidence was insufficient in " + insufficient.length + " viewport(s)."
+          : failed.length
+            ? "Ordered trace did not contain the required event sequence in " + failed.length + " viewport(s)."
+            : undefined,
+      });
+      continue;
+    }
     if (check.type === "observe_within") {
       const key = observeWithinKey(check);
       const timeoutMs = observeWithinTimeoutMs(check);
@@ -5890,6 +6226,7 @@ function assessProfile(profile, evidence) {
   if (!viewports.length || !checks.length) status = "proof_insufficient";
   else if (viewports.some((viewport) => viewport.navigation_error)) status = "environment_blocked";
   else if (expectedViewportCount && viewports.length < expectedViewportCount) status = "proof_insufficient";
+  else if (checks.some((check) => check.status === "proof_insufficient")) status = "proof_insufficient";
   else if (checks.some((check) => check.status === "needs_human_review")) status = "needs_human_review";
   else if (checks.some((check) => check.status === "failed")) status = "product_regression";
   const screenshotLabels = profileScreenshotLabels(viewports);
@@ -6821,7 +7158,7 @@ let activeViewportName = null;
 async function executeSetupAction(action, ordinal, viewport) {
   const type = setupActionType(action);
   const frameSelector = setupFrameSelector(action);
-  const base = { ok: false, action: type || "unknown", ordinal, selector: action.selector || null, frame_selector: frameSelector || null, optional: action.optional === true };
+  const base = { ok: false, action: type || "unknown", ordinal, label: action.label || null, selector: action.selector || null, frame_selector: frameSelector || null, optional: action.optional === true };
   const timeout = setupNumber(action.timeout_ms, 5000);
   try {
     if (type === "wait") {
@@ -9473,7 +9810,7 @@ async function captureViewport(viewport) {
     wait_error: waitError,
   };
 }
-${runtimeScriptAssessmentSource()}
+${runtimeScriptAssessmentSource(profile.checks.some((check) => check.type === "ordered_trace"))}
 const viewports = [];
 function buildProfileEvidence(currentViewports) {
   const expectedViewportCount = (profile.target.viewports || []).length;
@@ -9678,6 +10015,7 @@ function extractRiddleProofProfileResult(input) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS,
+  RIDDLE_PROOF_ORDERED_TRACE_OPERATORS,
   RIDDLE_PROOF_PROFILE_CHECK_TYPES,
   RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,
   RIDDLE_PROOF_PROFILE_NETWORK_ABORT_ERROR_CODES,
@@ -9686,6 +10024,8 @@ function extractRiddleProofProfileResult(input) {
   RIDDLE_PROOF_PROFILE_STATUSES,
   RIDDLE_PROOF_PROFILE_VERSION,
   applyRiddleProofProfileArtifactCompleteness,
+  assessRiddleProofOrderedTrace,
+  assessRiddleProofOrderedTraceSetupResults,
   assessRiddleProofProfileArtifactCompleteness,
   assessRiddleProofProfileEvidence,
   buildRiddleProofProfileScript,

package/dist/profile.d.cts

@@ -5,7 +5,7 @@ declare const RIDDLE_PROOF_PROFILE_VERSION: "riddle-proof.profile.v1";
 declare const RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION: "riddle-proof.profile-evidence.v1";
 declare const RIDDLE_PROOF_PROFILE_RESULT_VERSION: "riddle-proof.profile-result.v1";
 declare const RIDDLE_PROOF_PROFILE_STATUSES: readonly ["passed", "product_regression", "proof_insufficient", "environment_blocked", "configuration_error", "needs_human_review"];
-declare const RIDDLE_PROOF_PROFILE_CHECK_TYPES: readonly ["route_loaded", "url_search_param_equals", "url_search_param_absent", "selector_visible", "selector_absent", "selector_count_at_least", "selector_count_equals", "selector_count_equal", "selector_count_eq", "dialog_count_equals", "dialog_accept_count_equals", "dialog_dismiss_count_equals", "selector_text_visible", "selector_text_absent", "selector_text_order", "observe_within", "frame_text_visible", "frame_url_equals", "frame_url_matches", "frame_no_horizontal_overflow", "text_visible", "text_absent", "http_status", "link_status", "artifact_link_status", "route_inventory", "no_horizontal_overflow", "no_mobile_horizontal_overflow", "no_fatal_console_errors", "no_console_warnings"];
+declare const RIDDLE_PROOF_PROFILE_CHECK_TYPES: readonly ["route_loaded", "url_search_param_equals", "url_search_param_absent", "selector_visible", "selector_absent", "selector_count_at_least", "selector_count_equals", "selector_count_equal", "selector_count_eq", "dialog_count_equals", "dialog_accept_count_equals", "dialog_dismiss_count_equals", "selector_text_visible", "selector_text_absent", "selector_text_order", "ordered_trace", "observe_within", "frame_text_visible", "frame_url_equals", "frame_url_matches", "frame_no_horizontal_overflow", "text_visible", "text_absent", "http_status", "link_status", "artifact_link_status", "route_inventory", "no_horizontal_overflow", "no_mobile_horizontal_overflow", "no_fatal_console_errors", "no_console_warnings"];
 declare const RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES: readonly ["click", "tap", "tap_until", "drag", "press", "key_down", "key_up", "fill", "set_input_value", "set_range_value", "deterministic_runtime", "canvas_signature", "assert_text_visible", "assert_text_absent", "assert_selector_count", "assert_window_value", "assert_window_number", "local_storage", "session_storage", "clear_storage", "clear_console", "dialog_response", "screenshot", "wait", "wait_for_selector", "wait_for_text", "window_eval", "window_call", "window_call_until"];
 type RiddleProofProfileStatus = typeof RIDDLE_PROOF_PROFILE_STATUSES[number];
 type RiddleProofProfileCheckType = typeof RIDDLE_PROOF_PROFILE_CHECK_TYPES[number];
@@ -40,6 +40,36 @@ interface RiddleProofProfileHttpStatusPreflightFetchResponse {
 }
 type RiddleProofProfileHttpStatusPreflightFetch = (url: string, init?: Record<string, unknown>) => Promise<RiddleProofProfileHttpStatusPreflightFetchResponse>;
 type RiddleProofProfileJsonValueType = "array" | "boolean" | "null" | "number" | "object" | "string";
+declare const RIDDLE_PROOF_ORDERED_TRACE_OPERATORS: readonly ["exists", "equals", "not_equals", "truthy", "falsy", "gt", "gte", "lt", "lte", "abs_gt", "abs_gte", "abs_lt", "abs_lte"];
+type RiddleProofOrderedTraceOperator = typeof RIDDLE_PROOF_ORDERED_TRACE_OPERATORS[number];
+interface RiddleProofOrderedTracePredicate {
+    path: string;
+    op: RiddleProofOrderedTraceOperator;
+    value?: JsonValue;
+}
+interface RiddleProofOrderedTraceEvent {
+    label: string;
+    predicates: RiddleProofOrderedTracePredicate[];
+}
+interface RiddleProofOrderedTraceWitness {
+    label: string;
+    index: number;
+    observations: Array<{
+        path: string;
+        op: RiddleProofOrderedTraceOperator;
+        expected?: JsonValue;
+        observed: JsonValue;
+    }>;
+}
+interface RiddleProofOrderedTraceAssessment {
+    version: "riddle-proof.ordered-trace-assessment.v1";
+    status: "passed" | "failed" | "proof_insufficient";
+    trace_length: number;
+    witnesses: RiddleProofOrderedTraceWitness[];
+    missing_event?: string;
+    missing_paths?: string[];
+    reason?: string;
+}
 interface RiddleProofProfileHttpStatusBodyJsonAssertion {
     label?: string;
     path: string;
@@ -246,6 +276,9 @@ interface RiddleProofProfileCheck {
     body_not_patterns?: string[];
     body_json_assertions?: RiddleProofProfileHttpStatusBodyJsonAssertion[];
     expected_texts?: string[];
+    setup_action_label?: string;
+    trace_path?: string;
+    events?: RiddleProofOrderedTraceEvent[];
     link_selector?: string;
     source_selector?: string;
     route_path_prefix?: string;
@@ -372,7 +405,7 @@ interface RiddleProofProfileEvidence {
 interface RiddleProofProfileCheckResult {
     type: RiddleProofProfileCheckType | (string & {});
     label?: string;
-    status: "passed" | "failed" | "skipped" | "needs_human_review";
+    status: "passed" | "failed" | "skipped" | "proof_insufficient" | "needs_human_review";
     evidence: Record<string, JsonValue>;
     message?: string;
 }
@@ -454,6 +487,8 @@ interface NormalizeRiddleProofProfileOptions {
     route?: string;
     viewports?: RiddleProofProfileViewport[];
 }
+declare function assessRiddleProofOrderedTrace(trace: unknown, events: RiddleProofOrderedTraceEvent[]): RiddleProofOrderedTraceAssessment;
+declare function assessRiddleProofOrderedTraceSetupResults(results: unknown, setupActionLabel: string, tracePath: string, events: RiddleProofOrderedTraceEvent[]): RiddleProofOrderedTraceAssessment;
 declare function slugifyRiddleProofProfileName(value: string): string;
 declare function collectRiddleProofProfileWarnings(profile: RiddleProofProfile): string[];
 declare function normalizeRiddleProofProfile(input: unknown, options?: NormalizeRiddleProofProfileOptions): RiddleProofProfile;
@@ -514,4 +549,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_HOSTED_PROFILE_ARTIFACTS, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_NETWORK_ABORT_ERROR_CODES, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, type RiddleProofArtifactBodyAssertionInput, type RiddleProofArtifactBodyAssertionResult, type RiddleProofProfile, type RiddleProofProfileArtifactCompleteness, type RiddleProofProfileArtifactRef, type RiddleProofProfileBaselinePolicy, type RiddleProofProfileBoundsOffender, type RiddleProofProfileCheck, type RiddleProofProfileCheckResult, type RiddleProofProfileCheckType, type RiddleProofProfileEvidence, type RiddleProofProfileFailureAction, type RiddleProofProfileHttpStatusBodyJsonAssertion, type RiddleProofProfileHttpStatusBodyJsonAssertionResult, type RiddleProofProfileHttpStatusPreflightCheckResult, type RiddleProofProfileHttpStatusPreflightFetch, type RiddleProofProfileHttpStatusPreflightFetchResponse, type RiddleProofProfileHttpStatusPreflightOptions, type RiddleProofProfileHttpStatusPreflightResult, type RiddleProofProfileJsonValueType, type RiddleProofProfileNetworkAbortErrorCode, type RiddleProofProfileNetworkMock, type RiddleProofProfileNetworkMockResponse, type RiddleProofProfileResult, type RiddleProofProfileReturnSummaryField, type RiddleProofProfileRouteEvidence, type RiddleProofProfileRouteInventoryRoute, type RiddleProofProfileRunner, type RiddleProofProfileRunnerArtifactPreflight, type RiddleProofProfileSetupAction, type RiddleProofProfileSetupActionType, type RiddleProofProfileStatus, type RiddleProofProfileTarget, type RiddleProofProfileViewport, type RiddleProofProfileViewportEvidence, applyRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, collectRiddleProofProfileWarnings, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, deriveRiddleProofArtifactBodyAssertions, extractRiddleProofProfileResult, normalizeRiddleProofProfile, preflightRiddleProofProfileHttpStatusChecks, preflightRiddleProofProfileRunnerArtifacts, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult };
+export { type NormalizeRiddleProofProfileOptions, RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS, RIDDLE_PROOF_ORDERED_TRACE_OPERATORS, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_NETWORK_ABORT_ERROR_CODES, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, type RiddleProofArtifactBodyAssertionInput, type RiddleProofArtifactBodyAssertionResult, type RiddleProofOrderedTraceAssessment, type RiddleProofOrderedTraceEvent, type RiddleProofOrderedTraceOperator, type RiddleProofOrderedTracePredicate, type RiddleProofOrderedTraceWitness, type RiddleProofProfile, type RiddleProofProfileArtifactCompleteness, type RiddleProofProfileArtifactRef, type RiddleProofProfileBaselinePolicy, type RiddleProofProfileBoundsOffender, type RiddleProofProfileCheck, type RiddleProofProfileCheckResult, type RiddleProofProfileCheckType, type RiddleProofProfileEvidence, type RiddleProofProfileFailureAction, type RiddleProofProfileHttpStatusBodyJsonAssertion, type RiddleProofProfileHttpStatusBodyJsonAssertionResult, type RiddleProofProfileHttpStatusPreflightCheckResult, type RiddleProofProfileHttpStatusPreflightFetch, type RiddleProofProfileHttpStatusPreflightFetchResponse, type RiddleProofProfileHttpStatusPreflightOptions, type RiddleProofProfileHttpStatusPreflightResult, type RiddleProofProfileJsonValueType, type RiddleProofProfileNetworkAbortErrorCode, type RiddleProofProfileNetworkMock, type RiddleProofProfileNetworkMockResponse, type RiddleProofProfileResult, type RiddleProofProfileReturnSummaryField, type RiddleProofProfileRouteEvidence, type RiddleProofProfileRouteInventoryRoute, type RiddleProofProfileRunner, type RiddleProofProfileRunnerArtifactPreflight, type RiddleProofProfileSetupAction, type RiddleProofProfileSetupActionType, type RiddleProofProfileStatus, type RiddleProofProfileTarget, type RiddleProofProfileViewport, type RiddleProofProfileViewportEvidence, applyRiddleProofProfileArtifactCompleteness, assessRiddleProofOrderedTrace, assessRiddleProofOrderedTraceSetupResults, assessRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, collectRiddleProofProfileWarnings, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, deriveRiddleProofArtifactBodyAssertions, extractRiddleProofProfileResult, normalizeRiddleProofProfile, preflightRiddleProofProfileHttpStatusChecks, preflightRiddleProofProfileRunnerArtifacts, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult };