@inf-monkeys-tech/monkeys-design 0.4.32 → 0.4.33

package/dist/index.js

@@ -4,6 +4,7 @@ var React = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var ContextMenu = require('@radix-ui/react-context-menu');
 var DropdownMenu3 = require('@radix-ui/react-dropdown-menu');
+var core = require('@dnd-kit/core');
 var Tooltip = require('@radix-ui/react-tooltip');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -4548,7 +4549,7 @@ var require_lodash = __commonJS({
         function valuesIn(object) {
           return object == null ? [] : baseValues(object, keysIn(object));
         }
-        function clamp4(number, lower, upper) {
+        function clamp5(number, lower, upper) {
           if (upper === undefined2) {
             upper = lower;
             lower = undefined2;
@@ -5225,7 +5226,7 @@ var require_lodash = __commonJS({
         lodash.camelCase = camelCase;
         lodash.capitalize = capitalize;
         lodash.ceil = ceil;
-        lodash.clamp = clamp4;
+        lodash.clamp = clamp5;
         lodash.clone = clone;
         lodash.cloneDeep = cloneDeep;
         lodash.cloneDeepWith = cloneDeepWith;
@@ -8580,7 +8581,41 @@ var baseSlots = {
   tableEmptyActions: "mt-4 flex flex-wrap items-center justify-center gap-2",
   tableLoadingRow: "border-b border-border/60",
   tableLoadingCell: "px-3 py-2",
-  tableLoadingSkeleton: "h-4 w-full rounded-md bg-muted/70"
+  tableLoadingSkeleton: "h-4 w-full rounded-md bg-muted/70",
+  layoutRoot: cn(
+    "grid min-w-0 overflow-hidden grid-rows-[auto_minmax(0,1fr)_auto] gap-3 rounded-lg border border-border/70 bg-background p-3 text-foreground",
+    motionBase
+  ),
+  layoutRootFull: "h-full min-h-0",
+  layoutHeader: "min-w-0",
+  layoutBody: "grid min-h-0 min-w-0 overflow-hidden gap-3",
+  layoutSidebar: "min-h-0 min-w-0 overflow-hidden",
+  layoutMain: "min-h-0 min-w-0 overflow-hidden",
+  layoutAside: "min-h-0 min-w-0 overflow-hidden",
+  layoutFooter: "min-w-0",
+  layoutPane: cn(
+    "h-full max-h-full min-h-0 min-w-0 overflow-hidden rounded-lg bg-background text-foreground",
+    motionBase
+  ),
+  layoutPaneScrollable: "overflow-auto",
+  layoutPaneBordered: "border border-border/70",
+  layoutPaneMuted: "bg-muted/25",
+  layoutPaneSoft: "bg-background/95 shadow-sm",
+  layoutPaneTransparent: "bg-transparent shadow-none",
+  layoutSplitRoot: "grid min-h-0 min-w-0 overflow-hidden",
+  layoutSplitHorizontal: "grid-flow-col",
+  layoutSplitVertical: "grid-flow-row",
+  layoutSplitPane: "min-h-0 min-w-0 overflow-hidden",
+  layoutSplitPrimary: "",
+  layoutSplitSecondary: "",
+  layoutResizeHandle: cn(
+    "group/resize relative z-10 flex shrink-0 items-center justify-center bg-transparent text-muted-foreground hover:bg-border/60 active:bg-border/70 focus-visible:bg-border/60 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/30",
+    motionInteractive
+  ),
+  layoutResizeHandleHorizontal: "w-2 cursor-col-resize",
+  layoutResizeHandleVertical: "h-2 cursor-row-resize",
+  layoutResizeHandleDisabled: "cursor-default opacity-60",
+  layoutResizeHandleIndicator: "rounded-full bg-muted-foreground/45 group-hover/resize:bg-primary/70"
 };
 var densitySlots = {
   compact: {
@@ -8654,7 +8689,12 @@ var densitySlots = {
     tableCell: "px-2 py-1.5 text-xs",
     tableHeadLabel: "text-[11px]",
     tableHeadDescription: "text-[10px] leading-3",
-    tableLoadingCell: "px-2 py-1.5"
+    tableLoadingCell: "px-2 py-1.5",
+    layoutRoot: "gap-2 p-2",
+    layoutBody: "gap-2",
+    layoutPane: "rounded-md text-xs",
+    layoutResizeHandleHorizontal: "w-1.5",
+    layoutResizeHandleVertical: "h-1.5"
   },
   default: {
     buttonBase: "h-9"
@@ -8705,7 +8745,12 @@ var densitySlots = {
     menuSubTrigger: "min-h-9 px-3 py-2",
     tableHead: "h-12 px-4 py-3",
     tableCell: "px-4 py-3",
-    tableLoadingCell: "px-4 py-3"
+    tableLoadingCell: "px-4 py-3",
+    layoutRoot: "gap-4 p-4",
+    layoutBody: "gap-4",
+    layoutPane: "rounded-xl",
+    layoutResizeHandleHorizontal: "w-2.5",
+    layoutResizeHandleVertical: "h-2.5"
   }
 };
 var radiusSlots = {
@@ -8749,7 +8794,9 @@ var radiusSlots = {
     menuSubContent: "rounded-none",
     tableContainer: "rounded-none",
     tableEmptyIcon: "rounded-none",
-    tableLoadingSkeleton: "rounded-none"
+    tableLoadingSkeleton: "rounded-none",
+    layoutRoot: "rounded-none",
+    layoutPane: "rounded-none"
   },
   sm: {
     buttonBase: "rounded-sm",
@@ -8791,7 +8838,9 @@ var radiusSlots = {
     menuSubContent: "rounded-sm",
     tableContainer: "rounded-sm",
     tableEmptyIcon: "rounded-sm",
-    tableLoadingSkeleton: "rounded-sm"
+    tableLoadingSkeleton: "rounded-sm",
+    layoutRoot: "rounded-sm",
+    layoutPane: "rounded-sm"
   },
   md: {},
   lg: {
@@ -8828,7 +8877,9 @@ var radiusSlots = {
     menuSubContent: "rounded-lg",
     tableContainer: "rounded-xl",
     tableEmptyIcon: "rounded-xl",
-    tableLoadingSkeleton: "rounded-lg"
+    tableLoadingSkeleton: "rounded-lg",
+    layoutRoot: "rounded-xl",
+    layoutPane: "rounded-xl"
   },
   xl: {
     buttonBase: "rounded-xl",
@@ -8866,7 +8917,9 @@ var radiusSlots = {
     menuSubContent: "rounded-xl",
     tableContainer: "rounded-2xl",
     tableEmptyIcon: "rounded-2xl",
-    tableLoadingSkeleton: "rounded-xl"
+    tableLoadingSkeleton: "rounded-xl",
+    layoutRoot: "rounded-2xl",
+    layoutPane: "rounded-2xl"
   },
   full: {
     buttonBase: "rounded-full",
@@ -8908,7 +8961,9 @@ var radiusSlots = {
     menuSubContent: "rounded-2xl",
     tableContainer: "rounded-2xl",
     tableEmptyIcon: "rounded-full",
-    tableLoadingSkeleton: "rounded-full"
+    tableLoadingSkeleton: "rounded-full",
+    layoutRoot: "rounded-2xl",
+    layoutPane: "rounded-2xl"
   }
 };
 var borderSlots = {
@@ -8950,7 +9005,10 @@ var borderSlots = {
     tableFooterBarAttached: "border-t border-transparent",
     tableRow: "border-transparent",
     tableEmptyRow: "border-transparent",
-    tableLoadingRow: "border-transparent"
+    tableLoadingRow: "border-transparent",
+    layoutRoot: "border-transparent",
+    layoutPaneBordered: "border-transparent",
+    layoutResizeHandle: "bg-transparent hover:bg-transparent active:bg-transparent focus-visible:bg-transparent"
   },
   subtle: {
     buttonDefault: "border-border/60",
@@ -8990,7 +9048,9 @@ var borderSlots = {
     tableFooterBarAttached: "border-t border-border/60",
     tableRow: "border-border/50",
     tableEmptyRow: "border-border/50",
-    tableLoadingRow: "border-border/50"
+    tableLoadingRow: "border-border/50",
+    layoutRoot: "border-border/60",
+    layoutPaneBordered: "border-border/60"
   },
   solid: {},
   strong: {
@@ -9031,7 +9091,10 @@ var borderSlots = {
     tableFooterBarAttached: "border-t border-foreground/20",
     tableRow: "border-foreground/15",
     tableEmptyRow: "border-foreground/15",
-    tableLoadingRow: "border-foreground/15"
+    tableLoadingRow: "border-foreground/15",
+    layoutRoot: "border-foreground/20",
+    layoutPaneBordered: "border-foreground/20",
+    layoutResizeHandle: "hover:bg-foreground/15 active:bg-foreground/20 focus-visible:bg-foreground/15"
   }
 };
 var backgroundSlots = {
@@ -9073,7 +9136,11 @@ var backgroundSlots = {
     tableFooter: "bg-muted/35",
     tableFooterBar: "bg-muted/30 shadow-none",
     tableRowInteractive: "cursor-pointer hover:bg-muted/45",
-    tableLoadingSkeleton: "bg-muted"
+    tableLoadingSkeleton: "bg-muted",
+    layoutRoot: "bg-card",
+    layoutPane: "bg-card",
+    layoutPaneMuted: "bg-muted/35",
+    layoutResizeHandle: "hover:bg-border/70 active:bg-border/80 focus-visible:bg-border/70"
   },
   soft: {
     buttonDefault: "bg-muted/30 hover:bg-muted/55",
@@ -9109,7 +9176,10 @@ var backgroundSlots = {
     tableFooter: "bg-muted/25",
     tableFooterBar: "bg-muted/25 shadow-none",
     tableRowInteractive: "cursor-pointer hover:bg-muted/35",
-    tableLoadingSkeleton: "bg-muted/65"
+    tableLoadingSkeleton: "bg-muted/65",
+    layoutRoot: "bg-background/95 shadow-sm",
+    layoutPane: "bg-background/95 shadow-sm",
+    layoutPaneSoft: "bg-background/95 shadow-md"
   },
   glass: {
     buttonBase: "backdrop-blur-md",
@@ -9170,7 +9240,13 @@ var backgroundSlots = {
     tableRow: "border-white/10",
     tableRowInteractive: "cursor-pointer hover:bg-white/[0.08]",
     tableHeadLabel: "text-foreground",
-    tableLoadingSkeleton: "bg-white/[0.16]"
+    tableLoadingSkeleton: "bg-white/[0.16]",
+    layoutRoot: "border-white/10 bg-white/[0.05] shadow-none backdrop-blur-md",
+    layoutPane: "border-white/10 bg-white/[0.06] shadow-none backdrop-blur-md",
+    layoutPaneMuted: "bg-white/[0.08]",
+    layoutPaneSoft: "bg-white/[0.10] shadow-none backdrop-blur-md",
+    layoutResizeHandle: "text-foreground/65 hover:bg-white/10 active:bg-white/15 focus-visible:bg-white/10",
+    layoutResizeHandleIndicator: "bg-white/45 group-hover/resize:bg-white/75"
   },
   dark: {
     buttonBase: "border-white/15 text-white shadow-lg backdrop-blur",
@@ -9299,7 +9375,13 @@ var backgroundSlots = {
     menuSubTrigger: "text-white focus:bg-white/[0.10] focus:text-white data-[highlighted]:bg-white/[0.10] data-[highlighted]:text-white data-[state=open]:bg-white/[0.12]",
     menuSubTriggerIcon: "text-white/55",
     menuSubContent: "border-white/10 bg-slate-950 text-white shadow-2xl",
-    tableLoadingSkeleton: "bg-white/[0.14]"
+    tableLoadingSkeleton: "bg-white/[0.14]",
+    layoutRoot: "border-white/10 bg-slate-950 text-white shadow-none",
+    layoutPane: "border-white/10 bg-slate-950 text-white shadow-none",
+    layoutPaneMuted: "bg-white/[0.06]",
+    layoutPaneSoft: "bg-white/[0.08] shadow-none",
+    layoutResizeHandle: "text-white/65 hover:bg-white/10 active:bg-white/15 focus-visible:bg-white/10",
+    layoutResizeHandleIndicator: "bg-white/45 group-hover/resize:bg-white/75"
   }
 };
 var presetDefaults = {
@@ -11157,6 +11239,432 @@ var BaseInput = React.forwardRef(
     );
   }
 );
+var DEFAULT_SPLIT_SIZE = 50;
+var DEFAULT_MIN_SIZE = 20;
+var DEFAULT_MAX_SIZE = 80;
+var DEFAULT_KEYBOARD_STEP = 2.5;
+function toCssSize(value, fallback) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error("BaseLayout size and gap props must be finite, non-negative numbers.");
+    }
+    return `${value}px`;
+  }
+  return value ?? fallback;
+}
+function assertPercent(name, value) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`BaseLayoutSplit ${name} must be a finite number.`);
+  }
+  if (value < 0 || value > 100) {
+    throw new Error(`BaseLayoutSplit ${name} must be between 0 and 100.`);
+  }
+  return value;
+}
+function clamp(value, min5, max5) {
+  return Math.min(Math.max(value, min5), max5);
+}
+function resolveSplitBounds({
+  minSize = DEFAULT_MIN_SIZE,
+  maxSize = DEFAULT_MAX_SIZE,
+  keyboardStep = DEFAULT_KEYBOARD_STEP
+}) {
+  const min5 = assertPercent("minSize", minSize);
+  const max5 = assertPercent("maxSize", maxSize);
+  if (min5 > max5) {
+    throw new Error("BaseLayoutSplit minSize cannot be greater than maxSize.");
+  }
+  if (!Number.isFinite(keyboardStep) || keyboardStep <= 0) {
+    throw new Error("BaseLayoutSplit keyboardStep must be a finite positive number.");
+  }
+  return { min: min5, max: max5, keyboardStep };
+}
+function resolveSplitSize(name, value, fallback, min5, max5) {
+  return clamp(assertPercent(name, value ?? fallback), min5, max5);
+}
+function getSeparatorOrientation(orientation) {
+  return orientation === "horizontal" ? "vertical" : "horizontal";
+}
+function BaseLayout({
+  header,
+  sidebar,
+  aside,
+  footer,
+  children,
+  sidebarSize,
+  asideSize,
+  gap,
+  fullHeight,
+  appearance,
+  className,
+  classNames,
+  style,
+  ...layoutProps
+}) {
+  const theme = resolveBaseAppearance(appearance);
+  const hasHeader = hasRenderableNode(header);
+  const hasSidebar = hasRenderableNode(sidebar);
+  const hasAside = hasRenderableNode(aside);
+  const hasFooter = hasRenderableNode(footer);
+  const bodyColumns = [
+    hasSidebar ? "var(--base-layout-sidebar-size)" : void 0,
+    "minmax(0, 1fr)",
+    hasAside ? "var(--base-layout-aside-size)" : void 0
+  ].filter(Boolean).join(" ");
+  const layoutRows = [
+    hasHeader ? "auto" : void 0,
+    "minmax(0, 1fr)",
+    hasFooter ? "auto" : void 0
+  ].filter(Boolean).join(" ");
+  const resolvedGap = gap !== void 0 ? toCssSize(gap, "0px") : void 0;
+  const layoutStyle = {
+    ...theme.styles.layout,
+    "--base-layout-sidebar-size": toCssSize(sidebarSize, "16rem"),
+    "--base-layout-aside-size": toCssSize(asideSize, "20rem"),
+    gridTemplateRows: layoutRows,
+    ...resolvedGap !== void 0 ? { gap: resolvedGap } : {},
+    ...style
+  };
+  const bodyStyle = {
+    ...theme.styles.layoutBody,
+    gridTemplateColumns: bodyColumns,
+    ...resolvedGap !== void 0 ? { gap: resolvedGap } : {}
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ...layoutProps,
+      className: cn(
+        theme.slots.layoutRoot,
+        fullHeight && theme.slots.layoutRootFull,
+        classNames?.root,
+        className
+      ),
+      style: layoutStyle,
+      children: [
+        hasHeader ? /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: cn(theme.slots.layoutHeader, classNames?.header),
+            style: theme.styles.layoutHeader,
+            children: header
+          }
+        ) : null,
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: cn(theme.slots.layoutBody, classNames?.body),
+            style: bodyStyle,
+            children: [
+              hasSidebar ? /* @__PURE__ */ jsxRuntime.jsx(
+                "aside",
+                {
+                  className: cn(theme.slots.layoutSidebar, classNames?.sidebar),
+                  style: theme.styles.layoutSidebar,
+                  children: sidebar
+                }
+              ) : null,
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "main",
+                {
+                  className: cn(theme.slots.layoutMain, classNames?.main),
+                  style: theme.styles.layoutMain,
+                  children
+                }
+              ),
+              hasAside ? /* @__PURE__ */ jsxRuntime.jsx(
+                "aside",
+                {
+                  className: cn(theme.slots.layoutAside, classNames?.aside),
+                  style: theme.styles.layoutAside,
+                  children: aside
+                }
+              ) : null
+            ]
+          }
+        ),
+        hasFooter ? /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: cn(theme.slots.layoutFooter, classNames?.footer),
+            style: theme.styles.layoutFooter,
+            children: footer
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function BaseLayoutPane({
+  as = "div",
+  scrollable = false,
+  bordered = true,
+  surface = "default",
+  children,
+  appearance,
+  className,
+  classNames,
+  style,
+  ...paneProps
+}) {
+  const theme = resolveBaseAppearance(appearance);
+  const Component = as;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Component,
+    {
+      ...paneProps,
+      className: cn(
+        theme.slots.layoutPane,
+        scrollable && theme.slots.layoutPaneScrollable,
+        bordered && theme.slots.layoutPaneBordered,
+        surface === "muted" && theme.slots.layoutPaneMuted,
+        surface === "soft" && theme.slots.layoutPaneSoft,
+        surface === "transparent" && theme.slots.layoutPaneTransparent,
+        classNames?.root,
+        className
+      ),
+      style: {
+        ...theme.styles.layoutPane,
+        ...style
+      },
+      children
+    }
+  );
+}
+function BaseLayoutResizeHandle({
+  orientation = "horizontal",
+  resizable = false,
+  disabled = false,
+  size,
+  minSize,
+  maxSize,
+  label = "Resize panels",
+  appearance,
+  className,
+  classNames,
+  style,
+  tabIndex,
+  ...handleProps
+}) {
+  const theme = resolveBaseAppearance(appearance);
+  const interactive = resizable && !disabled;
+  const separatorOrientation = getSeparatorOrientation(orientation);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ...handleProps,
+      role: interactive ? "separator" : void 0,
+      "aria-label": interactive ? label : void 0,
+      "aria-orientation": interactive ? separatorOrientation : void 0,
+      "aria-valuemin": interactive ? minSize : void 0,
+      "aria-valuemax": interactive ? maxSize : void 0,
+      "aria-valuenow": interactive ? size : void 0,
+      "aria-disabled": interactive ? void 0 : true,
+      tabIndex: interactive ? tabIndex ?? 0 : void 0,
+      className: cn(
+        theme.slots.layoutResizeHandle,
+        orientation === "horizontal" ? theme.slots.layoutResizeHandleHorizontal : theme.slots.layoutResizeHandleVertical,
+        !interactive && theme.slots.layoutResizeHandleDisabled,
+        classNames?.root,
+        className
+      ),
+      style: {
+        ...theme.styles.layoutResizeHandle,
+        ...style
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          "aria-hidden": "true",
+          className: cn(
+            theme.slots.layoutResizeHandleIndicator,
+            orientation === "horizontal" ? "h-8 w-px" : "h-px w-8",
+            classNames?.indicator
+          )
+        }
+      )
+    }
+  );
+}
+function BaseLayoutSplit({
+  orientation = "horizontal",
+  primary,
+  secondary,
+  children,
+  resizable = false,
+  size,
+  defaultSize,
+  minSize,
+  maxSize,
+  gap,
+  keyboardStep,
+  resizeLabel,
+  appearance,
+  className,
+  classNames,
+  style,
+  onSizeChange,
+  ...splitProps
+}) {
+  const theme = resolveBaseAppearance(appearance);
+  const bounds = resolveSplitBounds({ minSize, maxSize, keyboardStep });
+  const initialSize = resolveSplitSize(
+    "defaultSize",
+    defaultSize,
+    DEFAULT_SPLIT_SIZE,
+    bounds.min,
+    bounds.max
+  );
+  const [uncontrolledSize, setUncontrolledSize] = React.useState(initialSize);
+  const rootRef = React.useRef(null);
+  const cleanupRef = React.useRef(null);
+  const controlled = size !== void 0;
+  const renderedSize = resolveSplitSize(
+    "size",
+    controlled ? size : uncontrolledSize,
+    initialSize,
+    bounds.min,
+    bounds.max
+  );
+  const commitSize = React.useCallback(
+    (nextSize) => {
+      const clampedSize = clamp(nextSize, bounds.min, bounds.max);
+      if (!controlled) {
+        setUncontrolledSize(clampedSize);
+      }
+      onSizeChange?.(clampedSize);
+    },
+    [bounds.max, bounds.min, controlled, onSizeChange]
+  );
+  const updateFromPointer = React.useCallback(
+    (event) => {
+      const root = rootRef.current;
+      if (!root) return;
+      const rect = root.getBoundingClientRect();
+      const total = orientation === "horizontal" ? rect.width : rect.height;
+      if (total <= 0) return;
+      const offset = orientation === "horizontal" ? event.clientX - rect.left : event.clientY - rect.top;
+      commitSize(offset / total * 100);
+    },
+    [commitSize, orientation]
+  );
+  const stopResize = React.useCallback(() => {
+    cleanupRef.current?.();
+    cleanupRef.current = null;
+  }, []);
+  React.useEffect(() => stopResize, [stopResize]);
+  const handlePointerDown = (event) => {
+    if (!resizable) return;
+    event.preventDefault();
+    stopResize();
+    updateFromPointer(event);
+    const handleMove = (nextEvent) => {
+      updateFromPointer(nextEvent);
+    };
+    const handleStop = () => {
+      stopResize();
+    };
+    window.addEventListener("pointermove", handleMove);
+    window.addEventListener("pointerup", handleStop, { once: true });
+    window.addEventListener("pointercancel", handleStop, { once: true });
+    cleanupRef.current = () => {
+      window.removeEventListener("pointermove", handleMove);
+      window.removeEventListener("pointerup", handleStop);
+      window.removeEventListener("pointercancel", handleStop);
+    };
+  };
+  const handleKeyDown = (event) => {
+    if (!resizable) return;
+    const step = event.shiftKey ? bounds.keyboardStep * 4 : bounds.keyboardStep;
+    let nextSize;
+    if (event.key === "Home") nextSize = bounds.min;
+    if (event.key === "End") nextSize = bounds.max;
+    if (orientation === "horizontal" && event.key === "ArrowLeft") {
+      nextSize = renderedSize - step;
+    }
+    if (orientation === "horizontal" && event.key === "ArrowRight") {
+      nextSize = renderedSize + step;
+    }
+    if (orientation === "vertical" && event.key === "ArrowUp") {
+      nextSize = renderedSize - step;
+    }
+    if (orientation === "vertical" && event.key === "ArrowDown") {
+      nextSize = renderedSize + step;
+    }
+    if (nextSize === void 0) return;
+    event.preventDefault();
+    commitSize(nextSize);
+  };
+  const resolvedGap = gap !== void 0 ? toCssSize(gap, "0px") : void 0;
+  const resizeTrack = resolvedGap !== void 0 ? "var(--base-layout-split-gap)" : "auto";
+  const resizeHandleStyle = resolvedGap !== void 0 ? orientation === "horizontal" ? { width: "var(--base-layout-split-gap)" } : { height: "var(--base-layout-split-gap)" } : void 0;
+  const splitStyle = {
+    ...theme.styles.layoutSplit,
+    [orientation === "horizontal" ? "gridTemplateColumns" : "gridTemplateRows"]: resizable ? `${renderedSize}% ${resizeTrack} minmax(0, 1fr)` : `${renderedSize}% minmax(0, 1fr)`,
+    ...resizable ? { gap: 0 } : {},
+    ...resolvedGap !== void 0 ? {
+      "--base-layout-split-gap": resolvedGap,
+      ...resizable ? {} : { gap: resolvedGap }
+    } : {},
+    ...style
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ...splitProps,
+      ref: rootRef,
+      className: cn(
+        theme.slots.layoutSplitRoot,
+        orientation === "horizontal" ? theme.slots.layoutSplitHorizontal : theme.slots.layoutSplitVertical,
+        classNames?.root,
+        className
+      ),
+      style: splitStyle,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: cn(
+              theme.slots.layoutSplitPane,
+              theme.slots.layoutSplitPrimary,
+              classNames?.primary
+            ),
+            style: theme.styles.layoutSplitPane,
+            children: hasRenderableNode(primary) ? primary : children
+          }
+        ),
+        resizable ? /* @__PURE__ */ jsxRuntime.jsx(
+          BaseLayoutResizeHandle,
+          {
+            orientation,
+            resizable: true,
+            size: renderedSize,
+            minSize: bounds.min,
+            maxSize: bounds.max,
+            label: resizeLabel,
+            appearance,
+            className: classNames?.handle,
+            style: resizeHandleStyle,
+            onPointerDown: handlePointerDown,
+            onKeyDown: handleKeyDown
+          }
+        ) : null,
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: cn(
+              theme.slots.layoutSplitPane,
+              theme.slots.layoutSplitSecondary,
+              classNames?.secondary
+            ),
+            style: theme.styles.layoutSplitPane,
+            children: secondary
+          }
+        )
+      ]
+    }
+  );
+}
 function DefaultLoadingIcon({ className }) {
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "svg",
@@ -11446,7 +11954,7 @@ function BasePagination({
 function toFiniteNumber(value, fallback) {
   return Number.isFinite(value) ? Number(value) : fallback;
 }
-function clamp(value, min5, max5) {
+function clamp2(value, min5, max5) {
   return Math.min(Math.max(value, min5), max5);
 }
 function BaseProgress({
@@ -11464,7 +11972,7 @@ function BaseProgress({
 }) {
   const theme = resolveBaseAppearance(appearance);
   const safeMax = Math.max(toFiniteNumber(max5, 100), 1);
-  const safeValue = clamp(toFiniteNumber(value, 0), 0, safeMax);
+  const safeValue = clamp2(toFiniteNumber(value, 0), 0, safeMax);
   const percent = safeValue / safeMax * 100;
   const renderedValue = valueFormatter?.(safeValue, safeMax) ?? `${Math.round(percent)}%`;
   const hasLabelRow = hasRenderableNode(label) || showValue;
@@ -12230,7 +12738,7 @@ function useBaseTableContext(appearance) {
     }
   };
 }
-function toCssSize(value) {
+function toCssSize2(value) {
   if (value === void 0) return void 0;
   return typeof value === "number" ? `${value}px` : value;
 }
@@ -12443,7 +12951,7 @@ function BaseTableRow({
     }
   );
 }
-function BaseTableHead({
+var BaseTableHead = React.forwardRef(function BaseTableHead2({
   columnId,
   align = "left",
   icon,
@@ -12471,10 +12979,18 @@ function BaseTableHead({
   onDragOver,
   onDrop,
   ...headProps
-}) {
+}, forwardedRef) {
   const tableContext = useBaseTableContext(appearance);
   const { theme } = tableContext;
   const headRef = React.useRef(null);
+  const setHeadRef = (node) => {
+    headRef.current = node;
+    if (typeof forwardedRef === "function") {
+      forwardedRef(node);
+    } else if (forwardedRef) {
+      forwardedRef.current = node;
+    }
+  };
   const controlledWidth = columnId && tableContext.columnSizes?.[columnId] !== void 0 ? tableContext.columnSizes[columnId] : width;
   const canDrag = Boolean(
     columnId && draggable !== false && (draggable || tableContext.columnDragEnabled) && tableContext.columnOrder && tableContext.onColumnOrderChange
@@ -12629,7 +13145,7 @@ function BaseTableHead({
     "th",
     {
       ...headProps,
-      ref: headRef,
+      ref: setHeadRef,
       scope: headProps.scope ?? "col",
       "aria-sort": ariaSort,
       className: cn(
@@ -12641,9 +13157,9 @@ function BaseTableHead({
       ),
       style: {
         ...theme.styles.tableHead,
-        width: toCssSize(controlledWidth),
-        minWidth: toCssSize(minWidth),
-        maxWidth: toCssSize(maxWidth),
+        width: toCssSize2(controlledWidth),
+        minWidth: toCssSize2(minWidth),
+        maxWidth: toCssSize2(maxWidth),
         ...style
       },
       onDragOver: handleDragOver,
@@ -12664,7 +13180,7 @@ function BaseTableHead({
       ]
     }
   );
-}
+});
 function BaseTableCell({
   align = "left",
   appearance,
@@ -12792,7 +13308,7 @@ function BaseTableLoading({
                 classNames?.skeleton
               ),
               style: {
-                width: toCssSize(columnWidths[columnIndex])
+                width: toCssSize2(columnWidths[columnIndex])
               }
             }
           )
@@ -15807,7 +16323,7 @@ var DEFAULT_ZOOM_STEP = 1.18;
 var DEFAULT_STAGE_PADDING = 16;
 var MAX_SAFE_SCALE = 1e6;
 var MIN_SAFE_SCALE = 1e-6;
-var clamp2 = (value, min5, max5) => Math.min(max5, Math.max(min5, value));
+var clamp3 = (value, min5, max5) => Math.min(max5, Math.max(min5, value));
 var isNoDragTarget = (target) => target instanceof Element && Boolean(target.closest('[data-no-drag="true"]'));
 function ResetIcon() {
   return /* @__PURE__ */ jsxRuntime.jsxs(
@@ -15931,7 +16447,7 @@ function DataExplorerImagePreview({
         availableWidth / size.width,
         availableHeight / size.height
       );
-      const nextScale = clamp2(
+      const nextScale = clamp3(
         fitScale,
         normalizedMinScale,
         normalizedMaxScale
@@ -15985,7 +16501,7 @@ function DataExplorerImagePreview({
       if (!Number.isFinite(factor) || factor === 1) return;
       if (!Number.isFinite(stageX) || !Number.isFinite(stageY)) return;
       setView((current) => {
-        const nextScale = clamp2(
+        const nextScale = clamp3(
           current.scale * factor,
           normalizedMinScale,
           normalizedMaxScale
@@ -21326,7 +21842,7 @@ function getWorkbenchIconComponent(icon) {
   if (!icon || !isWorkbenchIconComponent(icon)) return null;
   return icon;
 }
-function toCssSize2(value) {
+function toCssSize3(value) {
   if (value === void 0) return void 0;
   return typeof value === "number" ? `${value}px` : value;
 }
@@ -21475,7 +21991,7 @@ function WorkbenchTableView({
           "div",
           {
             className: cn("w-full overflow-auto", classNames?.scrollArea),
-            style: { maxHeight: toCssSize2(bodyMaxHeight) },
+            style: { maxHeight: toCssSize3(bodyMaxHeight) },
             children: /* @__PURE__ */ jsxRuntime.jsxs(
               BaseTable,
               {
@@ -21621,6 +22137,659 @@ function WorkbenchTableView({
     }
   );
 }
+function toCssSize4(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" ? `${value}px` : value;
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function defaultGetRowKey2(row, rowIndex) {
+  return row?.id ?? row?.key ?? rowIndex;
+}
+function getColumnDefaultSize(column) {
+  if (typeof column.width === "number") return column.width;
+  if (typeof column.minWidth === "number") return column.minWidth;
+  return 160;
+}
+function buildDefaultColumnSizes(columns, explicit) {
+  return columns.reduce((acc, column) => {
+    acc[column.key] = explicit?.[column.key] ?? getColumnDefaultSize(column);
+    return acc;
+  }, {});
+}
+function loadStoredColumnSizes(storageKey, defaults) {
+  if (!storageKey || !isBrowser()) return defaults;
+  try {
+    const parsed = JSON.parse(window.localStorage.getItem(storageKey) || "{}");
+    return Object.keys(defaults).reduce((acc, key) => {
+      const value = Number(parsed?.[key]);
+      acc[key] = Number.isFinite(value) ? value : defaults[key];
+      return acc;
+    }, {});
+  } catch {
+    return defaults;
+  }
+}
+function persistColumnSizes(storageKey, sizes) {
+  if (!storageKey || !isBrowser()) return;
+  window.localStorage.setItem(storageKey, JSON.stringify(sizes));
+}
+function getFrozenColumnStorageKey(storageKey) {
+  return storageKey ? `${storageKey}.frozenColumnCount` : void 0;
+}
+function getFrozenEndColumnStorageKey(storageKey) {
+  return storageKey ? `${storageKey}.frozenEndColumnCount` : void 0;
+}
+function clampFrozenColumnCount(count, columnCount) {
+  if (!Number.isFinite(count)) return 0;
+  return Math.max(0, Math.min(Math.round(count), columnCount));
+}
+function normalizeFrozenColumnCounts(startCount, endCount, columnCount) {
+  const normalizedStartCount = clampFrozenColumnCount(startCount, columnCount);
+  const normalizedEndCount = clampFrozenColumnCount(endCount, Math.max(0, columnCount - normalizedStartCount));
+  return {
+    startCount: normalizedStartCount,
+    endCount: normalizedEndCount
+  };
+}
+function loadStoredFrozenColumnCount(storageKey, defaultCount, columnCount) {
+  const fallback = clampFrozenColumnCount(defaultCount, columnCount);
+  const frozenStorageKey = getFrozenColumnStorageKey(storageKey);
+  if (!frozenStorageKey || !isBrowser()) return fallback;
+  try {
+    const storedValue = window.localStorage.getItem(frozenStorageKey);
+    if (storedValue === null) return fallback;
+    const value = Number(storedValue);
+    return Number.isFinite(value) ? clampFrozenColumnCount(value, columnCount) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function persistFrozenColumnCount(storageKey, count) {
+  const frozenStorageKey = getFrozenColumnStorageKey(storageKey);
+  if (!frozenStorageKey || !isBrowser()) return;
+  window.localStorage.setItem(frozenStorageKey, String(count));
+}
+function loadStoredFrozenEndColumnCount(storageKey, defaultCount, columnCount) {
+  const fallback = clampFrozenColumnCount(defaultCount, columnCount);
+  const frozenStorageKey = getFrozenEndColumnStorageKey(storageKey);
+  if (!frozenStorageKey || !isBrowser()) return fallback;
+  try {
+    const storedValue = window.localStorage.getItem(frozenStorageKey);
+    if (storedValue === null) return fallback;
+    const value = Number(storedValue);
+    return Number.isFinite(value) ? clampFrozenColumnCount(value, columnCount) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function persistFrozenEndColumnCount(storageKey, count) {
+  const frozenStorageKey = getFrozenEndColumnStorageKey(storageKey);
+  if (!frozenStorageKey || !isBrowser()) return;
+  window.localStorage.setItem(frozenStorageKey, String(count));
+}
+function normalizeColumnOrder2(columnKeys, columnOrder) {
+  const validColumnKeys = new Set(columnKeys);
+  const orderedKeys = (columnOrder || []).filter((columnKey) => validColumnKeys.has(columnKey));
+  const orderedKeySet = new Set(orderedKeys);
+  const remainingKeys = columnKeys.filter((columnKey) => !orderedKeySet.has(columnKey));
+  return [...orderedKeys, ...remainingKeys];
+}
+function getOrderedColumns2(columns, columnOrder) {
+  const normalizedOrder = normalizeColumnOrder2(columns.map((column) => column.key), columnOrder);
+  const columnMap = new Map(columns.map((column) => [column.key, column]));
+  return normalizedOrder.map((columnKey) => columnMap.get(columnKey)).filter(Boolean);
+}
+function getColumnNumericWidth(column, columnSizes) {
+  const controlledWidth = columnSizes[column.key];
+  if (typeof controlledWidth === "number") return controlledWidth;
+  return getColumnDefaultSize(column);
+}
+function buildFrozenOffsets(columns, columnSizes, frozenColumnCount) {
+  const offsets = /* @__PURE__ */ new Map();
+  let left = 0;
+  columns.slice(0, Math.max(0, frozenColumnCount)).forEach((column) => {
+    offsets.set(column.key, left);
+    left += getColumnNumericWidth(column, columnSizes);
+  });
+  return offsets;
+}
+function buildFrozenEndOffsets(columns, columnSizes, frozenEndColumnCount) {
+  const offsets = /* @__PURE__ */ new Map();
+  let right = 0;
+  columns.slice(Math.max(0, columns.length - frozenEndColumnCount)).reverse().forEach((column) => {
+    offsets.set(column.key, right);
+    right += getColumnNumericWidth(column, columnSizes);
+  });
+  return offsets;
+}
+function resolveRowClassName(rowClassName, row, rowIndex) {
+  return typeof rowClassName === "function" ? rowClassName(row, rowIndex) : rowClassName;
+}
+function renderDefaultCell(column, row) {
+  const value = row?.[column.key];
+  if (value === void 0 || value === null || value === "") return "\u2014";
+  return String(value);
+}
+function InteractiveTableCellContent({
+  children,
+  wrap
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: cn(
+        "min-w-0 max-w-full overflow-auto overscroll-contain [scrollbar-width:thin]",
+        wrap ? "max-h-20 whitespace-pre-wrap break-words leading-5" : "whitespace-nowrap"
+      ),
+      children
+    }
+  );
+}
+function PinIcon({ className }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      "aria-hidden": "true",
+      viewBox: "0 0 16 16",
+      className,
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.75",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M5.25 2.75h5.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M6.25 2.75v4L4.5 9.25h7L9.75 6.75v-4" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8 9.25v4" })
+      ]
+    }
+  );
+}
+function InteractiveTable({
+  rows = [],
+  columns = [],
+  pinnedTopRows = [],
+  getRowKey = defaultGetRowKey2,
+  getPinnedTopRowKey = defaultGetRowKey2,
+  renderCell,
+  renderPinnedTopCell,
+  renderColumnHeader,
+  onRowClick,
+  getRowState,
+  rowClassName,
+  pinnedTopRowClassName,
+  emptyState = "\u2014",
+  columnMenuLabels,
+  columnStorageKey,
+  columnOrder,
+  columnSizes,
+  defaultColumnSizes,
+  columnDragEnabled = false,
+  columnResizeEnabled = true,
+  frozenColumnCount = 0,
+  frozenEndColumnCount = 0,
+  tableMinWidth,
+  bodyMaxHeight = "min(60vh, 42rem)",
+  appearance,
+  className,
+  tableClassName,
+  classNames,
+  style,
+  onColumnOrderChange,
+  onColumnSizeChange,
+  onResetColumnSizes,
+  onFrozenColumnCountChange,
+  onFrozenEndColumnCountChange,
+  onSort
+}) {
+  const columnKeySignature = columns.map((column) => column.key).join("
");
+  const defaultOrder = React.useMemo(
+    () => columnKeySignature ? columnKeySignature.split("
") : [],
+    [columnKeySignature]
+  );
+  const defaultSizes = React.useMemo(
+    () => buildDefaultColumnSizes(columns, defaultColumnSizes),
+    [columns, defaultColumnSizes]
+  );
+  const [internalColumnOrder, setInternalColumnOrder] = React.useState(defaultOrder);
+  const [internalColumnSizes, setInternalColumnSizes] = React.useState(() => loadStoredColumnSizes(columnStorageKey, defaultSizes));
+  const [internalFrozenColumnCount, setInternalFrozenColumnCount] = React.useState(() => loadStoredFrozenColumnCount(columnStorageKey, frozenColumnCount, columns.length));
+  const [internalFrozenEndColumnCount, setInternalFrozenEndColumnCount] = React.useState(() => loadStoredFrozenEndColumnCount(columnStorageKey, frozenEndColumnCount, columns.length));
+  React.useEffect(() => {
+    setInternalColumnOrder((current) => normalizeColumnOrder2(defaultOrder, current));
+  }, [defaultOrder]);
+  React.useEffect(() => {
+    if (columnSizes) return;
+    setInternalColumnSizes(loadStoredColumnSizes(columnStorageKey, defaultSizes));
+  }, [columnSizes, columnStorageKey, defaultSizes]);
+  React.useEffect(() => {
+    setInternalFrozenColumnCount(loadStoredFrozenColumnCount(columnStorageKey, frozenColumnCount, columns.length));
+  }, [columnStorageKey, columns.length, frozenColumnCount]);
+  React.useEffect(() => {
+    setInternalFrozenEndColumnCount(loadStoredFrozenEndColumnCount(columnStorageKey, frozenEndColumnCount, columns.length));
+  }, [columnStorageKey, columns.length, frozenEndColumnCount]);
+  const resolvedColumnOrder = columnOrder ? normalizeColumnOrder2(defaultOrder, columnOrder) : internalColumnOrder;
+  const resolvedColumnSizes = columnSizes ?? internalColumnSizes;
+  const orderedColumns = getOrderedColumns2(columns, resolvedColumnOrder);
+  const {
+    startCount: resolvedFrozenColumnCount,
+    endCount: resolvedFrozenEndColumnCount
+  } = normalizeFrozenColumnCounts(internalFrozenColumnCount, internalFrozenEndColumnCount, orderedColumns.length);
+  const frozenOffsets = buildFrozenOffsets(orderedColumns, resolvedColumnSizes, resolvedFrozenColumnCount);
+  const frozenEndOffsets = buildFrozenEndOffsets(orderedColumns, resolvedColumnSizes, resolvedFrozenEndColumnCount);
+  const resolvedMinWidth = tableMinWidth ?? Math.max(760, orderedColumns.reduce((total, column) => total + getColumnNumericWidth(column, resolvedColumnSizes), 0));
+  const labels = {
+    columnActions: columnMenuLabels?.columnActions ?? "Column actions",
+    freezeColumn: columnMenuLabels?.freezeColumn ?? "Freeze to left",
+    freezeEndColumn: columnMenuLabels?.freezeEndColumn ?? "Freeze to right",
+    unfreezeColumn: columnMenuLabels?.unfreezeColumn ?? "Unfreeze from left",
+    unfreezeEndColumn: columnMenuLabels?.unfreezeEndColumn ?? "Unfreeze from right",
+    unfreezeAllColumns: columnMenuLabels?.unfreezeAllColumns ?? "Unfreeze all columns",
+    resetColumnWidth: columnMenuLabels?.resetColumnWidth ?? "Reset column width",
+    frozenColumnTitle: columnMenuLabels?.frozenColumnTitle ?? "Frozen column"
+  };
+  const handleColumnOrderChange = React.useCallback((nextOrder, detail) => {
+    const normalizedOrder = normalizeColumnOrder2(defaultOrder, nextOrder);
+    if (!columnOrder) {
+      setInternalColumnOrder(normalizedOrder);
+    }
+    onColumnOrderChange?.(normalizedOrder, detail);
+  }, [columnOrder, defaultOrder, onColumnOrderChange]);
+  const handleColumnSizeChange = React.useCallback((columnId, width, detail) => {
+    const column = columns.find((item) => item.key === columnId);
+    const minWidth = column?.minWidth;
+    const maxWidth = column?.maxWidth;
+    const nextWidth = Math.max(
+      typeof minWidth === "number" ? minWidth : 0,
+      Math.min(width, typeof maxWidth === "number" ? maxWidth : Number.POSITIVE_INFINITY)
+    );
+    const nextSizes = {
+      ...resolvedColumnSizes,
+      [columnId]: nextWidth
+    };
+    if (!columnSizes) {
+      setInternalColumnSizes(nextSizes);
+    }
+    persistColumnSizes(columnStorageKey, nextSizes);
+    onColumnSizeChange?.(columnId, nextWidth, detail);
+  }, [columnSizes, columnStorageKey, columns, onColumnSizeChange, resolvedColumnSizes]);
+  const handleResetColumnSize = React.useCallback((column) => {
+    const nextWidth = defaultSizes[column.key] ?? getColumnDefaultSize(column);
+    const previousWidth = getColumnNumericWidth(column, resolvedColumnSizes);
+    const nextSizes = {
+      ...resolvedColumnSizes,
+      [column.key]: nextWidth
+    };
+    if (!columnSizes) {
+      setInternalColumnSizes(nextSizes);
+    }
+    persistColumnSizes(columnStorageKey, nextSizes);
+    onColumnSizeChange?.(column.key, nextWidth, {
+      columnId: column.key,
+      previousWidth,
+      minWidth: column.minWidth,
+      maxWidth: column.maxWidth
+    });
+    onResetColumnSizes?.(nextSizes);
+  }, [columnSizes, columnStorageKey, defaultSizes, onColumnSizeChange, onResetColumnSizes, resolvedColumnSizes]);
+  const setFrozenColumnCount = React.useCallback((nextCount) => {
+    const normalizedCount = clampFrozenColumnCount(nextCount, Math.max(0, orderedColumns.length - resolvedFrozenEndColumnCount));
+    setInternalFrozenColumnCount(normalizedCount);
+    persistFrozenColumnCount(columnStorageKey, normalizedCount);
+    onFrozenColumnCountChange?.(normalizedCount);
+  }, [columnStorageKey, onFrozenColumnCountChange, orderedColumns.length, resolvedFrozenEndColumnCount]);
+  const setFrozenEndColumnCount = React.useCallback((nextCount) => {
+    const normalizedCount = clampFrozenColumnCount(nextCount, Math.max(0, orderedColumns.length - resolvedFrozenColumnCount));
+    setInternalFrozenEndColumnCount(normalizedCount);
+    persistFrozenEndColumnCount(columnStorageKey, normalizedCount);
+    onFrozenEndColumnCountChange?.(normalizedCount);
+  }, [columnStorageKey, onFrozenEndColumnCountChange, orderedColumns.length, resolvedFrozenColumnCount]);
+  const getFrozenPosition = (columnIndex) => {
+    if (columnIndex < resolvedFrozenColumnCount) return "start";
+    if (columnIndex >= orderedColumns.length - resolvedFrozenEndColumnCount) return "end";
+    return void 0;
+  };
+  const getFrozenClassName = (column, columnIndex, isHeader = false) => {
+    const position = getFrozenPosition(columnIndex);
+    if (!position) return void 0;
+    return cn(
+      "sticky",
+      position === "start" ? "shadow-[1px_0_0_0_hsl(var(--border)/0.45)]" : "shadow-[-1px_0_0_0_hsl(var(--border)/0.45)]",
+      isHeader ? "bg-muted/60" : "bg-inherit",
+      isHeader ? "z-40" : "z-20",
+      (columnIndex === 0 || columnIndex === orderedColumns.length - 1) && (isHeader ? "z-50" : "z-30")
+    );
+  };
+  const getFrozenStyle = (column, columnIndex) => {
+    const position = getFrozenPosition(columnIndex);
+    if (position === "start") return { left: frozenOffsets.get(column.key) ?? 0 };
+    if (position === "end") return { right: frozenEndOffsets.get(column.key) ?? 0 };
+    return void 0;
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    BaseTableContainer,
+    {
+      appearance,
+      className: cn("flex h-full min-h-0 flex-col overflow-hidden rounded-lg border border-border/60 bg-card", classNames?.root, className),
+      style,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: cn("min-h-0 flex-1 overflow-auto", classNames?.scrollArea),
+          style: { maxHeight: toCssSize4(bodyMaxHeight) },
+          children: /* @__PURE__ */ jsxRuntime.jsxs(
+            BaseTable,
+            {
+              appearance,
+              columnOrder: resolvedColumnOrder,
+              columnSizes: resolvedColumnSizes,
+              columnDragEnabled,
+              columnResizeEnabled,
+              onColumnOrderChange: handleColumnOrderChange,
+              onColumnSizeChange: handleColumnSizeChange,
+              className: cn("w-full table-fixed text-left text-xs", classNames?.table, tableClassName),
+              style: { minWidth: resolvedMinWidth },
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("colgroup", { children: orderedColumns.map((column) => /* @__PURE__ */ jsxRuntime.jsx(
+                  "col",
+                  {
+                    style: {
+                      width: toCssSize4(resolvedColumnSizes[column.key] ?? column.width),
+                      minWidth: toCssSize4(column.minWidth)
+                    }
+                  },
+                  column.key
+                )) }),
+                /* @__PURE__ */ jsxRuntime.jsx(BaseTableHeader, { appearance, className: cn("border-b border-border/60 bg-muted/60 text-[11px] font-medium text-muted-foreground", classNames?.tableHeader), children: /* @__PURE__ */ jsxRuntime.jsx(BaseTableRow, { appearance, className: cn("hover:bg-transparent", classNames?.headerRow), children: orderedColumns.map((column, columnIndex) => {
+                  const headerContent = renderColumnHeader ? renderColumnHeader(column, { column, columnIndex, columns: orderedColumns, rows }) : column.label;
+                  const sortable = Boolean(column.sortable);
+                  const handleSort = sortable && onSort ? () => onSort(column.key, column) : void 0;
+                  const isFrozenStart = columnIndex < resolvedFrozenColumnCount;
+                  const isFrozenEnd = columnIndex >= orderedColumns.length - resolvedFrozenEndColumnCount;
+                  const isFrozen = isFrozenStart || isFrozenEnd;
+                  const isColumnAtDefaultWidth = getColumnNumericWidth(column, resolvedColumnSizes) === (defaultSizes[column.key] ?? getColumnDefaultSize(column));
+                  return /* @__PURE__ */ jsxRuntime.jsxs(BaseContextMenu, { modal: false, children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(BaseContextMenuTrigger, { asChild: true, appearance, children: /* @__PURE__ */ jsxRuntime.jsx(
+                      BaseTableHead,
+                      {
+                        appearance,
+                        columnId: column.key,
+                        align: column.align,
+                        label: headerContent,
+                        description: column.description,
+                        trailing: isFrozen ? /* @__PURE__ */ jsxRuntime.jsx("span", { title: labels.frozenColumnTitle, className: "inline-flex h-5 w-5 items-center justify-center rounded text-primary", children: /* @__PURE__ */ jsxRuntime.jsx(PinIcon, { className: "h-3.5 w-3.5" }) }) : null,
+                        sortable,
+                        sortDirection: column.sortDirection,
+                        sortLabel: column.sortLabel,
+                        onSort: handleSort,
+                        draggable: column.draggable,
+                        resizable: column.resizable,
+                        width: column.width,
+                        minWidth: column.minWidth,
+                        maxWidth: column.maxWidth,
+                        className: cn(
+                          "sticky top-0 h-9 whitespace-nowrap border-r border-border/50 bg-muted/60 px-2.5 py-2 backdrop-blur",
+                          getFrozenClassName(column, columnIndex, true),
+                          column.headerClassName,
+                          column.className,
+                          classNames?.headerCell
+                        ),
+                        style: getFrozenStyle(column, columnIndex)
+                      }
+                    ) }),
+                    /* @__PURE__ */ jsxRuntime.jsxs(BaseContextMenuContent, { appearance, alignOffset: -4, className: "min-w-44", children: [
+                      /* @__PURE__ */ jsxRuntime.jsx(BaseContextMenuLabel, { appearance, children: labels.columnActions }),
+                      isFrozen ? /* @__PURE__ */ jsxRuntime.jsx(
+                        BaseContextMenuItem,
+                        {
+                          appearance,
+                          onSelect: () => {
+                            if (isFrozenEnd) setFrozenEndColumnCount(orderedColumns.length - columnIndex - 1);
+                            else setFrozenColumnCount(columnIndex);
+                          },
+                          children: isFrozenEnd ? labels.unfreezeEndColumn : labels.unfreezeColumn
+                        }
+                      ) : /* @__PURE__ */ jsxRuntime.jsx(
+                        BaseContextMenuItem,
+                        {
+                          appearance,
+                          onSelect: () => setFrozenColumnCount(columnIndex + 1),
+                          children: labels.freezeColumn
+                        }
+                      ),
+                      !isFrozen ? /* @__PURE__ */ jsxRuntime.jsx(
+                        BaseContextMenuItem,
+                        {
+                          appearance,
+                          onSelect: () => setFrozenEndColumnCount(orderedColumns.length - columnIndex),
+                          children: labels.freezeEndColumn
+                        }
+                      ) : null,
+                      /* @__PURE__ */ jsxRuntime.jsx(
+                        BaseContextMenuItem,
+                        {
+                          appearance,
+                          disabled: resolvedFrozenColumnCount === 0 && resolvedFrozenEndColumnCount === 0,
+                          onSelect: () => {
+                            setFrozenColumnCount(0);
+                            setFrozenEndColumnCount(0);
+                          },
+                          children: labels.unfreezeAllColumns
+                        }
+                      ),
+                      /* @__PURE__ */ jsxRuntime.jsx(BaseContextMenuSeparator, { appearance }),
+                      /* @__PURE__ */ jsxRuntime.jsx(
+                        BaseContextMenuItem,
+                        {
+                          appearance,
+                          disabled: isColumnAtDefaultWidth,
+                          onSelect: () => handleResetColumnSize(column),
+                          children: labels.resetColumnWidth
+                        }
+                      )
+                    ] })
+                  ] }, column.key);
+                }) }) }),
+                /* @__PURE__ */ jsxRuntime.jsxs(BaseTableBody, { appearance, className: cn("divide-y divide-border/50", classNames?.body), children: [
+                  pinnedTopRows.map((row, rowIndex) => {
+                    const key = getPinnedTopRowKey(row, rowIndex);
+                    const resolvedRowClassName = resolveRowClassName(pinnedTopRowClassName, row, rowIndex);
+                    return /* @__PURE__ */ jsxRuntime.jsx(
+                      BaseTableRow,
+                      {
+                        appearance,
+                        className: cn("bg-card/95", classNames?.pinnedTopRow, resolvedRowClassName),
+                        children: orderedColumns.map((column, columnIndex) => /* @__PURE__ */ jsxRuntime.jsx(
+                          BaseTableCell,
+                          {
+                            appearance,
+                            align: column.align,
+                            className: cn(
+                              "h-[52px] border-r border-border/50 px-2.5 py-1.5 align-middle",
+                              column.wrap ? "whitespace-normal" : "whitespace-nowrap",
+                              getFrozenClassName(column, columnIndex),
+                              column.cellClassName,
+                              classNames?.cell
+                            ),
+                            style: getFrozenStyle(column, columnIndex),
+                            children: /* @__PURE__ */ jsxRuntime.jsx(InteractiveTableCellContent, { wrap: column.wrap, children: renderPinnedTopCell ? renderPinnedTopCell(column, row, { row, rowIndex, column, columnIndex, isPinnedTopRow: true }) : renderDefaultCell(column, row) })
+                          },
+                          `pinned-${key}-${column.key}`
+                        ))
+                      },
+                      `pinned-${key}`
+                    );
+                  }),
+                  rows.length ? rows.map((row, rowIndex) => {
+                    const key = getRowKey(row, rowIndex);
+                    const state = getRowState?.(row, rowIndex) || {};
+                    const resolvedRowClassName = resolveRowClassName(rowClassName, row, rowIndex);
+                    return /* @__PURE__ */ jsxRuntime.jsx(
+                      BaseTableRow,
+                      {
+                        appearance,
+                        interactive: Boolean(onRowClick) && !state.disabled,
+                        selected: state.selected,
+                        disabled: state.disabled,
+                        onClick: () => {
+                          if (!state.disabled) onRowClick?.(row, rowIndex);
+                        },
+                        className: cn(
+                          "min-h-[52px] bg-card transition-colors",
+                          state.saving && "bg-primary/5",
+                          state.pending && "opacity-80",
+                          onRowClick && !state.disabled ? "cursor-pointer hover:bg-muted/30" : "hover:bg-muted/30",
+                          classNames?.row,
+                          resolvedRowClassName
+                        ),
+                        children: orderedColumns.map((column, columnIndex) => /* @__PURE__ */ jsxRuntime.jsx(
+                          BaseTableCell,
+                          {
+                            appearance,
+                            align: column.align,
+                            className: cn(
+                              "h-[52px] border-r border-border/50 px-2.5 py-1.5 align-middle",
+                              column.wrap ? "whitespace-normal" : "whitespace-nowrap",
+                              getFrozenClassName(column, columnIndex),
+                              column.cellClassName,
+                              classNames?.cell
+                            ),
+                            style: getFrozenStyle(column, columnIndex),
+                            children: /* @__PURE__ */ jsxRuntime.jsx(InteractiveTableCellContent, { wrap: column.wrap, children: renderCell ? renderCell(column, row, { row, rowIndex, column, columnIndex, isPinnedTopRow: false }) : renderDefaultCell(column, row) })
+                          },
+                          `${key}-${column.key}`
+                        ))
+                      },
+                      key
+                    );
+                  }) : pinnedTopRows.length ? null : /* @__PURE__ */ jsxRuntime.jsx(
+                    BaseTableEmpty,
+                    {
+                      appearance,
+                      colSpan: Math.max(orderedColumns.length, 1),
+                      className: classNames?.empty,
+                      children: emptyState
+                    }
+                  )
+                ] })
+              ]
+            }
+          )
+        }
+      )
+    }
+  );
+}
+function InteractiveTableEditableTextCell({
+  value,
+  placeholder,
+  disabled,
+  multiline = false,
+  commitOnBlur = true,
+  className,
+  inputClassName,
+  onCommit
+}) {
+  const initialValue = String(value || "");
+  const [draft, setDraft] = React.useState(initialValue);
+  React.useEffect(() => {
+    setDraft(initialValue);
+  }, [initialValue]);
+  const commit = React.useCallback(async () => {
+    const nextValue = String(draft || "").trim();
+    const previousValue = String(initialValue || "").trim();
+    if (nextValue === previousValue) return;
+    try {
+      await onCommit?.(nextValue);
+    } catch {
+      setDraft(initialValue);
+    }
+  }, [draft, initialValue, onCommit]);
+  const controlClassName = cn(
+    "w-full resize-none rounded-sm border border-transparent bg-transparent px-1.5 py-1 text-xs text-foreground outline-none transition-colors",
+    "placeholder:text-muted-foreground/70 hover:border-border/60 hover:bg-background focus:border-primary/45 focus:bg-background",
+    multiline ? "min-h-[42px] leading-5" : "h-8",
+    disabled && "cursor-not-allowed text-muted-foreground hover:border-transparent hover:bg-transparent",
+    inputClassName
+  );
+  if (multiline) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "textarea",
+      {
+        className: cn(controlClassName, className),
+        disabled,
+        value: draft,
+        placeholder,
+        onChange: (event) => setDraft(event.target.value),
+        onBlur: () => {
+          if (commitOnBlur) void commit();
+        },
+        onKeyDown: (event) => {
+          if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
+            event.currentTarget.blur();
+          }
+          if (event.key === "Escape") {
+            setDraft(initialValue);
+            event.currentTarget.blur();
+          }
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "input",
+    {
+      className: cn(controlClassName, className),
+      disabled,
+      value: draft,
+      placeholder,
+      onChange: (event) => setDraft(event.target.value),
+      onBlur: () => {
+        if (commitOnBlur) void commit();
+      },
+      onKeyDown: (event) => {
+        if (event.key === "Enter") event.currentTarget.blur();
+        if (event.key === "Escape") {
+          setDraft(initialValue);
+          event.currentTarget.blur();
+        }
+      }
+    }
+  );
+}
+function InteractiveTableReadonlyCell({
+  children,
+  mono = false,
+  className
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("min-w-0 text-xs text-muted-foreground", mono && "font-mono", className), children: hasRenderableNode(children) ? children : "\u2014" });
+}
+function InteractiveTableSelectCell({
+  value,
+  options,
+  disabled,
+  ariaLabel,
+  children,
+  className,
+  onChange
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("relative flex w-full items-center", className), children: [
+    children,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "select",
+      {
+        "aria-label": ariaLabel,
+        disabled,
+        value,
+        onChange: (event) => onChange?.(event.target.value),
+        className: "absolute inset-0 h-full w-full cursor-pointer opacity-0 disabled:cursor-not-allowed",
+        children: options.map((option) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: option.value, children: option.label }, option.value))
+      }
+    )
+  ] });
+}
 var imageExtPattern = /\.(png|jpe?g|webp|gif|svg|bmp|avif)$/i;
 var audioExtPattern = /\.(wav|mp3|ogg|m4a|flac|aac)$/i;
 var isLikelyUrl = (value) => /^https?:\/\//i.test(String(value || ""));
@@ -21947,7 +23116,7 @@ var DEFAULT_MASONRY_GAP_PX = 12;
 var DEFAULT_MASONRY_ROW_HEIGHT_PX = 8;
 var DEFAULT_MASONRY_COLUMN_WIDTH_PX = 280;
 var DEFAULT_MASONRY_ITEM_HEIGHT_PX = 240;
-function clamp3(value, min5, max5) {
+function clamp4(value, min5, max5) {
   return Math.min(Math.max(value, min5), max5);
 }
 function getRootFontSize(node) {
@@ -22022,10 +23191,10 @@ function getItemColumnSpan({
   gap
 }) {
   if (Number.isFinite(size?.columnSpan) && Number(size?.columnSpan) > 0) {
-    return clamp3(Math.round(Number(size?.columnSpan)), 1, columnCount);
+    return clamp4(Math.round(Number(size?.columnSpan)), 1, columnCount);
   }
   const itemWidth = resolveLengthToPixels(size?.width, columnWidth, null);
-  return clamp3(Math.ceil((itemWidth + gap) / (columnWidth + gap)), 1, columnCount);
+  return clamp4(Math.ceil((itemWidth + gap) / (columnWidth + gap)), 1, columnCount);
 }
 function getItemRowSpan({
   size,
@@ -22202,7 +23371,7 @@ function WorkbenchMasonryLayout({
       let nextColumnIndex = 0;
       let maxBottom = 0;
       const positionedItems = layoutItems.map(({ key, item, columnSpan, rowSpan, size }) => {
-        const resolvedSpan = clamp3(columnSpan, 1, columnCount);
+        const resolvedSpan = clamp4(columnSpan, 1, columnCount);
         let startColumn = nextColumnIndex;
         if (startColumn + resolvedSpan > columnCount) {
           startColumn = 0;
@@ -22807,6 +23976,173 @@ function WorkbenchGalleryView({
     }
   );
 }
+function toCssSize5(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" ? `${value}px` : value;
+}
+function defaultGetRowId(row, rowIndex) {
+  return String(row?.id ?? row?.key ?? rowIndex);
+}
+function defaultGetColumnId(row) {
+  return String(row?.columnId ?? row?.status ?? "");
+}
+function defaultRenderCard(row) {
+  const value = row?.title ?? row?.name ?? row?.id ?? "Untitled";
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-border/70 bg-card px-3 py-2 text-sm text-foreground shadow-sm", children: String(value) });
+}
+function WorkbenchLaneDraggableCard({
+  row,
+  rowId,
+  rowIndex,
+  column,
+  classNames,
+  renderCard
+}) {
+  const { attributes, listeners, setNodeRef, isDragging } = core.useDraggable({ id: rowId });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setNodeRef,
+      ...listeners,
+      ...attributes,
+      className: cn("touch-none", classNames?.cardWrapper),
+      children: renderCard(row, { row, rowIndex, column, isDragging, isOverlay: false })
+    }
+  );
+}
+function WorkbenchLaneColumnView({
+  column,
+  columnRows,
+  columnWidth,
+  columnMinHeight,
+  emptyColumn,
+  classNames,
+  renderCard
+}) {
+  const { setNodeRef, isOver } = core.useDroppable({ id: column.id });
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "section",
+    {
+      className: cn(
+        "flex shrink-0 flex-col rounded-xl border border-border/60 bg-card p-2 shadow-sm",
+        classNames?.column,
+        column.className
+      ),
+      style: { width: toCssSize5(columnWidth) ?? "280px" },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex h-10 items-center gap-2 px-1", classNames?.columnHeader, column.headerClassName), children: [
+          column.icon ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: cn("inline-flex h-4 w-4 items-center justify-center text-muted-foreground", classNames?.columnIcon, column.iconClassName), children: column.icon }) : null,
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: cn("inline-flex items-center rounded px-2 py-0.5 text-xs font-semibold bg-muted text-muted-foreground", classNames?.columnBadge, column.badgeClassName), children: column.label ?? column.id }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: cn("text-xs text-muted-foreground", classNames?.columnCount), children: columnRows.length })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            ref: setNodeRef,
+            className: cn(
+              "mt-1 flex min-h-[200px] flex-1 flex-col gap-2 overflow-y-auto rounded-lg p-1 transition-colors [scrollbar-width:thin]",
+              isOver && "bg-accent/60",
+              classNames?.columnBody,
+              column.bodyClassName
+            ),
+            style: { minHeight: toCssSize5(columnMinHeight) },
+            children: columnRows.length ? columnRows.map(({ row, rowIndex, rowId }) => /* @__PURE__ */ jsxRuntime.jsx(
+              WorkbenchLaneDraggableCard,
+              {
+                row,
+                rowId,
+                rowIndex,
+                column,
+                classNames,
+                renderCard
+              },
+              rowId
+            )) : emptyColumn ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("flex min-h-24 items-center justify-center rounded-lg border border-dashed border-border/60 px-3 py-4 text-xs text-muted-foreground", classNames?.emptyColumn), children: emptyColumn }) : null
+          }
+        )
+      ]
+    }
+  );
+}
+function WorkbenchLaneView({
+  rows = [],
+  columns = [],
+  getRowId = defaultGetRowId,
+  getColumnId = defaultGetColumnId,
+  renderCard = defaultRenderCard,
+  renderOverlayCard,
+  onMoveRow,
+  emptyColumn,
+  activationDistance = 5,
+  columnWidth = 280,
+  columnMinHeight,
+  className,
+  classNames,
+  style
+}) {
+  const [activeRowId, setActiveRowId] = React.useState(null);
+  const sensors = core.useSensors(core.useSensor(core.PointerSensor, { activationConstraint: { distance: activationDistance } }));
+  const columnMap = React.useMemo(() => new Map(columns.map((column) => [column.id, column])), [columns]);
+  const rowEntries = React.useMemo(() => rows.map((row, rowIndex) => ({
+    row,
+    rowIndex,
+    rowId: getRowId(row, rowIndex),
+    columnId: getColumnId(row, rowIndex)
+  })), [getColumnId, getRowId, rows]);
+  const activeEntry = activeRowId ? rowEntries.find((entry) => entry.rowId === activeRowId) : void 0;
+  const rowsByColumn = React.useMemo(() => {
+    const next = /* @__PURE__ */ new Map();
+    columns.forEach((column) => next.set(column.id, []));
+    rowEntries.forEach(({ row, rowIndex, rowId, columnId }) => {
+      next.get(columnId)?.push({ row, rowIndex, rowId });
+    });
+    return next;
+  }, [columns, rowEntries]);
+  const activeColumn = activeEntry ? columnMap.get(activeEntry.columnId) : void 0;
+  const handleDragStart = React.useCallback((event) => {
+    setActiveRowId(String(event.active.id));
+  }, []);
+  const handleDragEnd = React.useCallback((event) => {
+    setActiveRowId(null);
+    const rowId = String(event.active.id);
+    const nextColumnId = String(event.over?.id ?? "");
+    const activeRow = rowEntries.find((entry) => entry.rowId === rowId);
+    if (!activeRow || !columnMap.has(nextColumnId) || activeRow.columnId === nextColumnId) return;
+    onMoveRow?.(rowId, nextColumnId, activeRow.row);
+  }, [columnMap, onMoveRow, rowEntries]);
+  const handleDragCancel = React.useCallback(() => {
+    setActiveRowId(null);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(core.DndContext, { sensors, onDragStart: handleDragStart, onDragEnd: handleDragEnd, onDragCancel: handleDragCancel, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: cn("flex min-h-0 flex-1 gap-4 overflow-x-auto p-4 [scrollbar-width:thin]", classNames?.root, className),
+        style,
+        children: columns.map((column) => /* @__PURE__ */ jsxRuntime.jsx(
+          WorkbenchLaneColumnView,
+          {
+            column,
+            columnRows: rowsByColumn.get(column.id) || [],
+            columnWidth,
+            columnMinHeight,
+            emptyColumn,
+            classNames,
+            renderCard
+          },
+          column.id
+        ))
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(core.DragOverlay, { children: activeEntry && activeColumn ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn(classNames?.overlayWrapper), children: (renderOverlayCard || renderCard)(activeEntry.row, {
+      row: activeEntry.row,
+      rowIndex: activeEntry.rowIndex,
+      column: activeColumn,
+      isDragging: false,
+      isOverlay: true
+    }) }) : null })
+  ] });
+}
 function cn4(...inputs) {
   return inputs.filter(Boolean).join(" ");
 }
@@ -23134,6 +24470,10 @@ exports.BaseDropdownMenu = BaseDropdownMenu;
 exports.BaseEmptyState = BaseEmptyState;
 exports.BaseField = BaseField;
 exports.BaseInput = BaseInput;
+exports.BaseLayout = BaseLayout;
+exports.BaseLayoutPane = BaseLayoutPane;
+exports.BaseLayoutResizeHandle = BaseLayoutResizeHandle;
+exports.BaseLayoutSplit = BaseLayoutSplit;
 exports.BaseLoadingState = BaseLoadingState;
 exports.BaseNotice = BaseNotice;
 exports.BasePagination = BasePagination;
@@ -23198,6 +24538,10 @@ exports.DefaultLandingPage = DefaultLandingPage;
 exports.DynamicComponent = DynamicComponent;
 exports.EmailAuth = EmailAuth;
 exports.I18nSelector = I18nSelector;
+exports.InteractiveTable = InteractiveTable;
+exports.InteractiveTableEditableTextCell = InteractiveTableEditableTextCell;
+exports.InteractiveTableReadonlyCell = InteractiveTableReadonlyCell;
+exports.InteractiveTableSelectCell = InteractiveTableSelectCell;
 exports.LoginLayout = LoginLayout;
 exports.NavButton = NavButton;
 exports.OAuthButton = OAuthButton;
@@ -23210,6 +24554,7 @@ exports.WorkbenchGalleryCard = WorkbenchGalleryCard;
 exports.WorkbenchGallerySettingsButton = WorkbenchGallerySettingsButton;
 exports.WorkbenchGallerySettingsPanel = WorkbenchGallerySettingsPanel;
 exports.WorkbenchGalleryView = WorkbenchGalleryView;
+exports.WorkbenchLaneView = WorkbenchLaneView;
 exports.WorkbenchMasonryLayout = WorkbenchMasonryLayout;
 exports.WorkbenchResizableSidebar = WorkbenchResizableSidebar;
 exports.WorkbenchTableView = WorkbenchTableView;