@workflow/web 4.1.10 → 4.1.12

package/build/client/assets/{mermaid-3ZIDBTTL-ZIVWJOga.js → mermaid-3ZIDBTTL-B6kYjVMX.js}

@@ -1,4 +1,4 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/encryption-Bd25Keng.js","assets/index-7hulCzI_.js","assets/index-BsV8i_Jn.js","assets/highlighted-body-B3W2YXNL-qwkBshMM.js"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/encryption-BRhjWsZh.js","assets/index-DZSXezpI.js","assets/index-BsV8i_Jn.js","assets/highlighted-body-B3W2YXNL-BAYKR78e.js"])))=>i.map(i=>d[i]);
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -2376,7 +2376,7 @@ var Arrow$2 = reactExports.forwardRef((props, forwardedRef) => {
   );
 });
 Arrow$2.displayName = NAME$1;
-var Root$1 = Arrow$2;
+var Root$2 = Arrow$2;
 function useSize(element2) {
   const [size2, setSize] = reactExports.useState(void 0);
   useLayoutEffect2(() => {
@@ -2623,7 +2623,7 @@ var PopperArrow = reactExports.forwardRef(function PopperArrow2(props, forwarded
           visibility: contentContext.shouldHideArrow ? "hidden" : void 0
         },
         children: /* @__PURE__ */ jsxRuntimeExports.jsx(
-          Root$1,
+          Root$2,
           {
             ...arrowProps,
             ref: forwardedRef,
@@ -2898,7 +2898,7 @@ var VisuallyHidden = reactExports.forwardRef(
   }
 );
 VisuallyHidden.displayName = NAME;
-var Root = VisuallyHidden;
+var Root$1 = VisuallyHidden;
 var [createTooltipContext] = createContextScope("Tooltip", [
   createPopperScope
 ]);
@@ -3224,7 +3224,7 @@ var TooltipContentImpl = reactExports.forwardRef(
             },
             children: [
               /* @__PURE__ */ jsxRuntimeExports.jsx(Slottable$1, { children: children2 }),
-              /* @__PURE__ */ jsxRuntimeExports.jsx(VisuallyHiddenContentContextProvider, { scope: __scopeTooltip, isInside: true, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Root, { id: context.contentId, role: "tooltip", children: ariaLabel || children2 }) })
+              /* @__PURE__ */ jsxRuntimeExports.jsx(VisuallyHiddenContentContextProvider, { scope: __scopeTooltip, isInside: true, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Root$1, { id: context.contentId, role: "tooltip", children: ariaLabel || children2 }) })
             ]
           }
         )
@@ -6548,6 +6548,54 @@ const getDefaultConfig = () => {
     orderSensitiveModifiers: ["*", "**", "after", "backdrop", "before", "details-content", "file", "first-letter", "first-line", "marker", "placeholder", "selection"]
   };
 };
+const mergeConfigs = (baseConfig, {
+  cacheSize,
+  prefix,
+  experimentalParseClassName,
+  extend: extend2 = {},
+  override = {}
+}) => {
+  overrideProperty(baseConfig, "cacheSize", cacheSize);
+  overrideProperty(baseConfig, "prefix", prefix);
+  overrideProperty(baseConfig, "experimentalParseClassName", experimentalParseClassName);
+  overrideConfigProperties(baseConfig.theme, override.theme);
+  overrideConfigProperties(baseConfig.classGroups, override.classGroups);
+  overrideConfigProperties(baseConfig.conflictingClassGroups, override.conflictingClassGroups);
+  overrideConfigProperties(baseConfig.conflictingClassGroupModifiers, override.conflictingClassGroupModifiers);
+  overrideProperty(baseConfig, "orderSensitiveModifiers", override.orderSensitiveModifiers);
+  mergeConfigProperties(baseConfig.theme, extend2.theme);
+  mergeConfigProperties(baseConfig.classGroups, extend2.classGroups);
+  mergeConfigProperties(baseConfig.conflictingClassGroups, extend2.conflictingClassGroups);
+  mergeConfigProperties(baseConfig.conflictingClassGroupModifiers, extend2.conflictingClassGroupModifiers);
+  mergeArrayProperties(baseConfig, extend2, "orderSensitiveModifiers");
+  return baseConfig;
+};
+const overrideProperty = (baseObject, overrideKey, overrideValue) => {
+  if (overrideValue !== void 0) {
+    baseObject[overrideKey] = overrideValue;
+  }
+};
+const overrideConfigProperties = (baseObject, overrideObject) => {
+  if (overrideObject) {
+    for (const key in overrideObject) {
+      overrideProperty(baseObject, key, overrideObject[key]);
+    }
+  }
+};
+const mergeConfigProperties = (baseObject, mergeObject) => {
+  if (mergeObject) {
+    for (const key in mergeObject) {
+      mergeArrayProperties(baseObject, mergeObject, key);
+    }
+  }
+};
+const mergeArrayProperties = (baseObject, mergeObject, key) => {
+  const mergeValue = mergeObject[key];
+  if (mergeValue !== void 0) {
+    baseObject[key] = baseObject[key] ? baseObject[key].concat(mergeValue) : mergeValue;
+  }
+};
+const extendTailwindMerge = (configExtension, ...createConfig) => typeof configExtension === "function" ? createTailwindMerge(getDefaultConfig, configExtension, ...createConfig) : createTailwindMerge(() => mergeConfigs(getDefaultConfig(), configExtension), ...createConfig);
 const twMerge = /* @__PURE__ */ createTailwindMerge(getDefaultConfig);
 /**
  * @license lucide-react v0.575.0 - ISC
@@ -6692,70 +6740,78 @@ const __iconNode = [
   ["path", { d: "M7 11V7a5 5 0 0 1 10 0v4", key: "fwvmzm" }]
 ];
 const Lock = createLucideIcon("lock", __iconNode);
-function cn$4(...inputs) {
-  return twMerge(clsx(inputs));
-}
-const durationFormatter = new Intl.NumberFormat(void 0, {
-  maximumFractionDigits: 2
-});
-const MS_IN_SECOND = 1e3;
-const MS_IN_MINUTE = 60 * MS_IN_SECOND;
-const MS_IN_HOUR = 60 * MS_IN_MINUTE;
-const MS_IN_DAY = 24 * MS_IN_HOUR;
-function formatDuration(ms, compact = false) {
-  if (ms === 0) {
-    return "0";
-  }
-  if (ms < MS_IN_SECOND) {
-    return `${durationFormatter.format(ms)}ms`;
-  }
-  if (ms < MS_IN_MINUTE) {
-    return `${durationFormatter.format(ms / MS_IN_SECOND)}s`;
-  }
-  if (compact) {
-    if (ms < MS_IN_HOUR) {
-      const m3 = Math.floor(ms / MS_IN_MINUTE);
-      const s2 = Math.floor(ms % MS_IN_MINUTE / MS_IN_SECOND);
-      return s2 > 0 ? `${m3}m ${s2}s` : `${m3}m`;
+const twMergeConfig = {
+  extend: {
+    classGroups: {
+      "text-heading": [
+        {
+          "text-heading": [
+            "72",
+            "64",
+            "56",
+            "48",
+            "40",
+            "32",
+            "24",
+            "20",
+            "16",
+            "14"
+          ]
+        }
+      ],
+      "text-button": [
+        {
+          "text-button": ["16", "14", "12"]
+        }
+      ],
+      "text-label": [
+        {
+          "text-label": [
+            "20",
+            "18",
+            "16",
+            "14",
+            "14-mono",
+            "13",
+            "13-mono",
+            "12",
+            "12-mono"
+          ]
+        }
+      ],
+      "text-copy": [
+        {
+          "text-copy": ["24", "20", "18", "16", "14", "13", "13-mono"]
+        }
+      ],
+      material: [
+        {
+          material: [
+            "base",
+            "small",
+            "medium",
+            "large",
+            "tooltip",
+            "menu",
+            "modal",
+            "fullscreen"
+          ]
+        }
+      ]
+    },
+    // Make each category conflict with itself, so e.g. text-heading-32 overrides text-heading-24
+    conflictingClassGroups: {
+      "text-heading": ["text-heading"],
+      "text-button": ["text-button"],
+      "text-label": ["text-label"],
+      "text-copy": ["text-copy"],
+      material: ["material"]
     }
-    const h2 = Math.floor(ms / MS_IN_HOUR);
-    const m2 = Math.floor(ms % MS_IN_HOUR / MS_IN_MINUTE);
-    return m2 > 0 ? `${h2}h ${m2}m` : `${h2}h`;
-  }
-  const days = Math.floor(ms / MS_IN_DAY);
-  const hours = Math.floor(ms % MS_IN_DAY / MS_IN_HOUR);
-  const minutes = Math.floor(ms % MS_IN_HOUR / MS_IN_MINUTE);
-  const seconds = Math.floor(ms % MS_IN_MINUTE / MS_IN_SECOND);
-  const parts = [];
-  if (days > 0) {
-    parts.push(`${days}d`);
   }
-  if (hours > 0) {
-    parts.push(`${hours}h`);
-  }
-  if (minutes > 0) {
-    parts.push(`${minutes}m`);
-  }
-  if (hours <= 1 && (seconds > 0 || parts.length === 0)) {
-    parts.push(`${seconds}s`);
-  }
-  return parts.join(" ");
-}
-function isDoStreamStep(stepName) {
-  return stepName.endsWith("//doStreamStep");
-}
-function extractConversation(stepInput) {
-  if (!Array.isArray(stepInput) || stepInput.length === 0) {
-    return null;
-  }
-  const firstArg = stepInput[0];
-  if (!Array.isArray(firstArg)) {
-    return null;
-  }
-  if (!firstArg.every((msg) => msg && typeof msg === "object" && "role" in msg)) {
-    return null;
-  }
-  return firstArg;
+};
+const customTwMerge = extendTailwindMerge(twMergeConfig);
+function cn$4(...classes) {
+  return customTwMerge(clsx(...classes));
 }
 const ve$2 = 0, At$1 = 1, Jt$1 = 2, zn = 4;
 function un$1(t) {
@@ -10352,7 +10408,7 @@ function hydrateData(value, revivers) {
 async function hydrateDataWithKey(value, revivers, key) {
   if (value instanceof Uint8Array && isEncryptedData(value) && key) {
     const { decrypt } = await __vitePreload(async () => {
-      const { decrypt: decrypt2 } = await import("./encryption-Bd25Keng.js");
+      const { decrypt: decrypt2 } = await import("./encryption-BRhjWsZh.js");
       return { decrypt: decrypt2 };
     }, true ? __vite__mapDeps([0,1,2]) : void 0);
     const { payload } = decodeFormatPrefix(value);
@@ -10747,7 +10803,6 @@ function shallowClone(o) {
   return o;
 }
 const propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
-const primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -13053,51 +13108,6 @@ function handleReadonlyResult(payload) {
   payload.value = Object.freeze(payload.value);
   return payload;
 }
-const $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
-  $ZodType.init(inst, def);
-  const regexParts = [];
-  for (const part of def.parts) {
-    if (typeof part === "object" && part !== null) {
-      if (!part._zod.pattern) {
-        throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
-      }
-      const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
-      if (!source)
-        throw new Error(`Invalid template literal part: ${part._zod.traits}`);
-      const start = source.startsWith("^") ? 1 : 0;
-      const end = source.endsWith("$") ? source.length - 1 : source.length;
-      regexParts.push(source.slice(start, end));
-    } else if (part === null || primitiveTypes.has(typeof part)) {
-      regexParts.push(escapeRegex(`${part}`));
-    } else {
-      throw new Error(`Invalid template literal part: ${part}`);
-    }
-  }
-  inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
-  inst._zod.parse = (payload, _ctx) => {
-    if (typeof payload.value !== "string") {
-      payload.issues.push({
-        input: payload.value,
-        inst,
-        expected: "string",
-        code: "invalid_type"
-      });
-      return payload;
-    }
-    inst._zod.pattern.lastIndex = 0;
-    if (!inst._zod.pattern.test(payload.value)) {
-      payload.issues.push({
-        input: payload.value,
-        inst,
-        code: "invalid_format",
-        format: def.format ?? "template_literal",
-        pattern: inst._zod.pattern.source
-      });
-      return payload;
-    }
-    return payload;
-  };
-});
 const $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "innerType", () => def.getter());
@@ -14250,14 +14260,6 @@ const literalProcessor = (schema, ctx, json, _params) => {
     json.enum = vals;
   }
 };
-const templateLiteralProcessor = (schema, _ctx, json, _params) => {
-  const _json = json;
-  const pattern = schema._zod.pattern;
-  if (!pattern)
-    throw new Error("Pattern not found in template literal");
-  _json.type = "string";
-  _json.pattern = pattern.source;
-};
 const customProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
     throw new Error("Custom types cannot be represented in JSON Schema");
@@ -15171,18 +15173,6 @@ function readonly(innerType) {
     innerType
   });
 }
-const ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
-  $ZodTemplateLiteral.init(inst, def);
-  ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => templateLiteralProcessor(inst, ctx, json);
-});
-function templateLiteral(parts, params) {
-  return new ZodTemplateLiteral({
-    type: "template_literal",
-    parts,
-    ...normalizeParams(params)
-  });
-}
 const ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
@@ -15271,6 +15261,12 @@ const EventTypeSchema = _enum([
   "wait_created",
   "wait_completed"
 ]);
+const TerminalRunEventTypeSchema = EventTypeSchema.extract([
+  "run_completed",
+  "run_failed",
+  "run_cancelled"
+]);
+TerminalRunEventTypeSchema.options;
 const BaseEventSchema = object({
   eventType: EventTypeSchema,
   correlationId: string$2().optional(),
@@ -15281,6 +15277,10 @@ const StepCompletedEventSchema = BaseEventSchema.extend({
   correlationId: string$2(),
   eventData: object({
     stepName: string$2().optional(),
+    // Carried so a backend that keys payload refs by workflow name can build
+    // the key without an extra run lookup on this hot per-step write.
+    // Optional: older runtimes omit it and the backend falls back to a read.
+    workflowName: string$2().optional(),
     result: SerializedDataSchema
   })
 });
@@ -15308,7 +15308,11 @@ const StepStartedEventSchema = BaseEventSchema.extend({
   correlationId: string$2(),
   eventData: object({
     stepName: string$2().optional(),
-    attempt: number$2().optional()
+    attempt: number$2().optional(),
+    // Carried so a backend that keys payload refs by workflow name can
+    // build the key without re-reading the run on this hot per-step write.
+    // Optional: older runtimes omit it and the backend falls back to a read.
+    workflowName: string$2().optional()
   }).optional()
 });
 const StepCreatedEventSchema = BaseEventSchema.extend({
@@ -15316,6 +15320,7 @@ const StepCreatedEventSchema = BaseEventSchema.extend({
   correlationId: string$2(),
   eventData: object({
     stepName: string$2(),
+    workflowName: string$2().optional(),
     input: SerializedDataSchema
   })
 });
@@ -15324,7 +15329,14 @@ const HookCreatedEventSchema = BaseEventSchema.extend({
   correlationId: string$2(),
   eventData: object({
     token: string$2(),
-    metadata: SerializedDataSchema.optional()
+    metadata: SerializedDataSchema.optional(),
+    // Marks a hook created for a webhook (not resumable via the public
+    // webhook endpoint). The runtime emits this on hook_created and the
+    // backend consumes it; declaring it here keeps it on the wire.
+    // Also preserved on read so crash-recovery paths can rebuild the hook
+    // entity from the persisted `hook_created` event's payload (see
+    // `repairHookEntityFromPersistedEvent` in `@workflow/world-local`).
+    isWebhook: boolean$2().optional()
   })
 });
 const HookReceivedEventSchema = BaseEventSchema.extend({
@@ -15448,6 +15460,7 @@ AllEventsSchema.and(object({
   runId: string$2(),
   eventId: string$2(),
   createdAt: date(),
+  occurredAt: date().optional(),
   specVersion: number$2().optional()
 }));
 object({
@@ -15463,11 +15476,9 @@ object({
   specVersion: number$2().optional(),
   isWebhook: boolean$2().optional()
 });
-const QueuePrefix = union([
-  literal("__wkf_step_"),
-  literal("__wkf_workflow_")
-]);
-templateLiteral([QueuePrefix, string$2()]);
+string$2().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_(?:workflow|step)_$/, "Must match __wkf_{workflow|step}_ or __{namespace}_wkf_{workflow|step}_");
+string$2().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_(?:workflow|step)_.+$/, "Must be a valid queue name with a recognized prefix");
+string$2().regex(/^[a-z][a-z0-9]*$/, "Must be lowercase alphanumeric, starting with a letter");
 string$2().brand().describe("A stored queue message ID");
 const TraceCarrierSchema = record(string$2(), string$2());
 const RunInputSchema = object({
@@ -15531,6 +15542,12 @@ const WorkflowRunStatusSchema = _enum([
   "failed",
   "cancelled"
 ]);
+const TerminalWorkflowRunStatusSchema = WorkflowRunStatusSchema.extract([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+TerminalWorkflowRunStatusSchema.options;
 const WorkflowRunBaseSchema = object({
   runId: string$2(),
   status: WorkflowRunStatusSchema,
@@ -15651,6 +15668,12 @@ object({
   // Optional in database for backwards compatibility, defaults to 1 (legacy) when reading
   specVersion: number$2().optional()
 });
+const TerminalStepStatusSchema = StepStatusSchema.extract([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+TerminalStepStatusSchema.options;
 string$2().ulid();
 const WaitStatusSchema = _enum(["waiting", "completed"]);
 object({
@@ -15825,7 +15848,7 @@ async function hydrateResourceIOWithKey(resource, key) {
     return { hydrateDataWithKey: hydrateDataWithKey3 };
   }, true ? void 0 : void 0);
   const { importKey } = await __vitePreload(async () => {
-    const { importKey: importKey2 } = await import("./encryption-Bd25Keng.js");
+    const { importKey: importKey2 } = await import("./encryption-BRhjWsZh.js");
     return { importKey: importKey2 };
   }, true ? __vite__mapDeps([0,1,2]) : void 0);
   const cryptoKey = await importKey(key);
@@ -16968,6 +16991,797 @@ const ToastContext = reactExports.createContext(defaultAdapter);
 function useToast() {
   return reactExports.useContext(ToastContext);
 }
+const durationFormatter = new Intl.NumberFormat(void 0, {
+  maximumFractionDigits: 2
+});
+const MS_IN_SECOND = 1e3;
+const MS_IN_MINUTE = 60 * MS_IN_SECOND;
+const MS_IN_HOUR = 60 * MS_IN_MINUTE;
+const MS_IN_DAY = 24 * MS_IN_HOUR;
+function formatDuration(ms, compact = false) {
+  if (ms === 0) {
+    return "0";
+  }
+  if (ms < MS_IN_SECOND) {
+    return `${durationFormatter.format(ms)}ms`;
+  }
+  if (ms < MS_IN_MINUTE) {
+    return `${durationFormatter.format(ms / MS_IN_SECOND)}s`;
+  }
+  if (compact) {
+    if (ms < MS_IN_HOUR) {
+      const m3 = Math.floor(ms / MS_IN_MINUTE);
+      const s2 = Math.floor(ms % MS_IN_MINUTE / MS_IN_SECOND);
+      return s2 > 0 ? `${m3}m ${s2}s` : `${m3}m`;
+    }
+    const h2 = Math.floor(ms / MS_IN_HOUR);
+    const m2 = Math.floor(ms % MS_IN_HOUR / MS_IN_MINUTE);
+    return m2 > 0 ? `${h2}h ${m2}m` : `${h2}h`;
+  }
+  const days = Math.floor(ms / MS_IN_DAY);
+  const hours = Math.floor(ms % MS_IN_DAY / MS_IN_HOUR);
+  const minutes = Math.floor(ms % MS_IN_HOUR / MS_IN_MINUTE);
+  const seconds = Math.floor(ms % MS_IN_MINUTE / MS_IN_SECOND);
+  const parts = [];
+  if (days > 0) {
+    parts.push(`${days}d`);
+  }
+  if (hours > 0) {
+    parts.push(`${hours}h`);
+  }
+  if (minutes > 0) {
+    parts.push(`${minutes}m`);
+  }
+  if (hours <= 1 && (seconds > 0 || parts.length === 0)) {
+    parts.push(`${seconds}s`);
+  }
+  return parts.join(" ");
+}
+function isDoStreamStep(stepName) {
+  return stepName.endsWith("//doStreamStep");
+}
+function extractConversation(stepInput) {
+  if (!Array.isArray(stepInput) || stepInput.length === 0) {
+    return null;
+  }
+  const firstArg = stepInput[0];
+  if (!Array.isArray(firstArg)) {
+    return null;
+  }
+  if (!firstArg.every((msg) => msg && typeof msg === "object" && "role" in msg)) {
+    return null;
+  }
+  return firstArg;
+}
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node2) => {
+    let hasCleanup = false;
+    const cleanups = refs.map((ref) => {
+      const cleanup = setRef(ref, node2);
+      if (!hasCleanup && typeof cleanup == "function") {
+        hasCleanup = true;
+      }
+      return cleanup;
+    });
+    if (hasCleanup) {
+      return () => {
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (typeof cleanup == "function") {
+            cleanup();
+          } else {
+            setRef(refs[i], null);
+          }
+        }
+      };
+    }
+  };
+}
+function useComposedRefs(...refs) {
+  return reactExports.useCallback(composeRefs(...refs), refs);
+}
+var Slot = reactExports.forwardRef((props, forwardedRef) => {
+  const { children: children2, ...slotProps } = props;
+  const childrenArray = reactExports.Children.toArray(children2);
+  const slottable = childrenArray.find(isSlottable);
+  if (slottable) {
+    const newElement = slottable.props.children;
+    const newChildren = childrenArray.map((child) => {
+      if (child === slottable) {
+        if (reactExports.Children.count(newElement) > 1) return reactExports.Children.only(null);
+        return reactExports.isValidElement(newElement) ? newElement.props.children : null;
+      } else {
+        return child;
+      }
+    });
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(SlotClone, { ...slotProps, ref: forwardedRef, children: reactExports.isValidElement(newElement) ? reactExports.cloneElement(newElement, void 0, newChildren) : null });
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(SlotClone, { ...slotProps, ref: forwardedRef, children: children2 });
+});
+Slot.displayName = "Slot";
+var SlotClone = reactExports.forwardRef((props, forwardedRef) => {
+  const { children: children2, ...slotProps } = props;
+  if (reactExports.isValidElement(children2)) {
+    const childrenRef = getElementRef(children2);
+    return reactExports.cloneElement(children2, {
+      ...mergeProps(slotProps, children2.props),
+      // @ts-ignore
+      ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef
+    });
+  }
+  return reactExports.Children.count(children2) > 1 ? reactExports.Children.only(null) : null;
+});
+SlotClone.displayName = "SlotClone";
+var Slottable = ({ children: children2 }) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: children2 });
+};
+function isSlottable(child) {
+  return reactExports.isValidElement(child) && child.type === Slottable;
+}
+function mergeProps(slotProps, childProps) {
+  const overrideProps = { ...childProps };
+  for (const propName in childProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        overrideProps[propName] = (...args) => {
+          childPropValue(...args);
+          slotPropValue(...args);
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    }
+  }
+  return { ...slotProps, ...overrideProps };
+}
+function getElementRef(element2) {
+  var _a3, _b2;
+  let getter = (_a3 = Object.getOwnPropertyDescriptor(element2.props, "ref")) == null ? void 0 : _a3.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element2.ref;
+  }
+  getter = (_b2 = Object.getOwnPropertyDescriptor(element2, "ref")) == null ? void 0 : _b2.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element2.props.ref;
+  }
+  return element2.props.ref || element2.ref;
+}
+var Root = Slot;
+var debounce_1;
+var hasRequiredDebounce;
+function requireDebounce() {
+  if (hasRequiredDebounce) return debounce_1;
+  hasRequiredDebounce = 1;
+  function debounce(func, wait, immediate) {
+    var timeout, args, context, timestamp, result;
+    if (null == wait) wait = 100;
+    function later() {
+      var last = Date.now() - timestamp;
+      if (last < wait && last >= 0) {
+        timeout = setTimeout(later, wait - last);
+      } else {
+        timeout = null;
+        if (!immediate) {
+          result = func.apply(context, args);
+          context = args = null;
+        }
+      }
+    }
+    var debounced = function() {
+      context = this;
+      args = arguments;
+      timestamp = Date.now();
+      var callNow = immediate && !timeout;
+      if (!timeout) timeout = setTimeout(later, wait);
+      if (callNow) {
+        result = func.apply(context, args);
+        context = args = null;
+      }
+      return result;
+    };
+    debounced.clear = function() {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+    };
+    debounced.flush = function() {
+      if (timeout) {
+        result = func.apply(context, args);
+        context = args = null;
+        clearTimeout(timeout);
+        timeout = null;
+      }
+    };
+    return debounced;
+  }
+  debounce.debounce = debounce;
+  debounce_1 = debounce;
+  return debounce_1;
+}
+var debounceExports = requireDebounce();
+const createDebounce = /* @__PURE__ */ getDefaultExportFromCjs(debounceExports);
+function useMeasure(_temp) {
+  let {
+    debounce,
+    scroll,
+    polyfill,
+    offsetSize
+  } = {
+    debounce: 0,
+    scroll: false,
+    offsetSize: false
+  };
+  const ResizeObserver2 = polyfill || (typeof window === "undefined" ? class ResizeObserver {
+  } : window.ResizeObserver);
+  if (!ResizeObserver2) {
+    throw new Error("This browser does not support ResizeObserver out of the box. See: https://github.com/react-spring/react-use-measure/#resize-observer-polyfills");
+  }
+  const [bounds, set] = reactExports.useState({
+    left: 0,
+    top: 0,
+    width: 0,
+    height: 0,
+    bottom: 0,
+    right: 0,
+    x: 0,
+    y: 0
+  });
+  const state = reactExports.useRef({
+    element: null,
+    scrollContainers: null,
+    resizeObserver: null,
+    lastBounds: bounds
+  });
+  const scrollDebounce = debounce ? typeof debounce === "number" ? debounce : debounce.scroll : null;
+  const resizeDebounce = debounce ? typeof debounce === "number" ? debounce : debounce.resize : null;
+  const mounted = reactExports.useRef(false);
+  reactExports.useEffect(() => {
+    mounted.current = true;
+    return () => void (mounted.current = false);
+  });
+  const [forceRefresh, resizeChange, scrollChange] = reactExports.useMemo(() => {
+    const callback = () => {
+      if (!state.current.element) return;
+      const {
+        left,
+        top,
+        width,
+        height,
+        bottom,
+        right,
+        x: x2,
+        y: y2
+      } = state.current.element.getBoundingClientRect();
+      const size2 = {
+        left,
+        top,
+        width,
+        height,
+        bottom,
+        right,
+        x: x2,
+        y: y2
+      };
+      if (state.current.element instanceof HTMLElement && offsetSize) {
+        size2.height = state.current.element.offsetHeight;
+        size2.width = state.current.element.offsetWidth;
+      }
+      Object.freeze(size2);
+      if (mounted.current && !areBoundsEqual(state.current.lastBounds, size2)) set(state.current.lastBounds = size2);
+    };
+    return [callback, resizeDebounce ? createDebounce(callback, resizeDebounce) : callback, scrollDebounce ? createDebounce(callback, scrollDebounce) : callback];
+  }, [set, offsetSize, scrollDebounce, resizeDebounce]);
+  function removeListeners() {
+    if (state.current.scrollContainers) {
+      state.current.scrollContainers.forEach((element2) => element2.removeEventListener("scroll", scrollChange, true));
+      state.current.scrollContainers = null;
+    }
+    if (state.current.resizeObserver) {
+      state.current.resizeObserver.disconnect();
+      state.current.resizeObserver = null;
+    }
+  }
+  function addListeners() {
+    if (!state.current.element) return;
+    state.current.resizeObserver = new ResizeObserver2(scrollChange);
+    state.current.resizeObserver.observe(state.current.element);
+    if (scroll && state.current.scrollContainers) {
+      state.current.scrollContainers.forEach((scrollContainer) => scrollContainer.addEventListener("scroll", scrollChange, {
+        capture: true,
+        passive: true
+      }));
+    }
+  }
+  const ref = (node2) => {
+    if (!node2 || node2 === state.current.element) return;
+    removeListeners();
+    state.current.element = node2;
+    state.current.scrollContainers = findScrollContainers(node2);
+    addListeners();
+  };
+  useOnWindowScroll(scrollChange, Boolean(scroll));
+  useOnWindowResize(resizeChange);
+  reactExports.useEffect(() => {
+    removeListeners();
+    addListeners();
+  }, [scroll, scrollChange, resizeChange]);
+  reactExports.useEffect(() => removeListeners, []);
+  return [ref, bounds, forceRefresh];
+}
+function useOnWindowResize(onWindowResize) {
+  reactExports.useEffect(() => {
+    const cb = onWindowResize;
+    window.addEventListener("resize", cb);
+    return () => void window.removeEventListener("resize", cb);
+  }, [onWindowResize]);
+}
+function useOnWindowScroll(onScroll, enabled) {
+  reactExports.useEffect(() => {
+    if (enabled) {
+      const cb = onScroll;
+      window.addEventListener("scroll", cb, {
+        capture: true,
+        passive: true
+      });
+      return () => void window.removeEventListener("scroll", cb, true);
+    }
+  }, [onScroll, enabled]);
+}
+function findScrollContainers(element2) {
+  const result = [];
+  if (!element2 || element2 === document.body) return result;
+  const {
+    overflow,
+    overflowX,
+    overflowY
+  } = window.getComputedStyle(element2);
+  if ([overflow, overflowX, overflowY].some((prop) => prop === "auto" || prop === "scroll")) result.push(element2);
+  return [...result, ...findScrollContainers(element2.parentElement)];
+}
+const keys$1 = ["x", "y", "top", "bottom", "left", "right", "width", "height"];
+const areBoundsEqual = (a2, b2) => keys$1.every((key) => a2[key] === b2[key]);
+const QUERY = "(prefers-reduced-motion: reduce)";
+const useReducedMotion = () => {
+  const [reduced, setReduced] = reactExports.useState(() => {
+    if (typeof window === "undefined" || !window.matchMedia)
+      return false;
+    return window.matchMedia(QUERY).matches;
+  });
+  reactExports.useEffect(() => {
+    if (typeof window === "undefined" || !window.matchMedia)
+      return;
+    const media = window.matchMedia(QUERY);
+    const onChange = () => setReduced(media.matches);
+    media.addEventListener("change", onChange);
+    onChange();
+    return () => media.removeEventListener("change", onChange);
+  }, []);
+  return reduced;
+};
+const INACTIVE_TIMEOUT_MS = 250;
+const ENTER_DELAY_MS = 0;
+const OPEN_DELAY_MS = 150;
+const MAX_TRANSITION_DISTANCE_PX = 150;
+const MAX_OVERLAP_FOR_TRANSITION_PERCENT = 100;
+const PERSIST_TIMEOUT_MS = 1e3;
+const ContextCardContext = reactExports.createContext({
+  rootOrigin: { x: 0, y: 0 },
+  rootBounds: { width: 0, height: 0 },
+  portalRef: null,
+  activeId: null,
+  setActiveId: () => void 0,
+  hoveredId: null,
+  setHoveredId: () => void 0,
+  updateActiveContextCard: () => void 0,
+  skipTransition: false,
+  rootVisible: false,
+  distanceFromLast: 0,
+  lastOrigin: null,
+  isProvided: false
+});
+ContextCardContext.displayName = "ContextCardContext";
+function useHasContextCardProvider() {
+  return reactExports.useContext(ContextCardContext).isProvided;
+}
+function usePrevious(value) {
+  const ref = reactExports.useRef(null);
+  reactExports.useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+function isRefObject(value) {
+  return value !== null && value !== void 0 && "current" in value;
+}
+function ContextCardProvider({ children: children2, portalTarget }) {
+  const [isMounted, setIsMounted] = reactExports.useState(false);
+  reactExports.useEffect(() => setIsMounted(true), []);
+  const resolvedPortalTarget = isRefObject(portalTarget) ? portalTarget.current : portalTarget;
+  const [ref, bounds] = useMeasure();
+  const portalRef = reactExports.useRef(null);
+  const [activeContextCard, setActiveContextCard] = reactExports.useState(null);
+  const [visible, setVisible] = reactExports.useState(false);
+  const [hoveredId, setHoveredId] = reactExports.useState(null);
+  const activeId = reactExports.useRef(null);
+  function setActiveId(id) {
+    activeId.current = id;
+    setVisible(id !== null);
+  }
+  const updateActiveContextCard = (update) => {
+    if ((update == null ? void 0 : update.id) !== activeId.current && update !== null)
+      return;
+    setActiveContextCard(update);
+  };
+  const BORDER_WIDTH = 1;
+  const activeBounds = reactExports.useMemo(() => {
+    if (!activeContextCard)
+      return {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0,
+        side: "top",
+        arrowOffset: { x: 0, y: 0 }
+      };
+    return {
+      width: activeContextCard.contentSize.width + BORDER_WIDTH * 2,
+      height: activeContextCard.contentSize.height + BORDER_WIDTH * 2,
+      x: activeContextCard.origin.x,
+      y: activeContextCard.origin.y,
+      side: activeContextCard.side,
+      arrowOffset: activeContextCard.arrowOffset
+    };
+  }, [activeContextCard]);
+  const lastBounds = usePrevious(activeBounds);
+  const lastId = usePrevious(activeId.current);
+  const percentOverlapFromLast = reactExports.useMemo(() => {
+    if (!lastBounds)
+      return 0;
+    const overlapLeft = Math.max(activeBounds.x, lastBounds.x);
+    const overlapRight = Math.min(activeBounds.x + activeBounds.width, lastBounds.x + lastBounds.width);
+    const overlapTop = Math.max(activeBounds.y, lastBounds.y);
+    const overlapBottom = Math.min(activeBounds.y + activeBounds.height, lastBounds.y + lastBounds.height);
+    if (overlapLeft < overlapRight && overlapTop < overlapBottom) {
+      const overlapArea = (overlapRight - overlapLeft) * (overlapBottom - overlapTop);
+      const activeBoundsArea = activeBounds.width * activeBounds.height;
+      if (activeBoundsArea === 0)
+        return 0;
+      return overlapArea / activeBoundsArea * 100;
+    }
+    return 0;
+  }, [activeBounds, lastBounds]);
+  const distanceFromLast = reactExports.useMemo(() => Math.sqrt((((lastBounds == null ? void 0 : lastBounds.x) ?? 0) - activeBounds.x) ** 2 + (((lastBounds == null ? void 0 : lastBounds.y) ?? 0) - activeBounds.y) ** 2), [activeBounds.x, activeBounds.y, lastBounds == null ? void 0 : lastBounds.x, lastBounds == null ? void 0 : lastBounds.y]);
+  const lastOrigin = reactExports.useMemo(() => {
+    if (!lastBounds)
+      return null;
+    return {
+      x: lastBounds.x - activeBounds.x,
+      y: lastBounds.y - activeBounds.y
+    };
+  }, [activeBounds, lastBounds]);
+  const [isScrolling, setIsScrolling] = reactExports.useState(false);
+  const skipTransition = reactExports.useMemo(() => distanceFromLast > MAX_TRANSITION_DISTANCE_PX || percentOverlapFromLast > MAX_OVERLAP_FOR_TRANSITION_PERCENT || lastId === null || isScrolling, [distanceFromLast, isScrolling, lastId, percentOverlapFromLast]);
+  reactExports.useEffect(() => {
+    let isScrollingTimeout = null;
+    const onScroll = () => {
+      if (isScrollingTimeout)
+        window.clearTimeout(isScrollingTimeout);
+      isScrollingTimeout = setTimeout(() => {
+        setIsScrolling(false);
+      }, 66);
+      if (!isScrolling) {
+        setIsScrolling(true);
+      }
+    };
+    document.addEventListener("scroll", onScroll, true);
+    return () => {
+      document.removeEventListener("scroll", onScroll, true);
+    };
+  }, [isScrolling]);
+  const contextValue = reactExports.useMemo(() => ({
+    updateActiveContextCard,
+    rootOrigin: { ...activeBounds },
+    rootBounds: bounds,
+    portalRef,
+    setActiveId,
+    activeId,
+    setHoveredId,
+    hoveredId,
+    skipTransition,
+    rootVisible: visible,
+    distanceFromLast,
+    lastOrigin,
+    isProvided: true
+  }), [
+    activeBounds,
+    bounds,
+    hoveredId,
+    skipTransition,
+    visible,
+    distanceFromLast,
+    lastOrigin
+  ]);
+  return jsxRuntimeExports.jsxs(ContextCardContext.Provider, { value: contextValue, children: [children2, isMounted ? reactDomExports.createPortal(jsxRuntimeExports.jsx("div", { className: "w-full h-full inset-0 fixed pointer-events-none z-[100000]", ref, children: jsxRuntimeExports.jsx("div", { className: "min-w-max transition-all duration-150 ease-[easing-function:cubic-bezier(0.3,_0.57,_0.07,_0.95)] will-change-[transform,width,height] motion-reduce:!transition-none", style: {
+    opacity: visible ? 1 : 0
+  }, children: jsxRuntimeExports.jsxs("div", { className: cn$4("absolute bg-background-100 bg-clip-padding rounded-[6px] overflow-visible pointer-events-none z-[1000000] shadow-[var(--ds-shadow-tooltip),0_0_0_1px_var(--ds-background-100)] w-fit [--context-card-tip-stroke:var(--ds-gray-alpha-400)]", skipTransition ? "!transition-none" : "transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none"), "data-skip-transition": skipTransition, style: {
+    transform: `translate(${activeBounds.x}px,${activeBounds.y}px)`,
+    width: activeBounds.width,
+    height: activeBounds.height
+  }, children: [jsxRuntimeExports.jsx("div", { className: cn$4("w-[14px] h-[7px] absolute grid place-content-center z-[999999999] origin-center", {
+    "top-full -translate-x-1/2 rotate-0": activeBounds.side === "top",
+    "right-full -translate-y-1/2 rotate-90 -mr-[3.5px]": activeBounds.side === "right",
+    "bottom-full -translate-x-1/2 rotate-180": activeBounds.side === "bottom",
+    "left-full -translate-y-1/2 rotate-[270deg] -ml-[3.5px]": activeBounds.side === "left"
+  }, skipTransition ? "!transition-none" : "transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none"), style: {
+    ...activeBounds.side === "top" || activeBounds.side === "bottom" ? {
+      left: `calc(50% + ${activeBounds.arrowOffset.x}px)`
+    } : {
+      top: `calc(50% + ${activeBounds.arrowOffset.y}px)`
+    }
+  }, "data-skip-transition": skipTransition, "data-side": activeBounds.side, children: jsxRuntimeExports.jsxs("svg", { width: "14", height: "7", viewBox: "0 0 14 7", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", children: [jsxRuntimeExports.jsx("g", { clipPath: "url(#context-card-tip-clip)", children: jsxRuntimeExports.jsx("path", { d: "M15 -0.5V0.5H12.9834L12.8184 0.508789C12.4377 0.550822 12.0853 0.738056 11.8359 1.03418L8.53027 4.95996C7.73114 5.90893 6.26886 5.90892 5.46973 4.95996L2.16406 1.03418C1.87905 0.695733 1.45907 0.5 1.0166 0.5H-1V-0.5H15Z", fill: "var(--ds-background-100)", style: {
+    fill: "var(--ds-background-100)",
+    fillOpacity: 1,
+    stroke: "var(--context-card-tip-stroke)",
+    strokeOpacity: 1
+  } }) }), jsxRuntimeExports.jsx("defs", { children: jsxRuntimeExports.jsx("clipPath", { id: "context-card-tip-clip", children: jsxRuntimeExports.jsx("rect", { width: "14", height: "7", fill: "white", style: { fill: "white", fillOpacity: 1 } }) }) })] }) }), jsxRuntimeExports.jsx("div", { ref: portalRef })] }) }) }), resolvedPortalTarget ?? document.body) : null] });
+}
+function ContextCardTrigger({ content: content2, children: children2, side = "right", align = "center", sideOffset = 16, alignOffset = 0, ignoreCardPointerEvents = false, noPadding, asChild, className, hide: hide2, inactiveTimeoutMs = INACTIVE_TIMEOUT_MS }) {
+  const triggerRef = reactExports.useRef(null);
+  const contentRef = reactExports.useRef(null);
+  const [contentMeasureRef, contentMeasureBounds] = useMeasure();
+  const { portalRef, updateActiveContextCard, activeId, setActiveId, hoveredId, setHoveredId, skipTransition, rootVisible } = reactExports.useContext(ContextCardContext);
+  const id = reactExports.useId();
+  reactExports.useEffect(() => {
+    return () => {
+      if (activeId.current === id) {
+        setActiveId(null);
+      }
+    };
+  }, []);
+  const reduceMotion = useReducedMotion();
+  const [localHover, setLocalHover] = reactExports.useState(false);
+  const [persisting, setPersisting] = reactExports.useState(false);
+  const [visible, setVisible] = reactExports.useState(false);
+  const activeTimeout = reactExports.useRef(null);
+  const persistingTimeout = reactExports.useRef(null);
+  const openTimeout = reactExports.useRef(null);
+  reactExports.useEffect(() => {
+    if (localHover && contentMeasureBounds.width > 0 && contentMeasureBounds.height > 0) {
+      if (openTimeout.current)
+        clearTimeout(openTimeout.current);
+      openTimeout.current = setTimeout(() => {
+        setActiveId(id);
+        updateBounds();
+      }, rootVisible ? 0 : OPEN_DELAY_MS);
+    }
+    return () => {
+      if (openTimeout.current)
+        clearTimeout(openTimeout.current);
+    };
+  }, [localHover, contentMeasureBounds]);
+  const enterTimeout = reactExports.useRef(null);
+  reactExports.useEffect(() => {
+    if (enterTimeout.current)
+      clearTimeout(enterTimeout.current);
+    if (hoveredId !== id) {
+      setVisible(false);
+    } else {
+      enterTimeout.current = setTimeout(() => {
+        setVisible(true);
+      }, reduceMotion || skipTransition ? 0 : ENTER_DELAY_MS);
+    }
+  }, [hoveredId, id, reduceMotion, skipTransition]);
+  function updateBounds() {
+    if (!contentRef.current)
+      return;
+    const bounds = computeBounds();
+    updateActiveContextCard({ id, ...bounds });
+  }
+  function computeBounds(sideOverride) {
+    if (!triggerRef.current)
+      throw new Error("Trigger not found");
+    if (!contentRef.current)
+      throw new Error("Content not found");
+    const appliedSide = sideOverride ?? side;
+    const triggerRect = triggerRef.current.getBoundingClientRect();
+    const contentRect = contentRef.current.getBoundingClientRect();
+    contentRef.current.style.width = "max-content";
+    contentRef.current.style.position = "absolute";
+    const contentSize = {
+      width: Math.max(contentRect.width, contentRef.current.offsetWidth),
+      height: contentRect.height
+    };
+    let origin;
+    const arrowWidth = 14;
+    const halfArrowWidth = arrowWidth / 2;
+    const halfTriggerWidth = triggerRect.width / 2;
+    const halfTriggerHeight = triggerRect.height / 2;
+    const halfContentWidth = contentSize.width / 2;
+    const halfContentHeight = contentSize.height / 2;
+    const top = triggerRect.top;
+    const left = triggerRect.left;
+    let alignX = left + halfTriggerWidth - halfContentWidth + alignOffset;
+    if (align === "start")
+      alignX = left + alignOffset;
+    if (align === "end")
+      alignX = left + triggerRect.width - contentRect.width + alignOffset;
+    let alignY = top + halfTriggerHeight - halfContentHeight + alignOffset;
+    if (align === "start")
+      alignY = top + alignOffset;
+    if (align === "end")
+      alignY = top + triggerRect.height - contentRect.height + alignOffset;
+    switch (appliedSide) {
+      case "top":
+        origin = {
+          x: alignX,
+          y: top - contentRect.height - sideOffset
+        };
+        break;
+      case "right":
+        origin = {
+          x: left + triggerRect.width + sideOffset,
+          y: alignY
+        };
+        break;
+      case "bottom":
+        origin = {
+          x: alignX,
+          y: top + triggerRect.height + sideOffset
+        };
+        break;
+      case "left":
+        origin = {
+          x: left - contentRect.width - sideOffset,
+          y: alignY
+        };
+        break;
+      default: {
+        const _exhaustive = appliedSide;
+        throw new Error(`Unknown side: ${String(_exhaustive)}`);
+      }
+    }
+    const viewportWidth = document.documentElement.clientWidth;
+    const viewportHeight = document.documentElement.clientHeight;
+    const isOffscreenLeft = origin.x < 0;
+    const isOffscreenRight = origin.x + contentRect.width > viewportWidth;
+    const isOffscreenTop = origin.y < 0;
+    const isOffscreenBottom = origin.y + contentRect.height > viewportHeight;
+    if (!sideOverride) {
+      const spaceAbove = top;
+      const spaceBelow = viewportHeight - (top + triggerRect.height);
+      const spaceLeft = left;
+      const spaceRight = viewportWidth - (left + triggerRect.width);
+      if (side === "top" && isOffscreenTop && spaceBelow > spaceAbove) {
+        return computeBounds("bottom");
+      }
+      if (side === "bottom" && isOffscreenBottom && spaceAbove > spaceBelow) {
+        return computeBounds("top");
+      }
+      if (side === "right" && isOffscreenRight && spaceLeft > spaceRight) {
+        return computeBounds("left");
+      }
+      if (side === "left" && isOffscreenLeft && spaceRight > spaceLeft) {
+        return computeBounds("right");
+      }
+      if ((side === "top" || side === "bottom") && isOffscreenLeft && spaceRight > contentRect.width) {
+        return computeBounds("right");
+      }
+      if ((side === "top" || side === "bottom") && isOffscreenRight && spaceLeft > contentRect.width) {
+        return computeBounds("left");
+      }
+      if ((side === "left" || side === "right") && isOffscreenTop && spaceBelow > contentRect.height) {
+        return computeBounds("bottom");
+      }
+      if ((side === "left" || side === "right") && isOffscreenBottom && spaceAbove > contentRect.height) {
+        return computeBounds("top");
+      }
+    }
+    const viewportPadding = 8;
+    if (appliedSide === "left" || appliedSide === "right") {
+      origin.y = Math.max(viewportPadding, Math.min(origin.y, viewportHeight - contentSize.height - viewportPadding));
+    } else {
+      origin.x = Math.max(viewportPadding, Math.min(origin.x, viewportWidth - contentSize.width - viewportPadding));
+    }
+    origin.y = Math.max(viewportPadding, Math.min(origin.y, viewportHeight - contentSize.height - viewportPadding));
+    const triggerCenterX = left + halfTriggerWidth;
+    const triggerCenterY = top + halfTriggerHeight;
+    const cardCenterX = origin.x + contentSize.width / 2;
+    const cardCenterY = origin.y + contentSize.height / 2;
+    let arrowOffsetX = triggerCenterX - cardCenterX;
+    let arrowOffsetY = triggerCenterY - cardCenterY;
+    const maxArrowOffsetX = halfContentWidth - halfArrowWidth;
+    const maxArrowOffsetY = halfContentHeight - halfArrowWidth;
+    if (appliedSide === "top" || appliedSide === "bottom") {
+      arrowOffsetX = Math.max(-maxArrowOffsetX, Math.min(arrowOffsetX, maxArrowOffsetX));
+    }
+    if (appliedSide === "left" || appliedSide === "right") {
+      arrowOffsetY = Math.max(-maxArrowOffsetY, Math.min(arrowOffsetY, maxArrowOffsetY));
+    }
+    const arrowOffset = {
+      x: arrowOffsetX,
+      y: arrowOffsetY
+    };
+    return { origin, contentSize, side: appliedSide, arrowOffset };
+  }
+  reactExports.useEffect(() => {
+    document.addEventListener("scroll", updateBounds, true);
+    window.addEventListener("resize", updateBounds);
+    return () => {
+      document.removeEventListener("scroll", updateBounds, true);
+      window.removeEventListener("resize", updateBounds);
+    };
+  }, []);
+  function resetDestructiveTimeouts() {
+    if (activeTimeout.current)
+      clearTimeout(activeTimeout.current);
+    if (persistingTimeout.current)
+      clearTimeout(persistingTimeout.current);
+    if (openTimeout.current)
+      clearTimeout(openTimeout.current);
+  }
+  function attemptDeactivate() {
+    if (activeTimeout.current)
+      clearTimeout(activeTimeout.current);
+    activeTimeout.current = setTimeout(() => {
+      if (activeId.current !== id)
+        return;
+      setActiveId(null);
+    }, inactiveTimeoutMs);
+  }
+  function attemptPersist() {
+    setPersisting(true);
+    if (persistingTimeout.current)
+      clearTimeout(persistingTimeout.current);
+    persistingTimeout.current = setTimeout(() => {
+      setPersisting(false);
+    }, PERSIST_TIMEOUT_MS);
+  }
+  function onMouseEnter() {
+    resetDestructiveTimeouts();
+    setHoveredId(id);
+    setLocalHover(true);
+  }
+  function onMouseLeave() {
+    setLocalHover(false);
+    attemptDeactivate();
+    attemptPersist();
+  }
+  reactExports.useEffect(() => {
+    if (hide2) {
+      setLocalHover(false);
+      setActiveId(null);
+    }
+  }, [hide2, setActiveId]);
+  function handleClick(e) {
+    if (e.target instanceof HTMLElement && e.target.closest("a[href]")) {
+      onMouseLeave();
+    }
+  }
+  const Comp = asChild ? Root : "div";
+  return jsxRuntimeExports.jsxs(Comp, { className: cn$4("inline-flex cursor-pointer flex-[0_1_auto] overflow-hidden", className), onMouseEnter, onMouseLeave, onClick: handleClick, ref: triggerRef, children: [jsxRuntimeExports.jsx(Slottable, { children: children2 }), (portalRef == null ? void 0 : portalRef.current) && (localHover || persisting) ? reactDomExports.createPortal(jsxRuntimeExports.jsx("div", { className: cn$4("absolute top-0 p-3 left-0 max-w-max transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none", skipTransition && "!transition-none"), ref: contentRef, style: {
+    ...noPadding ? { padding: 0 } : {},
+    pointerEvents: rootVisible && visible && !ignoreCardPointerEvents ? "all" : "none"
+  }, children: jsxRuntimeExports.jsx("div", { className: cn$4("min-w-max transition-all duration-150 ease-[easing-function:cubic-bezier(0.3,_0.57,_0.07,_0.95)] will-change-[transform,width,height] motion-reduce:!transition-none", skipTransition ? "!transition-none" : "transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none"), ref: contentMeasureRef, style: {
+    opacity: Number(visible)
+  }, children: content2 }) }, id), portalRef.current) : null] });
+}
 const KEYFRAMES = `@keyframes wf-spinner-fade{0%{opacity:1}100%{opacity:.15}}`;
 function Spinner({ size: size2 = 14, color: color5 }) {
   const config2 = size2 <= 12 ? {
@@ -42839,7 +43653,7 @@ var tn = f("block", "before:content-[counter(line)]", "before:inline-block", "be
 var et = ({ className: e, language: t, style: o, isIncomplete: n, ...s2 }) => jsxRuntimeExports.jsx("div", { className: f("my-4 flex w-full flex-col gap-2 rounded-xl border border-border bg-sidebar p-2", e), "data-incomplete": n || void 0, "data-language": t, "data-streamdown": "code-block", style: { contentVisibility: "auto", containIntrinsicSize: "auto 200px", ...o }, ...s2 });
 var Se = reactExports.createContext({ code: "" }), de = () => reactExports.useContext(Se);
 var ot = ({ language: e }) => jsxRuntimeExports.jsx("div", { className: "flex h-8 items-center text-muted-foreground text-xs", "data-language": e, "data-streamdown": "code-block-header", children: jsxRuntimeExports.jsx("span", { className: "ml-1 font-mono lowercase", children: e }) });
-var cn$1 = /\n+$/, dn = reactExports.lazy(() => __vitePreload(() => import("./highlighted-body-B3W2YXNL-qwkBshMM.js"), true ? __vite__mapDeps([3,2]) : void 0).then((e) => ({ default: e.HighlightedCodeBlockBody }))), rt = ({ code: e, language: t, className: o, children: n, isIncomplete: s2 = false, ...r2 }) => {
+var cn$1 = /\n+$/, dn = reactExports.lazy(() => __vitePreload(() => import("./highlighted-body-B3W2YXNL-BAYKR78e.js"), true ? __vite__mapDeps([3,2]) : void 0).then((e) => ({ default: e.HighlightedCodeBlockBody }))), rt = ({ code: e, language: t, className: o, children: n, isIncomplete: s2 = false, ...r2 }) => {
   let i = reactExports.useMemo(() => e.replace(cn$1, ""), [e]), c = reactExports.useMemo(() => ({ bg: "transparent", fg: "inherit", tokens: i.split(`
 `).map((a2) => [{ content: a2, color: "inherit", bgColor: "transparent", htmlStyle: {}, offset: 0 }]) }), [i]);
   return jsxRuntimeExports.jsx(Se.Provider, { value: { code: e }, children: jsxRuntimeExports.jsxs(et, { isIncomplete: s2, language: t, children: [jsxRuntimeExports.jsx(ot, { language: t }), n ? jsxRuntimeExports.jsx("div", { className: "pointer-events-none sticky top-2 z-10 -mt-10 flex h-8 items-center justify-end", children: jsxRuntimeExports.jsx("div", { className: "pointer-events-auto flex shrink-0 items-center gap-2 rounded-md border border-sidebar bg-sidebar/80 px-1.5 py-1 supports-[backdrop-filter]:bg-sidebar/70 supports-[backdrop-filter]:backdrop-blur", "data-streamdown": "code-block-actions", children: n }) }) : null, jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: jsxRuntimeExports.jsx(Qe, { className: o, language: t, result: c, ...r2 }), children: jsxRuntimeExports.jsx(dn, { className: o, code: i, language: t, raw: c, ...r2 }) })] }) });
@@ -43948,127 +44762,127 @@ function TraceViewerContextProvider({ getQuickLinks, withPanel = false, children
 const useTraceViewer = () => reactExports.useContext(TraceViewerContext);
 const CustomPanelContext = reactExports.createContext(null);
 const useCustomPanelComponent = () => reactExports.useContext(CustomPanelContext);
-const traceNode = "_traceNode_1fmf2_1";
-const childRow = "_childRow_1fmf2_5";
-const spanNode = "_spanNode_1fmf2_11";
-const huge = "_huge_1fmf2_31";
-const spanName = "_spanName_1fmf2_34";
-const spanSpacer = "_spanSpacer_1fmf2_40";
-const spanDuration = "_spanDuration_1fmf2_44";
-const small = "_small_1fmf2_62";
-const xHover = "_xHover_1fmf2_62";
-const spanNodeEvent = "_spanNodeEvent_1fmf2_118";
-const eventDiamond = "_eventDiamond_1fmf2_124";
-const customEventColor = "_customEventColor_1fmf2_140";
-const hoverInfo = "_hoverInfo_1fmf2_145";
-const eventName = "_eventName_1fmf2_149";
-const eventTimestamp = "_eventTimestamp_1fmf2_153";
-const alignStart = "_alignStart_1fmf2_174";
-const alignEnd = "_alignEnd_1fmf2_178";
-const colorVercel = "_colorVercel_1fmf2_205";
-const color0 = "_color0_1fmf2_213";
-const color1 = "_color1_1fmf2_220";
-const color2 = "_color2_1fmf2_227";
-const color3 = "_color3_1fmf2_234";
-const color4 = "_color4_1fmf2_241";
-const colorHighlight = "_colorHighlight_1fmf2_248";
-const unlit = "_unlit_1fmf2_256";
-const mapContainer = "_mapContainer_1fmf2_262";
-const spanDetailPanel = "_spanDetailPanel_1fmf2_329";
-const spanDetailPanelResizer = "_spanDetailPanelResizer_1fmf2_338";
-const spanDetailPanelTop = "_spanDetailPanelTop_1fmf2_353";
-const spanDetailPanelBody = "_spanDetailPanelBody_1fmf2_362";
-const spanDetailPanelTopInfo = "_spanDetailPanelTopInfo_1fmf2_375";
-const spanNameDetailPanel = "_spanNameDetailPanel_1fmf2_389";
-const spanDetailPanelTruncatedHeading = "_spanDetailPanelTruncatedHeading_1fmf2_395";
-const spanDetailPanelName = "_spanDetailPanelName_1fmf2_405";
-const spanDetailPanelDuration = "_spanDetailPanelDuration_1fmf2_416";
-const spanDetailPanelCorner = "_spanDetailPanelCorner_1fmf2_427";
-const spanDetailPanelCornerInner = "_spanDetailPanelCornerInner_1fmf2_437";
-const spanDetailPanelCloseVerticalRule = "_spanDetailPanelCloseVerticalRule_1fmf2_445";
-const spanDetailPanelClose = "_spanDetailPanelClose_1fmf2_445";
-const spanDetailPanelAttribute = "_spanDetailPanelAttribute_1fmf2_467";
-const spanDetailPanelAttributeKey = "_spanDetailPanelAttributeKey_1fmf2_484";
-const spanDetailPanelAttributeValue = "_spanDetailPanelAttributeValue_1fmf2_492";
-const spanDetailPanelQuickLink = "_spanDetailPanelQuickLink_1fmf2_503";
-const spanDetailPanelQuickLinkLabel = "_spanDetailPanelQuickLinkLabel_1fmf2_506";
-const detailGroup = "_detailGroup_1fmf2_519";
-const expanded = "_expanded_1fmf2_533";
-const collapsed = "_collapsed_1fmf2_534";
-const ancestorGroup = "_ancestorGroup_1fmf2_535";
-const detailHeading = "_detailHeading_1fmf2_539";
-const buttonLink = "_buttonLink_1fmf2_562";
-const note = "_note_1fmf2_581";
-const skeleton = "_skeleton_1fmf2_589";
-const skeletonRounded = "_skeletonRounded_1fmf2_595";
-const detailHeadingIcon = "_detailHeadingIcon_1fmf2_599";
-const infraSpanDescription = "_infraSpanDescription_1fmf2_603";
-const ancestorNode = "_ancestorNode_1fmf2_613";
-const ancestorText = "_ancestorText_1fmf2_629";
-const ancestorName = "_ancestorName_1fmf2_639";
-const ancestorDuration = "_ancestorDuration_1fmf2_644";
-const ancestorLineContainer = "_ancestorLineContainer_1fmf2_649";
-const ancestorLine = "_ancestorLine_1fmf2_649";
-const zoomButtonGroup = "_zoomButtonGroup_1fmf2_701";
-const zoomButton = "_zoomButton_1fmf2_701";
-const divider = "_divider_1fmf2_751";
-const markersContainer = "_markersContainer_1fmf2_758";
-const markers = "_markers_1fmf2_758";
-const marker = "_marker_1fmf2_758";
-const notch = "_notch_1fmf2_792";
-const markerLabel = "_markerLabel_1fmf2_798";
-const markerClockTime = "_markerClockTime_1fmf2_807";
-const eventMarkersContainer = "_eventMarkersContainer_1fmf2_816";
-const eventMarkers = "_eventMarkers_1fmf2_816";
-const eventMarker = "_eventMarker_1fmf2_816";
-const cursorMarkerStickyParent = "_cursorMarkerStickyParent_1fmf2_839";
-const cursorMarkerLabelContainer = "_cursorMarkerLabelContainer_1fmf2_848";
-const cursorMarkerLabel = "_cursorMarkerLabel_1fmf2_848";
-const cursorMarkerContainer = "_cursorMarkerContainer_1fmf2_898";
-const cursorMarker = "_cursorMarker_1fmf2_839";
-const cursorSelection = "_cursorSelection_1fmf2_916";
-const traceViewer = "_traceViewer_1fmf2_966";
-const mapCanvas = "_mapCanvas_1fmf2_972";
-const zoomButtonTraceViewer = "_zoomButtonTraceViewer_1fmf2_988";
-const timeline = "_timeline_1fmf2_1011";
-const searchBar = "_searchBar_1fmf2_1019";
-const searchInput = "_searchInput_1fmf2_1031";
-const searchInputLabel = "_searchInputLabel_1fmf2_1038";
-const searchInputPrefix = "_searchInputPrefix_1fmf2_1063";
-const mapThumb = "_mapThumb_1fmf2_1101";
-const spanDetailPanelTraceViewer = "_spanDetailPanelTraceViewer_1fmf2_1115";
-const traceViewerContent = "_traceViewerContent_1fmf2_1134";
-const inert = "_inert_1fmf2_1144";
-const hidden = "_hidden_1fmf2_1180";
-const mobile = "_mobile_1fmf2_1184";
-const spanRunning = "_spanRunning_1fmf2_1194";
-const spanPending = "_spanPending_1fmf2_1195";
-const spanCompleted = "_spanCompleted_1fmf2_1203";
-const spanCancelled = "_spanCancelled_1fmf2_1211";
-const spanFailed = "_spanFailed_1fmf2_1219";
-const spanPendingStriped = "_spanPendingStriped_1fmf2_1228";
-const hasQueuedTime = "_hasQueuedTime_1fmf2_1242";
-const spanSleep = "_spanSleep_1fmf2_1254";
-const spanHook = "_spanHook_1fmf2_1263";
-const segmentLayer = "_segmentLayer_1fmf2_1275";
-const segment = "_segment_1fmf2_1275";
-const segmentLabel = "_segmentLabel_1fmf2_1291";
-const segmentTag = "_segmentTag_1fmf2_1306";
-const segQueued = "_segQueued_1fmf2_1314";
-const segRunning = "_segRunning_1fmf2_1325";
-const segFailed = "_segFailed_1fmf2_1330";
-const segRetrying = "_segRetrying_1fmf2_1335";
-const segSucceeded = "_segSucceeded_1fmf2_1346";
-const segWaiting = "_segWaiting_1fmf2_1351";
-const segSleeping = "_segSleeping_1fmf2_1362";
-const segReceived = "_segReceived_1fmf2_1367";
-const boundaryMarker = "_boundaryMarker_1fmf2_1372";
-const boundaryLine = "_boundaryLine_1fmf2_1373";
-const hasSegments = "_hasSegments_1fmf2_1395";
-const eventFailed = "_eventFailed_1fmf2_1432";
-const eventRetrying = "_eventRetrying_1fmf2_1441";
-const eventHook = "_eventHook_1fmf2_1450";
-const eventDefault = "_eventDefault_1fmf2_1459";
+const traceNode = "_traceNode_1ytrx_1";
+const childRow = "_childRow_1ytrx_5";
+const spanNode = "_spanNode_1ytrx_11";
+const huge = "_huge_1ytrx_31";
+const spanName = "_spanName_1ytrx_34";
+const spanSpacer = "_spanSpacer_1ytrx_40";
+const spanDuration = "_spanDuration_1ytrx_44";
+const small = "_small_1ytrx_62";
+const xHover = "_xHover_1ytrx_62";
+const spanNodeEvent = "_spanNodeEvent_1ytrx_118";
+const eventDiamond = "_eventDiamond_1ytrx_124";
+const customEventColor = "_customEventColor_1ytrx_140";
+const hoverInfo = "_hoverInfo_1ytrx_145";
+const eventName = "_eventName_1ytrx_149";
+const eventTimestamp = "_eventTimestamp_1ytrx_153";
+const alignStart = "_alignStart_1ytrx_174";
+const alignEnd = "_alignEnd_1ytrx_178";
+const colorVercel = "_colorVercel_1ytrx_205";
+const color0 = "_color0_1ytrx_213";
+const color1 = "_color1_1ytrx_220";
+const color2 = "_color2_1ytrx_227";
+const color3 = "_color3_1ytrx_234";
+const color4 = "_color4_1ytrx_241";
+const colorHighlight = "_colorHighlight_1ytrx_248";
+const unlit = "_unlit_1ytrx_256";
+const mapContainer = "_mapContainer_1ytrx_262";
+const spanDetailPanel = "_spanDetailPanel_1ytrx_329";
+const spanDetailPanelResizer = "_spanDetailPanelResizer_1ytrx_338";
+const spanDetailPanelTop = "_spanDetailPanelTop_1ytrx_353";
+const spanDetailPanelBody = "_spanDetailPanelBody_1ytrx_362";
+const spanDetailPanelTopInfo = "_spanDetailPanelTopInfo_1ytrx_375";
+const spanNameDetailPanel = "_spanNameDetailPanel_1ytrx_389";
+const spanDetailPanelTruncatedHeading = "_spanDetailPanelTruncatedHeading_1ytrx_395";
+const spanDetailPanelName = "_spanDetailPanelName_1ytrx_405";
+const spanDetailPanelDuration = "_spanDetailPanelDuration_1ytrx_416";
+const spanDetailPanelCorner = "_spanDetailPanelCorner_1ytrx_427";
+const spanDetailPanelCornerInner = "_spanDetailPanelCornerInner_1ytrx_437";
+const spanDetailPanelCloseVerticalRule = "_spanDetailPanelCloseVerticalRule_1ytrx_445";
+const spanDetailPanelClose = "_spanDetailPanelClose_1ytrx_445";
+const spanDetailPanelAttribute = "_spanDetailPanelAttribute_1ytrx_467";
+const spanDetailPanelAttributeKey = "_spanDetailPanelAttributeKey_1ytrx_484";
+const spanDetailPanelAttributeValue = "_spanDetailPanelAttributeValue_1ytrx_492";
+const spanDetailPanelQuickLink = "_spanDetailPanelQuickLink_1ytrx_503";
+const spanDetailPanelQuickLinkLabel = "_spanDetailPanelQuickLinkLabel_1ytrx_506";
+const detailGroup = "_detailGroup_1ytrx_519";
+const expanded = "_expanded_1ytrx_533";
+const collapsed = "_collapsed_1ytrx_534";
+const ancestorGroup = "_ancestorGroup_1ytrx_535";
+const detailHeading = "_detailHeading_1ytrx_539";
+const buttonLink = "_buttonLink_1ytrx_562";
+const note = "_note_1ytrx_581";
+const skeleton = "_skeleton_1ytrx_589";
+const skeletonRounded = "_skeletonRounded_1ytrx_595";
+const detailHeadingIcon = "_detailHeadingIcon_1ytrx_599";
+const infraSpanDescription = "_infraSpanDescription_1ytrx_603";
+const ancestorNode = "_ancestorNode_1ytrx_613";
+const ancestorText = "_ancestorText_1ytrx_629";
+const ancestorName = "_ancestorName_1ytrx_639";
+const ancestorDuration = "_ancestorDuration_1ytrx_644";
+const ancestorLineContainer = "_ancestorLineContainer_1ytrx_649";
+const ancestorLine = "_ancestorLine_1ytrx_649";
+const zoomButtonGroup = "_zoomButtonGroup_1ytrx_701";
+const zoomButton = "_zoomButton_1ytrx_701";
+const divider = "_divider_1ytrx_751";
+const markersContainer = "_markersContainer_1ytrx_758";
+const markers = "_markers_1ytrx_758";
+const marker = "_marker_1ytrx_758";
+const notch = "_notch_1ytrx_792";
+const markerLabel = "_markerLabel_1ytrx_798";
+const markerClockTime = "_markerClockTime_1ytrx_807";
+const eventMarkersContainer = "_eventMarkersContainer_1ytrx_816";
+const eventMarkers = "_eventMarkers_1ytrx_816";
+const eventMarker = "_eventMarker_1ytrx_816";
+const cursorMarkerStickyParent = "_cursorMarkerStickyParent_1ytrx_839";
+const cursorMarkerLabelContainer = "_cursorMarkerLabelContainer_1ytrx_848";
+const cursorMarkerLabel = "_cursorMarkerLabel_1ytrx_848";
+const cursorMarkerContainer = "_cursorMarkerContainer_1ytrx_898";
+const cursorMarker = "_cursorMarker_1ytrx_839";
+const cursorSelection = "_cursorSelection_1ytrx_916";
+const traceViewer = "_traceViewer_1ytrx_966";
+const mapCanvas = "_mapCanvas_1ytrx_972";
+const zoomButtonTraceViewer = "_zoomButtonTraceViewer_1ytrx_988";
+const timeline = "_timeline_1ytrx_1011";
+const searchBar = "_searchBar_1ytrx_1019";
+const searchInput = "_searchInput_1ytrx_1031";
+const searchInputLabel = "_searchInputLabel_1ytrx_1038";
+const searchInputPrefix = "_searchInputPrefix_1ytrx_1063";
+const mapThumb = "_mapThumb_1ytrx_1101";
+const spanDetailPanelTraceViewer = "_spanDetailPanelTraceViewer_1ytrx_1115";
+const traceViewerContent = "_traceViewerContent_1ytrx_1134";
+const inert = "_inert_1ytrx_1144";
+const hidden = "_hidden_1ytrx_1180";
+const mobile = "_mobile_1ytrx_1184";
+const spanRunning = "_spanRunning_1ytrx_1194";
+const spanPending = "_spanPending_1ytrx_1195";
+const spanCompleted = "_spanCompleted_1ytrx_1203";
+const spanCancelled = "_spanCancelled_1ytrx_1211";
+const spanFailed = "_spanFailed_1ytrx_1219";
+const spanPendingStriped = "_spanPendingStriped_1ytrx_1228";
+const hasQueuedTime = "_hasQueuedTime_1ytrx_1242";
+const spanSleep = "_spanSleep_1ytrx_1254";
+const spanHook = "_spanHook_1ytrx_1263";
+const segmentLayer = "_segmentLayer_1ytrx_1275";
+const segment = "_segment_1ytrx_1275";
+const segmentLabel = "_segmentLabel_1ytrx_1291";
+const segmentTag = "_segmentTag_1ytrx_1306";
+const segQueued = "_segQueued_1ytrx_1314";
+const segRunning = "_segRunning_1ytrx_1325";
+const segFailed = "_segFailed_1ytrx_1330";
+const segRetrying = "_segRetrying_1ytrx_1335";
+const segSucceeded = "_segSucceeded_1ytrx_1346";
+const segWaiting = "_segWaiting_1ytrx_1351";
+const segSleeping = "_segSleeping_1ytrx_1362";
+const segReceived = "_segReceived_1ytrx_1367";
+const boundaryMarker = "_boundaryMarker_1ytrx_1372";
+const boundaryLine = "_boundaryLine_1ytrx_1373";
+const hasSegments = "_hasSegments_1ytrx_1395";
+const eventFailed = "_eventFailed_1ytrx_1432";
+const eventRetrying = "_eventRetrying_1ytrx_1441";
+const eventHook = "_eventHook_1ytrx_1450";
+const eventDefault = "_eventDefault_1ytrx_1459";
 const styles = {
   traceNode,
   childRow,
@@ -44132,7 +44946,7 @@ const styles = {
   ancestorLineContainer,
   ancestorLine,
   zoomButtonGroup,
-  "zoom-buttons-fade-in": "_zoom-buttons-fade-in_1fmf2_1",
+  "zoom-buttons-fade-in": "_zoom-buttons-fade-in_1ytrx_1",
   zoomButton,
   divider,
   markersContainer,
@@ -44151,7 +44965,7 @@ const styles = {
   cursorMarker,
   cursorSelection,
   traceViewer,
-  "span-skeleton": "_span-skeleton_1fmf2_1",
+  "span-skeleton": "_span-skeleton_1ytrx_1",
   mapCanvas,
   zoomButtonTraceViewer,
   timeline,
@@ -45488,115 +46302,6 @@ function useServerConfig() {
   }
   return context;
 }
-function setRef(ref, value) {
-  if (typeof ref === "function") {
-    return ref(value);
-  } else if (ref !== null && ref !== void 0) {
-    ref.current = value;
-  }
-}
-function composeRefs(...refs) {
-  return (node2) => {
-    let hasCleanup = false;
-    const cleanups = refs.map((ref) => {
-      const cleanup = setRef(ref, node2);
-      if (!hasCleanup && typeof cleanup == "function") {
-        hasCleanup = true;
-      }
-      return cleanup;
-    });
-    if (hasCleanup) {
-      return () => {
-        for (let i = 0; i < cleanups.length; i++) {
-          const cleanup = cleanups[i];
-          if (typeof cleanup == "function") {
-            cleanup();
-          } else {
-            setRef(refs[i], null);
-          }
-        }
-      };
-    }
-  };
-}
-function useComposedRefs(...refs) {
-  return reactExports.useCallback(composeRefs(...refs), refs);
-}
-var Slot = reactExports.forwardRef((props, forwardedRef) => {
-  const { children: children2, ...slotProps } = props;
-  const childrenArray = reactExports.Children.toArray(children2);
-  const slottable = childrenArray.find(isSlottable);
-  if (slottable) {
-    const newElement = slottable.props.children;
-    const newChildren = childrenArray.map((child) => {
-      if (child === slottable) {
-        if (reactExports.Children.count(newElement) > 1) return reactExports.Children.only(null);
-        return reactExports.isValidElement(newElement) ? newElement.props.children : null;
-      } else {
-        return child;
-      }
-    });
-    return /* @__PURE__ */ jsxRuntimeExports.jsx(SlotClone, { ...slotProps, ref: forwardedRef, children: reactExports.isValidElement(newElement) ? reactExports.cloneElement(newElement, void 0, newChildren) : null });
-  }
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(SlotClone, { ...slotProps, ref: forwardedRef, children: children2 });
-});
-Slot.displayName = "Slot";
-var SlotClone = reactExports.forwardRef((props, forwardedRef) => {
-  const { children: children2, ...slotProps } = props;
-  if (reactExports.isValidElement(children2)) {
-    const childrenRef = getElementRef(children2);
-    return reactExports.cloneElement(children2, {
-      ...mergeProps(slotProps, children2.props),
-      // @ts-ignore
-      ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef
-    });
-  }
-  return reactExports.Children.count(children2) > 1 ? reactExports.Children.only(null) : null;
-});
-SlotClone.displayName = "SlotClone";
-var Slottable = ({ children: children2 }) => {
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: children2 });
-};
-function isSlottable(child) {
-  return reactExports.isValidElement(child) && child.type === Slottable;
-}
-function mergeProps(slotProps, childProps) {
-  const overrideProps = { ...childProps };
-  for (const propName in childProps) {
-    const slotPropValue = slotProps[propName];
-    const childPropValue = childProps[propName];
-    const isHandler = /^on[A-Z]/.test(propName);
-    if (isHandler) {
-      if (slotPropValue && childPropValue) {
-        overrideProps[propName] = (...args) => {
-          childPropValue(...args);
-          slotPropValue(...args);
-        };
-      } else if (slotPropValue) {
-        overrideProps[propName] = slotPropValue;
-      }
-    } else if (propName === "style") {
-      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
-    } else if (propName === "className") {
-      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
-    }
-  }
-  return { ...slotProps, ...overrideProps };
-}
-function getElementRef(element2) {
-  var _a3, _b2;
-  let getter = (_a3 = Object.getOwnPropertyDescriptor(element2.props, "ref")) == null ? void 0 : _a3.get;
-  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
-  if (mayWarn) {
-    return element2.ref;
-  }
-  getter = (_b2 = Object.getOwnPropertyDescriptor(element2, "ref")) == null ? void 0 : _b2.get;
-  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
-  if (mayWarn) {
-    return element2.props.ref;
-  }
-  return element2.props.ref || element2.ref;
-}
 const falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
 const cx = clsx;
 const cva = (base, config2) => (props) => {
@@ -47989,7 +48694,7 @@ const mermaid3ZIDBTTL = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.def
   Mermaid: Nt
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  isExpiredMarker as $,
+  DataInspector as $,
   Anchor as A,
   Button as B,
   Content as C,
@@ -48003,79 +48708,82 @@ export {
   Ks as K,
   LoaderCircle as L,
   Spinner as M,
-  Skeleton$1 as N,
-  DecryptClickContext as O,
+  useHasContextCardProvider as N,
+  ContextCardProvider as O,
   Primitive as P,
   Qe as Q,
   R,
   ServerConfigProvider as S,
   Tooltip as T,
-  isEncryptedMarker as U,
+  ContextCardTrigger as U,
   VISUALLY_HIDDEN_STYLES as V,
-  formatDuration as W,
-  DataInspector as X,
+  Skeleton$1 as W,
+  DecryptClickContext as X,
   Yr as Y,
-  StreamClickContext as Z,
-  _r as _,
+  isEncryptedMarker as Z,
+  formatDuration as _,
   TooltipTrigger as a,
-  isDoStreamStep as a0,
-  extractConversation as a1,
-  Lock as a2,
-  EVENT_DATA_REF_FIELDS as a3,
-  clsx as a4,
-  useTraceViewer as a5,
-  styles as a6,
-  formatDurationForTimeline as a7,
-  formatWallClockTime as a8,
-  useImmediateStyle as a9,
-  getWebRevivers as aA,
-  fetchEvent as aB,
-  fetchEventsByCorrelationId as aC,
-  LIVE_UPDATE_INTERVAL_MS as aD,
-  getEncryptionKeyForRun as aE,
-  StreamViewer as aF,
-  cn$4 as aG,
-  composeRefs as aH,
-  useFloating as aI,
-  offset as aJ,
-  shift as aK,
-  limitShift as aL,
-  flip as aM,
-  size as aN,
-  arrow as aO,
-  hide as aP,
-  autoUpdate as aQ,
-  cancelRun as aR,
-  reenqueueRun as aS,
-  wakeUpRun as aT,
-  resumeHook as aU,
-  recreateRun as aV,
-  TIMELINE_PADDING as aa,
-  formatTimeSelection as ab,
-  MARKER_HEIGHT as ac,
-  ROW_HEIGHT as ad,
-  ROW_PADDING as ae,
-  SEARCH_HEIGHT as af,
-  getHighResInMs as ag,
-  getMsInHighRes as ah,
-  MARKER_NOTCH_HEIGHT as ai,
-  MAP_HEIGHT as aj,
-  SEARCH_GAP as ak,
-  MiniMap as al,
-  SpanNodes as am,
-  SpanDetailPanel as an,
-  TraceViewerContextProvider as ao,
-  hydrateResourceIOWithKey as ap,
-  hydrateResourceIO as aq,
-  fetchHook as ar,
-  fetchStep as as,
-  hasEncryptedFields as at,
-  fetchStreams as au,
-  Slot as av,
-  Slottable as aw,
-  buttonVariants as ax,
-  isEncryptedData as ay,
-  hydrateData as az,
+  _r as a0,
+  StreamClickContext as a1,
+  isExpiredMarker as a2,
+  isDoStreamStep as a3,
+  extractConversation as a4,
+  Lock as a5,
+  EVENT_DATA_REF_FIELDS as a6,
+  clsx as a7,
+  useTraceViewer as a8,
+  styles as a9,
+  buttonVariants as aA,
+  isEncryptedData as aB,
+  hydrateData as aC,
+  getWebRevivers as aD,
+  fetchEvent as aE,
+  fetchEventsByCorrelationId as aF,
+  LIVE_UPDATE_INTERVAL_MS as aG,
+  getEncryptionKeyForRun as aH,
+  StreamViewer as aI,
+  cn$4 as aJ,
+  composeRefs as aK,
+  useFloating as aL,
+  offset as aM,
+  shift as aN,
+  limitShift as aO,
+  flip as aP,
+  size as aQ,
+  arrow as aR,
+  hide as aS,
+  autoUpdate as aT,
+  cancelRun as aU,
+  reenqueueRun as aV,
+  wakeUpRun as aW,
+  resumeHook as aX,
+  recreateRun as aY,
+  formatDurationForTimeline as aa,
+  formatWallClockTime as ab,
+  useImmediateStyle as ac,
+  TIMELINE_PADDING as ad,
+  formatTimeSelection as ae,
+  MARKER_HEIGHT as af,
+  ROW_HEIGHT as ag,
+  ROW_PADDING as ah,
+  SEARCH_HEIGHT as ai,
+  getHighResInMs as aj,
+  getMsInHighRes as ak,
+  MARKER_NOTCH_HEIGHT as al,
+  MAP_HEIGHT as am,
+  SEARCH_GAP as an,
+  MiniMap as ao,
+  SpanNodes as ap,
+  SpanDetailPanel as aq,
+  TraceViewerContextProvider as ar,
+  hydrateResourceIOWithKey as as,
+  hydrateResourceIO as at,
+  fetchHook as au,
+  fetchStep as av,
+  hasEncryptedFields as aw,
+  fetchStreams as ax,
+  Slot as ay,
+  Slottable as az,
   TooltipContent as b,
   createLucideIcon as c,
   cn as d,