@riddledc/riddle-proof 0.8.79 → 0.8.80

package/dist/profile/index.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,
@@ -79,6 +82,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",
@@ -142,6 +146,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 = [];
@@ -433,6 +452,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 = [];
@@ -539,6 +737,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,
@@ -557,6 +756,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,
@@ -1829,6 +2029,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);
@@ -1879,6 +2124,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.`);
@@ -1951,6 +2207,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),
@@ -2017,6 +2276,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"),
@@ -2029,7 +2302,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,
@@ -3042,6 +3315,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);
@@ -3541,6 +3840,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";
@@ -3870,8 +4170,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 "/";
@@ -4701,6 +5005,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,
@@ -4721,6 +5026,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,
@@ -5536,6 +5842,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);
@@ -5892,6 +6228,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);
@@ -6823,7 +7160,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") {
@@ -9475,7 +9812,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;
@@ -9680,6 +10017,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,
@@ -9688,6 +10026,8 @@ function extractRiddleProofProfileResult(input) {
   RIDDLE_PROOF_PROFILE_STATUSES,
   RIDDLE_PROOF_PROFILE_VERSION,
   applyRiddleProofProfileArtifactCompleteness,
+  assessRiddleProofOrderedTrace,
+  assessRiddleProofOrderedTraceSetupResults,
   assessRiddleProofProfileArtifactCompleteness,
   assessRiddleProofProfileEvidence,
   buildRiddleProofProfileScript,

package/dist/profile/index.d.cts

@@ -1,3 +1,3 @@
-export { 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, RiddleProofArtifactBodyAssertionInput, RiddleProofArtifactBodyAssertionResult, RiddleProofProfile, RiddleProofProfileArtifactCompleteness, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileBoundsOffender, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileHttpStatusBodyJsonAssertion, RiddleProofProfileHttpStatusBodyJsonAssertionResult, RiddleProofProfileHttpStatusPreflightCheckResult, RiddleProofProfileHttpStatusPreflightFetch, RiddleProofProfileHttpStatusPreflightFetchResponse, RiddleProofProfileHttpStatusPreflightOptions, RiddleProofProfileHttpStatusPreflightResult, RiddleProofProfileJsonValueType, RiddleProofProfileNetworkAbortErrorCode, RiddleProofProfileNetworkMock, RiddleProofProfileNetworkMockResponse, RiddleProofProfileResult, RiddleProofProfileReturnSummaryField, RiddleProofProfileRouteEvidence, RiddleProofProfileRouteInventoryRoute, RiddleProofProfileRunner, RiddleProofProfileRunnerArtifactPreflight, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, applyRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, collectRiddleProofProfileWarnings, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, deriveRiddleProofArtifactBodyAssertions, extractRiddleProofProfileResult, normalizeRiddleProofProfile, preflightRiddleProofProfileHttpStatusChecks, preflightRiddleProofProfileRunnerArtifacts, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from '../profile.cjs';
+export { 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, RiddleProofArtifactBodyAssertionInput, RiddleProofArtifactBodyAssertionResult, RiddleProofOrderedTraceAssessment, RiddleProofOrderedTraceEvent, RiddleProofOrderedTraceOperator, RiddleProofOrderedTracePredicate, RiddleProofOrderedTraceWitness, RiddleProofProfile, RiddleProofProfileArtifactCompleteness, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileBoundsOffender, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileHttpStatusBodyJsonAssertion, RiddleProofProfileHttpStatusBodyJsonAssertionResult, RiddleProofProfileHttpStatusPreflightCheckResult, RiddleProofProfileHttpStatusPreflightFetch, RiddleProofProfileHttpStatusPreflightFetchResponse, RiddleProofProfileHttpStatusPreflightOptions, RiddleProofProfileHttpStatusPreflightResult, RiddleProofProfileJsonValueType, RiddleProofProfileNetworkAbortErrorCode, RiddleProofProfileNetworkMock, RiddleProofProfileNetworkMockResponse, RiddleProofProfileResult, RiddleProofProfileReturnSummaryField, RiddleProofProfileRouteEvidence, RiddleProofProfileRouteInventoryRoute, RiddleProofProfileRunner, RiddleProofProfileRunnerArtifactPreflight, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, applyRiddleProofProfileArtifactCompleteness, assessRiddleProofOrderedTrace, assessRiddleProofOrderedTraceSetupResults, assessRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, collectRiddleProofProfileWarnings, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, deriveRiddleProofArtifactBodyAssertions, extractRiddleProofProfileResult, normalizeRiddleProofProfile, preflightRiddleProofProfileHttpStatusChecks, preflightRiddleProofProfileRunnerArtifacts, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from '../profile.cjs';
 import '../types.cjs';
 import '../public-state.cjs';

package/dist/profile/index.d.ts

@@ -1,3 +1,3 @@
-export { 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, RiddleProofArtifactBodyAssertionInput, RiddleProofArtifactBodyAssertionResult, RiddleProofProfile, RiddleProofProfileArtifactCompleteness, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileBoundsOffender, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileHttpStatusBodyJsonAssertion, RiddleProofProfileHttpStatusBodyJsonAssertionResult, RiddleProofProfileHttpStatusPreflightCheckResult, RiddleProofProfileHttpStatusPreflightFetch, RiddleProofProfileHttpStatusPreflightFetchResponse, RiddleProofProfileHttpStatusPreflightOptions, RiddleProofProfileHttpStatusPreflightResult, RiddleProofProfileJsonValueType, RiddleProofProfileNetworkAbortErrorCode, RiddleProofProfileNetworkMock, RiddleProofProfileNetworkMockResponse, RiddleProofProfileResult, RiddleProofProfileReturnSummaryField, RiddleProofProfileRouteEvidence, RiddleProofProfileRouteInventoryRoute, RiddleProofProfileRunner, RiddleProofProfileRunnerArtifactPreflight, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, applyRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, collectRiddleProofProfileWarnings, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, deriveRiddleProofArtifactBodyAssertions, extractRiddleProofProfileResult, normalizeRiddleProofProfile, preflightRiddleProofProfileHttpStatusChecks, preflightRiddleProofProfileRunnerArtifacts, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from '../profile.js';
+export { 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, RiddleProofArtifactBodyAssertionInput, RiddleProofArtifactBodyAssertionResult, RiddleProofOrderedTraceAssessment, RiddleProofOrderedTraceEvent, RiddleProofOrderedTraceOperator, RiddleProofOrderedTracePredicate, RiddleProofOrderedTraceWitness, RiddleProofProfile, RiddleProofProfileArtifactCompleteness, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileBoundsOffender, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileHttpStatusBodyJsonAssertion, RiddleProofProfileHttpStatusBodyJsonAssertionResult, RiddleProofProfileHttpStatusPreflightCheckResult, RiddleProofProfileHttpStatusPreflightFetch, RiddleProofProfileHttpStatusPreflightFetchResponse, RiddleProofProfileHttpStatusPreflightOptions, RiddleProofProfileHttpStatusPreflightResult, RiddleProofProfileJsonValueType, RiddleProofProfileNetworkAbortErrorCode, RiddleProofProfileNetworkMock, RiddleProofProfileNetworkMockResponse, RiddleProofProfileResult, RiddleProofProfileReturnSummaryField, RiddleProofProfileRouteEvidence, RiddleProofProfileRouteInventoryRoute, RiddleProofProfileRunner, RiddleProofProfileRunnerArtifactPreflight, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, applyRiddleProofProfileArtifactCompleteness, assessRiddleProofOrderedTrace, assessRiddleProofOrderedTraceSetupResults, assessRiddleProofProfileArtifactCompleteness, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, collectRiddleProofProfileWarnings, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, deriveRiddleProofArtifactBodyAssertions, extractRiddleProofProfileResult, normalizeRiddleProofProfile, preflightRiddleProofProfileHttpStatusChecks, preflightRiddleProofProfileRunnerArtifacts, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from '../profile.js';
 import '../types.js';
 import '../public-state.js';

package/dist/profile/index.js

@@ -1,5 +1,6 @@
 import {
   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,
@@ -8,6 +9,8 @@ import {
   RIDDLE_PROOF_PROFILE_STATUSES,
   RIDDLE_PROOF_PROFILE_VERSION,
   applyRiddleProofProfileArtifactCompleteness,
+  assessRiddleProofOrderedTrace,
+  assessRiddleProofOrderedTraceSetupResults,
   assessRiddleProofProfileArtifactCompleteness,
   assessRiddleProofProfileEvidence,
   buildRiddleProofProfileScript,
@@ -27,10 +30,11 @@ import {
   resolveRiddleProofProfileTimeoutSec,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult
-} from "../chunk-FCSJZBC5.js";
+} from "../chunk-ZNVYJFR7.js";
 import "../chunk-MLKGABMK.js";
 export {
   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,
@@ -39,6 +43,8 @@ export {
   RIDDLE_PROOF_PROFILE_STATUSES,
   RIDDLE_PROOF_PROFILE_VERSION,
   applyRiddleProofProfileArtifactCompleteness,
+  assessRiddleProofOrderedTrace,
+  assessRiddleProofOrderedTraceSetupResults,
   assessRiddleProofProfileArtifactCompleteness,
   assessRiddleProofProfileEvidence,
   buildRiddleProofProfileScript,

package/dist/profile-suggestions.js

@@ -1,8 +1,8 @@
 import {
   RIDDLE_PROOF_PROFILE_SUGGESTIONS_VERSION,
   suggestRiddleProofProfileChecks
-} from "./chunk-RQPCKRKT.js";
-import "./chunk-FCSJZBC5.js";
+} from "./chunk-A4EF4M3B.js";
+import "./chunk-ZNVYJFR7.js";
 import "./chunk-MLKGABMK.js";
 export {
   RIDDLE_PROOF_PROFILE_SUGGESTIONS_VERSION,