@riddledc/riddle-proof 0.8.78 → 0.8.80

package/dist/cli/index.js

@@ -1,11 +1,11 @@
-import "../chunk-HSGZV2NK.js";
+import "../chunk-N7EETHYG.js";
 import "../chunk-5IFZSUPF.js";
 import "../chunk-JFQXAJH2.js";
-import "../chunk-7N6X54WG.js";
-import "../chunk-RQPCKRKT.js";
-import "../chunk-6VFS2JFR.js";
+import "../chunk-6T6ZAK77.js";
+import "../chunk-A4EF4M3B.js";
+import "../chunk-IL7MLYB5.js";
 import "../chunk-MEVVL4TI.js";
-import "../chunk-FCSJZBC5.js";
+import "../chunk-ZNVYJFR7.js";
 import "../chunk-KXLEN4SA.js";
 import "../chunk-WLUMLHII.js";
 import "../chunk-CGJX7LJO.js";

package/dist/cli.cjs

@@ -8775,6 +8775,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",
@@ -8838,6 +8839,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 = [];
@@ -9129,6 +9145,185 @@ function resolveJsonPath(root, path7) {
   }
   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 = (path7) => {
+    const segments = [];
+    let token = "";
+    const pushToken = () => {
+      const value = token.trim();
+      if (value) segments.push(value);
+      token = "";
+    };
+    for (let index = 0; index < path7.length; index += 1) {
+      const char = path7[index];
+      if (char === ".") {
+        pushToken();
+        continue;
+      }
+      if (char !== "[") {
+        token += char;
+        continue;
+      }
+      pushToken();
+      const closeIndex = path7.indexOf("]", index + 1);
+      if (closeIndex === -1) throw new Error(`unterminated bracket at ${index}`);
+      const bracket = path7.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, path7) => {
+    let segments;
+    try {
+      segments = parsePath(path7);
+    } 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 = [];
@@ -9235,6 +9430,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,
@@ -9253,6 +9449,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,
@@ -10525,6 +10722,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 (!isRecord2(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 (!isRecord2(predicateInput)) throw new Error(`${predicateLabel} must be an object.`);
+      const path7 = stringFromOwn(predicateInput, "path", "field", "key");
+      if (!path7) 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: path7,
+        op,
+        value: requiresValue ? toJsonValue(value2) : void 0
+      };
+    });
+    return { label: name, predicates };
+  });
+}
 function normalizeCheck(input, index) {
   if (!isRecord2(input)) throw new Error(`checks[${index}] must be an object.`);
   const type = stringValue3(input.type);
@@ -10575,6 +10817,17 @@ function normalizeCheck(input, index) {
     if (!stringValue3(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.`);
@@ -10647,6 +10900,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: stringValue3(input.link_selector) || stringValue3(input.linkSelector),
     source_selector: stringValue3(input.source_selector) || stringValue3(input.sourceSelector),
     route_path_prefix: stringValue3(input.route_path_prefix) || stringValue3(input.routePathPrefix),
@@ -10713,6 +10969,20 @@ function normalizeRiddleProofProfile(input, options = {}) {
   const targetUrl = stringValue3(options.url) || stringValue3(targetInput.url);
   const route = stringValue3(options.route) || stringValue3(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"),
@@ -10725,7 +10995,7 @@ function normalizeRiddleProofProfile(input, options = {}) {
       wait_for_selector: stringValue3(targetInput.wait_for_selector) || stringValue3(targetInput.waitForSelector),
       wait_ms: numberValue2(targetInput.wait_ms) ?? numberValue2(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,
@@ -11738,6 +12008,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);
@@ -12237,6 +12533,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";
@@ -12566,8 +12863,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 "/";
@@ -13397,6 +13698,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,
@@ -13417,6 +13719,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,
@@ -14232,6 +14535,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);
@@ -14588,6 +14921,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);
@@ -15519,7 +15853,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") {
@@ -18171,7 +18505,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;
@@ -23812,7 +24146,22 @@ function profileHttpStatusSummaryMarkdown(result) {
 }
 function profileResultTargetUrl(result) {
   const legacyRoute = result.route;
-  return result.route.observed || result.route.requested || legacyRoute.url || result.evidence?.target_url || "unknown";
+  const observed = result.route.observed;
+  const requested = result.route.requested || legacyRoute.url || result.evidence?.target_url;
+  if (observed) {
+    try {
+      return new URL(observed, requested).href;
+    } catch {
+    }
+  }
+  if (requested) {
+    try {
+      return new URL(requested).href;
+    } catch {
+      return requested;
+    }
+  }
+  return observed || "unknown";
 }
 function profileObservationForOutput(result, outputDir, options) {
   if (options.observation) return options.observation;

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import "./chunk-HSGZV2NK.js";
+import "./chunk-N7EETHYG.js";
 import "./chunk-5IFZSUPF.js";
 import "./chunk-JFQXAJH2.js";
-import "./chunk-7N6X54WG.js";
-import "./chunk-RQPCKRKT.js";
-import "./chunk-6VFS2JFR.js";
+import "./chunk-6T6ZAK77.js";
+import "./chunk-A4EF4M3B.js";
+import "./chunk-IL7MLYB5.js";
 import "./chunk-MEVVL4TI.js";
-import "./chunk-FCSJZBC5.js";
+import "./chunk-ZNVYJFR7.js";
 import "./chunk-KXLEN4SA.js";
 import "./chunk-WLUMLHII.js";
 import "./chunk-CGJX7LJO.js";