@industry-theme/xterm-terminal-panel 0.5.5 → 0.5.7

package/dist/index.js

@@ -1159,10 +1159,11 @@ function useThemedTerminal() {
 // src/components/TabBar/TabBar.tsx
 import { useTheme as useTheme4 } from "@principal-ade/industry-theme";
 import { Plus } from "lucide-react";
-import { useState as useState2 } from "react";
+import { useState as useState2, useCallback as useCallback3 } from "react";
 
 // src/components/TabBar/TabButton.tsx
 import { useTheme as useTheme3 } from "@principal-ade/industry-theme";
+import { useCallback as useCallback2 } from "react";
 import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var TabButton = ({
   tab,
@@ -1175,12 +1176,68 @@ var TabButton = ({
   keyboardHint,
   renderAccessory,
   renderIcon,
-  renderLabel
+  renderLabel,
+  draggable = false,
+  onDragStart,
+  onDragEnd,
+  onDrop,
+  canAcceptDrop = false,
+  isDragOver = false,
+  onDragEnter,
+  onDragLeave,
+  isBeingDragged: _isBeingDragged = false
 }) => {
   const { theme } = useTheme3();
   const showCloseButton = isHovered || isActive;
   const closable = tab.closable !== false;
+  const handleDragStart = useCallback2((e) => {
+    e.dataTransfer.setData("application/x-tab-association", tab.id);
+    e.dataTransfer.effectAllowed = "move";
+    onDragStart?.(tab.id);
+  }, [tab.id, onDragStart]);
+  const handleDragEnd = useCallback2(() => {
+    onDragEnd?.();
+  }, [onDragEnd]);
+  const handleDragOver = useCallback2((e) => {
+    if (canAcceptDrop) {
+      e.preventDefault();
+      e.dataTransfer.dropEffect = "move";
+    }
+  }, [canAcceptDrop]);
+  const handleDrop = useCallback2((e) => {
+    e.preventDefault();
+    const draggedTabId = e.dataTransfer.getData("text/plain");
+    if (draggedTabId && draggedTabId !== tab.id) {
+      onDrop?.(draggedTabId);
+    }
+  }, [tab.id, onDrop]);
+  const handleDragEnter = useCallback2((e) => {
+    e.preventDefault();
+    onDragEnter?.();
+  }, [onDragEnter]);
+  const handleDragLeave = useCallback2((e) => {
+    e.preventDefault();
+    onDragLeave?.();
+  }, [onDragLeave]);
+  const getDragOverStyles = () => {
+    if (isDragOver && canAcceptDrop) {
+      return {
+        outline: `2px solid ${theme.colors.primary}`,
+        outlineOffset: "-2px",
+        backgroundColor: theme.colors.backgroundTertiary
+      };
+    }
+    return {};
+  };
   return /* @__PURE__ */ jsxs3("div", {
+    "data-tab-id": tab.id,
+    draggable,
+    onDragStart: draggable ? handleDragStart : undefined,
+    onDragEnd: draggable ? handleDragEnd : undefined,
+    onDragOver: handleDragOver,
+    onDrop: handleDrop,
+    onDragEnter: handleDragEnter,
+    onDragLeave: handleDragLeave,
     onMouseEnter,
     onMouseLeave,
     onClick,
@@ -1191,7 +1248,7 @@ var TabButton = ({
       gap: "6px",
       padding: "6px 8px",
       backgroundColor: isActive ? theme.colors.background : theme.colors.backgroundSecondary,
-      cursor: "pointer",
+      cursor: draggable ? "grab" : "pointer",
       fontSize: theme.fontSizes[1],
       fontWeight: isActive ? theme.fontWeights.semibold : theme.fontWeights.body,
       fontFamily: theme.fonts.body,
@@ -1202,7 +1259,8 @@ var TabButton = ({
       minWidth: 0,
       height: "100%",
       position: "relative",
-      boxSizing: "border-box"
+      boxSizing: "border-box",
+      ...getDragOverStyles()
     },
     children: [
       closable && showCloseButton && /* @__PURE__ */ jsx4("button", {
@@ -1283,10 +1341,35 @@ var TabBar = ({
   renderTabIcon,
   renderTabLabel,
   className,
-  showKeyboardHints = true
+  showKeyboardHints = true,
+  onTabDrop,
+  canDropOnTab,
+  enableDragAndDrop = false
 }) => {
   const { theme } = useTheme4();
   const [hoveredTabId, setHoveredTabId] = useState2(null);
+  const [draggedTabId, setDraggedTabId] = useState2(null);
+  const [dragOverTabId, setDragOverTabId] = useState2(null);
+  const handleDragStart = useCallback3((tabId) => {
+    setDraggedTabId(tabId);
+  }, []);
+  const handleDragEnd = useCallback3(() => {
+    setDraggedTabId(null);
+    setDragOverTabId(null);
+  }, []);
+  const handleDrop = useCallback3((targetTabId, draggedId) => {
+    if (draggedId !== targetTabId) {
+      onTabDrop?.(draggedId, targetTabId);
+    }
+    setDraggedTabId(null);
+    setDragOverTabId(null);
+  }, [onTabDrop]);
+  const handleDragEnter = useCallback3((tabId) => {
+    setDragOverTabId(tabId);
+  }, []);
+  const handleDragLeave = useCallback3(() => {
+    setDragOverTabId(null);
+  }, []);
   return /* @__PURE__ */ jsxs4("div", {
     className,
     style: {
@@ -1320,19 +1403,31 @@ var TabBar = ({
           borderBottom: `1px solid ${theme.colors.border}`,
           boxSizing: "border-box"
         },
-        children: tabs.map((tab, index) => /* @__PURE__ */ jsx5(TabButton, {
-          tab,
-          isActive: tab.id === activeTabId,
-          isHovered: tab.id === hoveredTabId,
-          onMouseEnter: () => setHoveredTabId(tab.id),
-          onMouseLeave: () => setHoveredTabId(null),
-          onClick: () => onTabClick(tab.id),
-          onClose: () => onTabClose(tab.id),
-          keyboardHint: showKeyboardHints && index < 9 ? `⌘ ${index + 1}` : undefined,
-          renderAccessory: renderTabAccessory,
-          renderIcon: renderTabIcon,
-          renderLabel: renderTabLabel
-        }, tab.id))
+        children: tabs.map((tab, index) => {
+          const canDrop = enableDragAndDrop && draggedTabId !== null && draggedTabId !== tab.id ? canDropOnTab ? canDropOnTab(draggedTabId, tab.id) : true : false;
+          return /* @__PURE__ */ jsx5(TabButton, {
+            tab,
+            isActive: tab.id === activeTabId,
+            isHovered: tab.id === hoveredTabId,
+            onMouseEnter: () => setHoveredTabId(tab.id),
+            onMouseLeave: () => setHoveredTabId(null),
+            onClick: () => onTabClick(tab.id),
+            onClose: () => onTabClose(tab.id),
+            keyboardHint: showKeyboardHints && index < 9 ? `⌘ ${index + 1}` : undefined,
+            renderAccessory: renderTabAccessory,
+            renderIcon: renderTabIcon,
+            renderLabel: renderTabLabel,
+            draggable: enableDragAndDrop,
+            onDragStart: handleDragStart,
+            onDragEnd: handleDragEnd,
+            onDrop: (draggedId) => handleDrop(tab.id, draggedId),
+            canAcceptDrop: canDrop,
+            isDragOver: dragOverTabId === tab.id,
+            isBeingDragged: draggedTabId === tab.id,
+            onDragEnter: () => handleDragEnter(tab.id),
+            onDragLeave: handleDragLeave
+          }, tab.id);
+        })
       }),
       rightSection !== undefined ? rightSection && /* @__PURE__ */ jsx5("div", {
         style: {
@@ -1431,7 +1526,7 @@ var useTabKeyboardShortcuts = ({
 // src/panels/TerminalPanel.tsx
 import { useTheme as useTheme5 } from "@principal-ade/industry-theme";
 import { Lock, Unlock, ArrowDown } from "lucide-react";
-import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
 
 // src/panel-types/index.ts
 function getTerminalSessions(context2) {
@@ -1595,197 +1690,2573 @@ var TerminalPanel = ({
       if (autoScrollTimeout) {
         clearTimeout(autoScrollTimeout);
       }
-    };
-  }, [usingMessagePort]);
-  const handleTerminalData = useCallback2((data) => {
-    if (sessionId && actions.writeToTerminal) {
-      actions.writeToTerminal(sessionId, data);
+    };
+  }, [usingMessagePort]);
+  const handleTerminalData = useCallback4((data) => {
+    if (sessionId && actions.writeToTerminal) {
+      actions.writeToTerminal(sessionId, data);
+    }
+  }, [sessionId, actions.writeToTerminal]);
+  const hasNotifiedPtyRef = useRef2(false);
+  const handleTerminalResize = useCallback4((cols, rows) => {
+    if (sessionId && actions.resizeTerminal) {
+      const isInitialNotification = !hasNotifiedPtyRef.current;
+      actions.resizeTerminal(sessionId, cols, rows);
+      if (isInitialNotification && actions.writeToTerminal) {
+        setTimeout(() => {
+          actions.writeToTerminal(sessionId, "\f");
+        }, 50);
+      }
+      hasNotifiedPtyRef.current = true;
+    }
+  }, [sessionId, actions.resizeTerminal, actions.writeToTerminal]);
+  useEffect3(() => {
+    hasNotifiedPtyRef.current = false;
+  }, [sessionId]);
+  const handleScrollPositionChange = useCallback4((position) => {
+    setScrollPosition(position);
+    isScrollLockedRef.current = position.isScrollLocked;
+  }, []);
+  const sessionInfo = sessionId ? getTerminalSession(context2, sessionId) : undefined;
+  if (error) {
+    return /* @__PURE__ */ jsxs5("div", {
+      style: {
+        padding: "20px",
+        color: "#ef4444",
+        backgroundColor: "#1a1a1a",
+        height: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        flexDirection: "column",
+        gap: "10px"
+      },
+      children: [
+        /* @__PURE__ */ jsx6("div", {
+          style: { fontSize: "16px", fontWeight: "bold" },
+          children: "Terminal Error"
+        }),
+        /* @__PURE__ */ jsx6("div", {
+          style: { fontSize: "14px", opacity: 0.8 },
+          children: error
+        })
+      ]
+    });
+  }
+  if (isInitializing || !sessionId) {
+    return /* @__PURE__ */ jsx6("div", {
+      style: {
+        padding: "20px",
+        color: "#a0a0a0",
+        backgroundColor: "#1a1a1a",
+        height: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center"
+      },
+      children: "Initializing terminal..."
+    });
+  }
+  const handleScrollToBottom = () => {
+    terminalRef.current?.scrollToBottom();
+  };
+  const handleToggleScrollLock = () => {
+    if (scrollPosition.isScrollLocked) {
+      const terminal = terminalRef.current?.getTerminal();
+      if (terminal) {
+        terminal.scrollLines(-1);
+      }
+    } else {
+      terminalRef.current?.scrollToBottom();
+    }
+  };
+  return /* @__PURE__ */ jsxs5("div", {
+    style: { height: "100%", width: "100%", display: "flex", flexDirection: "column" },
+    children: [
+      /* @__PURE__ */ jsxs5("div", {
+        style: {
+          display: "flex",
+          gap: "8px",
+          padding: "8px 12px",
+          backgroundColor: theme.colors.backgroundSecondary,
+          borderBottom: `1px solid ${theme.colors.border}`,
+          alignItems: "center"
+        },
+        children: [
+          /* @__PURE__ */ jsxs5("span", {
+            style: {
+              fontSize: "12px",
+              color: theme.colors.textSecondary,
+              marginRight: "auto",
+              fontFamily: theme.fonts.monospace
+            },
+            children: [
+              sessionInfo?.cwd || "Terminal",
+              " • ",
+              sessionInfo?.shell
+            ]
+          }),
+          /* @__PURE__ */ jsxs5("button", {
+            onClick: handleToggleScrollLock,
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "4px",
+              fontSize: "11px",
+              padding: "4px 8px",
+              borderRadius: "4px",
+              backgroundColor: scrollPosition.isScrollLocked ? `${theme.colors.success}22` : `${theme.colors.warning}22`,
+              color: scrollPosition.isScrollLocked ? theme.colors.success : theme.colors.warning,
+              border: `1px solid ${scrollPosition.isScrollLocked ? `${theme.colors.success}44` : `${theme.colors.warning}44`}`,
+              cursor: "pointer",
+              transition: "opacity 0.2s"
+            },
+            onMouseEnter: (e) => e.currentTarget.style.opacity = "0.8",
+            onMouseLeave: (e) => e.currentTarget.style.opacity = "1",
+            title: scrollPosition.isScrollLocked ? "Click to unlock scroll" : "Click to lock scroll to bottom",
+            children: [
+              scrollPosition.isScrollLocked ? /* @__PURE__ */ jsx6(Lock, {
+                size: 12
+              }) : /* @__PURE__ */ jsx6(Unlock, {
+                size: 12
+              }),
+              /* @__PURE__ */ jsx6("span", {
+                children: scrollPosition.isScrollLocked ? "Locked" : "Unlocked"
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsxs5("button", {
+            onClick: handleScrollToBottom,
+            disabled: scrollPosition.isAtBottom,
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "4px",
+              fontSize: "11px",
+              padding: "4px 10px",
+              borderRadius: "4px",
+              backgroundColor: scrollPosition.isAtBottom ? theme.colors.backgroundHover : theme.colors.accent,
+              color: scrollPosition.isAtBottom ? theme.colors.textTertiary : theme.colors.text,
+              border: `1px solid ${theme.colors.border}`,
+              cursor: scrollPosition.isAtBottom ? "not-allowed" : "pointer",
+              transition: "opacity 0.2s",
+              opacity: scrollPosition.isAtBottom ? 0.5 : 1
+            },
+            onMouseEnter: (e) => !scrollPosition.isAtBottom && (e.currentTarget.style.opacity = "0.8"),
+            onMouseLeave: (e) => !scrollPosition.isAtBottom && (e.currentTarget.style.opacity = "1"),
+            title: "Scroll to bottom and lock",
+            children: [
+              /* @__PURE__ */ jsx6(ArrowDown, {
+                size: 12
+              }),
+              /* @__PURE__ */ jsx6("span", {
+                children: "Bottom"
+              })
+            ]
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx6("div", {
+        style: { flex: 1 },
+        children: /* @__PURE__ */ jsx6(ThemedTerminalWithProvider, {
+          ref: terminalRef,
+          onData: handleTerminalData,
+          onResize: handleTerminalResize,
+          onScrollPositionChange: handleScrollPositionChange,
+          hideHeader: true,
+          autoFocus: true,
+          convertEol: true,
+          cursorBlink: true,
+          scrollback: 1e4,
+          enableSearch: true,
+          enableWebLinks: true
+        })
+      })
+    ]
+  });
+};
+// src/panels/TabbedTerminalPanel.tsx
+import { useTheme as useTheme6 } from "@principal-ade/industry-theme";
+
+// node_modules/@principal-ade/panels/dist/index.esm.js
+import { jsx as e, jsxs as t, Fragment as n } from "react/jsx-runtime";
+import r, { useState as o, useRef as i, useCallback as a, useEffect as l, createContext as s, useContext as c, forwardRef as d, useImperativeHandle as u, useMemo as p, useLayoutEffect as h, memo as m, useReducer as f } from "react";
+
+// node_modules/react-resizable-panels/dist/react-resizable-panels.js
+import { jsx as ie } from "react/jsx-runtime";
+import { useState as re, useCallback as ne, useId as pt, useLayoutEffect as Be, useEffect as de, useRef as T, createContext as ht, useImperativeHandle as We, useMemo as Ue, useSyncExternalStore as Ke, useContext as mt } from "react";
+"use client";
+function gt(e, t) {
+  const n = getComputedStyle(e), o = parseFloat(n.fontSize);
+  return t * o;
+}
+function St(e, t) {
+  const n = getComputedStyle(e.ownerDocument.body), o = parseFloat(n.fontSize);
+  return t * o;
+}
+function yt(e) {
+  return e / 100 * window.innerHeight;
+}
+function vt(e) {
+  return e / 100 * window.innerWidth;
+}
+function zt(e) {
+  switch (typeof e) {
+    case "number":
+      return [e, "px"];
+    case "string": {
+      const t = parseFloat(e);
+      return e.endsWith("%") ? [t, "%"] : e.endsWith("px") ? [t, "px"] : e.endsWith("rem") ? [t, "rem"] : e.endsWith("em") ? [t, "em"] : e.endsWith("vh") ? [t, "vh"] : e.endsWith("vw") ? [t, "vw"] : [t, "%"];
+    }
+  }
+}
+function te({
+  groupSize: e,
+  panelElement: t,
+  styleProp: n
+}) {
+  let o;
+  const [i, s] = zt(n);
+  switch (s) {
+    case "%": {
+      o = i / 100 * e;
+      break;
+    }
+    case "px": {
+      o = i;
+      break;
+    }
+    case "rem": {
+      o = St(t, i);
+      break;
+    }
+    case "em": {
+      o = gt(t, i);
+      break;
+    }
+    case "vh": {
+      o = yt(i);
+      break;
+    }
+    case "vw": {
+      o = vt(i);
+      break;
+    }
+  }
+  return o;
+}
+function D(e) {
+  return parseFloat(e.toFixed(3));
+}
+function Q({
+  group: e
+}) {
+  const { orientation: t, panels: n } = e;
+  return n.reduce((o, i) => (o += t === "horizontal" ? i.element.offsetWidth : i.element.offsetHeight, o), 0);
+}
+function ge(e) {
+  const { panels: t } = e, n = Q({ group: e });
+  return n === 0 ? t.map((o) => ({
+    groupResizeBehavior: o.panelConstraints.groupResizeBehavior,
+    collapsedSize: 0,
+    collapsible: o.panelConstraints.collapsible === true,
+    defaultSize: undefined,
+    disabled: o.panelConstraints.disabled,
+    minSize: 0,
+    maxSize: 100,
+    panelId: o.id
+  })) : t.map((o) => {
+    const { element: i, panelConstraints: s } = o;
+    let l = 0;
+    if (s.collapsedSize !== undefined) {
+      const c = te({
+        groupSize: n,
+        panelElement: i,
+        styleProp: s.collapsedSize
+      });
+      l = D(c / n * 100);
+    }
+    let r;
+    if (s.defaultSize !== undefined) {
+      const c = te({
+        groupSize: n,
+        panelElement: i,
+        styleProp: s.defaultSize
+      });
+      r = D(c / n * 100);
+    }
+    let a = 0;
+    if (s.minSize !== undefined) {
+      const c = te({
+        groupSize: n,
+        panelElement: i,
+        styleProp: s.minSize
+      });
+      a = D(c / n * 100);
+    }
+    let u = 100;
+    if (s.maxSize !== undefined) {
+      const c = te({
+        groupSize: n,
+        panelElement: i,
+        styleProp: s.maxSize
+      });
+      u = D(c / n * 100);
+    }
+    return {
+      groupResizeBehavior: s.groupResizeBehavior,
+      collapsedSize: l,
+      collapsible: s.collapsible === true,
+      defaultSize: r,
+      disabled: s.disabled,
+      minSize: a,
+      maxSize: u,
+      panelId: o.id
+    };
+  });
+}
+function L(e, t = "Assertion error") {
+  if (!e)
+    throw Error(t);
+}
+function Se(e, t) {
+  return Array.from(t).sort(e === "horizontal" ? bt : xt);
+}
+function bt(e, t) {
+  const n = e.element.offsetLeft - t.element.offsetLeft;
+  return n !== 0 ? n : e.element.offsetWidth - t.element.offsetWidth;
+}
+function xt(e, t) {
+  const n = e.element.offsetTop - t.element.offsetTop;
+  return n !== 0 ? n : e.element.offsetHeight - t.element.offsetHeight;
+}
+function Xe(e) {
+  return e !== null && typeof e == "object" && "nodeType" in e && e.nodeType === Node.ELEMENT_NODE;
+}
+function qe(e, t) {
+  return {
+    x: e.x >= t.left && e.x <= t.right ? 0 : Math.min(Math.abs(e.x - t.left), Math.abs(e.x - t.right)),
+    y: e.y >= t.top && e.y <= t.bottom ? 0 : Math.min(Math.abs(e.y - t.top), Math.abs(e.y - t.bottom))
+  };
+}
+function wt({
+  orientation: e,
+  rects: t,
+  targetRect: n
+}) {
+  const o = {
+    x: n.x + n.width / 2,
+    y: n.y + n.height / 2
+  };
+  let i, s = Number.MAX_VALUE;
+  for (const l of t) {
+    const { x: r, y: a } = qe(o, l), u = e === "horizontal" ? r : a;
+    u < s && (s = u, i = l);
+  }
+  return L(i, "No rect found"), i;
+}
+var ue;
+function Pt() {
+  return ue === undefined && (typeof matchMedia == "function" ? ue = !!matchMedia("(pointer:coarse)").matches : ue = false), ue;
+}
+function Ye(e) {
+  const { element: t, orientation: n, panels: o, separators: i } = e, s = Se(n, Array.from(t.children).filter(Xe).map((x) => ({ element: x }))).map(({ element: x }) => x), l = [];
+  let r = false, a = false, u = -1, c = -1, m = 0, d, v = [];
+  {
+    let x = -1;
+    for (const f of s)
+      f.hasAttribute("data-panel") && (x++, f.ariaDisabled === null && (m++, u === -1 && (u = x), c = x));
+  }
+  if (m > 1) {
+    let x = -1;
+    for (const f of s)
+      if (f.hasAttribute("data-panel")) {
+        x++;
+        const h = o.find((g) => g.element === f);
+        if (h) {
+          if (d) {
+            const g = d.element.getBoundingClientRect(), y = f.getBoundingClientRect();
+            let z;
+            if (a) {
+              const S = n === "horizontal" ? new DOMRect(g.right, g.top, 0, g.height) : new DOMRect(g.left, g.bottom, g.width, 0), p = n === "horizontal" ? new DOMRect(y.left, y.top, 0, y.height) : new DOMRect(y.left, y.top, y.width, 0);
+              switch (v.length) {
+                case 0: {
+                  z = [
+                    S,
+                    p
+                  ];
+                  break;
+                }
+                case 1: {
+                  const P = v[0], R = wt({
+                    orientation: n,
+                    rects: [g, y],
+                    targetRect: P.element.getBoundingClientRect()
+                  });
+                  z = [
+                    P,
+                    R === g ? p : S
+                  ];
+                  break;
+                }
+                default: {
+                  z = v;
+                  break;
+                }
+              }
+            } else
+              v.length ? z = v : z = [
+                n === "horizontal" ? new DOMRect(g.right, y.top, y.left - g.right, y.height) : new DOMRect(y.left, g.bottom, y.width, y.top - g.bottom)
+              ];
+            for (const S of z) {
+              let p = "width" in S ? S : S.element.getBoundingClientRect();
+              const P = Pt() ? e.resizeTargetMinimumSize.coarse : e.resizeTargetMinimumSize.fine;
+              if (p.width < P) {
+                const C = P - p.width;
+                p = new DOMRect(p.x - C / 2, p.y, p.width + C, p.height);
+              }
+              if (p.height < P) {
+                const C = P - p.height;
+                p = new DOMRect(p.x, p.y - C / 2, p.width, p.height + C);
+              }
+              const R = x <= u || x > c;
+              !r && !R && l.push({
+                group: e,
+                groupSize: Q({ group: e }),
+                panels: [d, h],
+                separator: "width" in S ? undefined : S,
+                rect: p
+              }), r = false;
+            }
+          }
+          a = false, d = h, v = [];
+        }
+      } else if (f.hasAttribute("data-separator")) {
+        f.ariaDisabled !== null && (r = true);
+        const h = i.find((g) => g.element === f);
+        h ? v.push(h) : (d = undefined, v = []);
+      } else
+        a = true;
+  }
+  return l;
+}
+
+class Je {
+  #e = {};
+  addListener(t, n) {
+    const o = this.#e[t];
+    return o === undefined ? this.#e[t] = [n] : o.includes(n) || o.push(n), () => {
+      this.removeListener(t, n);
+    };
+  }
+  emit(t, n) {
+    const o = this.#e[t];
+    if (o !== undefined)
+      if (o.length === 1)
+        o[0].call(null, n);
+      else {
+        let i = false, s = null;
+        const l = Array.from(o);
+        for (let r = 0;r < l.length; r++) {
+          const a = l[r];
+          try {
+            a.call(null, n);
+          } catch (u) {
+            s === null && (i = true, s = u);
+          }
+        }
+        if (i)
+          throw s;
+      }
+  }
+  removeAllListeners() {
+    this.#e = {};
+  }
+  removeListener(t, n) {
+    const o = this.#e[t];
+    if (o !== undefined) {
+      const i = o.indexOf(n);
+      i >= 0 && o.splice(i, 1);
+    }
+  }
+}
+var A = /* @__PURE__ */ new Map;
+var Ze = new Je;
+function Lt(e) {
+  A = new Map(A), A.delete(e);
+}
+function Me(e, t) {
+  for (const [n] of A)
+    if (n.id === e)
+      return n;
+}
+function $(e, t) {
+  for (const [n, o] of A)
+    if (n.id === e)
+      return o;
+  if (t)
+    throw Error(`Could not find data for Group with id ${e}`);
+}
+function U() {
+  return A;
+}
+function ye(e, t) {
+  return Ze.addListener("groupChange", (n) => {
+    n.group.id === e && t(n);
+  });
+}
+function _(e, t) {
+  const n = A.get(e);
+  A = new Map(A), A.set(e, t), Ze.emit("groupChange", {
+    group: e,
+    prev: n,
+    next: t
+  });
+}
+function Ct(e, t, n) {
+  let o, i = {
+    x: 1 / 0,
+    y: 1 / 0
+  };
+  for (const s of t) {
+    const l = qe(n, s.rect);
+    switch (e) {
+      case "horizontal": {
+        l.x <= i.x && (o = s, i = l);
+        break;
+      }
+      case "vertical": {
+        l.y <= i.y && (o = s, i = l);
+        break;
+      }
+    }
+  }
+  return o ? {
+    distance: i,
+    hitRegion: o
+  } : undefined;
+}
+function Rt(e) {
+  return e !== null && typeof e == "object" && "nodeType" in e && e.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
+}
+function Mt(e, t) {
+  if (e === t)
+    throw new Error("Cannot compare node with itself");
+  const n = {
+    a: ke(e),
+    b: ke(t)
+  };
+  let o;
+  for (;n.a.at(-1) === n.b.at(-1); )
+    o = n.a.pop(), n.b.pop();
+  L(o, "Stacking order can only be calculated for elements with a common ancestor");
+  const i = {
+    a: Ie(Ee(n.a)),
+    b: Ie(Ee(n.b))
+  };
+  if (i.a === i.b) {
+    const s = o.childNodes, l = {
+      a: n.a.at(-1),
+      b: n.b.at(-1)
+    };
+    let r = s.length;
+    for (;r--; ) {
+      const a = s[r];
+      if (a === l.a)
+        return 1;
+      if (a === l.b)
+        return -1;
+    }
+  }
+  return Math.sign(i.a - i.b);
+}
+var Et = /\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\b/;
+function It(e) {
+  const t = getComputedStyle(Qe(e) ?? e).display;
+  return t === "flex" || t === "inline-flex";
+}
+function kt(e) {
+  const t = getComputedStyle(e);
+  return !!(t.position === "fixed" || t.zIndex !== "auto" && (t.position !== "static" || It(e)) || +t.opacity < 1 || ("transform" in t) && t.transform !== "none" || ("webkitTransform" in t) && t.webkitTransform !== "none" || ("mixBlendMode" in t) && t.mixBlendMode !== "normal" || ("filter" in t) && t.filter !== "none" || ("webkitFilter" in t) && t.webkitFilter !== "none" || ("isolation" in t) && t.isolation === "isolate" || Et.test(t.willChange) || t.webkitOverflowScrolling === "touch");
+}
+function Ee(e) {
+  let t = e.length;
+  for (;t--; ) {
+    const n = e[t];
+    if (L(n, "Missing node"), kt(n))
+      return n;
+  }
+  return null;
+}
+function Ie(e) {
+  return e && Number(getComputedStyle(e).zIndex) || 0;
+}
+function ke(e) {
+  const t = [];
+  for (;e; )
+    t.push(e), e = Qe(e);
+  return t;
+}
+function Qe(e) {
+  const { parentNode: t } = e;
+  return Rt(t) ? t.host : t;
+}
+function Dt(e, t) {
+  return e.x < t.x + t.width && e.x + e.width > t.x && e.y < t.y + t.height && e.y + e.height > t.y;
+}
+function Tt({
+  groupElement: e,
+  hitRegion: t,
+  pointerEventTarget: n
+}) {
+  if (!Xe(n) || n.contains(e) || e.contains(n))
+    return true;
+  if (Mt(n, e) > 0) {
+    let o = n;
+    for (;o; ) {
+      if (o.contains(e))
+        return true;
+      if (Dt(o.getBoundingClientRect(), t))
+        return false;
+      o = o.parentElement;
+    }
+  }
+  return true;
+}
+function ve(e, t) {
+  const n = [];
+  return t.forEach((o, i) => {
+    if (i.disabled)
+      return;
+    const s = Ye(i), l = Ct(i.orientation, s, {
+      x: e.clientX,
+      y: e.clientY
+    });
+    l && l.distance.x <= 0 && l.distance.y <= 0 && Tt({
+      groupElement: i.element,
+      hitRegion: l.hitRegion.rect,
+      pointerEventTarget: e.target
+    }) && n.push(l.hitRegion);
+  }), n;
+}
+function Ot(e, t) {
+  if (e.length !== t.length)
+    return false;
+  for (let n = 0;n < e.length; n++)
+    if (e[n] != t[n])
+      return false;
+  return true;
+}
+function I(e, t, n = 0) {
+  return Math.abs(D(e) - D(t)) <= n;
+}
+function G(e, t) {
+  return I(e, t) ? 0 : e > t ? 1 : -1;
+}
+function Y({
+  overrideDisabledPanels: e,
+  panelConstraints: t,
+  prevSize: n,
+  size: o
+}) {
+  const {
+    collapsedSize: i = 0,
+    collapsible: s,
+    disabled: l,
+    maxSize: r = 100,
+    minSize: a = 0
+  } = t;
+  if (l && !e)
+    return n;
+  if (G(o, a) < 0)
+    if (s) {
+      const u = (i + a) / 2;
+      G(o, u) < 0 ? o = i : o = a;
+    } else
+      o = a;
+  return o = Math.min(r, o), o = D(o), o;
+}
+function se({
+  delta: e,
+  initialLayout: t,
+  panelConstraints: n,
+  pivotIndices: o,
+  prevLayout: i,
+  trigger: s
+}) {
+  if (I(e, 0))
+    return t;
+  const l = s === "imperative-api", r = Object.values(t), a = Object.values(i), u = [...r], [c, m] = o;
+  L(c != null, "Invalid first pivot index"), L(m != null, "Invalid second pivot index");
+  let d = 0;
+  switch (s) {
+    case "keyboard": {
+      {
+        const f = e < 0 ? m : c, h = n[f];
+        L(h, `Panel constraints not found for index ${f}`);
+        const {
+          collapsedSize: g = 0,
+          collapsible: y,
+          minSize: z = 0
+        } = h;
+        if (y) {
+          const S = r[f];
+          if (L(S != null, `Previous layout not found for panel index ${f}`), I(S, g)) {
+            const p = z - S;
+            G(p, Math.abs(e)) > 0 && (e = e < 0 ? 0 - p : p);
+          }
+        }
+      }
+      {
+        const f = e < 0 ? c : m, h = n[f];
+        L(h, `No panel constraints found for index ${f}`);
+        const {
+          collapsedSize: g = 0,
+          collapsible: y,
+          minSize: z = 0
+        } = h;
+        if (y) {
+          const S = r[f];
+          if (L(S != null, `Previous layout not found for panel index ${f}`), I(S, z)) {
+            const p = S - g;
+            G(p, Math.abs(e)) > 0 && (e = e < 0 ? 0 - p : p);
+          }
+        }
+      }
+      break;
+    }
+    default: {
+      const f = e < 0 ? m : c, h = n[f];
+      L(h, `Panel constraints not found for index ${f}`);
+      const g = r[f], { collapsible: y, collapsedSize: z, minSize: S } = h;
+      if (y && G(g, S) < 0)
+        if (e > 0) {
+          const p = S - z, P = p / 2, R = g + e;
+          G(R, S) < 0 && (e = G(e, P) <= 0 ? 0 : p);
+        } else {
+          const p = S - z, P = 100 - p / 2, R = g - e;
+          G(R, S) < 0 && (e = G(100 + e, P) > 0 ? 0 : -p);
+        }
+      break;
+    }
+  }
+  {
+    const f = e < 0 ? 1 : -1;
+    let h = e < 0 ? m : c, g = 0;
+    for (;; ) {
+      const z = r[h];
+      L(z != null, `Previous layout not found for panel index ${h}`);
+      const p = Y({
+        overrideDisabledPanels: l,
+        panelConstraints: n[h],
+        prevSize: z,
+        size: 100
+      }) - z;
+      if (g += p, h += f, h < 0 || h >= n.length)
+        break;
+    }
+    const y = Math.min(Math.abs(e), Math.abs(g));
+    e = e < 0 ? 0 - y : y;
+  }
+  {
+    let h = e < 0 ? c : m;
+    for (;h >= 0 && h < n.length; ) {
+      const g = Math.abs(e) - Math.abs(d), y = r[h];
+      L(y != null, `Previous layout not found for panel index ${h}`);
+      const z = y - g, S = Y({
+        overrideDisabledPanels: l,
+        panelConstraints: n[h],
+        prevSize: y,
+        size: z
+      });
+      if (!I(y, S) && (d += y - S, u[h] = S, d.toFixed(3).localeCompare(Math.abs(e).toFixed(3), undefined, {
+        numeric: true
+      }) >= 0))
+        break;
+      e < 0 ? h-- : h++;
+    }
+  }
+  if (Ot(a, u))
+    return i;
+  {
+    const f = e < 0 ? m : c, h = r[f];
+    L(h != null, `Previous layout not found for panel index ${f}`);
+    const g = h + d, y = Y({
+      overrideDisabledPanels: l,
+      panelConstraints: n[f],
+      prevSize: h,
+      size: g
+    });
+    if (u[f] = y, !I(y, g)) {
+      let z = g - y, p = e < 0 ? m : c;
+      for (;p >= 0 && p < n.length; ) {
+        const P = u[p];
+        L(P != null, `Previous layout not found for panel index ${p}`);
+        const R = P + z, C = Y({
+          overrideDisabledPanels: l,
+          panelConstraints: n[p],
+          prevSize: P,
+          size: R
+        });
+        if (I(P, C) || (z -= C - P, u[p] = C), I(z, 0))
+          break;
+        e > 0 ? p-- : p++;
+      }
+    }
+  }
+  const v = Object.values(u).reduce((f, h) => h + f, 0);
+  if (!I(v, 100, 0.1))
+    return i;
+  const x = Object.keys(i);
+  return u.reduce((f, h, g) => (f[x[g]] = h, f), {});
+}
+function j(e, t) {
+  if (Object.keys(e).length !== Object.keys(t).length)
+    return false;
+  for (const n in e)
+    if (t[n] === undefined || G(e[n], t[n]) !== 0)
+      return false;
+  return true;
+}
+function B({
+  layout: e,
+  panelConstraints: t
+}) {
+  const n = Object.values(e), o = [...n], i = o.reduce((r, a) => r + a, 0);
+  if (o.length !== t.length)
+    throw Error(`Invalid ${t.length} panel layout: ${o.map((r) => `${r}%`).join(", ")}`);
+  if (!I(i, 100) && o.length > 0)
+    for (let r = 0;r < t.length; r++) {
+      const a = o[r];
+      L(a != null, `No layout data found for index ${r}`);
+      const u = 100 / i * a;
+      o[r] = u;
+    }
+  let s = 0;
+  for (let r = 0;r < t.length; r++) {
+    const a = n[r];
+    L(a != null, `No layout data found for index ${r}`);
+    const u = o[r];
+    L(u != null, `No layout data found for index ${r}`);
+    const c = Y({
+      overrideDisabledPanels: true,
+      panelConstraints: t[r],
+      prevSize: a,
+      size: u
+    });
+    u != c && (s += u - c, o[r] = c);
+  }
+  if (!I(s, 0))
+    for (let r = 0;r < t.length; r++) {
+      const a = o[r];
+      L(a != null, `No layout data found for index ${r}`);
+      const u = a + s, c = Y({
+        overrideDisabledPanels: true,
+        panelConstraints: t[r],
+        prevSize: a,
+        size: u
+      });
+      if (a !== c && (s -= c - a, o[r] = c, I(s, 0)))
+        break;
+    }
+  const l = Object.keys(e);
+  return o.reduce((r, a, u) => (r[l[u]] = a, r), {});
+}
+function et({
+  groupId: e,
+  panelId: t
+}) {
+  const n = () => {
+    const r = U();
+    for (const [
+      a,
+      {
+        defaultLayoutDeferred: u,
+        derivedPanelConstraints: c,
+        layout: m,
+        groupSize: d,
+        separatorToPanels: v
+      }
+    ] of r)
+      if (a.id === e)
+        return {
+          defaultLayoutDeferred: u,
+          derivedPanelConstraints: c,
+          group: a,
+          groupSize: d,
+          layout: m,
+          separatorToPanels: v
+        };
+    throw Error(`Group ${e} not found`);
+  }, o = () => {
+    const r = n().derivedPanelConstraints.find((a) => a.panelId === t);
+    if (r !== undefined)
+      return r;
+    throw Error(`Panel constraints not found for Panel ${t}`);
+  }, i = () => {
+    const r = n().group.panels.find((a) => a.id === t);
+    if (r !== undefined)
+      return r;
+    throw Error(`Layout not found for Panel ${t}`);
+  }, s = () => {
+    const r = n().layout[t];
+    if (r !== undefined)
+      return r;
+    throw Error(`Layout not found for Panel ${t}`);
+  }, l = (r) => {
+    const a = s();
+    if (r === a)
+      return;
+    const {
+      defaultLayoutDeferred: u,
+      derivedPanelConstraints: c,
+      group: m,
+      groupSize: d,
+      layout: v,
+      separatorToPanels: x
+    } = n(), f = m.panels.findIndex((z) => z.id === t), h = f === m.panels.length - 1, g = se({
+      delta: h ? a - r : r - a,
+      initialLayout: v,
+      panelConstraints: c,
+      pivotIndices: h ? [f - 1, f] : [f, f + 1],
+      prevLayout: v,
+      trigger: "imperative-api"
+    }), y = B({
+      layout: g,
+      panelConstraints: c
+    });
+    j(v, y) || _(m, {
+      defaultLayoutDeferred: u,
+      derivedPanelConstraints: c,
+      groupSize: d,
+      layout: y,
+      separatorToPanels: x
+    });
+  };
+  return {
+    collapse: () => {
+      const { collapsible: r, collapsedSize: a } = o(), { mutableValues: u } = i(), c = s();
+      r && c !== a && (u.expandToSize = c, l(a));
+    },
+    expand: () => {
+      const { collapsible: r, collapsedSize: a, minSize: u } = o(), { mutableValues: c } = i(), m = s();
+      if (r && m === a) {
+        let d = c.expandToSize ?? u;
+        d === 0 && (d = 1), l(d);
+      }
+    },
+    getSize: () => {
+      const { group: r } = n(), a = s(), { element: u } = i(), c = r.orientation === "horizontal" ? u.offsetWidth : u.offsetHeight;
+      return {
+        asPercentage: a,
+        inPixels: c
+      };
+    },
+    isCollapsed: () => {
+      const { collapsible: r, collapsedSize: a } = o(), u = s();
+      return r && I(a, u);
+    },
+    resize: (r) => {
+      const { group: a } = n(), { element: u } = i(), c = Q({ group: a }), m = te({
+        groupSize: c,
+        panelElement: u,
+        styleProp: r
+      }), d = D(m / c * 100);
+      l(d);
+    }
+  };
+}
+function De(e) {
+  if (e.defaultPrevented)
+    return;
+  const t = U();
+  ve(e, t).forEach((o) => {
+    if (o.separator) {
+      const i = o.panels.find((s) => s.panelConstraints.defaultSize !== undefined);
+      if (i) {
+        const s = i.panelConstraints.defaultSize, l = et({
+          groupId: o.group.id,
+          panelId: i.id
+        });
+        l && s !== undefined && (l.resize(s), e.preventDefault());
+      }
+    }
+  });
+}
+function fe(e) {
+  const t = U();
+  for (const [n] of t)
+    if (n.separators.some((o) => o.element === e))
+      return n;
+  throw Error("Could not find parent Group for separator element");
+}
+function tt({
+  groupId: e
+}) {
+  const t = () => {
+    const n = U();
+    for (const [o, i] of n)
+      if (o.id === e)
+        return { group: o, ...i };
+    throw Error(`Could not find Group with id "${e}"`);
+  };
+  return {
+    getLayout() {
+      const { defaultLayoutDeferred: n, layout: o } = t();
+      return n ? {} : o;
+    },
+    setLayout(n) {
+      const {
+        defaultLayoutDeferred: o,
+        derivedPanelConstraints: i,
+        group: s,
+        groupSize: l,
+        layout: r,
+        separatorToPanels: a
+      } = t(), u = B({
+        layout: n,
+        panelConstraints: i
+      });
+      return o ? r : (j(r, u) || _(s, {
+        defaultLayoutDeferred: o,
+        derivedPanelConstraints: i,
+        groupSize: l,
+        layout: u,
+        separatorToPanels: a
+      }), u);
+    }
+  };
+}
+function V(e, t) {
+  const n = fe(e), o = $(n.id, true), i = n.separators.find((m) => m.element === e);
+  L(i, "Matching separator not found");
+  const s = o.separatorToPanels.get(i);
+  L(s, "Matching panels not found");
+  const l = s.map((m) => n.panels.indexOf(m)), a = tt({ groupId: n.id }).getLayout(), u = se({
+    delta: t,
+    initialLayout: a,
+    panelConstraints: o.derivedPanelConstraints,
+    pivotIndices: l,
+    prevLayout: a,
+    trigger: "keyboard"
+  }), c = B({
+    layout: u,
+    panelConstraints: o.derivedPanelConstraints
+  });
+  j(a, c) || _(n, {
+    defaultLayoutDeferred: o.defaultLayoutDeferred,
+    derivedPanelConstraints: o.derivedPanelConstraints,
+    groupSize: o.groupSize,
+    layout: c,
+    separatorToPanels: o.separatorToPanels
+  });
+}
+function Te(e) {
+  if (e.defaultPrevented)
+    return;
+  const t = e.currentTarget, n = fe(t);
+  if (!n.disabled)
+    switch (e.key) {
+      case "ArrowDown": {
+        e.preventDefault(), n.orientation === "vertical" && V(t, 5);
+        break;
+      }
+      case "ArrowLeft": {
+        e.preventDefault(), n.orientation === "horizontal" && V(t, -5);
+        break;
+      }
+      case "ArrowRight": {
+        e.preventDefault(), n.orientation === "horizontal" && V(t, 5);
+        break;
+      }
+      case "ArrowUp": {
+        e.preventDefault(), n.orientation === "vertical" && V(t, -5);
+        break;
+      }
+      case "End": {
+        e.preventDefault(), V(t, 100);
+        break;
+      }
+      case "Enter": {
+        e.preventDefault();
+        const o = fe(t), i = $(o.id, true), { derivedPanelConstraints: s, layout: l, separatorToPanels: r } = i, a = o.separators.find((d) => d.element === t);
+        L(a, "Matching separator not found");
+        const u = r.get(a);
+        L(u, "Matching panels not found");
+        const c = u[0], m = s.find((d) => d.panelId === c.id);
+        if (L(m, "Panel metadata not found"), m.collapsible) {
+          const d = l[c.id], v = m.collapsedSize === d ? o.mutableState.expandedPanelSizes[c.id] ?? m.minSize : m.collapsedSize;
+          V(t, v - d);
+        }
+        break;
+      }
+      case "F6": {
+        e.preventDefault();
+        const i = fe(t).separators.map((a) => a.element), s = Array.from(i).findIndex((a) => a === e.currentTarget);
+        L(s !== null, "Index not found");
+        const l = e.shiftKey ? s > 0 ? s - 1 : i.length - 1 : s + 1 < i.length ? s + 1 : 0;
+        i[l].focus({
+          preventScroll: true
+        });
+        break;
+      }
+      case "Home": {
+        e.preventDefault(), V(t, -100);
+        break;
+      }
+    }
+}
+var J = {
+  cursorFlags: 0,
+  state: "inactive"
+};
+var ze = new Je;
+function W() {
+  return J;
+}
+function Gt(e) {
+  return ze.addListener("change", e);
+}
+function At(e) {
+  const t = J, n = { ...J };
+  n.cursorFlags = e, J = n, ze.emit("change", {
+    prev: t,
+    next: n
+  });
+}
+function Z(e) {
+  const t = J;
+  J = e, ze.emit("change", {
+    prev: t,
+    next: e
+  });
+}
+function Oe(e) {
+  if (e.defaultPrevented)
+    return;
+  if (e.pointerType === "mouse" && e.button > 0)
+    return;
+  const t = U(), n = ve(e, t), o = /* @__PURE__ */ new Map;
+  let i = false;
+  n.forEach((s) => {
+    s.separator && (i || (i = true, s.separator.element.focus({
+      preventScroll: true
+    })));
+    const l = t.get(s.group);
+    l && o.set(s.group, l.layout);
+  }), Z({
+    cursorFlags: 0,
+    hitRegions: n,
+    initialLayoutMap: o,
+    pointerDownAtPoint: { x: e.clientX, y: e.clientY },
+    state: "active"
+  }), n.length && e.preventDefault();
+}
+var Nt = (e) => e;
+var he = () => {};
+var nt = 1;
+var ot = 2;
+var it = 4;
+var rt = 8;
+var Ge = 3;
+var Ae = 12;
+var ce;
+function Ne() {
+  return ce === undefined && (ce = false, typeof window < "u" && (window.navigator.userAgent.includes("Chrome") || window.navigator.userAgent.includes("Firefox")) && (ce = true)), ce;
+}
+function _t({
+  cursorFlags: e,
+  groups: t,
+  state: n
+}) {
+  let o = 0, i = 0;
+  switch (n) {
+    case "active":
+    case "hover":
+      t.forEach((s) => {
+        if (!s.mutableState.disableCursor)
+          switch (s.orientation) {
+            case "horizontal": {
+              o++;
+              break;
+            }
+            case "vertical": {
+              i++;
+              break;
+            }
+          }
+      });
+  }
+  if (!(o === 0 && i === 0)) {
+    switch (n) {
+      case "active": {
+        if (e && Ne()) {
+          const s = (e & nt) !== 0, l = (e & ot) !== 0, r = (e & it) !== 0, a = (e & rt) !== 0;
+          if (s)
+            return r ? "se-resize" : a ? "ne-resize" : "e-resize";
+          if (l)
+            return r ? "sw-resize" : a ? "nw-resize" : "w-resize";
+          if (r)
+            return "s-resize";
+          if (a)
+            return "n-resize";
+        }
+        break;
+      }
+    }
+    return Ne() ? o > 0 && i > 0 ? "move" : o > 0 ? "ew-resize" : "ns-resize" : o > 0 && i > 0 ? "grab" : o > 0 ? "col-resize" : "row-resize";
+  }
+}
+var _e = /* @__PURE__ */ new WeakMap;
+function be(e) {
+  if (e.defaultView === null || e.defaultView === undefined)
+    return;
+  let { prevStyle: t, styleSheet: n } = _e.get(e) ?? {};
+  n === undefined && (n = new e.defaultView.CSSStyleSheet, e.adoptedStyleSheets && e.adoptedStyleSheets.push(n));
+  const o = W();
+  switch (o.state) {
+    case "active":
+    case "hover": {
+      const i = _t({
+        cursorFlags: o.cursorFlags,
+        groups: o.hitRegions.map((l) => l.group),
+        state: o.state
+      }), s = `*, *:hover {cursor: ${i} !important; }`;
+      if (t === s)
+        return;
+      t = s, i ? n.cssRules.length === 0 ? n.insertRule(s) : n.replaceSync(s) : n.cssRules.length === 1 && n.deleteRule(0);
+      break;
+    }
+    case "inactive": {
+      t = undefined, n.cssRules.length === 1 && n.deleteRule(0);
+      break;
+    }
+  }
+  _e.set(e, {
+    prevStyle: t,
+    styleSheet: n
+  });
+}
+function st({
+  document: e,
+  event: t,
+  hitRegions: n,
+  initialLayoutMap: o,
+  mountedGroups: i,
+  pointerDownAtPoint: s,
+  prevCursorFlags: l
+}) {
+  let r = 0;
+  n.forEach((u) => {
+    const { group: c, groupSize: m } = u, { orientation: d, panels: v } = c, { disableCursor: x } = c.mutableState;
+    let f = 0;
+    s ? d === "horizontal" ? f = (t.clientX - s.x) / m * 100 : f = (t.clientY - s.y) / m * 100 : d === "horizontal" ? f = t.clientX < 0 ? -100 : 100 : f = t.clientY < 0 ? -100 : 100;
+    const h = o.get(c), g = i.get(c);
+    if (!h || !g)
+      return;
+    const {
+      defaultLayoutDeferred: y,
+      derivedPanelConstraints: z,
+      groupSize: S,
+      layout: p,
+      separatorToPanels: P
+    } = g;
+    if (z && p && P) {
+      const R = se({
+        delta: f,
+        initialLayout: h,
+        panelConstraints: z,
+        pivotIndices: u.panels.map((C) => v.indexOf(C)),
+        prevLayout: p,
+        trigger: "mouse-or-touch"
+      });
+      if (j(R, p)) {
+        if (f !== 0 && !x)
+          switch (d) {
+            case "horizontal": {
+              r |= f < 0 ? nt : ot;
+              break;
+            }
+            case "vertical": {
+              r |= f < 0 ? it : rt;
+              break;
+            }
+          }
+      } else
+        _(u.group, {
+          defaultLayoutDeferred: y,
+          derivedPanelConstraints: z,
+          groupSize: S,
+          layout: R,
+          separatorToPanels: P
+        });
+    }
+  });
+  let a = 0;
+  t.movementX === 0 ? a |= l & Ge : a |= r & Ge, t.movementY === 0 ? a |= l & Ae : a |= r & Ae, At(a), be(e);
+}
+function Fe(e) {
+  const t = U(), n = W();
+  switch (n.state) {
+    case "active":
+      st({
+        document: e.currentTarget,
+        event: e,
+        hitRegions: n.hitRegions,
+        initialLayoutMap: n.initialLayoutMap,
+        mountedGroups: t,
+        prevCursorFlags: n.cursorFlags
+      });
+  }
+}
+function $e(e) {
+  if (e.defaultPrevented)
+    return;
+  const t = W(), n = U();
+  switch (t.state) {
+    case "active": {
+      if (e.buttons === 0) {
+        Z({
+          cursorFlags: 0,
+          state: "inactive"
+        }), t.hitRegions.forEach((o) => {
+          const i = $(o.group.id, true);
+          _(o.group, i);
+        });
+        return;
+      }
+      st({
+        document: e.currentTarget,
+        event: e,
+        hitRegions: t.hitRegions,
+        initialLayoutMap: t.initialLayoutMap,
+        mountedGroups: n,
+        pointerDownAtPoint: t.pointerDownAtPoint,
+        prevCursorFlags: t.cursorFlags
+      });
+      break;
+    }
+    default: {
+      const o = ve(e, n);
+      o.length === 0 ? t.state !== "inactive" && Z({
+        cursorFlags: 0,
+        state: "inactive"
+      }) : Z({
+        cursorFlags: 0,
+        hitRegions: o,
+        state: "hover"
+      }), be(e.currentTarget);
+      break;
+    }
+  }
+}
+function He(e) {
+  if (e.relatedTarget instanceof HTMLIFrameElement)
+    switch (W().state) {
+      case "hover":
+        Z({
+          cursorFlags: 0,
+          state: "inactive"
+        });
+    }
+}
+function Ve(e) {
+  if (e.defaultPrevented)
+    return;
+  if (e.pointerType === "mouse" && e.button > 0)
+    return;
+  const t = W();
+  switch (t.state) {
+    case "active":
+      Z({
+        cursorFlags: 0,
+        state: "inactive"
+      }), t.hitRegions.length > 0 && (be(e.currentTarget), t.hitRegions.forEach((n) => {
+        const o = $(n.group.id, true);
+        _(n.group, o);
+      }), e.preventDefault());
+  }
+}
+function je(e) {
+  let t = 0, n = 0;
+  const o = {};
+  for (const s of e)
+    if (s.defaultSize !== undefined) {
+      t++;
+      const l = D(s.defaultSize);
+      n += l, o[s.panelId] = l;
+    } else
+      o[s.panelId] = undefined;
+  const i = e.length - t;
+  if (i !== 0) {
+    const s = D((100 - n) / i);
+    for (const l of e)
+      l.defaultSize === undefined && (o[l.panelId] = s);
+  }
+  return o;
+}
+function Ft(e, t, n) {
+  if (!n[0])
+    return;
+  const i = e.panels.find((u) => u.element === t);
+  if (!i || !i.onResize)
+    return;
+  const s = Q({ group: e }), l = e.orientation === "horizontal" ? i.element.offsetWidth : i.element.offsetHeight, r = i.mutableValues.prevSize, a = {
+    asPercentage: D(l / s * 100),
+    inPixels: l
+  };
+  i.mutableValues.prevSize = a, i.onResize(a, i.id, r);
+}
+function $t(e, t) {
+  if (Object.keys(e).length !== Object.keys(t).length)
+    return false;
+  for (const o in e)
+    if (e[o] !== t[o])
+      return false;
+  return true;
+}
+function Ht({
+  group: e,
+  nextGroupSize: t,
+  prevGroupSize: n,
+  prevLayout: o
+}) {
+  if (n <= 0 || t <= 0 || n === t)
+    return o;
+  let i = 0, s = 0, l = false;
+  const r = /* @__PURE__ */ new Map, a = [];
+  for (const m of e.panels) {
+    const d = o[m.id] ?? 0;
+    switch (m.panelConstraints.groupResizeBehavior) {
+      case "preserve-pixel-size": {
+        l = true;
+        const v = d / 100 * n, x = D(v / t * 100);
+        r.set(m.id, x), i += x;
+        break;
+      }
+      case "preserve-relative-size":
+      default: {
+        a.push(m.id), s += d;
+        break;
+      }
+    }
+  }
+  if (!l || a.length === 0)
+    return o;
+  const u = 100 - i, c = { ...o };
+  if (r.forEach((m, d) => {
+    c[d] = m;
+  }), s > 0)
+    for (const m of a) {
+      const d = o[m] ?? 0;
+      c[m] = D(d / s * u);
+    }
+  else {
+    const m = D(u / a.length);
+    for (const d of a)
+      c[d] = m;
+  }
+  return c;
+}
+function Vt(e, t) {
+  const n = e.map((i) => i.id), o = Object.keys(t);
+  if (n.length !== o.length)
+    return false;
+  for (const i of n)
+    if (!o.includes(i))
+      return false;
+  return true;
+}
+var q = /* @__PURE__ */ new Map;
+function jt(e) {
+  let t = true;
+  L(e.element.ownerDocument.defaultView, "Cannot register an unmounted Group");
+  const n = e.element.ownerDocument.defaultView.ResizeObserver, o = /* @__PURE__ */ new Set, i = /* @__PURE__ */ new Set, s = new n((f) => {
+    for (const h of f) {
+      const { borderBoxSize: g, target: y } = h;
+      if (y === e.element) {
+        if (t) {
+          const z = Q({ group: e });
+          if (z === 0)
+            return;
+          const S = $(e.id);
+          if (!S)
+            return;
+          const p = ge(e), P = S.defaultLayoutDeferred ? je(p) : S.layout, R = Ht({
+            group: e,
+            nextGroupSize: z,
+            prevGroupSize: S.groupSize,
+            prevLayout: P
+          }), C = B({
+            layout: R,
+            panelConstraints: p
+          });
+          if (!S.defaultLayoutDeferred && j(S.layout, C) && $t(S.derivedPanelConstraints, p) && S.groupSize === z)
+            return;
+          _(e, {
+            defaultLayoutDeferred: false,
+            derivedPanelConstraints: p,
+            groupSize: z,
+            layout: C,
+            separatorToPanels: S.separatorToPanels
+          });
+        }
+      } else
+        Ft(e, y, g);
+    }
+  });
+  s.observe(e.element), e.panels.forEach((f) => {
+    L(!o.has(f.id), `Panel ids must be unique; id "${f.id}" was used more than once`), o.add(f.id), f.onResize && s.observe(f.element);
+  });
+  const l = Q({ group: e }), r = ge(e), a = e.panels.map(({ id: f }) => f).join(",");
+  let u = e.mutableState.defaultLayout;
+  u && (Vt(e.panels, u) || (u = undefined));
+  const c = e.mutableState.layouts[a] ?? u ?? je(r), m = B({
+    layout: c,
+    panelConstraints: r
+  }), d = e.element.ownerDocument;
+  q.set(d, (q.get(d) ?? 0) + 1);
+  const v = /* @__PURE__ */ new Map;
+  return Ye(e).forEach((f) => {
+    f.separator && v.set(f.separator, f.panels);
+  }), _(e, {
+    defaultLayoutDeferred: l === 0,
+    derivedPanelConstraints: r,
+    groupSize: l,
+    layout: m,
+    separatorToPanels: v
+  }), e.separators.forEach((f) => {
+    L(!i.has(f.id), `Separator ids must be unique; id "${f.id}" was used more than once`), i.add(f.id), f.element.addEventListener("keydown", Te);
+  }), q.get(d) === 1 && (d.addEventListener("dblclick", De, true), d.addEventListener("pointerdown", Oe, true), d.addEventListener("pointerleave", Fe), d.addEventListener("pointermove", $e), d.addEventListener("pointerout", He), d.addEventListener("pointerup", Ve, true)), function() {
+    t = false, q.set(d, Math.max(0, (q.get(d) ?? 0) - 1)), Lt(e), e.separators.forEach((h) => {
+      h.element.removeEventListener("keydown", Te);
+    }), q.get(d) || (d.removeEventListener("dblclick", De, true), d.removeEventListener("pointerdown", Oe, true), d.removeEventListener("pointerleave", Fe), d.removeEventListener("pointermove", $e), d.removeEventListener("pointerout", He), d.removeEventListener("pointerup", Ve, true)), s.disconnect();
+  };
+}
+function Bt() {
+  const [e, t] = re({}), n = ne(() => t({}), []);
+  return [e, n];
+}
+function xe(e) {
+  const t = pt();
+  return `${e ?? t}`;
+}
+var K = typeof window < "u" ? Be : de;
+function oe(e) {
+  const t = T(e);
+  return K(() => {
+    t.current = e;
+  }, [e]), ne((...n) => t.current?.(...n), [t]);
+}
+function we(...e) {
+  return oe((t) => {
+    e.forEach((n) => {
+      if (n)
+        switch (typeof n) {
+          case "function": {
+            n(t);
+            break;
+          }
+          case "object": {
+            n.current = t;
+            break;
+          }
+        }
+    });
+  });
+}
+function Pe(e) {
+  const t = T({ ...e });
+  return K(() => {
+    for (const n in e)
+      t.current[n] = e[n];
+  }, [e]), t.current;
+}
+var at = ht(null);
+function Wt(e, t) {
+  const n = T({
+    getLayout: () => ({}),
+    setLayout: Nt
+  });
+  We(t, () => n.current, []), K(() => {
+    Object.assign(n.current, tt({ groupId: e }));
+  });
+}
+function Ut({
+  children: e,
+  className: t,
+  defaultLayout: n,
+  disableCursor: o,
+  disabled: i,
+  elementRef: s,
+  groupRef: l,
+  id: r,
+  onLayoutChange: a,
+  onLayoutChanged: u,
+  orientation: c = "horizontal",
+  resizeTargetMinimumSize: m = {
+    coarse: 20,
+    fine: 10
+  },
+  style: d,
+  ...v
+}) {
+  const x = T({
+    onLayoutChange: {},
+    onLayoutChanged: {}
+  }), f = oe((b) => {
+    j(x.current.onLayoutChange, b) || (x.current.onLayoutChange = b, a?.(b));
+  }), h = oe((b) => {
+    j(x.current.onLayoutChanged, b) || (x.current.onLayoutChanged = b, u?.(b));
+  }), g = xe(r), y = T(null), [z, S] = Bt(), p = T({
+    lastExpandedPanelSizes: {},
+    layouts: {},
+    panels: [],
+    resizeTargetMinimumSize: m,
+    separators: []
+  }), P = we(y, s);
+  Wt(g, l);
+  const R = oe((b, w) => {
+    const E = W(), M = Me(b), k = $(b);
+    if (k) {
+      let O = false;
+      switch (E.state) {
+        case "active": {
+          O = E.hitRegions.some((H) => H.group === M);
+          break;
+        }
+      }
+      return {
+        flexGrow: k.layout[w] ?? 1,
+        pointerEvents: O ? "none" : undefined
+      };
+    }
+    return {
+      flexGrow: n?.[w] ?? 1
+    };
+  }), C = Pe({
+    defaultLayout: n,
+    disableCursor: o
+  }), X2 = Ue(() => ({
+    get disableCursor() {
+      return !!C.disableCursor;
+    },
+    getPanelStyles: R,
+    id: g,
+    orientation: c,
+    registerPanel: (b) => {
+      const w = p.current;
+      return w.panels = Se(c, [
+        ...w.panels,
+        b
+      ]), S(), () => {
+        w.panels = w.panels.filter((E) => E !== b), S();
+      };
+    },
+    registerSeparator: (b) => {
+      const w = p.current;
+      return w.separators = Se(c, [
+        ...w.separators,
+        b
+      ]), S(), () => {
+        w.separators = w.separators.filter((E) => E !== b), S();
+      };
+    },
+    togglePanelDisabled: (b, w) => {
+      const M = p.current.panels.find((H) => H.id === b);
+      M && (M.panelConstraints.disabled = w);
+      const k = Me(g), O = $(g);
+      k && O && _(k, {
+        ...O,
+        derivedPanelConstraints: ge(k)
+      });
+    },
+    toggleSeparatorDisabled: (b, w) => {
+      const M = p.current.separators.find((k) => k.id === b);
+      M && (M.disabled = w);
+    }
+  }), [R, g, S, c, C]), F = T(null);
+  return K(() => {
+    const b = y.current;
+    if (b === null)
+      return;
+    const w = p.current;
+    let E;
+    if (C.defaultLayout !== undefined && Object.keys(C.defaultLayout).length === w.panels.length) {
+      E = {};
+      for (const ee of w.panels) {
+        const ae = C.defaultLayout[ee.id];
+        ae !== undefined && (E[ee.id] = ae);
+      }
+    }
+    const M = {
+      disabled: !!i,
+      element: b,
+      id: g,
+      mutableState: {
+        defaultLayout: E,
+        disableCursor: !!C.disableCursor,
+        expandedPanelSizes: p.current.lastExpandedPanelSizes,
+        layouts: p.current.layouts
+      },
+      orientation: c,
+      panels: w.panels,
+      resizeTargetMinimumSize: w.resizeTargetMinimumSize,
+      separators: w.separators
+    };
+    F.current = M;
+    const k = jt(M), { defaultLayoutDeferred: O, derivedPanelConstraints: H, layout: Ce } = $(M.id, true);
+    !O && H.length > 0 && (f(Ce), h(Ce));
+    const lt = ye(g, (ee) => {
+      const { defaultLayoutDeferred: ae, derivedPanelConstraints: Re, layout: le } = ee.next;
+      if (ae || Re.length === 0)
+        return;
+      const ut = M.panels.map(({ id: N }) => N).join(",");
+      M.mutableState.layouts[ut] = le, Re.forEach((N) => {
+        if (N.collapsible) {
+          const { layout: pe } = ee.prev ?? {};
+          if (pe) {
+            const ft = I(N.collapsedSize, le[N.panelId]), dt = I(N.collapsedSize, pe[N.panelId]);
+            ft && !dt && (M.mutableState.expandedPanelSizes[N.panelId] = pe[N.panelId]);
+          }
+        }
+      });
+      const ct = W().state !== "active";
+      f(le), ct && h(le);
+    });
+    return () => {
+      F.current = null, k(), lt();
+    };
+  }, [
+    i,
+    g,
+    h,
+    f,
+    c,
+    z,
+    C
+  ]), de(() => {
+    const b = F.current;
+    b && (b.mutableState.defaultLayout = n, b.mutableState.disableCursor = !!o);
+  }), /* @__PURE__ */ ie(at.Provider, { value: X2, children: /* @__PURE__ */ ie("div", {
+    ...v,
+    className: t,
+    "data-group": true,
+    "data-testid": g,
+    id: g,
+    ref: P,
+    style: {
+      height: "100%",
+      width: "100%",
+      overflow: "hidden",
+      ...d,
+      display: "flex",
+      flexDirection: c === "horizontal" ? "row" : "column",
+      flexWrap: "nowrap",
+      touchAction: c === "horizontal" ? "pan-y" : "pan-x"
+    },
+    children: e
+  }) });
+}
+Ut.displayName = "Group";
+function Le() {
+  const e = mt(at);
+  return L(e, "Group Context not found; did you render a Panel or Separator outside of a Group?"), e;
+}
+function Xt(e, t) {
+  const { id: n } = Le(), o = T({
+    collapse: he,
+    expand: he,
+    getSize: () => ({
+      asPercentage: 0,
+      inPixels: 0
+    }),
+    isCollapsed: () => false,
+    resize: he
+  });
+  We(t, () => o.current, []), K(() => {
+    Object.assign(o.current, et({ groupId: n, panelId: e }));
+  });
+}
+function qt({
+  children: e,
+  className: t,
+  collapsedSize: n = "0%",
+  collapsible: o = false,
+  defaultSize: i,
+  disabled: s,
+  elementRef: l,
+  groupResizeBehavior: r = "preserve-relative-size",
+  id: a,
+  maxSize: u = "100%",
+  minSize: c = "0%",
+  onResize: m,
+  panelRef: d,
+  style: v,
+  ...x
+}) {
+  const f = !!a, h = xe(a), g = Pe({
+    disabled: s
+  }), y = T(null), z = we(y, l), {
+    getPanelStyles: S,
+    id: p,
+    orientation: P,
+    registerPanel: R,
+    togglePanelDisabled: C
+  } = Le(), X2 = m !== null, F = oe((w, E, M) => {
+    m?.(w, a, M);
+  });
+  K(() => {
+    const w = y.current;
+    if (w !== null) {
+      const E = {
+        element: w,
+        id: h,
+        idIsStable: f,
+        mutableValues: {
+          expandToSize: undefined,
+          prevSize: undefined
+        },
+        onResize: X2 ? F : undefined,
+        panelConstraints: {
+          groupResizeBehavior: r,
+          collapsedSize: n,
+          collapsible: o,
+          defaultSize: i,
+          disabled: g.disabled,
+          maxSize: u,
+          minSize: c
+        }
+      };
+      return R(E);
+    }
+  }, [
+    r,
+    n,
+    o,
+    i,
+    X2,
+    h,
+    f,
+    u,
+    c,
+    F,
+    R,
+    g
+  ]), de(() => {
+    C(h, !!s);
+  }, [s, h, C]), Xt(h, d);
+  const b = Ke((w) => ye(p, w), () => JSON.stringify(S(p, h)), () => JSON.stringify(S(p, h)));
+  return /* @__PURE__ */ ie("div", {
+    ...x,
+    "aria-disabled": s || undefined,
+    "data-panel": true,
+    "data-testid": h,
+    id: h,
+    ref: z,
+    style: {
+      ...Yt,
+      display: "flex",
+      flexBasis: 0,
+      flexShrink: 1,
+      overflow: "visible",
+      ...JSON.parse(b)
+    },
+    children: /* @__PURE__ */ ie("div", {
+      className: t,
+      style: {
+        maxHeight: "100%",
+        maxWidth: "100%",
+        flexGrow: 1,
+        overflow: "auto",
+        ...v,
+        touchAction: P === "horizontal" ? "pan-y" : "pan-x"
+      },
+      children: e
+    })
+  });
+}
+qt.displayName = "Panel";
+var Yt = {
+  minHeight: 0,
+  maxHeight: "100%",
+  height: "auto",
+  minWidth: 0,
+  maxWidth: "100%",
+  width: "auto",
+  border: "none",
+  borderWidth: 0,
+  padding: 0,
+  margin: 0
+};
+function Jt({
+  layout: e,
+  panelConstraints: t,
+  panelId: n,
+  panelIndex: o
+}) {
+  let i, s;
+  const l = e[n], r = t.find((a) => a.panelId === n);
+  if (r) {
+    const a = r.maxSize, u = r.collapsible ? r.collapsedSize : r.minSize, c = [o, o + 1];
+    s = B({
+      layout: se({
+        delta: u - l,
+        initialLayout: e,
+        panelConstraints: t,
+        pivotIndices: c,
+        prevLayout: e
+      }),
+      panelConstraints: t
+    })[n], i = B({
+      layout: se({
+        delta: a - l,
+        initialLayout: e,
+        panelConstraints: t,
+        pivotIndices: c,
+        prevLayout: e
+      }),
+      panelConstraints: t
+    })[n];
+  }
+  return {
+    valueControls: n,
+    valueMax: i,
+    valueMin: s,
+    valueNow: l
+  };
+}
+function Zt({
+  children: e,
+  className: t,
+  disabled: n,
+  elementRef: o,
+  id: i,
+  style: s,
+  ...l
+}) {
+  const r = xe(i), a = Pe({
+    disabled: n
+  }), [u, c] = re({}), [m, d] = re("inactive"), v = T(null), x = we(v, o), {
+    disableCursor: f,
+    id: h,
+    orientation: g,
+    registerSeparator: y,
+    toggleSeparatorDisabled: z
+  } = Le(), S = g === "horizontal" ? "vertical" : "horizontal";
+  K(() => {
+    const P = v.current;
+    if (P !== null) {
+      const R = {
+        disabled: a.disabled,
+        element: P,
+        id: r
+      }, C = y(R), X2 = Gt((b) => {
+        d(b.next.state !== "inactive" && b.next.hitRegions.some((w) => w.separator === R) ? b.next.state : "inactive");
+      }), F = ye(h, (b) => {
+        const { derivedPanelConstraints: w, layout: E, separatorToPanels: M } = b.next, k = M.get(R);
+        if (k) {
+          const O = k[0], H = k.indexOf(O);
+          c(Jt({
+            layout: E,
+            panelConstraints: w,
+            panelId: O.id,
+            panelIndex: H
+          }));
+        }
+      });
+      return () => {
+        X2(), F(), C();
+      };
+    }
+  }, [h, r, y, a]), de(() => {
+    z(r, !!n);
+  }, [n, r, z]);
+  let p;
+  return n && !f && (p = "not-allowed"), /* @__PURE__ */ ie("div", {
+    ...l,
+    "aria-controls": u.valueControls,
+    "aria-disabled": n || undefined,
+    "aria-orientation": S,
+    "aria-valuemax": u.valueMax,
+    "aria-valuemin": u.valueMin,
+    "aria-valuenow": u.valueNow,
+    children: e,
+    className: t,
+    "data-separator": n ? "disabled" : m,
+    "data-testid": r,
+    id: r,
+    ref: x,
+    role: "separator",
+    style: {
+      flexBasis: "auto",
+      cursor: p,
+      ...s,
+      flexGrow: 0,
+      flexShrink: 0,
+      touchAction: "none"
+    },
+    tabIndex: n ? undefined : 0
+  });
+}
+Zt.displayName = "Separator";
+
+// node_modules/@principal-ade/panels/dist/index.esm.js
+import { flushSync as y, unstable_batchedUpdates as w, createPortal as x } from "react-dom";
+import { useTheme as C } from "@principal-ade/industry-theme";
+function S(e2) {
+  return { "--panel-background": e2.colors.background, "--panel-border": e2.colors.border, "--panel-handle": e2.colors.backgroundSecondary, "--panel-handle-hover": e2.colors.backgroundHover, "--panel-handle-active": e2.colors.primary, "--panel-button-bg": e2.colors.surface, "--panel-button-hover": e2.colors.backgroundHover, "--panel-button-border": e2.colors.border, "--panel-button-icon": e2.colors.textSecondary, "--panel-accent-bg": e2.colors.primary + "15" };
+}
+var z = ({ primaryContent: t2, secondaryContent: n2, collapsedHeader: r2, collapsed: o2 = true, onCollapsedChange: i2, ratio: a2 = 0.3, onRatioChange: l2, maxRatio: s2 = 0.8, collapsedHeight: c2 = 28, theme: d2, className: u2 = "", style: p2, animationDuration: h2 = 200, onCollapseStart: m2, onCollapseComplete: f2, onExpandStart: g, onExpandComplete: v }) => {
+  const b = S(d2);
+  return n2 ? /* @__PURE__ */ e(D2, { primaryContent: t2, secondaryContent: n2, collapsedHeader: r2 ?? { title: "Content" }, collapsed: o2, onCollapsedChange: i2 ?? (() => {}), ratio: a2, onRatioChange: l2 ?? (() => {}), maxRatio: s2, collapsedHeight: c2, theme: d2, className: u2, style: p2, animationDuration: h2, onCollapseStart: m2, onCollapseComplete: f2, onExpandStart: g, onExpandComplete: v }) : /* @__PURE__ */ e("div", { className: `collapsible-split-pane ${u2}`, style: { ...b, ...p2 }, children: /* @__PURE__ */ e("div", { className: "csp-primary-content-full", children: t2 }) });
+};
+var D2 = ({ primaryContent: n2, secondaryContent: r2, collapsedHeader: s2, collapsed: c2, onCollapsedChange: d2, ratio: u2, onRatioChange: p2, maxRatio: h2 = 0.8, collapsedHeight: m2 = 28, theme: f2, className: y2 = "", style: w2, animationDuration: x2 = 200, onCollapseStart: C2, onCollapseComplete: R, onExpandStart: N, onExpandComplete: E }) => {
+  const [z2, D3] = o(false), [M, T2] = o(false), A2 = i(null), k = i(undefined), L2 = i(undefined), $2 = i(u2), P = i(false), F = i(c2), B2 = (e2) => 100 * e2;
+  l(() => {
+    F.current = c2;
+  }, [c2]), l(() => {
+    !c2 && u2 > 0 && ($2.current = u2);
+  }, [c2, u2]);
+  const O = a((e2, t2, n3) => {
+    if (!A2.current)
+      return;
+    k.current && cancelAnimationFrame(k.current), L2.current = performance.now();
+    const r3 = (o2) => {
+      if (!L2.current || !A2.current)
+        return;
+      const i2 = o2 - L2.current, a2 = Math.min(i2 / x2, 1), l2 = a2 < 0.5 ? 4 * a2 * a2 * a2 : 1 - Math.pow(-2 * a2 + 2, 3) / 2, s3 = e2 + (t2 - e2) * l2;
+      A2.current.resize(`${s3}%`), a2 < 1 ? k.current = requestAnimationFrame(r3) : (A2.current.resize(`${t2}%`), n3 && n3(), P.current = false, D3(false));
+    };
+    k.current = requestAnimationFrame(r3);
+  }, [x2]), I2 = a(() => {
+    if (z2 || M || !A2.current)
+      return;
+    u2 > 0 && ($2.current = u2), P.current = true, D3(true), C2?.();
+    const e2 = B2(u2);
+    O(e2, 0, () => {
+      F.current = true, d2(true), R?.();
+    });
+  }, [z2, M, u2, O, d2, C2, R]), q2 = a(() => {
+    if (z2 || M || !A2.current)
+      return;
+    P.current = true, D3(true), N?.();
+    const e2 = $2.current || u2 || 0.3, t2 = B2(e2);
+    O(0, t2, () => {
+      F.current = false, d2(false), p2(e2), E?.();
+    });
+  }, [z2, M, u2, O, d2, p2, N, E]), W2 = a(() => {
+    c2 ? q2() : I2();
+  }, [c2, I2, q2]), H = a((e2) => {
+    if (P.current)
+      return;
+    const t2 = e2.asPercentage / 100;
+    t2 <= 0.01 && !F.current ? ($2.current = 0.4, F.current = true, d2(true)) : t2 > 0.01 && F.current && (F.current = false, d2(false)), F.current || p2(t2);
+  }, [p2, d2]), j2 = a(() => {
+    z2 || T2(true);
+  }, [z2]), K2 = a(() => {
+    T2(false);
+  }, []);
+  l(() => {
+    if (c2 && !z2 && A2.current) {
+      A2.current.getSize().asPercentage > 0 && I2();
+    } else if (!c2 && !z2 && A2.current) {
+      A2.current.getSize().asPercentage === 0 && q2();
+    }
+  }, [c2]), l(() => () => {
+    k.current && cancelAnimationFrame(k.current);
+  }, []);
+  const U2 = S(f2), X2 = ["csp-secondary-panel", z2 && !M ? "csp-animating" : "", c2 ? "csp-collapsed" : ""].filter(Boolean).join(" ");
+  return t("div", { className: `collapsible-split-pane ${y2}`, style: { ...U2, ...w2 }, children: [
+    /* @__PURE__ */ t("div", { className: "csp-header " + (c2 ? "csp-header-collapsed" : ""), style: { height: m2, backgroundColor: f2.colors.backgroundSecondary, borderBottom: `1px solid ${f2.colors.border}` }, onClick: c2 ? W2 : undefined, role: c2 ? "button" : undefined, tabIndex: c2 ? 0 : undefined, onKeyDown: c2 ? (e2) => {
+      e2.key !== "Enter" && e2.key !== " " || (e2.preventDefault(), W2());
+    } : undefined, "aria-expanded": !c2, "aria-label": c2 ? `Expand ${s2.title}` : s2.title, children: [
+      s2.icon && /* @__PURE__ */ e("span", { className: "csp-header-icon", style: { color: f2.colors.textSecondary }, children: s2.icon }),
+      /* @__PURE__ */ e("span", { className: "csp-header-title", style: { color: f2.colors.text, fontFamily: f2.fonts.body, fontSize: f2.fontSizes[1], fontWeight: f2.fontWeights.medium }, children: s2.title }),
+      /* @__PURE__ */ e("button", { className: "csp-header-toggle", style: { color: f2.colors.textSecondary }, onClick: (e2) => {
+        e2.stopPropagation(), W2();
+      }, "aria-label": c2 ? `Expand ${s2.title}` : `Collapse ${s2.title}`, children: /* @__PURE__ */ e("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", children: /* @__PURE__ */ e("path", { d: c2 ? "M3 5L6 8L9 5" : "M3 7L6 4L9 7" }) }) })
+    ] }),
+    /* @__PURE__ */ e("div", { className: "csp-content-area", children: /* @__PURE__ */ t(Ut, { orientation: "vertical", onLayoutChange: j2, onLayoutChanged: K2, children: [
+      /* @__PURE__ */ e(qt, { panelRef: A2, defaultSize: c2 ? "0%" : `${B2(u2)}%`, minSize: "0%", maxSize: `${B2(h2)}%`, onResize: H, className: X2, children: /* @__PURE__ */ e("div", { className: "csp-secondary-body", children: r2 }) }),
+      /* @__PURE__ */ e(Zt, { className: "csp-resize-handle", children: /* @__PURE__ */ e("div", { className: "csp-resize-handle-bar" }) }),
+      /* @__PURE__ */ e(qt, { className: "csp-primary-panel", minSize: "20%", children: /* @__PURE__ */ e("div", { className: "csp-panel-content", children: n2 }) })
+    ] }) })
+  ] });
+};
+var A2 = s(null);
+var F = d(({ panels: o2, className: a2 = "", style: s2, theme: c2, minPanelWidth: d2 = 350, idealPanelWidth: p2 = 0.333, showSeparator: h2 = false, onPanelChange: m2, preventKeyboardScroll: f2 = true, disableSwipe: g = false }, v) => {
+  const b = i(null), y2 = i(false), w2 = i(null), x2 = S(c2);
+  u(v, () => ({ scrollToPanel: (e2) => {
+    if (!b.current)
+      return;
+    const t2 = b.current, n2 = t2.children[e2];
+    if (n2) {
+      y2.current = true, w2.current && clearTimeout(w2.current);
+      const e3 = n2.offsetLeft;
+      t2.scrollTo({ left: e3, behavior: "smooth" }), w2.current = setTimeout(() => {
+        y2.current = false;
+      }, 500);
+    }
+  }, getCurrentPanel: () => {
+    if (!b.current || b.current.children.length === 0)
+      return 0;
+    const e2 = b.current, t2 = e2.getBoundingClientRect().left;
+    let n2 = 0, r2 = 1 / 0;
+    for (let o3 = 0;o3 < e2.children.length; o3++) {
+      const i2 = e2.children[o3].getBoundingClientRect(), a3 = Math.abs(i2.left - t2);
+      a3 < r2 && (r2 = a3, n2 = o3);
+    }
+    return n2;
+  } }));
+  l(() => {
+    if (!f2 || !b.current)
+      return;
+    const e2 = b.current, t2 = (e3) => {
+      const t3 = e3.target;
+      if (t3.tagName === "INPUT" || t3.tagName === "TEXTAREA" || t3.tagName === "SELECT" || t3.isContentEditable || t3.closest(".xterm") !== null || t3.closest('[contenteditable="true"]') !== null)
+        return;
+      [" ", "Space", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "PageUp", "PageDown"].includes(e3.key) && e3.preventDefault();
+    };
+    return e2.addEventListener("keydown", t2), () => {
+      e2.removeEventListener("keydown", t2);
+    };
+  }, [f2]), l(() => () => {
+    w2.current && clearTimeout(w2.current);
+  }, []);
+  const C2 = o2.length, R = 2 * d2;
+  let N;
+  N = C2 === 1 || C2 === 2 ? "100%" : `max(${d2}px, ${100 * p2}%)`;
+  const E = r.useId().replace(/:/g, "_");
+  return t(n, { children: [
+    C2 === 2 && /* @__PURE__ */ e("style", { children: `
+            .snap-carousel-container[data-carousel-id="${E}"][data-panel-count="2"] .snap-carousel-panel {
+              width: 100%;
+            }
+            @container (min-width: ${R}px) {
+              .snap-carousel-container[data-carousel-id="${E}"][data-panel-count="2"] .snap-carousel-panel {
+                width: 50%;
+              }
+            }
+          ` }),
+    /* @__PURE__ */ e("div", { ref: b, className: `snap-carousel-container ${g ? "swipe-disabled" : ""} ${a2}`, style: { ...x2, ...s2, "--snap-carousel-min-width": `${d2}px`, "--snap-carousel-ideal-width": 100 * p2 + "%", "--snap-carousel-gap": h2 ? "1px" : "0px", "--snap-carousel-panel-width": N, "--snap-carousel-panel-count": C2, "--snap-carousel-two-panel-threshold": `${R}px` }, onScroll: (e2) => {
+      if (!m2 || !b.current || b.current.children.length === 0)
+        return;
+      if (y2.current)
+        return;
+      const t2 = b.current, n2 = t2.getBoundingClientRect().left;
+      let r2 = 0, o3 = 1 / 0;
+      for (let i2 = 0;i2 < t2.children.length; i2++) {
+        const e3 = t2.children[i2].getBoundingClientRect(), a3 = Math.abs(e3.left - n2);
+        a3 < o3 && (o3 = a3, r2 = i2);
+      }
+      m2(r2);
+    }, "data-panel-count": C2, "data-carousel-id": E, children: o2.map((t2, n2) => /* @__PURE__ */ e("div", { className: "snap-carousel-panel", children: t2 }, n2)) })
+  ] });
+});
+F.displayName = "SnapCarousel";
+var I2 = typeof window != "undefined" && window.document !== undefined && window.document.createElement !== undefined;
+function q2(e2) {
+  const t2 = Object.prototype.toString.call(e2);
+  return t2 === "[object Window]" || t2 === "[object global]";
+}
+function W2(e2) {
+  return "nodeType" in e2;
+}
+function H(e2) {
+  var t2, n2;
+  return e2 ? q2(e2) ? e2 : W2(e2) && (t2 = (n2 = e2.ownerDocument) == null ? undefined : n2.defaultView) != null ? t2 : window : window;
+}
+function j2(e2) {
+  const { Document: t2 } = H(e2);
+  return e2 instanceof t2;
+}
+function K2(e2) {
+  return !q2(e2) && e2 instanceof H(e2).HTMLElement;
+}
+function U2(e2) {
+  return e2 instanceof H(e2).SVGElement;
+}
+function X2(e2) {
+  return e2 ? q2(e2) ? e2.document : W2(e2) ? j2(e2) ? e2 : K2(e2) || U2(e2) ? e2.ownerDocument : document : document : document;
+}
+function te2(e2) {
+  return function(t2) {
+    for (var n2 = arguments.length, r2 = new Array(n2 > 1 ? n2 - 1 : 0), o2 = 1;o2 < n2; o2++)
+      r2[o2 - 1] = arguments[o2];
+    return r2.reduce((t3, n3) => {
+      const r3 = Object.entries(n3);
+      for (const [o3, i2] of r3) {
+        const n4 = t3[o3];
+        n4 != null && (t3[o3] = n4 + e2 * i2);
+      }
+      return t3;
+    }, { ...t2 });
+  };
+}
+var ne2 = /* @__PURE__ */ te2(1);
+var re2 = /* @__PURE__ */ te2(-1);
+function oe2(e2) {
+  if (!e2)
+    return false;
+  const { KeyboardEvent: t2 } = H(e2.target);
+  return t2 && e2 instanceof t2;
+}
+function ie2(e2) {
+  if (function(e3) {
+    if (!e3)
+      return false;
+    const { TouchEvent: t2 } = H(e3.target);
+    return t2 && e3 instanceof t2;
+  }(e2)) {
+    if (e2.touches && e2.touches.length) {
+      const { clientX: t2, clientY: n2 } = e2.touches[0];
+      return { x: t2, y: n2 };
+    }
+    if (e2.changedTouches && e2.changedTouches.length) {
+      const { clientX: t2, clientY: n2 } = e2.changedTouches[0];
+      return { x: t2, y: n2 };
+    }
+  }
+  return function(e3) {
+    return "clientX" in e3 && "clientY" in e3;
+  }(e2) ? { x: e2.clientX, y: e2.clientY } : null;
+}
+var fe2;
+var ge2;
+(ge2 = fe2 || (fe2 = {})).DragStart = "dragStart", ge2.DragMove = "dragMove", ge2.DragEnd = "dragEnd", ge2.DragCancel = "dragCancel", ge2.DragOver = "dragOver", ge2.RegisterDroppable = "registerDroppable", ge2.SetDroppableDisabled = "setDroppableDisabled", ge2.UnregisterDroppable = "unregisterDroppable";
+var be2 = /* @__PURE__ */ Object.freeze({ x: 0, y: 0 });
+var Me2 = { ignoreTransform: false };
+function Te2(e2, t2) {
+  t2 === undefined && (t2 = Me2);
+  let n2 = e2.getBoundingClientRect();
+  if (t2.ignoreTransform) {
+    const { transform: t3, transformOrigin: r3 } = H(e2).getComputedStyle(e2);
+    t3 && (n2 = function(e3, t4, n3) {
+      const r4 = function(e4) {
+        if (e4.startsWith("matrix3d(")) {
+          const t5 = e4.slice(9, -1).split(/, /);
+          return { x: +t5[12], y: +t5[13], scaleX: +t5[0], scaleY: +t5[5] };
+        }
+        if (e4.startsWith("matrix(")) {
+          const t5 = e4.slice(7, -1).split(/, /);
+          return { x: +t5[4], y: +t5[5], scaleX: +t5[0], scaleY: +t5[3] };
+        }
+        return null;
+      }(t4);
+      if (!r4)
+        return e3;
+      const { scaleX: o3, scaleY: i3, x: a3, y: l3 } = r4, s3 = e3.left - a3 - (1 - o3) * parseFloat(n3), c2 = e3.top - l3 - (1 - i3) * parseFloat(n3.slice(n3.indexOf(" ") + 1)), d2 = o3 ? e3.width / o3 : e3.width, u2 = i3 ? e3.height / i3 : e3.height;
+      return { width: d2, height: u2, top: c2, right: s3 + d2, bottom: c2 + u2, left: s3 };
+    }(n2, t3, r3));
+  }
+  const { top: r2, left: o2, width: i2, height: a2, bottom: l2, right: s2 } = n2;
+  return { top: r2, left: o2, width: i2, height: a2, bottom: l2, right: s2 };
+}
+function Ae2(e2) {
+  return Te2(e2, { ignoreTransform: true });
+}
+function ke2(e2, t2) {
+  const n2 = [];
+  return e2 ? function r(o2) {
+    if (t2 != null && n2.length >= t2)
+      return n2;
+    if (!o2)
+      return n2;
+    if (j2(o2) && o2.scrollingElement != null && !n2.includes(o2.scrollingElement))
+      return n2.push(o2.scrollingElement), n2;
+    if (!K2(o2) || U2(o2))
+      return n2;
+    if (n2.includes(o2))
+      return n2;
+    const i2 = H(e2).getComputedStyle(o2);
+    return o2 !== e2 && function(e3, t3) {
+      t3 === undefined && (t3 = H(e3).getComputedStyle(e3));
+      const n3 = /(auto|scroll|overlay)/;
+      return ["overflow", "overflowX", "overflowY"].some((e4) => {
+        const r2 = t3[e4];
+        return typeof r2 == "string" && n3.test(r2);
+      });
+    }(o2, i2) && n2.push(o2), function(e3, t3) {
+      return t3 === undefined && (t3 = H(e3).getComputedStyle(e3)), t3.position === "fixed";
+    }(o2, i2) ? n2 : r(o2.parentNode);
+  }(e2) : n2;
+}
+function Le2(e2) {
+  const [t2] = ke2(e2, 1);
+  return t2 != null ? t2 : null;
+}
+var Oe2;
+var Ie2;
+function qe2(e2) {
+  return !(!I2 || !e2) && e2 === document.scrollingElement;
+}
+function We2(e2) {
+  const t2 = { x: 0, y: 0 }, n2 = qe2(e2) ? { height: window.innerHeight, width: window.innerWidth } : { height: e2.clientHeight, width: e2.clientWidth }, r2 = { x: e2.scrollWidth - n2.width, y: e2.scrollHeight - n2.height };
+  return { isTop: e2.scrollTop <= t2.y, isLeft: e2.scrollLeft <= t2.x, isBottom: e2.scrollTop >= r2.y, isRight: e2.scrollLeft >= r2.x, maxScroll: r2, minScroll: t2 };
+}
+(Ie2 = Oe2 || (Oe2 = {}))[Ie2.Forward = 1] = "Forward", Ie2[Ie2.Backward = -1] = "Backward";
+function Ke2(e2) {
+  if (e2 === document.scrollingElement) {
+    const { innerWidth: e3, innerHeight: t3 } = window;
+    return { top: 0, left: 0, right: e3, bottom: t3, width: e3, height: t3 };
+  }
+  const { top: t2, left: n2, right: r2, bottom: o2 } = e2.getBoundingClientRect();
+  return { top: t2, left: n2, right: r2, bottom: o2, width: e2.clientWidth, height: e2.clientHeight };
+}
+class Ve2 {
+  constructor(e2) {
+    this.target = undefined, this.listeners = [], this.removeAll = () => {
+      this.listeners.forEach((e3) => {
+        var t2;
+        return (t2 = this.target) == null ? undefined : t2.removeEventListener(...e3);
+      });
+    }, this.target = e2;
+  }
+  add(e2, t2, n2) {
+    var r2;
+    (r2 = this.target) == null || r2.addEventListener(e2, t2, n2), this.listeners.push([e2, t2, n2]);
+  }
+}
+function Je2(e2, t2) {
+  const n2 = Math.abs(e2.x), r2 = Math.abs(e2.y);
+  return typeof t2 == "number" ? Math.sqrt(n2 ** 2 + r2 ** 2) > t2 : ("x" in t2) && ("y" in t2) ? n2 > t2.x && r2 > t2.y : ("x" in t2) ? n2 > t2.x : ("y" in t2) && r2 > t2.y;
+}
+var Ge2;
+var _e2;
+var Qe2;
+var Ze2;
+function et2(e2) {
+  e2.preventDefault();
+}
+function tt2(e2) {
+  e2.stopPropagation();
+}
+(_e2 = Ge2 || (Ge2 = {})).Click = "click", _e2.DragStart = "dragstart", _e2.Keydown = "keydown", _e2.ContextMenu = "contextmenu", _e2.Resize = "resize", _e2.SelectionChange = "selectionchange", _e2.VisibilityChange = "visibilitychange", (Ze2 = Qe2 || (Qe2 = {})).Space = "Space", Ze2.Down = "ArrowDown", Ze2.Right = "ArrowRight", Ze2.Left = "ArrowLeft", Ze2.Up = "ArrowUp", Ze2.Esc = "Escape", Ze2.Enter = "Enter", Ze2.Tab = "Tab";
+var nt2 = { start: [Qe2.Space, Qe2.Enter], cancel: [Qe2.Esc], end: [Qe2.Space, Qe2.Enter, Qe2.Tab] };
+var rt2 = (e2, t2) => {
+  let { currentCoordinates: n2 } = t2;
+  switch (e2.code) {
+    case Qe2.Right:
+      return { ...n2, x: n2.x + 25 };
+    case Qe2.Left:
+      return { ...n2, x: n2.x - 25 };
+    case Qe2.Down:
+      return { ...n2, y: n2.y + 25 };
+    case Qe2.Up:
+      return { ...n2, y: n2.y - 25 };
+  }
+};
+
+class ot2 {
+  constructor(e2) {
+    this.props = undefined, this.autoScrollEnabled = false, this.referenceCoordinates = undefined, this.listeners = undefined, this.windowListeners = undefined, this.props = e2;
+    const { event: { target: t2 } } = e2;
+    this.props = e2, this.listeners = new Ve2(X2(t2)), this.windowListeners = new Ve2(H(t2)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(Ge2.Resize, this.handleCancel), this.windowListeners.add(Ge2.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(Ge2.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const { activeNode: e2, onStart: t2 } = this.props, n2 = e2.node.current;
+    n2 && function(e3, t3) {
+      if (t3 === undefined && (t3 = Te2), !e3)
+        return;
+      const { top: n3, left: r2, bottom: o2, right: i2 } = t3(e3);
+      Le2(e3) && (o2 <= 0 || i2 <= 0 || n3 >= window.innerHeight || r2 >= window.innerWidth) && e3.scrollIntoView({ block: "center", inline: "center" });
+    }(n2), t2(be2);
+  }
+  handleKeyDown(e2) {
+    if (oe2(e2)) {
+      const { active: t2, context: n2, options: r2 } = this.props, { keyboardCodes: o2 = nt2, coordinateGetter: i2 = rt2, scrollBehavior: a2 = "smooth" } = r2, { code: l2 } = e2;
+      if (o2.end.includes(l2))
+        return void this.handleEnd(e2);
+      if (o2.cancel.includes(l2))
+        return void this.handleCancel(e2);
+      const { collisionRect: s2 } = n2.current, c2 = s2 ? { x: s2.left, y: s2.top } : be2;
+      this.referenceCoordinates || (this.referenceCoordinates = c2);
+      const d2 = i2(e2, { active: t2, context: n2.current, currentCoordinates: c2 });
+      if (d2) {
+        const t3 = re2(d2, c2), r3 = { x: 0, y: 0 }, { scrollableAncestors: o3 } = n2.current;
+        for (const n3 of o3) {
+          const o4 = e2.code, { isTop: i3, isRight: l3, isLeft: s3, isBottom: c3, maxScroll: u2, minScroll: p2 } = We2(n3), h2 = Ke2(n3), m2 = { x: Math.min(o4 === Qe2.Right ? h2.right - h2.width / 2 : h2.right, Math.max(o4 === Qe2.Right ? h2.left : h2.left + h2.width / 2, d2.x)), y: Math.min(o4 === Qe2.Down ? h2.bottom - h2.height / 2 : h2.bottom, Math.max(o4 === Qe2.Down ? h2.top : h2.top + h2.height / 2, d2.y)) }, f2 = o4 === Qe2.Right && !l3 || o4 === Qe2.Left && !s3, g = o4 === Qe2.Down && !c3 || o4 === Qe2.Up && !i3;
+          if (f2 && m2.x !== d2.x) {
+            const e3 = n3.scrollLeft + t3.x, i4 = o4 === Qe2.Right && e3 <= u2.x || o4 === Qe2.Left && e3 >= p2.x;
+            if (i4 && !t3.y)
+              return void n3.scrollTo({ left: e3, behavior: a2 });
+            r3.x = i4 ? n3.scrollLeft - e3 : o4 === Qe2.Right ? n3.scrollLeft - u2.x : n3.scrollLeft - p2.x, r3.x && n3.scrollBy({ left: -r3.x, behavior: a2 });
+            break;
+          }
+          if (g && m2.y !== d2.y) {
+            const e3 = n3.scrollTop + t3.y, i4 = o4 === Qe2.Down && e3 <= u2.y || o4 === Qe2.Up && e3 >= p2.y;
+            if (i4 && !t3.x)
+              return void n3.scrollTo({ top: e3, behavior: a2 });
+            r3.y = i4 ? n3.scrollTop - e3 : o4 === Qe2.Down ? n3.scrollTop - u2.y : n3.scrollTop - p2.y, r3.y && n3.scrollBy({ top: -r3.y, behavior: a2 });
+            break;
+          }
+        }
+        this.handleMove(e2, ne2(re2(d2, this.referenceCoordinates), r3));
+      }
     }
-  }, [sessionId, actions.writeToTerminal]);
-  const hasNotifiedPtyRef = useRef2(false);
-  const handleTerminalResize = useCallback2((cols, rows) => {
-    if (sessionId && actions.resizeTerminal) {
-      const isInitialNotification = !hasNotifiedPtyRef.current;
-      actions.resizeTerminal(sessionId, cols, rows);
-      if (isInitialNotification && actions.writeToTerminal) {
-        setTimeout(() => {
-          actions.writeToTerminal(sessionId, "\f");
-        }, 50);
-      }
-      hasNotifiedPtyRef.current = true;
+  }
+  handleMove(e2, t2) {
+    const { onMove: n2 } = this.props;
+    e2.preventDefault(), n2(t2);
+  }
+  handleEnd(e2) {
+    const { onEnd: t2 } = this.props;
+    e2.preventDefault(), this.detach(), t2();
+  }
+  handleCancel(e2) {
+    const { onCancel: t2 } = this.props;
+    e2.preventDefault(), this.detach(), t2();
+  }
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll();
+  }
+}
+function it2(e2) {
+  return Boolean(e2 && "distance" in e2);
+}
+function at2(e2) {
+  return Boolean(e2 && "delay" in e2);
+}
+ot2.activators = [{ eventName: "onKeyDown", handler: (e2, t2, n2) => {
+  let { keyboardCodes: r2 = nt2, onActivation: o2 } = t2, { active: i2 } = n2;
+  const { code: a2 } = e2.nativeEvent;
+  if (r2.start.includes(a2)) {
+    const t3 = i2.activatorNode.current;
+    return (!t3 || e2.target === t3) && (e2.preventDefault(), o2 == null || o2({ event: e2.nativeEvent }), true);
+  }
+  return false;
+} }];
+
+class lt {
+  constructor(e2, t2, n2) {
+    var r2;
+    n2 === undefined && (n2 = function(e3) {
+      const { EventTarget: t3 } = H(e3);
+      return e3 instanceof t3 ? e3 : X2(e3);
+    }(e2.event.target)), this.props = undefined, this.events = undefined, this.autoScrollEnabled = true, this.document = undefined, this.activated = false, this.initialCoordinates = undefined, this.timeoutId = null, this.listeners = undefined, this.documentListeners = undefined, this.windowListeners = undefined, this.props = e2, this.events = t2;
+    const { event: o2 } = e2, { target: i2 } = o2;
+    this.props = e2, this.events = t2, this.document = X2(i2), this.documentListeners = new Ve2(this.document), this.listeners = new Ve2(n2), this.windowListeners = new Ve2(H(i2)), this.initialCoordinates = (r2 = ie2(o2)) != null ? r2 : be2, this.handleStart = this.handleStart.bind(this), this.handleMove = this.handleMove.bind(this), this.handleEnd = this.handleEnd.bind(this), this.handleCancel = this.handleCancel.bind(this), this.handleKeydown = this.handleKeydown.bind(this), this.removeTextSelection = this.removeTextSelection.bind(this), this.attach();
+  }
+  attach() {
+    const { events: e2, props: { options: { activationConstraint: t2, bypassActivationConstraint: n2 } } } = this;
+    if (this.listeners.add(e2.move.name, this.handleMove, { passive: false }), this.listeners.add(e2.end.name, this.handleEnd), e2.cancel && this.listeners.add(e2.cancel.name, this.handleCancel), this.windowListeners.add(Ge2.Resize, this.handleCancel), this.windowListeners.add(Ge2.DragStart, et2), this.windowListeners.add(Ge2.VisibilityChange, this.handleCancel), this.windowListeners.add(Ge2.ContextMenu, et2), this.documentListeners.add(Ge2.Keydown, this.handleKeydown), t2) {
+      if (n2 != null && n2({ event: this.props.event, activeNode: this.props.activeNode, options: this.props.options }))
+        return this.handleStart();
+      if (at2(t2))
+        return this.timeoutId = setTimeout(this.handleStart, t2.delay), void this.handlePending(t2);
+      if (it2(t2))
+        return void this.handlePending(t2);
     }
-  }, [sessionId, actions.resizeTerminal, actions.writeToTerminal]);
-  useEffect3(() => {
-    hasNotifiedPtyRef.current = false;
-  }, [sessionId]);
-  const handleScrollPositionChange = useCallback2((position) => {
-    setScrollPosition(position);
-    isScrollLockedRef.current = position.isScrollLocked;
-  }, []);
-  const sessionInfo = sessionId ? getTerminalSession(context2, sessionId) : undefined;
-  if (error) {
-    return /* @__PURE__ */ jsxs5("div", {
-      style: {
-        padding: "20px",
-        color: "#ef4444",
-        backgroundColor: "#1a1a1a",
-        height: "100%",
-        display: "flex",
-        alignItems: "center",
-        justifyContent: "center",
-        flexDirection: "column",
-        gap: "10px"
-      },
-      children: [
-        /* @__PURE__ */ jsx6("div", {
-          style: { fontSize: "16px", fontWeight: "bold" },
-          children: "Terminal Error"
-        }),
-        /* @__PURE__ */ jsx6("div", {
-          style: { fontSize: "14px", opacity: 0.8 },
-          children: error
-        })
-      ]
-    });
+    this.handleStart();
   }
-  if (isInitializing || !sessionId) {
-    return /* @__PURE__ */ jsx6("div", {
-      style: {
-        padding: "20px",
-        color: "#a0a0a0",
-        backgroundColor: "#1a1a1a",
-        height: "100%",
-        display: "flex",
-        alignItems: "center",
-        justifyContent: "center"
-      },
-      children: "Initializing terminal..."
-    });
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll(), setTimeout(this.documentListeners.removeAll, 50), this.timeoutId !== null && (clearTimeout(this.timeoutId), this.timeoutId = null);
   }
-  const handleScrollToBottom = () => {
-    terminalRef.current?.scrollToBottom();
-  };
-  const handleToggleScrollLock = () => {
-    if (scrollPosition.isScrollLocked) {
-      const terminal = terminalRef.current?.getTerminal();
-      if (terminal) {
-        terminal.scrollLines(-1);
+  handlePending(e2, t2) {
+    const { active: n2, onPending: r2 } = this.props;
+    r2(n2, e2, this.initialCoordinates, t2);
+  }
+  handleStart() {
+    const { initialCoordinates: e2 } = this, { onStart: t2 } = this.props;
+    e2 && (this.activated = true, this.documentListeners.add(Ge2.Click, tt2, { capture: true }), this.removeTextSelection(), this.documentListeners.add(Ge2.SelectionChange, this.removeTextSelection), t2(e2));
+  }
+  handleMove(e2) {
+    var t2;
+    const { activated: n2, initialCoordinates: r2, props: o2 } = this, { onMove: i2, options: { activationConstraint: a2 } } = o2;
+    if (!r2)
+      return;
+    const l2 = (t2 = ie2(e2)) != null ? t2 : be2, s2 = re2(r2, l2);
+    if (!n2 && a2) {
+      if (it2(a2)) {
+        if (a2.tolerance != null && Je2(s2, a2.tolerance))
+          return this.handleCancel();
+        if (Je2(s2, a2.distance))
+          return this.handleStart();
       }
-    } else {
-      terminalRef.current?.scrollToBottom();
+      return at2(a2) && Je2(s2, a2.tolerance) ? this.handleCancel() : void this.handlePending(a2, s2);
     }
-  };
-  return /* @__PURE__ */ jsxs5("div", {
-    style: { height: "100%", width: "100%", display: "flex", flexDirection: "column" },
-    children: [
-      /* @__PURE__ */ jsxs5("div", {
-        style: {
-          display: "flex",
-          gap: "8px",
-          padding: "8px 12px",
-          backgroundColor: theme.colors.backgroundSecondary,
-          borderBottom: `1px solid ${theme.colors.border}`,
-          alignItems: "center"
-        },
-        children: [
-          /* @__PURE__ */ jsxs5("span", {
-            style: {
-              fontSize: "12px",
-              color: theme.colors.textSecondary,
-              marginRight: "auto",
-              fontFamily: theme.fonts.monospace
-            },
-            children: [
-              sessionInfo?.cwd || "Terminal",
-              " • ",
-              sessionInfo?.shell
-            ]
-          }),
-          /* @__PURE__ */ jsxs5("button", {
-            onClick: handleToggleScrollLock,
-            style: {
-              display: "flex",
-              alignItems: "center",
-              gap: "4px",
-              fontSize: "11px",
-              padding: "4px 8px",
-              borderRadius: "4px",
-              backgroundColor: scrollPosition.isScrollLocked ? `${theme.colors.success}22` : `${theme.colors.warning}22`,
-              color: scrollPosition.isScrollLocked ? theme.colors.success : theme.colors.warning,
-              border: `1px solid ${scrollPosition.isScrollLocked ? `${theme.colors.success}44` : `${theme.colors.warning}44`}`,
-              cursor: "pointer",
-              transition: "opacity 0.2s"
-            },
-            onMouseEnter: (e) => e.currentTarget.style.opacity = "0.8",
-            onMouseLeave: (e) => e.currentTarget.style.opacity = "1",
-            title: scrollPosition.isScrollLocked ? "Click to unlock scroll" : "Click to lock scroll to bottom",
-            children: [
-              scrollPosition.isScrollLocked ? /* @__PURE__ */ jsx6(Lock, {
-                size: 12
-              }) : /* @__PURE__ */ jsx6(Unlock, {
-                size: 12
-              }),
-              /* @__PURE__ */ jsx6("span", {
-                children: scrollPosition.isScrollLocked ? "Locked" : "Unlocked"
-              })
-            ]
-          }),
-          /* @__PURE__ */ jsxs5("button", {
-            onClick: handleScrollToBottom,
-            disabled: scrollPosition.isAtBottom,
-            style: {
-              display: "flex",
-              alignItems: "center",
-              gap: "4px",
-              fontSize: "11px",
-              padding: "4px 10px",
-              borderRadius: "4px",
-              backgroundColor: scrollPosition.isAtBottom ? theme.colors.backgroundHover : theme.colors.accent,
-              color: scrollPosition.isAtBottom ? theme.colors.textTertiary : theme.colors.text,
-              border: `1px solid ${theme.colors.border}`,
-              cursor: scrollPosition.isAtBottom ? "not-allowed" : "pointer",
-              transition: "opacity 0.2s",
-              opacity: scrollPosition.isAtBottom ? 0.5 : 1
-            },
-            onMouseEnter: (e) => !scrollPosition.isAtBottom && (e.currentTarget.style.opacity = "0.8"),
-            onMouseLeave: (e) => !scrollPosition.isAtBottom && (e.currentTarget.style.opacity = "1"),
-            title: "Scroll to bottom and lock",
-            children: [
-              /* @__PURE__ */ jsx6(ArrowDown, {
-                size: 12
-              }),
-              /* @__PURE__ */ jsx6("span", {
-                children: "Bottom"
-              })
-            ]
-          })
-        ]
-      }),
-      /* @__PURE__ */ jsx6("div", {
-        style: { flex: 1 },
-        children: /* @__PURE__ */ jsx6(ThemedTerminalWithProvider, {
-          ref: terminalRef,
-          onData: handleTerminalData,
-          onResize: handleTerminalResize,
-          onScrollPositionChange: handleScrollPositionChange,
-          hideHeader: true,
-          autoFocus: true,
-          convertEol: true,
-          cursorBlink: true,
-          scrollback: 1e4,
-          enableSearch: true,
-          enableWebLinks: true
-        })
-      })
-    ]
-  });
-};
+    e2.cancelable && e2.preventDefault(), i2(l2);
+  }
+  handleEnd() {
+    const { onAbort: e2, onEnd: t2 } = this.props;
+    this.detach(), this.activated || e2(this.props.active), t2();
+  }
+  handleCancel() {
+    const { onAbort: e2, onCancel: t2 } = this.props;
+    this.detach(), this.activated || e2(this.props.active), t2();
+  }
+  handleKeydown(e2) {
+    e2.code === Qe2.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var e2;
+    (e2 = this.document.getSelection()) == null || e2.removeAllRanges();
+  }
+}
+var st2 = { cancel: { name: "pointercancel" }, move: { name: "pointermove" }, end: { name: "pointerup" } };
+
+class ct extends lt {
+  constructor(e2) {
+    const { event: t2 } = e2, n2 = X2(t2.target);
+    super(e2, st2, n2);
+  }
+}
+ct.activators = [{ eventName: "onPointerDown", handler: (e2, t2) => {
+  let { nativeEvent: n2 } = e2, { onActivation: r2 } = t2;
+  return !(!n2.isPrimary || n2.button !== 0) && (r2 == null || r2({ event: n2 }), true);
+} }];
+var dt = { move: { name: "mousemove" }, end: { name: "mouseup" } };
+var ut;
+var pt2;
+(pt2 = ut || (ut = {}))[pt2.RightClick = 2] = "RightClick";
+(class extends lt {
+  constructor(e2) {
+    super(e2, dt, X2(e2.event.target));
+  }
+}).activators = [{ eventName: "onMouseDown", handler: (e2, t2) => {
+  let { nativeEvent: n2 } = e2, { onActivation: r2 } = t2;
+  return n2.button !== ut.RightClick && (r2 == null || r2({ event: n2 }), true);
+} }];
+var ht2 = { cancel: { name: "touchcancel" }, move: { name: "touchmove" }, end: { name: "touchend" } };
+var mt2;
+var ft;
+var gt2;
+var vt2;
+(class extends lt {
+  constructor(e2) {
+    super(e2, ht2);
+  }
+  static setup() {
+    return window.addEventListener(ht2.move.name, e2, { capture: false, passive: false }), function() {
+      window.removeEventListener(ht2.move.name, e2);
+    };
+    function e2() {}
+  }
+}).activators = [{ eventName: "onTouchStart", handler: (e2, t2) => {
+  let { nativeEvent: n2 } = e2, { onActivation: r2 } = t2;
+  const { touches: o2 } = n2;
+  return !(o2.length > 1) && (r2 == null || r2({ event: n2 }), true);
+} }], (ft = mt2 || (mt2 = {}))[ft.Pointer = 0] = "Pointer", ft[ft.DraggableRect = 1] = "DraggableRect", (vt2 = gt2 || (gt2 = {}))[vt2.TreeOrder = 0] = "TreeOrder", vt2[vt2.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+var yt2 = { x: { [Oe2.Backward]: false, [Oe2.Forward]: false }, y: { [Oe2.Backward]: false, [Oe2.Forward]: false } };
+var wt2;
+var xt2;
+var Ct2;
+(xt2 = wt2 || (wt2 = {}))[xt2.Always = 0] = "Always", xt2[xt2.BeforeDragging = 1] = "BeforeDragging", xt2[xt2.WhileDragging = 2] = "WhileDragging", (Ct2 || (Ct2 = {})).Optimized = "optimized";
+var Pt2 = { draggable: { measure: Ae2 }, droppable: { measure: Ae2, strategy: wt2.WhileDragging, frequency: Ct2.Optimized }, dragOverlay: { measure: Te2 } };
+var jt2 = /* @__PURE__ */ s({ ...be2, scaleX: 1, scaleY: 1 });
+var Kt;
+var Ut2;
+(Ut2 = Kt || (Kt = {}))[Ut2.Uninitialized = 0] = "Uninitialized", Ut2[Ut2.Initializing = 1] = "Initializing", Ut2[Ut2.Initialized = 2] = "Initialized";
+
 // src/panels/TabbedTerminalPanel.tsx
-import { useTheme as useTheme6 } from "@principal-ade/industry-theme";
 import { Terminal as TerminalIcon2, Lock as Lock2, Unlock as Unlock2, Box, Boxes } from "lucide-react";
-import React2, {
+import React3, {
   useState as useState4,
-  useCallback as useCallback3,
+  useCallback as useCallback5,
   useEffect as useEffect4,
   useRef as useRef3
 } from "react";
@@ -1793,7 +4264,7 @@ import { jsx as jsx7, jsxs as jsxs6, Fragment as Fragment2 } from "react/jsx-run
 var ActivityIndicator = ({ color, isAnimating }) => /* @__PURE__ */ jsxs6("div", {
   style: { display: "flex", gap: 1, alignItems: "center", height: 12 },
   children: [
-    [0, 1, 2, 3, 4].map((i) => /* @__PURE__ */ jsx7("div", {
+    [0, 1, 2, 3, 4].map((i2) => /* @__PURE__ */ jsx7("div", {
       style: {
         width: 2,
         height: 10,
@@ -1801,9 +4272,9 @@ var ActivityIndicator = ({ color, isAnimating }) => /* @__PURE__ */ jsxs6("div",
         borderRadius: 1,
         transformOrigin: "center",
         transform: isAnimating ? undefined : "scaleY(0.4)",
-        animation: isAnimating ? `waveSine 1.2s ease-in-out ${i * 0.1}s infinite` : "none"
+        animation: isAnimating ? `waveSine 1.2s ease-in-out ${i2 * 0.1}s infinite` : "none"
       }
-    }, i)),
+    }, i2)),
     /* @__PURE__ */ jsx7("style", {
       children: `
         @keyframes waveSine {
@@ -1830,7 +4301,7 @@ function TerminalTabContentInner(props, ref) {
   const [shouldRenderTerminal, setShouldRenderTerminal] = useState4(true);
   const [ownerWindowId, setOwnerWindowId] = useState4(null);
   const needsRefreshOnResizeRef = useRef3(false);
-  const claimAndConnect = useCallback3(async (targetSessionId, force = false) => {
+  const claimAndConnect = useCallback5(async (targetSessionId, force = false) => {
     try {
       if (actions.claimTerminalOwnership) {
         await actions.claimTerminalOwnership(targetSessionId, force);
@@ -1938,17 +4409,17 @@ function TerminalTabContentInner(props, ref) {
       unsubscribe();
     };
   }, [localSessionId, isInitialized, actions, shouldRenderTerminal, tab.id]);
-  const handleData = useCallback3((data) => {
+  const handleData = useCallback5((data) => {
     if (localSessionId && actions.writeToTerminal) {
       actions.writeToTerminal(localSessionId, data);
     }
   }, [localSessionId, actions]);
-  const handleResize = useCallback3((cols, rows) => {
+  const handleResize = useCallback5((cols, rows) => {
     if (localSessionId && actions.resizeTerminal) {
       actions.resizeTerminal(localSessionId, cols, rows);
     }
   }, [localSessionId, actions]);
-  const handleReady = useCallback3((cols, rows) => {
+  const handleReady = useCallback5((cols, rows) => {
     if (localSessionId && actions.resizeTerminal) {
       const shouldForce = needsRefreshOnResizeRef.current;
       if (shouldForce) {
@@ -1957,7 +4428,7 @@ function TerminalTabContentInner(props, ref) {
       actions.resizeTerminal(localSessionId, cols, rows, shouldForce);
     }
   }, [localSessionId, actions]);
-  const handleLinkClick = useCallback3((url, modifiers) => {
+  const handleLinkClick = useCallback5((url, modifiers) => {
     if (localSessionId) {
       events.emit({
         type: "terminal:link-click",
@@ -1988,17 +4459,17 @@ function TerminalTabContentInner(props, ref) {
       unsubscribe();
     };
   }, [localSessionId, actions]);
-  const handleTakeControl = useCallback3(async () => {
+  const handleTakeControl = useCallback5(async () => {
     if (!localSessionId) {
       return;
     }
     await claimAndConnect(localSessionId, true);
   }, [localSessionId, claimAndConnect]);
-  const handleScrollPositionChange = useCallback3((position) => {
+  const handleScrollPositionChange = useCallback5((position) => {
     setScrollPosition(position);
     onScrollPositionChange?.(tab.id, position);
   }, [tab.id, onScrollPositionChange]);
-  const handleShortcut = useCallback3((shortcutEvent) => {
+  const handleShortcut = useCallback5((shortcutEvent) => {
     if (localSessionId) {
       events.emit({
         type: "terminal:shortcut",
@@ -2011,7 +4482,7 @@ function TerminalTabContentInner(props, ref) {
       });
     }
   }, [localSessionId, events]);
-  const handleActivityChange = useCallback3((state) => {
+  const handleActivityChange = useCallback5((state) => {
     if (localSessionId) {
       onActivityStateChange?.(localSessionId, state.isActive);
       events.emit({
@@ -2026,10 +4497,10 @@ function TerminalTabContentInner(props, ref) {
       });
     }
   }, [localSessionId, events, onActivityStateChange]);
-  const handleScrollToBottom = useCallback3(() => {
+  const handleScrollToBottom = useCallback5(() => {
     terminalRef.current?.scrollToBottom();
   }, []);
-  const handleToggleScrollLock = useCallback3(() => {
+  const handleToggleScrollLock = useCallback5(() => {
     if (scrollPosition.isScrollLocked) {
       const terminal = terminalRef.current?.getTerminal();
       if (terminal) {
@@ -2039,7 +4510,7 @@ function TerminalTabContentInner(props, ref) {
       terminalRef.current?.scrollToBottom();
     }
   }, [scrollPosition.isScrollLocked]);
-  React2.useImperativeHandle(ref, () => ({
+  React3.useImperativeHandle(ref, () => ({
     scrollToBottom: handleScrollToBottom,
     toggleScrollLock: handleToggleScrollLock
   }), [handleScrollToBottom, handleToggleScrollLock]);
@@ -2142,8 +4613,8 @@ var areTerminalTabContentPropsEqual = (prevProps, nextProps) => {
   }
   return changes.length === 0;
 };
-var TerminalTabContentForwarded = React2.forwardRef(TerminalTabContentInner);
-var TerminalTabContent = React2.memo(TerminalTabContentForwarded, areTerminalTabContentPropsEqual);
+var TerminalTabContentForwarded = React3.forwardRef(TerminalTabContentInner);
+var TerminalTabContent = React3.memo(TerminalTabContentForwarded, areTerminalTabContentPropsEqual);
 TerminalTabContent.displayName = "TerminalTabContent";
 var TabbedTerminalPanelInner = ({
   context: _context,
@@ -2170,7 +4641,15 @@ var TabbedTerminalPanelInner = ({
   workingStates,
   activityDetection = true,
   activityTimeout = 500,
-  autoShowBlinds = false
+  autoShowBlinds = false,
+  associations,
+  onAssociationCollapsedChange,
+  onAssociationRatioChange,
+  renderAssociatedContent,
+  getAssociatedHeader,
+  enableTabAssociationDrag = false,
+  onTabAssociate,
+  onTabDissociate: _onTabDissociate
 }) => {
   console.log("[TabbedTerminalPanel] RENDER", { terminalContext, directory, width });
   const { theme } = useTheme6();
@@ -2179,7 +4658,7 @@ var TabbedTerminalPanelInner = ({
   const [internalActiveTabId, setInternalActiveTabId] = useState4(null);
   const isControlled = activeTabIdProp !== undefined;
   const activeTabId = isControlled ? activeTabIdProp : internalActiveTabId;
-  const setActiveTabId = React2.useCallback((tabId) => {
+  const setActiveTabId = React3.useCallback((tabId) => {
     if (isControlled) {
       onActiveTabChange?.(tabId);
     } else {
@@ -2190,7 +4669,7 @@ var TabbedTerminalPanelInner = ({
   const [sessionIds, setSessionIds] = useState4(new Map);
   const [scrollPositions, setScrollPositions] = useState4(new Map);
   const [activityStates, setActivityStates] = useState4(new Map);
-  const customTabsKey = React2.useMemo(() => {
+  const customTabsKey = React3.useMemo(() => {
     const customTabs = initialTabs.filter((tab) => tab.contentType !== "terminal");
     return JSON.stringify(customTabs);
   }, [initialTabs]);
@@ -2198,16 +4677,13 @@ var TabbedTerminalPanelInner = ({
     const customTabsFromProp = initialTabs.filter((tab) => tab.contentType !== "terminal");
     setOwnedTabs((prevTabs) => {
       const existingTerminalTabs = prevTabs.filter((tab) => tab.contentType === "terminal");
-      const customTabIds = new Set(customTabsFromProp.map((t) => t.id));
-      const existingCustomTabs = prevTabs.filter((tab) => tab.contentType !== "terminal" && !customTabIds.has(tab.id));
       const mergedTabs = [
         ...existingTerminalTabs,
-        ...existingCustomTabs,
         ...customTabsFromProp
       ];
       const prevCustomTabs = prevTabs.filter((tab) => tab.contentType !== "terminal");
       const customTabsChanged = prevCustomTabs.length !== customTabsFromProp.length || !customTabsFromProp.every((tab) => {
-        const prev = prevCustomTabs.find((p) => p.id === tab.id);
+        const prev = prevCustomTabs.find((p2) => p2.id === tab.id);
         if (!prev)
           return false;
         return JSON.stringify(tab) === JSON.stringify(prev);
@@ -2233,21 +4709,21 @@ var TabbedTerminalPanelInner = ({
       onFocusTabHandled?.();
     }
   }, [requestFocusTabId, ownedTabs, foreignTabs, setActiveTabId, onFocusTabHandled, activeTabId]);
-  const getOwnedTabLabel = useCallback3((index, _directory) => {
+  const getOwnedTabLabel = useCallback5((index, _directory) => {
     if (tabLabelPrefix) {
       return `${tabLabelPrefix} ${index + 1}`;
     }
     return `⌘ ${index + 1}`;
   }, [tabLabelPrefix]);
-  const tabs = React2.useMemo(() => {
+  const tabs = React3.useMemo(() => {
     const labeledOwnedTabs = ownedTabs.map((tab, index) => ({
       ...tab,
       label: tab.contentType === "terminal" ? getOwnedTabLabel(index, tab.directory) : tab.label
     }));
-    const sortedForeignTabs = [...foreignTabs].sort((a, b) => a.label.localeCompare(b.label));
+    const sortedForeignTabs = [...foreignTabs].sort((a2, b) => a2.label.localeCompare(b.label));
     return [...labeledOwnedTabs, ...sortedForeignTabs];
   }, [ownedTabs, foreignTabs, getOwnedTabLabel]);
-  const genericTabs = React2.useMemo(() => {
+  const genericTabs = React3.useMemo(() => {
     return tabs.map((tab) => ({
       id: tab.id,
       label: tab.label,
@@ -2261,7 +4737,7 @@ var TabbedTerminalPanelInner = ({
   }, [tabs]);
   const tabRefsMap = useRef3(new Map);
   const refCallbacksMap = useRef3(new Map);
-  const getRefCallback = useCallback3((tabId) => {
+  const getRefCallback = useCallback5((tabId) => {
     let callback = refCallbacksMap.current.get(tabId);
     if (!callback) {
       callback = (ref) => {
@@ -2278,7 +4754,7 @@ var TabbedTerminalPanelInner = ({
   const hasInitializedRef = useRef3(false);
   const isCreatingTabRef = useRef3(false);
   const headerRef = useRef3(null);
-  const handleTabScrollPositionChange = useCallback3((tabId, position) => {
+  const handleTabScrollPositionChange = useCallback5((tabId, position) => {
     setScrollPositions((prev) => new Map(prev).set(tabId, position));
   }, []);
   const defaultScrollPosition = {
@@ -2286,12 +4762,12 @@ var TabbedTerminalPanelInner = ({
     isAtBottom: true,
     isScrollLocked: false
   };
-  const handleToggleScrollLock = useCallback3(() => {
+  const handleToggleScrollLock = useCallback5(() => {
     if (activeTabId) {
       tabRefsMap.current.get(activeTabId)?.toggleScrollLock();
     }
   }, [activeTabId]);
-  const restoreOwnedSessions = useCallback3(async () => {
+  const restoreOwnedSessions = useCallback5(async () => {
     try {
       let sessions = [];
       if (actions.listTerminalSessions) {
@@ -2326,7 +4802,7 @@ var TabbedTerminalPanelInner = ({
       console.error("[TabbedTerminalPanel] Failed to restore owned sessions:", err);
     }
   }, [terminalContext, initialTabs, onTabsChange, actions, directory]);
-  const fetchForeignSessions = useCallback3(async () => {
+  const fetchForeignSessions = useCallback5(async () => {
     try {
       if (!actions.listTerminalSessions) {
         return;
@@ -2358,9 +4834,9 @@ var TabbedTerminalPanelInner = ({
       console.error("[TabbedTerminalPanel] Failed to fetch foreign sessions:", err);
     }
   }, [terminalContext, actions]);
-  const clearForeignTabs = useCallback3(() => {
+  const clearForeignTabs = useCallback5(() => {
     setForeignTabs((prevForeign) => {
-      const foreignTabIds = new Set(prevForeign.map((t) => t.id));
+      const foreignTabIds = new Set(prevForeign.map((t2) => t2.id));
       setSessionIds((prev) => {
         const updated = new Map(prev);
         foreignTabIds.forEach((id) => updated.delete(id));
@@ -2396,10 +4872,10 @@ var TabbedTerminalPanelInner = ({
       clearForeignTabs();
     }
   }, [showAllTerminals, fetchForeignSessions, clearForeignTabs]);
-  const switchTab = useCallback3((tabId) => {
+  const switchTab = useCallback5((tabId) => {
     setActiveTabId(tabId);
   }, [setActiveTabId]);
-  const addNewTab = useCallback3((label, command, targetDirectory) => {
+  const addNewTab = useCallback5((label, command, targetDirectory) => {
     const targetDir = targetDirectory || directory;
     const directoryName = targetDir.split("/").pop() || targetDir;
     const newTab = {
@@ -2417,10 +4893,10 @@ var TabbedTerminalPanelInner = ({
     });
     setActiveTabId(newTab.id);
   }, [directory, onTabsChange]);
-  const isForeignTab = useCallback3((tabId) => {
+  const isForeignTab = useCallback5((tabId) => {
     return tabId.startsWith("tab-foreign-");
   }, []);
-  const closeTab = useCallback3(async (tabId) => {
+  const closeTab = useCallback5(async (tabId) => {
     const sessionId = sessionIds.get(tabId);
     const isForeign = isForeignTab(tabId);
     if (!isForeign && sessionId && actions.destroyTerminalSession) {
@@ -2462,7 +4938,7 @@ var TabbedTerminalPanelInner = ({
       return newMap;
     });
     const findNextActiveTab = (allTabs) => {
-      const remaining = allTabs.filter((t) => t.id !== tabId);
+      const remaining = allTabs.filter((t2) => t2.id !== tabId);
       if (activeTabId === tabId && remaining.length > 0) {
         const newActive = remaining[remaining.length - 1];
         return newActive.id;
@@ -2471,7 +4947,7 @@ var TabbedTerminalPanelInner = ({
     };
     if (isForeign) {
       setForeignTabs((prevTabs) => {
-        const newTabs = prevTabs.filter((t) => t.id !== tabId);
+        const newTabs = prevTabs.filter((t2) => t2.id !== tabId);
         const nextActiveId = findNextActiveTab([...ownedTabs, ...newTabs]);
         if (nextActiveId !== activeTabId) {
           setActiveTabId(nextActiveId);
@@ -2480,7 +4956,7 @@ var TabbedTerminalPanelInner = ({
       });
     } else {
       setOwnedTabs((prevTabs) => {
-        const newTabs = prevTabs.filter((t) => t.id !== tabId);
+        const newTabs = prevTabs.filter((t2) => t2.id !== tabId);
         const nextActiveId = findNextActiveTab([...newTabs, ...foreignTabs]);
         if (nextActiveId !== activeTabId) {
           setActiveTabId(nextActiveId);
@@ -2490,10 +4966,10 @@ var TabbedTerminalPanelInner = ({
       });
     }
   }, [activeTabId, sessionIds, actions, onTabsChange, isForeignTab, ownedTabs, foreignTabs]);
-  const handleSessionCreated = useCallback3((tabId, sessionId) => {
+  const handleSessionCreated = useCallback5((tabId, sessionId) => {
     setSessionIds((prev) => new Map(prev).set(tabId, sessionId));
   }, []);
-  const handleActivityStateChange = useCallback3((sessionId, isActive) => {
+  const handleActivityStateChange = useCallback5((sessionId, isActive) => {
     setActivityStates((prev) => {
       const next = new Map(prev);
       if (isActive) {
@@ -2524,7 +5000,7 @@ var TabbedTerminalPanelInner = ({
       }
     }
   });
-  const renderTabAccessory = useCallback3((tab) => {
+  const renderTabAccessory = useCallback5((tab) => {
     const tabSessionId = sessionIds.get(tab.id);
     const hasExternalWorkingState = tabSessionId ? workingStates?.[tabSessionId]?.isWorking : false;
     const hasInternalActivity = tabSessionId ? activityStates.get(tabSessionId) : false;
@@ -2536,8 +5012,8 @@ var TabbedTerminalPanelInner = ({
     return /* @__PURE__ */ jsxs6(Fragment2, {
       children: [
         /* @__PURE__ */ jsx7("button", {
-          onClick: (e) => {
-            e.stopPropagation();
+          onClick: (e2) => {
+            e2.stopPropagation();
             handleToggleScrollLock();
           },
           style: {
@@ -2553,11 +5029,11 @@ var TabbedTerminalPanelInner = ({
             color: scrollPosition.isScrollLocked ? theme.colors.success : theme.colors.warning,
             padding: 0
           },
-          onMouseEnter: (e) => {
-            e.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
+          onMouseEnter: (e2) => {
+            e2.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
           },
-          onMouseLeave: (e) => {
-            e.currentTarget.style.backgroundColor = "transparent";
+          onMouseLeave: (e2) => {
+            e2.currentTarget.style.backgroundColor = "transparent";
           },
           title: scrollPosition.isScrollLocked ? "Scroll locked" : "Scroll unlocked",
           children: scrollPosition.isScrollLocked ? /* @__PURE__ */ jsx7(Lock2, {
@@ -2585,6 +5061,112 @@ var TabbedTerminalPanelInner = ({
       ]
     });
   }, [activeTabId, scrollPositions, defaultScrollPosition, handleToggleScrollLock, theme, sessionIds, workingStates, activityStates]);
+  const renderTerminalWithAssociation = useCallback5((tab, isActive, sessionId, association) => {
+    const terminalContent = /* @__PURE__ */ jsx7(TerminalTabContent, {
+      ref: getRefCallback(tab.id),
+      tab,
+      sessionId,
+      isActive,
+      isVisible,
+      actions,
+      events,
+      terminalContext,
+      onSessionCreated: handleSessionCreated,
+      onScrollPositionChange: handleTabScrollPositionChange,
+      isForeign: tab.id.startsWith("tab-foreign-"),
+      defaultScrollLocked,
+      activityDetection,
+      activityTimeout,
+      autoShowBlinds,
+      onActivityStateChange: handleActivityStateChange
+    }, `terminal-${tab.id}`);
+    const secondaryContent = association && renderAssociatedContent ? renderAssociatedContent(association.associatedTabId, isActive) : /* @__PURE__ */ jsx7("div", {
+      style: {
+        height: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        color: theme.colors.textMuted,
+        fontSize: "13px",
+        backgroundColor: theme.colors.backgroundSecondary,
+        borderBottom: `1px solid ${theme.colors.border}`
+      },
+      children: "Drag a tab here to associate it with this terminal"
+    });
+    const headerConfig = association && getAssociatedHeader ? getAssociatedHeader(association.associatedTabId) : { title: "Drop zone", icon: "\uD83D\uDCCE" };
+    const hasAssociation = !!association;
+    return /* @__PURE__ */ jsx7(z, {
+      style: { height: "100%" },
+      primaryContent: terminalContent,
+      secondaryContent,
+      collapsedHeader: headerConfig,
+      collapsed: hasAssociation ? association.collapsed : false,
+      onCollapsedChange: hasAssociation ? (collapsed) => onAssociationCollapsedChange?.(tab.id, collapsed) : undefined,
+      ratio: hasAssociation ? association.ratio : 0.15,
+      onRatioChange: hasAssociation ? (ratio) => onAssociationRatioChange?.(tab.id, ratio) : undefined,
+      theme
+    });
+  }, [
+    getRefCallback,
+    isVisible,
+    actions,
+    events,
+    terminalContext,
+    handleSessionCreated,
+    handleTabScrollPositionChange,
+    defaultScrollLocked,
+    activityDetection,
+    activityTimeout,
+    autoShowBlinds,
+    handleActivityStateChange,
+    renderAssociatedContent,
+    getAssociatedHeader,
+    onAssociationCollapsedChange,
+    onAssociationRatioChange,
+    theme
+  ]);
+  const handleTabDrop = useCallback5((draggedTabId, targetTabId) => {
+    const draggedTab = tabs.find((t2) => t2.id === draggedTabId);
+    const targetTab = tabs.find((t2) => t2.id === targetTabId);
+    if (targetTab?.contentType === "terminal" && draggedTab?.contentType !== "terminal") {
+      onTabAssociate?.(targetTabId, draggedTabId);
+    }
+  }, [tabs, onTabAssociate]);
+  const canDropOnTab = useCallback5((draggedTabId, targetTabId) => {
+    const draggedTab = tabs.find((t2) => t2.id === draggedTabId);
+    const targetTab = tabs.find((t2) => t2.id === targetTabId);
+    return targetTab?.contentType === "terminal" && draggedTab?.contentType !== "terminal";
+  }, [tabs]);
+  const [isDragOverContent, setIsDragOverContent] = useState4(false);
+  const handleContentDragEnter = useCallback5((e2) => {
+    e2.preventDefault();
+    if (activeTabId) {
+      const activeTab = tabs.find((t2) => t2.id === activeTabId);
+      if (activeTab?.contentType === "terminal") {
+        setIsDragOverContent(true);
+      }
+    }
+  }, [activeTabId, tabs]);
+  const handleContentDragLeave = useCallback5((e2) => {
+    const relatedTarget = e2.relatedTarget;
+    if (!e2.currentTarget.contains(relatedTarget)) {
+      setIsDragOverContent(false);
+    }
+  }, []);
+  const handleContentDrop = useCallback5((e2) => {
+    e2.preventDefault();
+    e2.stopPropagation();
+    setIsDragOverContent(false);
+    const draggedTabId = e2.dataTransfer.getData("application/x-tab-association");
+    if (!draggedTabId || !activeTabId) {
+      return;
+    }
+    const draggedTab = tabs.find((t2) => t2.id === draggedTabId);
+    const activeTab = tabs.find((t2) => t2.id === activeTabId);
+    if (activeTab?.contentType === "terminal" && draggedTab?.contentType !== "terminal") {
+      onTabAssociate?.(activeTabId, draggedTabId);
+    }
+  }, [activeTabId, tabs, onTabAssociate]);
   return /* @__PURE__ */ jsxs6("div", {
     style: {
       display: "flex",
@@ -2615,14 +5197,14 @@ var TabbedTerminalPanelInner = ({
               cursor: "pointer",
               color: showAllTerminals ? theme.colors.primary : theme.colors.textSecondary
             },
-            onMouseEnter: (e) => {
+            onMouseEnter: (e2) => {
               if (!showAllTerminals) {
-                e.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
+                e2.currentTarget.style.backgroundColor = theme.colors.backgroundTertiary;
               }
             },
-            onMouseLeave: (e) => {
+            onMouseLeave: (e2) => {
               if (!showAllTerminals) {
-                e.currentTarget.style.backgroundColor = "transparent";
+                e2.currentTarget.style.backgroundColor = "transparent";
               }
             },
             title: showAllTerminals ? "Showing all terminals (click to filter by context)" : "Show all terminals",
@@ -2635,7 +5217,10 @@ var TabbedTerminalPanelInner = ({
           renderTabAccessory,
           renderTabIcon,
           renderTabLabel,
-          showKeyboardHints: false
+          showKeyboardHints: false,
+          enableDragAndDrop: enableTabAssociationDrag,
+          onTabDrop: handleTabDrop,
+          canDropOnTab
         })
       }),
       /* @__PURE__ */ jsxs6("div", {
@@ -2645,7 +5230,44 @@ var TabbedTerminalPanelInner = ({
           flexDirection: "column",
           overflow: "hidden",
           width: "100%",
-          minHeight: 0
+          minHeight: 0,
+          position: "relative",
+          outline: isDragOverContent ? `3px dashed ${theme.colors.primary}` : "none",
+          outlineOffset: "-3px"
+        },
+        onDragEnterCapture: (e2) => {
+          if (!enableTabAssociationDrag)
+            return;
+          if (!e2.dataTransfer.types.includes("application/x-tab-association"))
+            return;
+          e2.preventDefault();
+          e2.stopPropagation();
+          handleContentDragEnter(e2);
+        },
+        onDragOverCapture: (e2) => {
+          if (!enableTabAssociationDrag)
+            return;
+          if (!e2.dataTransfer.types.includes("application/x-tab-association"))
+            return;
+          e2.preventDefault();
+          e2.stopPropagation();
+          e2.dataTransfer.dropEffect = "move";
+        },
+        onDragLeaveCapture: (e2) => {
+          if (!enableTabAssociationDrag)
+            return;
+          if (!e2.dataTransfer.types.includes("application/x-tab-association"))
+            return;
+          handleContentDragLeave(e2);
+        },
+        onDropCapture: (e2) => {
+          if (!enableTabAssociationDrag)
+            return;
+          if (!e2.dataTransfer.types.includes("application/x-tab-association"))
+            return;
+          e2.preventDefault();
+          e2.stopPropagation();
+          handleContentDrop(e2);
         },
         children: [
           tabs.map((tab) => {
@@ -2654,23 +5276,15 @@ var TabbedTerminalPanelInner = ({
             if (renderTabContent) {
               const customContent = renderTabContent(tab, isActive, sessionId, width);
               if (customContent === null && tab.contentType === "terminal") {
-                return /* @__PURE__ */ jsx7(TerminalTabContent, {
-                  ref: getRefCallback(tab.id),
-                  tab,
-                  sessionId,
-                  isActive,
-                  isVisible,
-                  actions,
-                  events,
-                  terminalContext,
-                  onSessionCreated: handleSessionCreated,
-                  onScrollPositionChange: handleTabScrollPositionChange,
-                  isForeign: tab.id.startsWith("tab-foreign-"),
-                  defaultScrollLocked,
-                  activityDetection,
-                  activityTimeout,
-                  autoShowBlinds,
-                  onActivityStateChange: handleActivityStateChange
+                const association = associations?.[tab.id];
+                return /* @__PURE__ */ jsx7("div", {
+                  style: {
+                    display: isActive ? "flex" : "none",
+                    flexDirection: "column",
+                    height: "100%",
+                    width: "100%"
+                  },
+                  children: renderTerminalWithAssociation(tab, isActive, sessionId, association)
                 }, tab.id);
               }
               return /* @__PURE__ */ jsx7("div", {
@@ -2684,23 +5298,15 @@ var TabbedTerminalPanelInner = ({
               }, tab.id);
             }
             if (tab.contentType === "terminal") {
-              return /* @__PURE__ */ jsx7(TerminalTabContent, {
-                ref: getRefCallback(tab.id),
-                tab,
-                sessionId,
-                isActive,
-                isVisible,
-                actions,
-                events,
-                terminalContext,
-                onSessionCreated: handleSessionCreated,
-                onScrollPositionChange: handleTabScrollPositionChange,
-                isForeign: tab.id.startsWith("tab-foreign-"),
-                defaultScrollLocked,
-                activityDetection,
-                activityTimeout,
-                autoShowBlinds,
-                onActivityStateChange: handleActivityStateChange
+              const association = associations?.[tab.id];
+              return /* @__PURE__ */ jsx7("div", {
+                style: {
+                  display: isActive ? "flex" : "none",
+                  flexDirection: "column",
+                  height: "100%",
+                  width: "100%"
+                },
+                children: renderTerminalWithAssociation(tab, isActive, sessionId, association)
               }, tab.id);
             }
             return /* @__PURE__ */ jsxs6("div", {
@@ -2739,10 +5345,6 @@ var TabbedTerminalPanelInner = ({
                 size: 32,
                 style: { opacity: 0.5, marginBottom: "16px" }
               }),
-              /* @__PURE__ */ jsx7("p", {
-                style: { fontFamily: theme.fonts.body, fontSize: theme.fontSizes[1] },
-                children: "No terminal sessions"
-              }),
               /* @__PURE__ */ jsx7("button", {
                 onClick: () => addNewTab(),
                 style: {
@@ -2766,7 +5368,7 @@ var TabbedTerminalPanelInner = ({
   });
 };
 TabbedTerminalPanelInner.displayName = "TabbedTerminalPanelInner";
-var TabbedTerminalPanelMemoized = React2.memo(TabbedTerminalPanelInner, (prevProps, nextProps) => {
+var TabbedTerminalPanelMemoized = React3.memo(TabbedTerminalPanelInner, (prevProps, nextProps) => {
   const changes = [];
   if (prevProps.terminalContext !== nextProps.terminalContext)
     changes.push("terminalContext");
@@ -2808,19 +5410,17 @@ var TabbedTerminalPanelMemoized = React2.memo(TabbedTerminalPanelInner, (prevPro
     changes.push("activityTimeout");
   if (prevProps.autoShowBlinds !== nextProps.autoShowBlinds)
     changes.push("autoShowBlinds");
+  if (prevProps.associations !== nextProps.associations)
+    changes.push("associations");
+  if (prevProps.renderAssociatedContent !== nextProps.renderAssociatedContent)
+    changes.push("renderAssociatedContent");
+  if (prevProps.getAssociatedHeader !== nextProps.getAssociatedHeader)
+    changes.push("getAssociatedHeader");
   const ignoredChanges = [];
   if (prevProps.context !== nextProps.context)
     ignoredChanges.push("context");
   if (prevProps.events !== nextProps.events)
     ignoredChanges.push("events");
-  console.log("[TabbedTerminalPanel] MEMO check", {
-    willRerender: changes.length > 0,
-    propsChanged: changes.length > 0 ? changes : "none",
-    ignoredPropsChanged: ignoredChanges.length > 0 ? ignoredChanges : "none"
-  });
-  if (changes.length > 0) {
-    console.log("[TabbedTerminalPanel] MEMO - will re-render, props changed:", changes);
-  }
   return changes.length === 0;
 });
 TabbedTerminalPanelMemoized.displayName = "TabbedTerminalPanel";