@agg-build/ui 1.2.7 → 1.2.8

package/dist/{chunk-3RG2K7MV.mjs → chunk-U6YU5OE7.mjs}

@@ -7,10 +7,10 @@ import {
   getTradingValueLabel,
   getTradingVenueLabel,
   resolveOrderEligibilityMessage
-} from "./chunk-TBKDLNOE.mjs";
+} from "./chunk-RPIYL7EA.mjs";
 import {
   GeoBlockBanner
-} from "./chunk-5FXMHTVR.mjs";
+} from "./chunk-BW4DQYWM.mjs";
 import {
   AGG_TERMS_OF_SERVICE_URL,
   Button,
@@ -37,7 +37,7 @@ import {
   getMotionClassName,
   normalizeVenueMarketCluster,
   skeletonViews
-} from "./chunk-34L7ZKJW.mjs";
+} from "./chunk-HQRT3B3L.mjs";
 
 // src/trading/types.ts
 import { Venue, enumGuard, isFiniteNonNeg, safeParse } from "@agg-build/sdk";
@@ -244,6 +244,447 @@ var PLACE_ORDER_OUTCOME_BUTTON_CLASS_NAMES = {
   inactive: "border-transparent bg-agg-secondary-hover font-agg-normal text-agg-foreground hover:bg-agg-tertiary"
 };
 
+// src/trading/place-order/index.place-order.execution-steps.ts
+import { Venue as Venue2 } from "@agg-build/sdk";
+var WAIT_STEP_TYPES = /* @__PURE__ */ new Set(["_wait", "wait"]);
+var CHECKING_BALANCE_STEP_TYPES = /* @__PURE__ */ new Set([
+  "check-balance",
+  "check-position",
+  "position-reserve",
+  "position-release"
+]);
+var VENUE_BUY_SELL_REGEX = /^(?:buy|sell)-([a-z]+)$/;
+var VENUE_FINALIZE_REGEX = /^([a-z]+)-finalize$/;
+var VENUE_NAME_MAP = {
+  kalshi: Venue2.kalshi,
+  polymarket: Venue2.polymarket,
+  limitless: Venue2.limitless,
+  opinion: Venue2.opinion,
+  predict: Venue2.predict,
+  probable: Venue2.probable,
+  myriad: Venue2.myriad,
+  hyperliquid: Venue2.hyperliquid
+};
+var parseVenueName = (raw) => VENUE_NAME_MAP[raw];
+var NON_VENUE_FINALIZE_PREFIXES = /* @__PURE__ */ new Set(["bridge"]);
+var classifyExecutionStepType = (stepType) => {
+  if (!stepType) return null;
+  if (WAIT_STEP_TYPES.has(stepType)) return null;
+  if (CHECKING_BALANCE_STEP_TYPES.has(stepType)) {
+    return { kind: "checking-balance" };
+  }
+  const buySellMatch = stepType.match(VENUE_BUY_SELL_REGEX);
+  if (buySellMatch) {
+    const venue = parseVenueName(buySellMatch[1]);
+    if (venue) return { kind: "executing-venue", venue };
+  }
+  const finalizeMatch = stepType.match(VENUE_FINALIZE_REGEX);
+  if (finalizeMatch && !NON_VENUE_FINALIZE_PREFIXES.has(finalizeMatch[1])) {
+    const venue = parseVenueName(finalizeMatch[1]);
+    if (venue) return { kind: "executing-venue", venue };
+  }
+  if (stepType === "submit-verify-order-status") {
+    return null;
+  }
+  return { kind: "submitting" };
+};
+var buildPhaseTimeline = (dag) => {
+  const timeline = [];
+  const completed = new Set(dag.completedSequences);
+  for (let seq = 1; seq <= dag.totalSteps; seq++) {
+    const stepType = dag.stepTypes[seq];
+    if (!stepType) continue;
+    const classified = classifyExecutionStepType(stepType);
+    if (!classified) continue;
+    const isCompleted = completed.has(seq);
+    const last = timeline[timeline.length - 1];
+    if (last && last.kind === classified.kind && last.venue === classified.venue) {
+      last.lastSeq = seq;
+      last.allCompleted = last.allCompleted && isCompleted;
+      continue;
+    }
+    timeline.push({
+      kind: classified.kind,
+      venue: classified.venue,
+      firstSeq: seq,
+      lastSeq: seq,
+      allCompleted: isCompleted
+    });
+  }
+  return timeline;
+};
+var phaseRowId = (phase) => phase.venue ? `${phase.kind}:${phase.venue}` : phase.kind;
+var phaseRowLabel = (phase, labels) => {
+  switch (phase.kind) {
+    case "finding-route":
+      return labels.findingBestRoute;
+    case "checking-balance":
+      return labels.checkingBalance;
+    case "submitting":
+      return labels.submittingOrderProgress;
+    case "wallet-confirm":
+      return labels.confirmTransactionInWallet;
+    case "executing-venue":
+      return labels.executingOnVenue(getTradingVenueLabel(phase.venue));
+    case "filled":
+      return labels.executionConfirmed;
+    case "failed":
+      return labels.orderFailureTitle;
+  }
+};
+var buildSubmissionDisplayRows = ({
+  phase,
+  dagProgress,
+  executionVenue,
+  isAwaitingWalletConfirmation,
+  labels
+}) => {
+  if (phase === "finding-route") {
+    return [
+      {
+        id: "finding-route",
+        label: labels.findingBestRoute,
+        status: "pending"
+      }
+    ];
+  }
+  const rows = [
+    {
+      id: "finding-route",
+      label: labels.findingBestRoute,
+      status: "complete"
+    }
+  ];
+  const pushPhase = (phaseEntry, status) => {
+    const id = phaseRowId(phaseEntry);
+    if (rows.some((row) => row.id === id)) return;
+    rows.push({
+      id,
+      label: phaseRowLabel(phaseEntry, labels),
+      status,
+      venue: phaseEntry.venue
+    });
+  };
+  if (dagProgress && dagProgress.totalSteps > 0) {
+    const timeline = buildPhaseTimeline(dagProgress);
+    let activeEmitted = false;
+    for (const entry of timeline) {
+      const id = phaseRowId(entry);
+      const alreadyShown = rows.some((row) => row.id === id);
+      if (entry.allCompleted) {
+        if (alreadyShown) continue;
+        pushPhase(entry, "complete");
+        continue;
+      }
+      if (activeEmitted) break;
+      if (alreadyShown) continue;
+      if (isAwaitingWalletConfirmation && entry.kind === "submitting") {
+        pushPhase({ kind: "wallet-confirm" }, "pending");
+      } else {
+        pushPhase(entry, "pending");
+      }
+      activeEmitted = true;
+    }
+    if (!activeEmitted) {
+      const last = rows[rows.length - 1];
+      if (last && last.id.startsWith("executing-venue")) {
+        last.status = "pending";
+      } else {
+        const fallbackVenue = executionVenue;
+        rows.push({
+          id: fallbackVenue ? `executing-venue:${fallbackVenue}` : "executing-venue",
+          label: phaseRowLabel({ kind: "executing-venue", venue: fallbackVenue }, labels),
+          status: "pending",
+          venue: fallbackVenue
+        });
+      }
+    }
+    return rows;
+  }
+  if (isAwaitingWalletConfirmation) {
+    pushPhase({ kind: "wallet-confirm" }, "pending");
+    return rows;
+  }
+  if (phase === "submitting") {
+    pushPhase({ kind: "submitting" }, "pending");
+    return rows;
+  }
+  pushPhase({ kind: "submitting" }, "complete");
+  pushPhase({ kind: "executing-venue", venue: executionVenue }, "pending");
+  return rows;
+};
+
+// src/trading/place-order/index.place-order.execution-debug.ts
+var REDACTED = "[redacted]";
+var SENSITIVE_FIELD_PATTERNS = [
+  "token",
+  "authorization",
+  "cookie",
+  "secret",
+  "signature",
+  "privatekey",
+  "private_key",
+  "accesstoken",
+  "access_token",
+  "refreshtoken",
+  "refresh_token",
+  "jwt",
+  "password",
+  "apikey",
+  "api_key",
+  "email",
+  "headers"
+];
+var isSensitiveFieldName = (name) => {
+  const normalized = name.toLowerCase();
+  return SENSITIVE_FIELD_PATTERNS.some((pattern) => normalized.includes(pattern));
+};
+var sanitizeExecutionDebugValue = (input) => {
+  const ancestors = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (value === null || value === void 0) return value;
+    if (typeof value !== "object") return value;
+    if (ancestors.has(value)) return "[circular]";
+    ancestors.add(value);
+    try {
+      if (Array.isArray(value)) {
+        return value.map((entry) => walk(entry));
+      }
+      if (value instanceof Error) {
+        return {
+          name: value.name,
+          message: value.message,
+          stack: value.stack
+        };
+      }
+      const out = {};
+      for (const [key, raw] of Object.entries(value)) {
+        if (isSensitiveFieldName(key)) {
+          out[key] = REDACTED;
+          continue;
+        }
+        out[key] = walk(raw);
+      }
+      return out;
+    } finally {
+      ancestors.delete(value);
+    }
+  };
+  return walk(input);
+};
+var cloneEnvironment = (env) => __spreadProps(__spreadValues({}, env), {
+  packageVersions: env.packageVersions ? __spreadValues({}, env.packageVersions) : void 0
+});
+var buildEnvironment = (overrides) => {
+  var _a;
+  const url = typeof window !== "undefined" ? (_a = window.location) == null ? void 0 : _a.href : void 0;
+  const userAgent = typeof navigator !== "undefined" && typeof navigator.userAgent === "string" ? navigator.userAgent : void 0;
+  return __spreadValues({
+    url,
+    userAgent,
+    capturedAt: Date.now()
+  }, overrides);
+};
+var generateAttemptId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `attempt-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+};
+var createExecutionDebugStore = (initial) => {
+  let attempts = [];
+  let environment = buildEnvironment(initial);
+  const findAttempt = (attemptId) => attempts.find((attempt) => attempt.attemptId === attemptId);
+  const touch = (attempt) => {
+    attempt.updatedAt = Date.now();
+  };
+  return {
+    appendAttempt(input = {}) {
+      var _a, _b;
+      const now = Date.now();
+      const attempt = {
+        attemptId: (_a = input.attemptId) != null ? _a : generateAttemptId(),
+        startedAt: now,
+        updatedAt: now,
+        status: (_b = input.status) != null ? _b : "quoting",
+        quoteId: input.quoteId,
+        orderId: input.orderId,
+        orderIds: input.orderIds,
+        quote: input.quote,
+        selectedRoute: input.selectedRoute,
+        bridge: input.bridge,
+        venueExecution: input.venueExecution,
+        rawEvents: [],
+        normalizedSteps: [],
+        errors: []
+      };
+      attempts = [...attempts, attempt];
+      return attempt;
+    },
+    updateAttempt(attemptId, patch) {
+      const attempt = findAttempt(attemptId);
+      if (!attempt) return;
+      if (patch.status !== void 0) attempt.status = patch.status;
+      if (patch.quoteId !== void 0) attempt.quoteId = patch.quoteId;
+      if (patch.orderId !== void 0) attempt.orderId = patch.orderId;
+      if (patch.orderIds !== void 0) attempt.orderIds = patch.orderIds;
+      if (patch.quote !== void 0) attempt.quote = patch.quote;
+      if (patch.selectedRoute !== void 0) attempt.selectedRoute = patch.selectedRoute;
+      if (patch.bridge !== void 0) attempt.bridge = patch.bridge;
+      if (patch.venueExecution !== void 0) attempt.venueExecution = patch.venueExecution;
+      if (patch.finalStatus !== void 0) attempt.finalStatus = patch.finalStatus;
+      touch(attempt);
+    },
+    appendEvent(attemptId, event) {
+      var _a;
+      const attempt = findAttempt(attemptId);
+      if (!attempt) return;
+      attempt.rawEvents.push({
+        kind: event.kind,
+        label: event.label,
+        data: event.data,
+        timestamp: (_a = event.timestamp) != null ? _a : Date.now()
+      });
+      touch(attempt);
+    },
+    appendError(attemptId, error) {
+      var _a;
+      const attempt = findAttempt(attemptId);
+      if (!attempt) return;
+      attempt.errors.push({
+        message: error.message,
+        name: error.name,
+        code: error.code,
+        stack: error.stack,
+        failedStep: error.failedStep,
+        data: error.data,
+        timestamp: (_a = error.timestamp) != null ? _a : Date.now()
+      });
+      touch(attempt);
+    },
+    setNormalizedSteps(attemptId, steps) {
+      const attempt = findAttempt(attemptId);
+      if (!attempt) return;
+      attempt.normalizedSteps = steps;
+      touch(attempt);
+    },
+    getSnapshot() {
+      return {
+        attempts: attempts.map((attempt) => __spreadProps(__spreadValues({}, attempt), {
+          rawEvents: [...attempt.rawEvents],
+          normalizedSteps: [...attempt.normalizedSteps],
+          errors: [...attempt.errors]
+        })),
+        environment: cloneEnvironment(environment)
+      };
+    },
+    getFailedAttempts() {
+      return attempts.filter(
+        (attempt) => attempt.status === "failed" || attempt.finalStatus === "failed" || attempt.errors.length > 0
+      ).map((attempt) => __spreadProps(__spreadValues({}, attempt), {
+        rawEvents: [...attempt.rawEvents],
+        normalizedSteps: [...attempt.normalizedSteps],
+        errors: [...attempt.errors]
+      }));
+    },
+    clear() {
+      attempts = [];
+      environment = buildEnvironment(initial);
+    }
+  };
+};
+var writeClipboardLegacy = (text) => {
+  if (typeof document === "undefined") return false;
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.setAttribute("readonly", "");
+  textarea.style.position = "fixed";
+  textarea.style.top = "-1000px";
+  textarea.style.opacity = "0";
+  document.body.appendChild(textarea);
+  try {
+    textarea.select();
+    return document.execCommand("copy");
+  } catch (e) {
+    return false;
+  } finally {
+    document.body.removeChild(textarea);
+  }
+};
+var tryWriteClipboard = (text, consoleImpl) => __async(null, null, function* () {
+  var _a;
+  if (typeof navigator !== "undefined" && ((_a = navigator.clipboard) == null ? void 0 : _a.writeText)) {
+    try {
+      yield navigator.clipboard.writeText(text);
+      consoleImpl.info("[agg-execution-debug] Copied execution data to clipboard.");
+      return;
+    } catch (e) {
+    }
+  }
+  if (writeClipboardLegacy(text)) {
+    consoleImpl.info("[agg-execution-debug] Copied execution data to clipboard.");
+    return;
+  }
+  consoleImpl.warn(
+    "[agg-execution-debug] Clipboard copy was blocked by the browser. The JSON is logged below \u2014 right-click the entry and copy."
+  );
+  consoleImpl.log(text);
+});
+var installExecutionDebugWindow = ({
+  store,
+  consoleImpl
+}) => {
+  if (typeof window === "undefined") return () => {
+  };
+  const targetConsole = consoleImpl != null ? consoleImpl : console;
+  const previous = {
+    executionData: window.executionData,
+    getExecutionData: window.getExecutionData,
+    getFailedExecutionData: window.getFailedExecutionData,
+    clearExecutionData: window.clearExecutionData,
+    storeRef: window.__aggExecutionDebugStore
+  };
+  const refresh = () => {
+    window.executionData = sanitizeExecutionDebugValue(store.getSnapshot());
+  };
+  refresh();
+  window.__aggExecutionDebugStore = store;
+  window.getExecutionData = () => {
+    const data = sanitizeExecutionDebugValue(store.getSnapshot());
+    window.executionData = data;
+    void tryWriteClipboard(JSON.stringify(data, null, 2), targetConsole);
+    return data;
+  };
+  window.getFailedExecutionData = () => {
+    const failed = sanitizeExecutionDebugValue({ attempts: store.getFailedAttempts() });
+    void tryWriteClipboard(JSON.stringify(failed, null, 2), targetConsole);
+    return failed;
+  };
+  window.clearExecutionData = () => {
+    store.clear();
+    refresh();
+  };
+  targetConsole.info(
+    "AGG execution debug enabled. Run window.getFailedExecutionData() after a failed order to copy logs."
+  );
+  return () => {
+    if (typeof window === "undefined") return;
+    window.executionData = previous.executionData;
+    window.getExecutionData = previous.getExecutionData;
+    window.getFailedExecutionData = previous.getFailedExecutionData;
+    window.clearExecutionData = previous.clearExecutionData;
+    window.__aggExecutionDebugStore = previous.storeRef;
+  };
+};
+var enableExecutionDebugInBrowser = (initial) => {
+  if (typeof window === "undefined") return null;
+  const existing = window.__aggExecutionDebugStore;
+  if (existing) return existing;
+  const store = createExecutionDebugStore(initial);
+  installExecutionDebugWindow({ store });
+  return store;
+};
+
 // src/trading/place-order/index.place-order.utils.ts
 var routePriceLabelFormatter = new Intl.NumberFormat("en-US", {
   minimumFractionDigits: 0,
@@ -1431,21 +1872,6 @@ PlaceOrderSuccessView.displayName = "PlaceOrderSuccessView";
 
 // src/trading/place-order/index.tsx
 import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-var DEFAULT_STEP_LABELS = {
-  "check-balance": "Checking balance",
-  "check-position": "Checking position",
-  "lane-bridge": "Bridging funds",
-  bridge: "Bridging funds",
-  "bridge-to-user": "Transferring to wallet",
-  "sweep-bridge": "Completing bridge",
-  "submit-order": "Submitting order",
-  "order-bridge-execute": "Executing order",
-  "transfer-to-user": "Transferring to wallet"
-};
-var getDefaultStepLabel = (stepType) => {
-  var _a;
-  return (_a = DEFAULT_STEP_LABELS[stepType]) != null ? _a : stepType.replace(/-/g, " ").replace(/^\w/, (c) => c.toUpperCase());
-};
 var resolveRefetchedQuoteData = (result) => {
   if (!result || typeof result !== "object" || !("data" in result)) return null;
   const data = result.data;
@@ -1945,7 +2371,6 @@ var renderRouteCard = ({
     }
   );
 };
-var normalizeOrderIdLabelInput2 = (orderId) => orderId.replace(/^#+/, "");
 var renderSubmissionSurface = ({
   actionLabel,
   className,
@@ -1957,81 +2382,12 @@ var renderSubmissionSurface = ({
   progressState,
   tradingLabels
 }) => {
-  const resolveStepGroups = () => {
-    var _a, _b, _c;
-    if (progressState.phase === "finding-route") {
-      return [
-        [
-          {
-            id: "finding-route",
-            label: tradingLabels.findingBestRoute,
-            status: "pending"
-          }
-        ]
-      ];
-    }
-    const dag = progressState.dagProgress;
-    if (dag && dag.totalSteps > 0) {
-      const steps = [
-        {
-          id: "finding-route",
-          label: tradingLabels.findingBestRoute,
-          status: "complete"
-        }
-      ];
-      for (let i = 1; i <= dag.totalSteps; i++) {
-        const isCompleted = dag.completedSequences.includes(i);
-        const isCurrent = i === dag.currentSequence && !isCompleted;
-        const stepType = (_a = dag.stepTypes[i]) != null ? _a : null;
-        const stepLabel = stepType ? getDefaultStepLabel(stepType) : `Step ${i} of ${dag.totalSteps}`;
-        const prev = steps[steps.length - 1];
-        if (prev && prev.label === stepLabel) {
-          if (prev.status === "complete" && !isCompleted) {
-            prev.status = "pending";
-          }
-          continue;
-        }
-        steps.push({
-          id: `dag-step-${i}`,
-          label: stepLabel,
-          status: isCompleted ? "complete" : isCurrent ? "pending" : "pending"
-        });
-      }
-      return [steps];
-    }
-    const baseSteps = [
-      {
-        id: "finding-route",
-        label: tradingLabels.findingBestRoute,
-        status: "complete"
-      },
-      {
-        id: "submitting-order",
-        label: tradingLabels.submittingOrderProgress,
-        status: "complete"
-      }
-    ];
-    const submittedOrderId = (_c = progressState.orderId) != null ? _c : (_b = progressState.orderIds) == null ? void 0 : _b[0];
-    if (submittedOrderId) {
-      baseSteps.push({
-        id: "order-submitted",
-        label: tradingLabels.orderSubmittedProgress(normalizeOrderIdLabelInput2(submittedOrderId)),
-        status: "complete"
-      });
-    }
-    return [
-      baseSteps,
-      [
-        {
-          id: "executing-order",
-          label: tradingLabels.executingOnVenue(getTradingVenueLabel(progressState.executionVenue)),
-          status: "pending",
-          venue: progressState.executionVenue
-        }
-      ]
-    ];
-  };
-  const stepGroups = resolveStepGroups();
+  const displayRows = buildSubmissionDisplayRows({
+    phase: progressState.phase,
+    dagProgress: progressState.dagProgress,
+    executionVenue: progressState.executionVenue,
+    labels: tradingLabels
+  });
   return /* @__PURE__ */ jsx4(
     Card,
     {
@@ -2053,51 +2409,50 @@ var renderSubmissionSurface = ({
             /* @__PURE__ */ jsx4(LoadingGlyph, { enableAnimations, className: "h-4 w-4 text-current" }),
             /* @__PURE__ */ jsx4("span", { children: actionLabel })
           ] }),
-          /* @__PURE__ */ jsx4("div", { className: "agg-order-submission-steps flex flex-col gap-4", children: stepGroups.map((steps, groupIndex) => {
-            return /* @__PURE__ */ jsx4(
-              "div",
-              {
-                className: "agg-order-submission-group flex flex-col gap-2",
-                children: steps.map((step) => {
-                  return /* @__PURE__ */ jsxs3(
-                    "div",
-                    {
-                      className: "agg-order-submission-step flex items-center gap-2 text-agg-sm leading-agg-5 text-agg-foreground",
-                      children: [
-                        step.status === "complete" ? /* @__PURE__ */ jsx4(
-                          Icon,
-                          {
-                            name: "check-circle",
-                            size: "small",
-                            className: "h-3 w-3 shrink-0 text-agg-primary",
-                            "aria-hidden": "true"
-                          }
-                        ) : /* @__PURE__ */ jsx4(
-                          LoadingGlyph,
-                          {
-                            enableAnimations,
-                            className: "h-3 w-3 shrink-0 text-agg-primary"
-                          }
-                        ),
-                        /* @__PURE__ */ jsx4("p", { className: "min-w-0 flex-1", children: step.label }),
-                        step.venue ? /* @__PURE__ */ jsx4(
-                          VenueLogo,
-                          {
-                            venue: step.venue,
-                            size: "small",
-                            ariaLabel: getTradingVenueLabel(step.venue),
-                            className: "h-4 w-4"
-                          }
-                        ) : null
-                      ]
-                    },
-                    step.id
-                  );
-                })
-              },
-              `step-group-${groupIndex}`
-            );
-          }) })
+          /* @__PURE__ */ jsx4(
+            "div",
+            {
+              className: "agg-order-submission-steps agg-order-submission-group flex flex-col gap-2",
+              "data-testid": "agg-order-submission-steps",
+              children: displayRows.map((step) => {
+                return /* @__PURE__ */ jsxs3(
+                  "div",
+                  {
+                    className: "agg-order-submission-step flex items-center gap-2 text-agg-sm leading-agg-5 text-agg-foreground",
+                    "data-status": step.status,
+                    children: [
+                      step.status === "complete" ? /* @__PURE__ */ jsx4(
+                        Icon,
+                        {
+                          name: "check-circle",
+                          size: "small",
+                          className: "h-3 w-3 shrink-0 text-agg-primary",
+                          "aria-hidden": "true"
+                        }
+                      ) : /* @__PURE__ */ jsx4(
+                        LoadingGlyph,
+                        {
+                          enableAnimations,
+                          className: "h-3 w-3 shrink-0 text-agg-primary"
+                        }
+                      ),
+                      /* @__PURE__ */ jsx4("p", { className: "min-w-0 flex-1", children: step.label }),
+                      step.venue ? /* @__PURE__ */ jsx4(
+                        VenueLogo,
+                        {
+                          venue: step.venue,
+                          size: "small",
+                          ariaLabel: getTradingVenueLabel(step.venue),
+                          className: "h-4 w-4"
+                        }
+                      ) : null
+                    ]
+                  },
+                  step.id
+                );
+              })
+            }
+          )
         ] })
       ] })
     }
@@ -2233,6 +2588,7 @@ var PlaceOrder = ({
 }) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D;
   const {
+    enableDebug: isExecutionDebugEnabled,
     features: { enableAnimations, showFeesBreakdown },
     general: { locale }
   } = useSdkUiConfig();
@@ -2329,6 +2685,27 @@ var PlaceOrder = ({
   const [isSplitDetailOpen, setIsSplitDetailOpen] = useState3(false);
   const [submissionFeedback, setSubmissionFeedback] = useState3(null);
   const [submissionProgressState, setSubmissionProgressState] = useState3(null);
+  const executionDebugStoreRef = useRef2(null);
+  const executionDebugAttemptIdRef = useRef2(null);
+  useEffect2(() => {
+    if (!isExecutionDebugEnabled) {
+      executionDebugStoreRef.current = null;
+      return;
+    }
+    executionDebugStoreRef.current = enableExecutionDebugInBrowser();
+  }, [isExecutionDebugEnabled]);
+  useEffect2(() => {
+    if (!isExecutionDebugEnabled) return;
+    const store = executionDebugStoreRef.current;
+    if (!store) return;
+    store.clear();
+    executionDebugAttemptIdRef.current = null;
+  }, [
+    isExecutionDebugEnabled,
+    scopedSelectedEvent == null ? void 0 : scopedSelectedEvent.id,
+    scopedSelectedMarket == null ? void 0 : scopedSelectedMarket.id,
+    scopedSelectedOutcomeId
+  ]);
   const debouncedAmount = useDebouncedValue(internalAmount, 300);
   const isSell = useMemo2(() => internalTab === "sell", [internalTab]);
   const {
@@ -2588,8 +2965,39 @@ var PlaceOrder = ({
     selectedRouteCard == null ? void 0 : selectedRouteCard.quoteData
   ]);
   useEffect2(() => {
+    var _a2, _b2;
     const dp = executionProgress.dagProgress;
     if (!dp) return;
+    const debugStore = executionDebugStoreRef.current;
+    const debugAttemptId = executionDebugAttemptIdRef.current;
+    if (debugStore && debugAttemptId) {
+      debugStore.appendEvent(debugAttemptId, {
+        kind: "ws_update",
+        label: "dag_progress",
+        data: dp
+      });
+      const normalizedRows = buildSubmissionDisplayRows({
+        phase: "executing",
+        dagProgress: dp,
+        labels: tradingLabels
+      });
+      debugStore.setNormalizedSteps(debugAttemptId, normalizedRows);
+      debugStore.appendEvent(debugAttemptId, {
+        kind: "normalized_steps",
+        data: normalizedRows
+      });
+      if (dp.status === "failed") {
+        debugStore.appendError(debugAttemptId, {
+          message: (_a2 = dp.errorReason) != null ? _a2 : "DAG execution failed",
+          failedStep: (_b2 = dp.currentStepType) != null ? _b2 : void 0,
+          data: { currentSequence: dp.currentSequence, totalSteps: dp.totalSteps }
+        });
+        debugStore.updateAttempt(debugAttemptId, {
+          status: "failed",
+          finalStatus: "failed"
+        });
+      }
+    }
     setSubmissionProgressState((prev) => {
       if (!prev) return prev;
       if (dp.status === "failed") {
@@ -2605,7 +3013,7 @@ var PlaceOrder = ({
       }
       return __spreadProps(__spreadValues({}, prev), { dagProgress: dp });
     });
-  }, [executionProgress.dagProgress, tradingLabels.orderFailed]);
+  }, [executionProgress.dagProgress, tradingLabels]);
   useEffect2(() => {
     const orderIds = submissionProgressState == null ? void 0 : submissionProgressState.orderIds;
     if (!(orderIds == null ? void 0 : orderIds.length)) return;
@@ -2613,6 +3021,17 @@ var PlaceOrder = ({
       orderIds,
       executionProgress.terminalOrderEvents
     );
+    const debugStore = executionDebugStoreRef.current;
+    const debugAttemptId = executionDebugAttemptIdRef.current;
+    if (debugStore && debugAttemptId && executionProgress.terminalOrderEvents.length > 0) {
+      debugStore.appendEvent(debugAttemptId, {
+        kind: "terminal_event",
+        data: {
+          aggregateStatus,
+          events: executionProgress.terminalOrderEvents
+        }
+      });
+    }
     if (aggregateStatus === "pending") return;
     setSubmissionProgressState((prev) => {
       var _a2, _b2, _c2;
@@ -2655,14 +3074,45 @@ var PlaceOrder = ({
     tradingLabels.orderFailed
   ]);
   useEffect2(() => {
+    var _a2, _b2;
     if (!submissionProgressState) return;
     onExecutionStateChange == null ? void 0 : onExecutionStateChange(submissionProgressState);
+    const debugStore = executionDebugStoreRef.current;
+    const debugAttemptId = executionDebugAttemptIdRef.current;
+    if (debugStore && debugAttemptId) {
+      debugStore.appendEvent(debugAttemptId, {
+        kind: "state_change",
+        label: submissionProgressState.phase,
+        data: {
+          phase: submissionProgressState.phase,
+          executionVenue: submissionProgressState.executionVenue,
+          orderIds: submissionProgressState.orderIds,
+          errorMessage: submissionProgressState.errorMessage
+        }
+      });
+    }
     if (submissionProgressState.phase === "success" && submissionProgressState.summary) {
       invalidateBalanceQueries(queryClient);
       invalidatePositionQueries(queryClient);
+      if (debugStore && debugAttemptId) {
+        debugStore.updateAttempt(debugAttemptId, {
+          status: "succeeded",
+          finalStatus: "succeeded"
+        });
+      }
       onSuccess == null ? void 0 : onSuccess(submissionProgressState.summary);
     }
     if (submissionProgressState.phase === "failed" && submissionProgressState.errorMessage) {
+      if (debugStore && debugAttemptId) {
+        debugStore.appendError(debugAttemptId, {
+          message: submissionProgressState.errorMessage,
+          failedStep: (_b2 = (_a2 = submissionProgressState.dagProgress) == null ? void 0 : _a2.currentStepType) != null ? _b2 : void 0
+        });
+        debugStore.updateAttempt(debugAttemptId, {
+          status: "failed",
+          finalStatus: "failed"
+        });
+      }
       onError == null ? void 0 : onError(new Error(submissionProgressState.errorMessage));
     }
   }, [submissionProgressState, onExecutionStateChange, onSuccess, onError, queryClient]);
@@ -2836,23 +3286,91 @@ var PlaceOrder = ({
   };
   const handleExecuteQuote = useCallback2(
     (quoteData) => __async(null, null, function* () {
+      var _a2, _b2, _c2;
       const quoteId = quoteData == null ? void 0 : quoteData.quoteId;
       if (!quoteId) {
         throw new Error(tradingLabels.quoteUnavailable);
       }
+      const debugStore = executionDebugStoreRef.current;
+      const venues = (_b2 = (_a2 = quoteData == null ? void 0 : quoteData.fills) == null ? void 0 : _a2.map((fill) => fill.venue).filter(Boolean)) != null ? _b2 : [];
+      const debugAttempt = debugStore == null ? void 0 : debugStore.appendAttempt({
+        status: "executing",
+        quoteId,
+        quote: {
+          request: {
+            venueMarketOutcomeId: scopedSelectedOutcomeId,
+            amount: internalAmount,
+            slippage: internalSlippage,
+            tradeSide: isSell ? "sell" : "buy"
+          },
+          response: smartRoute.data,
+          selectedRoute: quoteData,
+          side: isSell ? "sell" : "buy",
+          marketId: scopedSelectedMarket == null ? void 0 : scopedSelectedMarket.id,
+          eventId: scopedSelectedEvent == null ? void 0 : scopedSelectedEvent.id,
+          outcomeId: scopedSelectedOutcomeId != null ? scopedSelectedOutcomeId : void 0,
+          venues,
+          capturedAt: Date.now()
+        },
+        selectedRoute: quoteData
+      });
+      executionDebugAttemptIdRef.current = (_c2 = debugAttempt == null ? void 0 : debugAttempt.attemptId) != null ? _c2 : null;
       if (onPrimaryAction) {
+        debugStore == null ? void 0 : debugStore.appendEvent(debugAttempt.attemptId, {
+          kind: "execute_request",
+          label: "delegated_to_partner",
+          data: { quoteId }
+        });
         onPrimaryAction({ quoteId });
         return;
       }
-      const response = yield executeManaged.mutateAsync({ quoteId });
-      setSubmissionProgressState({
-        executionVenue: resolveExecutionVenueFromQuote(quoteData),
-        orderId: response.orderIds[0],
-        orderIds: response.orderIds,
-        phase: "submitting"
-      });
+      try {
+        const response = yield executeManaged.mutateAsync({ quoteId });
+        if (debugAttempt) {
+          debugStore == null ? void 0 : debugStore.appendEvent(debugAttempt.attemptId, {
+            kind: "execute_response",
+            data: { orderIds: response.orderIds }
+          });
+          debugStore == null ? void 0 : debugStore.updateAttempt(debugAttempt.attemptId, {
+            orderId: response.orderIds[0],
+            orderIds: response.orderIds
+          });
+        }
+        setSubmissionProgressState({
+          executionVenue: resolveExecutionVenueFromQuote(quoteData),
+          orderId: response.orderIds[0],
+          orderIds: response.orderIds,
+          phase: "submitting"
+        });
+      } catch (error) {
+        if (debugAttempt) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          debugStore == null ? void 0 : debugStore.appendError(debugAttempt.attemptId, {
+            message: err.message,
+            name: err.name,
+            stack: err.stack,
+            failedStep: "execute_request"
+          });
+          debugStore == null ? void 0 : debugStore.updateAttempt(debugAttempt.attemptId, {
+            status: "failed",
+            finalStatus: "failed"
+          });
+        }
+        throw error;
+      }
     }),
-    [executeManaged, onPrimaryAction, tradingLabels.quoteUnavailable]
+    [
+      executeManaged,
+      internalAmount,
+      internalSlippage,
+      isSell,
+      onPrimaryAction,
+      scopedSelectedEvent == null ? void 0 : scopedSelectedEvent.id,
+      scopedSelectedMarket == null ? void 0 : scopedSelectedMarket.id,
+      scopedSelectedOutcomeId,
+      smartRoute.data,
+      tradingLabels.quoteUnavailable
+    ]
   );
   const handleSkipToSuccess = useCallback2(() => {
     const primaryFilledEvent = executionProgress.terminalOrderEvents.find(