@railtownai/railtracks-visualizer 0.0.39 → 0.0.40

package/dist/cjs/index.js

@@ -3203,7 +3203,8 @@ const initialConnection = {
     to: null,
     toHandle: null,
     toPosition: null,
-    toNode: null
+    toNode: null,
+    pointer: null
 };
 /**
  * If you set the `connectionLineType` prop on your [`<ReactFlow />`](/api-reference/react-flow#connection-connectionLineType)
@@ -5570,7 +5571,8 @@ function onPointerDown(event, { connectionMode, connectionRadius, handleId, node
         to: position,
         toHandle: null,
         toPosition: oppositePosition[fromHandle.position],
-        toNode: null
+        toNode: null,
+        pointer: position
     };
     function startConnection() {
         connectionStarted = true;
@@ -5634,14 +5636,9 @@ function onPointerDown(event, { connectionMode, connectionRadius, handleId, node
             }, transform) : position,
             toHandle: result.toHandle,
             toPosition: isValid && result.toHandle ? result.toHandle.position : oppositePosition[fromHandle.position],
-            toNode: result.toHandle ? nodeLookup.get(result.toHandle.nodeId) : null
+            toNode: result.toHandle ? nodeLookup.get(result.toHandle.nodeId) : null,
+            pointer: position
         };
-        /*
-         * we don't want to trigger an update when the connection
-         * is snapped to the same handle as before
-         */ if (isValid && closestHandle && previousConnection.toHandle && newConnection.toHandle && previousConnection.toHandle.type === newConnection.toHandle.type && previousConnection.toHandle.nodeId === newConnection.toHandle.nodeId && previousConnection.toHandle.id === newConnection.toHandle.id && previousConnection.to.x === newConnection.to.x && previousConnection.to.y === newConnection.to.y) {
-            return;
-        }
         updateConnection(newConnection);
         previousConnection = newConnection;
     }
@@ -10860,7 +10857,7 @@ function ConnectionLineWrapper({ containerStyle, style, type, component }) {
     });
 }
 const ConnectionLine = ({ style, type = ConnectionLineType.Bezier, CustomComponent, isValid })=>{
-    const { inProgress, from, fromNode, fromHandle, fromPosition, to, toNode, toHandle, toPosition } = useConnection();
+    const { inProgress, from, fromNode, fromHandle, fromPosition, to, toNode, toHandle, toPosition, pointer } = useConnection();
     if (!inProgress) {
         return;
     }
@@ -10878,7 +10875,8 @@ const ConnectionLine = ({ style, type = ConnectionLineType.Bezier, CustomCompone
             toPosition: toPosition,
             connectionStatus: getConnectionStatus(isValid),
             toNode: toNode,
-            toHandle: toHandle
+            toHandle: toHandle,
+            pointer: pointer
         });
     }
     let path = '';
@@ -11570,7 +11568,7 @@ const wrapperStyle = {
     position: 'relative',
     zIndex: 0
 };
-function ReactFlow({ nodes, edges, defaultNodes, defaultEdges, className, nodeTypes, edgeTypes, onNodeClick, onEdgeClick, onInit, onMove, onMoveStart, onMoveEnd, onConnect, onConnectStart, onConnectEnd, onClickConnectStart, onClickConnectEnd, onNodeMouseEnter, onNodeMouseMove, onNodeMouseLeave, onNodeContextMenu, onNodeDoubleClick, onNodeDragStart, onNodeDrag, onNodeDragStop, onNodesDelete, onEdgesDelete, onDelete, onSelectionChange, onSelectionDragStart, onSelectionDrag, onSelectionDragStop, onSelectionContextMenu, onSelectionStart, onSelectionEnd, onBeforeDelete, connectionMode, connectionLineType = ConnectionLineType.Bezier, connectionLineStyle, connectionLineComponent, connectionLineContainerStyle, deleteKeyCode = 'Backspace', selectionKeyCode = 'Shift', selectionOnDrag = false, selectionMode = SelectionMode.Full, panActivationKeyCode = 'Space', multiSelectionKeyCode = isMacOs() ? 'Meta' : 'Control', zoomActivationKeyCode = isMacOs() ? 'Meta' : 'Control', snapToGrid, snapGrid, onlyRenderVisibleElements = false, selectNodesOnDrag, nodesDraggable, autoPanOnNodeFocus, nodesConnectable, nodesFocusable, nodeOrigin = defaultNodeOrigin, edgesFocusable, edgesReconnectable, elementsSelectable = true, defaultViewport: defaultViewport$1 = defaultViewport, minZoom = 0.5, maxZoom = 2, translateExtent = infiniteExtent, preventScrolling = true, nodeExtent, defaultMarkerColor = '#b1b1b7', zoomOnScroll = true, zoomOnPinch = true, panOnScroll = false, panOnScrollSpeed = 0.5, panOnScrollMode = PanOnScrollMode.Free, zoomOnDoubleClick = true, panOnDrag = true, onPaneClick, onPaneMouseEnter, onPaneMouseMove, onPaneMouseLeave, onPaneScroll, onPaneContextMenu, paneClickDistance = 0, nodeClickDistance = 0, children, onReconnect, onReconnectStart, onReconnectEnd, onEdgeContextMenu, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseMove, onEdgeMouseLeave, reconnectRadius = 10, onNodesChange, onEdgesChange, noDragClassName = 'nodrag', noWheelClassName = 'nowheel', noPanClassName = 'nopan', fitView, fitViewOptions, connectOnClick, attributionPosition, proOptions, defaultEdgeOptions, elevateNodesOnSelect, elevateEdgesOnSelect, disableKeyboardA11y = false, autoPanOnConnect, autoPanOnNodeDrag, autoPanSpeed, connectionRadius, isValidConnection, onError, style, id, nodeDragThreshold, connectionDragThreshold, viewport, onViewportChange, width, height, colorMode = 'light', debug, onScroll, ariaLabelConfig, ...rest }, ref) {
+function ReactFlow({ nodes, edges, defaultNodes, defaultEdges, className, nodeTypes, edgeTypes, onNodeClick, onEdgeClick, onInit, onMove, onMoveStart, onMoveEnd, onConnect, onConnectStart, onConnectEnd, onClickConnectStart, onClickConnectEnd, onNodeMouseEnter, onNodeMouseMove, onNodeMouseLeave, onNodeContextMenu, onNodeDoubleClick, onNodeDragStart, onNodeDrag, onNodeDragStop, onNodesDelete, onEdgesDelete, onDelete, onSelectionChange, onSelectionDragStart, onSelectionDrag, onSelectionDragStop, onSelectionContextMenu, onSelectionStart, onSelectionEnd, onBeforeDelete, connectionMode, connectionLineType = ConnectionLineType.Bezier, connectionLineStyle, connectionLineComponent, connectionLineContainerStyle, deleteKeyCode = 'Backspace', selectionKeyCode = 'Shift', selectionOnDrag = false, selectionMode = SelectionMode.Full, panActivationKeyCode = 'Space', multiSelectionKeyCode = isMacOs() ? 'Meta' : 'Control', zoomActivationKeyCode = isMacOs() ? 'Meta' : 'Control', snapToGrid, snapGrid, onlyRenderVisibleElements = false, selectNodesOnDrag, nodesDraggable, autoPanOnNodeFocus, nodesConnectable, nodesFocusable, nodeOrigin = defaultNodeOrigin, edgesFocusable, edgesReconnectable, elementsSelectable = true, defaultViewport: defaultViewport$1 = defaultViewport, minZoom = 0.5, maxZoom = 2, translateExtent = infiniteExtent, preventScrolling = true, nodeExtent, defaultMarkerColor = '#b1b1b7', zoomOnScroll = true, zoomOnPinch = true, panOnScroll = false, panOnScrollSpeed = 0.5, panOnScrollMode = PanOnScrollMode.Free, zoomOnDoubleClick = true, panOnDrag = true, onPaneClick, onPaneMouseEnter, onPaneMouseMove, onPaneMouseLeave, onPaneScroll, onPaneContextMenu, paneClickDistance = 1, nodeClickDistance = 0, children, onReconnect, onReconnectStart, onReconnectEnd, onEdgeContextMenu, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseMove, onEdgeMouseLeave, reconnectRadius = 10, onNodesChange, onEdgesChange, noDragClassName = 'nodrag', noWheelClassName = 'nowheel', noPanClassName = 'nopan', fitView, fitViewOptions, connectOnClick, attributionPosition, proOptions, defaultEdgeOptions, elevateNodesOnSelect, elevateEdgesOnSelect, disableKeyboardA11y = false, autoPanOnConnect, autoPanOnNodeDrag, autoPanSpeed, connectionRadius, isValidConnection, onError, style, id, nodeDragThreshold, connectionDragThreshold, viewport, onViewportChange, width, height, colorMode = 'light', debug, onScroll, ariaLabelConfig, ...rest }, ref) {
     const rfId = id || '1';
     const colorModeClassName = useColorModeClass(colorMode);
     // Undo scroll events, preventing viewport from shifting when nodes outside of it are focused
@@ -12699,7 +12697,7 @@ var css_248z = "/* this gets exported as style.css and can be used for the defau
 styleInject(css_248z);
 
 /**
- * @license lucide-react v0.553.0 - ISC
+ * @license lucide-react v0.554.0 - ISC
  *
  * This source code is licensed under the ISC license.
  * See the LICENSE file in the root directory of this source tree.
@@ -12721,7 +12719,7 @@ const hasA11yProp = (props)=>{
 };
 
 /**
- * @license lucide-react v0.553.0 - ISC
+ * @license lucide-react v0.554.0 - ISC
  *
  * This source code is licensed under the ISC license.
  * See the LICENSE file in the root directory of this source tree.
@@ -13962,6 +13960,372 @@ function _extends() {
     }, _extends.apply(null, arguments);
 }
 
+var reactIs = {exports: {}};
+
+var reactIs_production_min = {};
+
+var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+    if (hasRequiredReactIs_production_min) return reactIs_production_min;
+    hasRequiredReactIs_production_min = 1;
+    var b = "function" === typeof Symbol && Symbol.for, c = b ? Symbol.for("react.element") : 60103, d = b ? Symbol.for("react.portal") : 60106, e = b ? Symbol.for("react.fragment") : 60107, f = b ? Symbol.for("react.strict_mode") : 60108, g = b ? Symbol.for("react.profiler") : 60114, h = b ? Symbol.for("react.provider") : 60109, k = b ? Symbol.for("react.context") : 60110, l = b ? Symbol.for("react.async_mode") : 60111, m = b ? Symbol.for("react.concurrent_mode") : 60111, n = b ? Symbol.for("react.forward_ref") : 60112, p = b ? Symbol.for("react.suspense") : 60113, q = b ? Symbol.for("react.suspense_list") : 60120, r = b ? Symbol.for("react.memo") : 60115, t = b ? Symbol.for("react.lazy") : 60116, v = b ? Symbol.for("react.block") : 60121, w = b ? Symbol.for("react.fundamental") : 60117, x = b ? Symbol.for("react.responder") : 60118, y = b ? Symbol.for("react.scope") : 60119;
+    function z(a) {
+        if ("object" === typeof a && null !== a) {
+            var u = a.$$typeof;
+            switch(u){
+                case c:
+                    switch(a = a.type, a){
+                        case l:
+                        case m:
+                        case e:
+                        case g:
+                        case f:
+                        case p:
+                            return a;
+                        default:
+                            switch(a = a && a.$$typeof, a){
+                                case k:
+                                case n:
+                                case t:
+                                case r:
+                                case h:
+                                    return a;
+                                default:
+                                    return u;
+                            }
+                    }
+                case d:
+                    return u;
+            }
+        }
+    }
+    function A(a) {
+        return z(a) === m;
+    }
+    reactIs_production_min.AsyncMode = l;
+    reactIs_production_min.ConcurrentMode = m;
+    reactIs_production_min.ContextConsumer = k;
+    reactIs_production_min.ContextProvider = h;
+    reactIs_production_min.Element = c;
+    reactIs_production_min.ForwardRef = n;
+    reactIs_production_min.Fragment = e;
+    reactIs_production_min.Lazy = t;
+    reactIs_production_min.Memo = r;
+    reactIs_production_min.Portal = d;
+    reactIs_production_min.Profiler = g;
+    reactIs_production_min.StrictMode = f;
+    reactIs_production_min.Suspense = p;
+    reactIs_production_min.isAsyncMode = function(a) {
+        return A(a) || z(a) === l;
+    };
+    reactIs_production_min.isConcurrentMode = A;
+    reactIs_production_min.isContextConsumer = function(a) {
+        return z(a) === k;
+    };
+    reactIs_production_min.isContextProvider = function(a) {
+        return z(a) === h;
+    };
+    reactIs_production_min.isElement = function(a) {
+        return "object" === typeof a && null !== a && a.$$typeof === c;
+    };
+    reactIs_production_min.isForwardRef = function(a) {
+        return z(a) === n;
+    };
+    reactIs_production_min.isFragment = function(a) {
+        return z(a) === e;
+    };
+    reactIs_production_min.isLazy = function(a) {
+        return z(a) === t;
+    };
+    reactIs_production_min.isMemo = function(a) {
+        return z(a) === r;
+    };
+    reactIs_production_min.isPortal = function(a) {
+        return z(a) === d;
+    };
+    reactIs_production_min.isProfiler = function(a) {
+        return z(a) === g;
+    };
+    reactIs_production_min.isStrictMode = function(a) {
+        return z(a) === f;
+    };
+    reactIs_production_min.isSuspense = function(a) {
+        return z(a) === p;
+    };
+    reactIs_production_min.isValidElementType = function(a) {
+        return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+    };
+    reactIs_production_min.typeOf = z;
+    return reactIs_production_min;
+}
+
+var reactIs_development = {};
+
+var hasRequiredReactIs_development;
+function requireReactIs_development() {
+    if (hasRequiredReactIs_development) return reactIs_development;
+    hasRequiredReactIs_development = 1;
+    if (process.env.NODE_ENV !== "production") {
+        (function() {
+            // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+            // nor polyfill, then a plain number is used for performance.
+            var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+            var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+            var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+            var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+            var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+            var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+            var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+            var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+            // (unstable) APIs that have been removed. Can we remove the symbols?
+            var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+            var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+            var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+            var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+            var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+            var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+            var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+            var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+            var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+            var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+            var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+            function isValidElementType(type) {
+                return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+                type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+            }
+            function typeOf(object) {
+                if (typeof object === 'object' && object !== null) {
+                    var $$typeof = object.$$typeof;
+                    switch($$typeof){
+                        case REACT_ELEMENT_TYPE:
+                            var type = object.type;
+                            switch(type){
+                                case REACT_ASYNC_MODE_TYPE:
+                                case REACT_CONCURRENT_MODE_TYPE:
+                                case REACT_FRAGMENT_TYPE:
+                                case REACT_PROFILER_TYPE:
+                                case REACT_STRICT_MODE_TYPE:
+                                case REACT_SUSPENSE_TYPE:
+                                    return type;
+                                default:
+                                    var $$typeofType = type && type.$$typeof;
+                                    switch($$typeofType){
+                                        case REACT_CONTEXT_TYPE:
+                                        case REACT_FORWARD_REF_TYPE:
+                                        case REACT_LAZY_TYPE:
+                                        case REACT_MEMO_TYPE:
+                                        case REACT_PROVIDER_TYPE:
+                                            return $$typeofType;
+                                        default:
+                                            return $$typeof;
+                                    }
+                            }
+                        case REACT_PORTAL_TYPE:
+                            return $$typeof;
+                    }
+                }
+                return undefined;
+            } // AsyncMode is deprecated along with isAsyncMode
+            var AsyncMode = REACT_ASYNC_MODE_TYPE;
+            var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+            var ContextConsumer = REACT_CONTEXT_TYPE;
+            var ContextProvider = REACT_PROVIDER_TYPE;
+            var Element = REACT_ELEMENT_TYPE;
+            var ForwardRef = REACT_FORWARD_REF_TYPE;
+            var Fragment = REACT_FRAGMENT_TYPE;
+            var Lazy = REACT_LAZY_TYPE;
+            var Memo = REACT_MEMO_TYPE;
+            var Portal = REACT_PORTAL_TYPE;
+            var Profiler = REACT_PROFILER_TYPE;
+            var StrictMode = REACT_STRICT_MODE_TYPE;
+            var Suspense = REACT_SUSPENSE_TYPE;
+            var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+            function isAsyncMode(object) {
+                {
+                    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+                        hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+                        console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+                    }
+                }
+                return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+            }
+            function isConcurrentMode(object) {
+                return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+            }
+            function isContextConsumer(object) {
+                return typeOf(object) === REACT_CONTEXT_TYPE;
+            }
+            function isContextProvider(object) {
+                return typeOf(object) === REACT_PROVIDER_TYPE;
+            }
+            function isElement(object) {
+                return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+            }
+            function isForwardRef(object) {
+                return typeOf(object) === REACT_FORWARD_REF_TYPE;
+            }
+            function isFragment(object) {
+                return typeOf(object) === REACT_FRAGMENT_TYPE;
+            }
+            function isLazy(object) {
+                return typeOf(object) === REACT_LAZY_TYPE;
+            }
+            function isMemo(object) {
+                return typeOf(object) === REACT_MEMO_TYPE;
+            }
+            function isPortal(object) {
+                return typeOf(object) === REACT_PORTAL_TYPE;
+            }
+            function isProfiler(object) {
+                return typeOf(object) === REACT_PROFILER_TYPE;
+            }
+            function isStrictMode(object) {
+                return typeOf(object) === REACT_STRICT_MODE_TYPE;
+            }
+            function isSuspense(object) {
+                return typeOf(object) === REACT_SUSPENSE_TYPE;
+            }
+            reactIs_development.AsyncMode = AsyncMode;
+            reactIs_development.ConcurrentMode = ConcurrentMode;
+            reactIs_development.ContextConsumer = ContextConsumer;
+            reactIs_development.ContextProvider = ContextProvider;
+            reactIs_development.Element = Element;
+            reactIs_development.ForwardRef = ForwardRef;
+            reactIs_development.Fragment = Fragment;
+            reactIs_development.Lazy = Lazy;
+            reactIs_development.Memo = Memo;
+            reactIs_development.Portal = Portal;
+            reactIs_development.Profiler = Profiler;
+            reactIs_development.StrictMode = StrictMode;
+            reactIs_development.Suspense = Suspense;
+            reactIs_development.isAsyncMode = isAsyncMode;
+            reactIs_development.isConcurrentMode = isConcurrentMode;
+            reactIs_development.isContextConsumer = isContextConsumer;
+            reactIs_development.isContextProvider = isContextProvider;
+            reactIs_development.isElement = isElement;
+            reactIs_development.isForwardRef = isForwardRef;
+            reactIs_development.isFragment = isFragment;
+            reactIs_development.isLazy = isLazy;
+            reactIs_development.isMemo = isMemo;
+            reactIs_development.isPortal = isPortal;
+            reactIs_development.isProfiler = isProfiler;
+            reactIs_development.isStrictMode = isStrictMode;
+            reactIs_development.isSuspense = isSuspense;
+            reactIs_development.isValidElementType = isValidElementType;
+            reactIs_development.typeOf = typeOf;
+        })();
+    }
+    return reactIs_development;
+}
+
+var hasRequiredReactIs;
+function requireReactIs() {
+    if (hasRequiredReactIs) return reactIs.exports;
+    hasRequiredReactIs = 1;
+    if (process.env.NODE_ENV === 'production') {
+        reactIs.exports = requireReactIs_production_min();
+    } else {
+        reactIs.exports = requireReactIs_development();
+    }
+    return reactIs.exports;
+}
+
+var hoistNonReactStatics_cjs;
+var hasRequiredHoistNonReactStatics_cjs;
+function requireHoistNonReactStatics_cjs() {
+    if (hasRequiredHoistNonReactStatics_cjs) return hoistNonReactStatics_cjs;
+    hasRequiredHoistNonReactStatics_cjs = 1;
+    var reactIs = requireReactIs();
+    /**
+	 * Copyright 2015, Yahoo! Inc.
+	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+	 */ var REACT_STATICS = {
+        childContextTypes: true,
+        contextType: true,
+        contextTypes: true,
+        defaultProps: true,
+        displayName: true,
+        getDefaultProps: true,
+        getDerivedStateFromError: true,
+        getDerivedStateFromProps: true,
+        mixins: true,
+        propTypes: true,
+        type: true
+    };
+    var KNOWN_STATICS = {
+        name: true,
+        length: true,
+        prototype: true,
+        caller: true,
+        callee: true,
+        arguments: true,
+        arity: true
+    };
+    var FORWARD_REF_STATICS = {
+        '$$typeof': true,
+        render: true,
+        defaultProps: true,
+        displayName: true,
+        propTypes: true
+    };
+    var MEMO_STATICS = {
+        '$$typeof': true,
+        compare: true,
+        defaultProps: true,
+        displayName: true,
+        propTypes: true,
+        type: true
+    };
+    var TYPE_STATICS = {};
+    TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+    TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+    function getStatics(component) {
+        // React v16.11 and below
+        if (reactIs.isMemo(component)) {
+            return MEMO_STATICS;
+        } // React v16.12 and above
+        return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
+    }
+    var defineProperty = Object.defineProperty;
+    var getOwnPropertyNames = Object.getOwnPropertyNames;
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    var getPrototypeOf = Object.getPrototypeOf;
+    var objectPrototype = Object.prototype;
+    function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
+        if (typeof sourceComponent !== 'string') {
+            // don't hoist over string (html) components
+            if (objectPrototype) {
+                var inheritedComponent = getPrototypeOf(sourceComponent);
+                if (inheritedComponent && inheritedComponent !== objectPrototype) {
+                    hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
+                }
+            }
+            var keys = getOwnPropertyNames(sourceComponent);
+            if (getOwnPropertySymbols) {
+                keys = keys.concat(getOwnPropertySymbols(sourceComponent));
+            }
+            var targetStatics = getStatics(targetComponent);
+            var sourceStatics = getStatics(sourceComponent);
+            for(var i = 0; i < keys.length; ++i){
+                var key = keys[i];
+                if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
+                    var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
+                    try {
+                        // Avoid failures from read-only properties
+                        defineProperty(targetComponent, key, descriptor);
+                    } catch (e) {}
+                }
+            }
+        }
+        return targetComponent;
+    }
+    hoistNonReactStatics_cjs = hoistNonReactStatics;
+    return hoistNonReactStatics_cjs;
+}
+
+requireHoistNonReactStatics_cjs();
+
 var isBrowser = true;
 function getRegisteredStyles(registered, registeredStyles, classNames) {
     var rawClassName = '';
@@ -14264,6 +14628,7 @@ var syncFallback = function syncFallback(create) {
 };
 var useInsertionEffect$1 = React__namespace['useInsertion' + 'Effect'] ? React__namespace['useInsertion' + 'Effect'] : false;
 var useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect$1 || syncFallback;
+var useInsertionEffectWithLayoutFallback = useInsertionEffect$1 || React__namespace.useLayoutEffect;
 
 var EmotionCacheContext = /* #__PURE__ */ React__namespace.createContext(// because this module is primarily intended for the browser and node
 // but it's also required in react native and similar environments sometimes
@@ -14303,6 +14668,153 @@ var ThemeProvider$1 = function ThemeProvider(props) {
         value: theme
     }, props.children);
 };
+var hasOwn = {}.hasOwnProperty;
+var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+var createEmotionProps = function createEmotionProps(type, props) {
+    var newProps = {};
+    for(var _key in props){
+        if (hasOwn.call(props, _key)) {
+            newProps[_key] = props[_key];
+        }
+    }
+    newProps[typePropName] = type; // Runtime labeling is an opt-in feature because:
+    return newProps;
+};
+var Insertion$1 = function Insertion(_ref) {
+    var cache = _ref.cache, serialized = _ref.serialized, isStringTag = _ref.isStringTag;
+    registerStyles(cache, serialized, isStringTag);
+    useInsertionEffectAlwaysWithSyncFallback(function() {
+        return insertStyles(cache, serialized, isStringTag);
+    });
+    return null;
+};
+var Emotion = /* #__PURE__ */ withEmotionCache(function(props, cache, ref) {
+    var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+    // not passing the registered cache to serializeStyles because it would
+    // make certain babel optimisations not possible
+    if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+        cssProp = cache.registered[cssProp];
+    }
+    var WrappedComponent = props[typePropName];
+    var registeredStyles = [
+        cssProp
+    ];
+    var className = '';
+    if (typeof props.className === 'string') {
+        className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
+    } else if (props.className != null) {
+        className = props.className + " ";
+    }
+    var serialized = serializeStyles(registeredStyles, undefined, React__namespace.useContext(ThemeContext$1));
+    className += cache.key + "-" + serialized.name;
+    var newProps = {};
+    for(var _key2 in props){
+        if (hasOwn.call(props, _key2) && _key2 !== 'css' && _key2 !== typePropName && true) {
+            newProps[_key2] = props[_key2];
+        }
+    }
+    newProps.className = className;
+    if (ref) {
+        newProps.ref = ref;
+    }
+    return /*#__PURE__*/ React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/ React__namespace.createElement(Insertion$1, {
+        cache: cache,
+        serialized: serialized,
+        isStringTag: typeof WrappedComponent === 'string'
+    }), /*#__PURE__*/ React__namespace.createElement(WrappedComponent, newProps));
+});
+var Emotion$1 = Emotion;
+
+var jsx = function jsx(type, props) {
+    // eslint-disable-next-line prefer-rest-params
+    var args = arguments;
+    if (props == null || !hasOwn.call(props, 'css')) {
+        return React__namespace.createElement.apply(undefined, args);
+    }
+    var argsLength = args.length;
+    var createElementArgArray = new Array(argsLength);
+    createElementArgArray[0] = Emotion$1;
+    createElementArgArray[1] = createEmotionProps(type, props);
+    for(var i = 2; i < argsLength; i++){
+        createElementArgArray[i] = args[i];
+    }
+    return React__namespace.createElement.apply(null, createElementArgArray);
+};
+(function(_jsx) {
+    var JSX;
+    (function(_JSX) {})(JSX || (JSX = _jsx.JSX || (_jsx.JSX = {})));
+})(jsx || (jsx = {}));
+// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+// initial client-side render from SSR, use place of hydrating tag
+var Global = /* #__PURE__ */ withEmotionCache(function(props, cache) {
+    var styles = props.styles;
+    var serialized = serializeStyles([
+        styles
+    ], undefined, React__namespace.useContext(ThemeContext$1));
+    // but it is based on a constant that will never change at runtime
+    // it's effectively like having two implementations and switching them out
+    // so it's not actually breaking anything
+    var sheetRef = React__namespace.useRef();
+    useInsertionEffectWithLayoutFallback(function() {
+        var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
+        var sheet = new cache.sheet.constructor({
+            key: key,
+            nonce: cache.sheet.nonce,
+            container: cache.sheet.container,
+            speedy: cache.sheet.isSpeedy
+        });
+        var rehydrating = false;
+        var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
+        if (cache.sheet.tags.length) {
+            sheet.before = cache.sheet.tags[0];
+        }
+        if (node !== null) {
+            rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+            node.setAttribute('data-emotion', key);
+            sheet.hydrate([
+                node
+            ]);
+        }
+        sheetRef.current = [
+            sheet,
+            rehydrating
+        ];
+        return function() {
+            sheet.flush();
+        };
+    }, [
+        cache
+    ]);
+    useInsertionEffectWithLayoutFallback(function() {
+        var sheetRefCurrent = sheetRef.current;
+        var sheet = sheetRefCurrent[0], rehydrating = sheetRefCurrent[1];
+        if (rehydrating) {
+            sheetRefCurrent[1] = false;
+            return;
+        }
+        if (serialized.next !== undefined) {
+            // insert keyframes
+            insertStyles(cache, serialized.next, true);
+        }
+        if (sheet.tags.length) {
+            // if this doesn't exist then it will be null so the style element will be appended
+            var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
+            sheet.before = element;
+            sheet.flush();
+        }
+        cache.insert("", serialized, sheet, false);
+    }, [
+        cache,
+        serialized.name
+    ]);
+    return null;
+});
+function css() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    return serializeStyles(args);
+}
 
 const lightTheme = {
     colors: {
@@ -14410,9 +14922,15 @@ const ThemeProvider = ({ children, theme: propTheme })=>{
             return propTheme;
         }
         // Only check localStorage if no theme prop is provided
-        const savedTheme = localStorage.getItem("theme");
-        if (savedTheme === "dark") {
-            return darkTheme;
+        // Handle cases where localStorage might not be available (e.g., test environments)
+        try {
+            const savedTheme = localStorage.getItem("theme");
+            if (savedTheme === "dark") {
+                return darkTheme;
+            }
+        } catch (e) {
+        // localStorage not available, fall back to light theme
+        // This can happen in test environments or when localStorage is disabled
         }
         return lightTheme;
     });
@@ -14431,11 +14949,15 @@ const ThemeProvider = ({ children, theme: propTheme })=>{
             return;
         }
         const handleStorageChange = ()=>{
-            const savedTheme = localStorage.getItem("theme");
-            if (savedTheme === "dark") {
-                setCurrentTheme(darkTheme);
-            } else {
-                setCurrentTheme(lightTheme);
+            try {
+                const savedTheme = localStorage.getItem("theme");
+                if (savedTheme === "dark") {
+                    setCurrentTheme(darkTheme);
+                } else {
+                    setCurrentTheme(lightTheme);
+                }
+            } catch (e) {
+            // localStorage not available, ignore storage changes
             }
         };
         // Listen for storage events (when localStorage changes in other tabs)
@@ -17041,15 +17563,24 @@ const NodeIcon$3 = styled.div`
 `;
 
 // Helper function to get node icon
-const getNodeIcon = (modelProvider)=>{
+const getNodeIcon = (modelProvider, size = 16)=>{
     if (modelProvider === "OpenAI") {
-        return /*#__PURE__*/ React.createElement(OpenAIIcon, null);
+        return /*#__PURE__*/ React.createElement(OpenAIIcon, {
+            width: size,
+            height: size
+        });
     }
     if (modelProvider === "Anthropic") {
-        return /*#__PURE__*/ React.createElement(AnthropicIcon, null);
+        return /*#__PURE__*/ React.createElement(AnthropicIcon, {
+            width: size,
+            height: size
+        });
     }
     if (modelProvider === "Google" || modelProvider === "Vertex_AI") {
-        return /*#__PURE__*/ React.createElement(GoogleIcon, null);
+        return /*#__PURE__*/ React.createElement(GoogleIcon, {
+            width: size,
+            height: size
+        });
     }
     return "🤖";
 };
@@ -17872,7 +18403,7 @@ function useControllableState$1({ prop, defaultProp, onChange = ()=>{}, caller }
     }
     const setValue = React__namespace.useCallback((nextValue)=>{
         if (isControlled) {
-            const value2 = isFunction$1(nextValue) ? nextValue(prop) : nextValue;
+            const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
             if (value2 !== prop) {
                 onChangeRef.current?.(value2);
             }
@@ -17914,7 +18445,7 @@ function useUncontrolledState$1({ defaultProp, onChange }) {
         onChangeRef
     ];
 }
-function isFunction$1(value) {
+function isFunction(value) {
     return typeof value === "function";
 }
 
@@ -19727,23 +20258,23 @@ var Dialog = (props)=>{
     });
 };
 Dialog.displayName = DIALOG_NAME;
-var TRIGGER_NAME$2 = "DialogTrigger";
+var TRIGGER_NAME$1 = "DialogTrigger";
 var DialogTrigger = React__namespace.forwardRef((props, forwardedRef)=>{
     const { __scopeDialog, ...triggerProps } = props;
-    const context = useDialogContext(TRIGGER_NAME$2, __scopeDialog);
+    const context = useDialogContext(TRIGGER_NAME$1, __scopeDialog);
     const composedTriggerRef = useComposedRefs$1(forwardedRef, context.triggerRef);
     return /* @__PURE__ */ jsxRuntime.jsx(Primitive.button, {
         type: "button",
         "aria-haspopup": "dialog",
         "aria-expanded": context.open,
         "aria-controls": context.contentId,
-        "data-state": getState$1(context.open),
+        "data-state": getState(context.open),
         ...triggerProps,
         ref: composedTriggerRef,
         onClick: composeEventHandlers(props.onClick, context.onOpenToggle)
     });
 });
-DialogTrigger.displayName = TRIGGER_NAME$2;
+DialogTrigger.displayName = TRIGGER_NAME$1;
 var PORTAL_NAME$1 = "DialogPortal";
 var [PortalProvider, usePortalContext] = createDialogContext(PORTAL_NAME$1, {
     forceMount: void 0
@@ -19792,7 +20323,7 @@ var DialogOverlayImpl = React__namespace.forwardRef((props, forwardedRef)=>{
             context.contentRef
         ],
         children: /* @__PURE__ */ jsxRuntime.jsx(Primitive.div, {
-            "data-state": getState$1(context.open),
+            "data-state": getState(context.open),
             ...overlayProps,
             ref: forwardedRef,
             style: {
@@ -19899,7 +20430,7 @@ var DialogContentImpl = React__namespace.forwardRef((props, forwardedRef)=>{
                     id: context.contentId,
                     "aria-describedby": context.descriptionId,
                     "aria-labelledby": context.titleId,
-                    "data-state": getState$1(context.open),
+                    "data-state": getState(context.open),
                     ...contentProps,
                     ref: composedRefs,
                     onDismiss: ()=>context.onOpenChange(false)
@@ -19953,7 +20484,7 @@ var DialogClose = React__namespace.forwardRef((props, forwardedRef)=>{
     });
 });
 DialogClose.displayName = CLOSE_NAME;
-function getState$1(open) {
+function getState(open) {
     return open ? "open" : "closed";
 }
 var TITLE_WARNING_NAME = "DialogTitleWarning";
@@ -23526,11 +24057,11 @@ var Select$1 = (props)=>{
     });
 };
 Select$1.displayName = SELECT_NAME;
-var TRIGGER_NAME$1 = "SelectTrigger";
+var TRIGGER_NAME = "SelectTrigger";
 var SelectTrigger$1 = React__namespace.forwardRef((props, forwardedRef)=>{
     const { __scopeSelect, disabled = false, ...triggerProps } = props;
     const popperScope = usePopperScope(__scopeSelect);
-    const context = useSelectContext(TRIGGER_NAME$1, __scopeSelect);
+    const context = useSelectContext(TRIGGER_NAME, __scopeSelect);
     const isDisabled = context.disabled || disabled;
     const composedRefs = useComposedRefs$1(forwardedRef, context.onTriggerChange);
     const getItems = useCollection(__scopeSelect);
@@ -23602,7 +24133,7 @@ var SelectTrigger$1 = React__namespace.forwardRef((props, forwardedRef)=>{
         })
     });
 });
-SelectTrigger$1.displayName = TRIGGER_NAME$1;
+SelectTrigger$1.displayName = TRIGGER_NAME;
 var VALUE_NAME = "SelectValue";
 var SelectValue$1 = React__namespace.forwardRef((props, forwardedRef)=>{
     const { __scopeSelect, className, style, children, placeholder = "", ...valueProps } = props;
@@ -24463,7 +24994,7 @@ var SelectArrow = React__namespace.forwardRef((props, forwardedRef)=>{
     }) : null;
 });
 SelectArrow.displayName = ARROW_NAME;
-var BUBBLE_INPUT_NAME$1 = "SelectBubbleInput";
+var BUBBLE_INPUT_NAME = "SelectBubbleInput";
 var SelectBubbleInput = React__namespace.forwardRef(({ __scopeSelect, value, ...props }, forwardedRef)=>{
     const ref = React__namespace.useRef(null);
     const composedRefs = useComposedRefs$1(forwardedRef, ref);
@@ -24495,7 +25026,7 @@ var SelectBubbleInput = React__namespace.forwardRef(({ __scopeSelect, value, ...
         defaultValue: value
     });
 });
-SelectBubbleInput.displayName = BUBBLE_INPUT_NAME$1;
+SelectBubbleInput.displayName = BUBBLE_INPUT_NAME;
 function shouldShowPlaceholder(value) {
     return value === "" || value === void 0;
 }
@@ -24955,240 +25486,6 @@ const FileSelector = ({ files, currentFile, onFileSelect, onRefresh, loading = f
     }, loading ? /*#__PURE__*/ React.createElement(LoadingIcon, null) : /*#__PURE__*/ React.createElement(RefreshIcon, null)));
 };
 
-var CHECKBOX_NAME = "Checkbox";
-var [createCheckboxContext] = createContextScope(CHECKBOX_NAME);
-var [CheckboxProviderImpl, useCheckboxContext] = createCheckboxContext(CHECKBOX_NAME);
-function CheckboxProvider(props) {
-    const { __scopeCheckbox, checked: checkedProp, children, defaultChecked, disabled, form, name, onCheckedChange, required, value = "on", // @ts-expect-error
-    internal_do_not_use_render } = props;
-    const [checked, setChecked] = useControllableState$1({
-        prop: checkedProp,
-        defaultProp: defaultChecked ?? false,
-        onChange: onCheckedChange,
-        caller: CHECKBOX_NAME
-    });
-    const [control, setControl] = React__namespace.useState(null);
-    const [bubbleInput, setBubbleInput] = React__namespace.useState(null);
-    const hasConsumerStoppedPropagationRef = React__namespace.useRef(false);
-    const isFormControl = control ? !!form || !!control.closest("form") : // We set this to true by default so that events bubble to forms without JS (SSR)
-    true;
-    const context = {
-        checked,
-        disabled,
-        setChecked,
-        control,
-        setControl,
-        name,
-        form,
-        value,
-        hasConsumerStoppedPropagationRef,
-        required,
-        defaultChecked: isIndeterminate(defaultChecked) ? false : defaultChecked,
-        isFormControl,
-        bubbleInput,
-        setBubbleInput
-    };
-    return /* @__PURE__ */ jsxRuntime.jsx(CheckboxProviderImpl, {
-        scope: __scopeCheckbox,
-        ...context,
-        children: isFunction(internal_do_not_use_render) ? internal_do_not_use_render(context) : children
-    });
-}
-var TRIGGER_NAME = "CheckboxTrigger";
-var CheckboxTrigger = React__namespace.forwardRef(({ __scopeCheckbox, onKeyDown, onClick, ...checkboxProps }, forwardedRef)=>{
-    const { control, value, disabled, checked, required, setControl, setChecked, hasConsumerStoppedPropagationRef, isFormControl, bubbleInput } = useCheckboxContext(TRIGGER_NAME, __scopeCheckbox);
-    const composedRefs = useComposedRefs$1(forwardedRef, setControl);
-    const initialCheckedStateRef = React__namespace.useRef(checked);
-    React__namespace.useEffect(()=>{
-        const form = control?.form;
-        if (form) {
-            const reset = ()=>setChecked(initialCheckedStateRef.current);
-            form.addEventListener("reset", reset);
-            return ()=>form.removeEventListener("reset", reset);
-        }
-    }, [
-        control,
-        setChecked
-    ]);
-    return /* @__PURE__ */ jsxRuntime.jsx(Primitive.button, {
-        type: "button",
-        role: "checkbox",
-        "aria-checked": isIndeterminate(checked) ? "mixed" : checked,
-        "aria-required": required,
-        "data-state": getState(checked),
-        "data-disabled": disabled ? "" : void 0,
-        disabled,
-        value,
-        ...checkboxProps,
-        ref: composedRefs,
-        onKeyDown: composeEventHandlers(onKeyDown, (event)=>{
-            if (event.key === "Enter") event.preventDefault();
-        }),
-        onClick: composeEventHandlers(onClick, (event)=>{
-            setChecked((prevChecked)=>isIndeterminate(prevChecked) ? true : !prevChecked);
-            if (bubbleInput && isFormControl) {
-                hasConsumerStoppedPropagationRef.current = event.isPropagationStopped();
-                if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();
-            }
-        })
-    });
-});
-CheckboxTrigger.displayName = TRIGGER_NAME;
-var Checkbox$1 = React__namespace.forwardRef((props, forwardedRef)=>{
-    const { __scopeCheckbox, name, checked, defaultChecked, required, disabled, value, onCheckedChange, form, ...checkboxProps } = props;
-    return /* @__PURE__ */ jsxRuntime.jsx(CheckboxProvider, {
-        __scopeCheckbox,
-        checked,
-        defaultChecked,
-        disabled,
-        required,
-        onCheckedChange,
-        name,
-        form,
-        value,
-        internal_do_not_use_render: ({ isFormControl })=>/* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, {
-                children: [
-                    /* @__PURE__ */ jsxRuntime.jsx(CheckboxTrigger, {
-                        ...checkboxProps,
-                        ref: forwardedRef,
-                        __scopeCheckbox
-                    }),
-                    isFormControl && /* @__PURE__ */ jsxRuntime.jsx(CheckboxBubbleInput, {
-                        __scopeCheckbox
-                    })
-                ]
-            })
-    });
-});
-Checkbox$1.displayName = CHECKBOX_NAME;
-var INDICATOR_NAME = "CheckboxIndicator";
-var CheckboxIndicator$1 = React__namespace.forwardRef((props, forwardedRef)=>{
-    const { __scopeCheckbox, forceMount, ...indicatorProps } = props;
-    const context = useCheckboxContext(INDICATOR_NAME, __scopeCheckbox);
-    return /* @__PURE__ */ jsxRuntime.jsx(Presence, {
-        present: forceMount || isIndeterminate(context.checked) || context.checked === true,
-        children: /* @__PURE__ */ jsxRuntime.jsx(Primitive.span, {
-            "data-state": getState(context.checked),
-            "data-disabled": context.disabled ? "" : void 0,
-            ...indicatorProps,
-            ref: forwardedRef,
-            style: {
-                pointerEvents: "none",
-                ...props.style
-            }
-        })
-    });
-});
-CheckboxIndicator$1.displayName = INDICATOR_NAME;
-var BUBBLE_INPUT_NAME = "CheckboxBubbleInput";
-var CheckboxBubbleInput = React__namespace.forwardRef(({ __scopeCheckbox, ...props }, forwardedRef)=>{
-    const { control, hasConsumerStoppedPropagationRef, checked, defaultChecked, required, disabled, name, value, form, bubbleInput, setBubbleInput } = useCheckboxContext(BUBBLE_INPUT_NAME, __scopeCheckbox);
-    const composedRefs = useComposedRefs$1(forwardedRef, setBubbleInput);
-    const prevChecked = usePrevious(checked);
-    const controlSize = useSize(control);
-    React__namespace.useEffect(()=>{
-        const input = bubbleInput;
-        if (!input) return;
-        const inputProto = window.HTMLInputElement.prototype;
-        const descriptor = Object.getOwnPropertyDescriptor(inputProto, "checked");
-        const setChecked = descriptor.set;
-        const bubbles = !hasConsumerStoppedPropagationRef.current;
-        if (prevChecked !== checked && setChecked) {
-            const event = new Event("click", {
-                bubbles
-            });
-            input.indeterminate = isIndeterminate(checked);
-            setChecked.call(input, isIndeterminate(checked) ? false : checked);
-            input.dispatchEvent(event);
-        }
-    }, [
-        bubbleInput,
-        prevChecked,
-        checked,
-        hasConsumerStoppedPropagationRef
-    ]);
-    const defaultCheckedRef = React__namespace.useRef(isIndeterminate(checked) ? false : checked);
-    return /* @__PURE__ */ jsxRuntime.jsx(Primitive.input, {
-        type: "checkbox",
-        "aria-hidden": true,
-        defaultChecked: defaultChecked ?? defaultCheckedRef.current,
-        required,
-        disabled,
-        name,
-        value,
-        form,
-        ...props,
-        tabIndex: -1,
-        ref: composedRefs,
-        style: {
-            ...props.style,
-            ...controlSize,
-            position: "absolute",
-            pointerEvents: "none",
-            opacity: 0,
-            margin: 0,
-            // We transform because the input is absolutely positioned but we have
-            // rendered it **after** the button. This pulls it back to sit on top
-            // of the button.
-            transform: "translateX(-100%)"
-        }
-    });
-});
-CheckboxBubbleInput.displayName = BUBBLE_INPUT_NAME;
-function isFunction(value) {
-    return typeof value === "function";
-}
-function isIndeterminate(checked) {
-    return checked === "indeterminate";
-}
-function getState(checked) {
-    return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
-}
-
-const CheckboxRoot = styled(Checkbox$1)`
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  height: 1rem;
-  width: 1rem;
-  flex-shrink: 0;
-  border-radius: 0.125rem;
-  border: 1px solid #6366f1;
-  background-color: transparent;
-  outline: none;
-  transition: all 0.2s ease-in-out;
-
-  &:focus-visible {
-    outline: none;
-    box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.2);
-  }
-
-  &:disabled {
-    cursor: not-allowed;
-    opacity: 0.5;
-  }
-
-  &[data-state="checked"] {
-    background-color: #6366f1;
-    color: white;
-  }
-`;
-const CheckboxIndicator = styled(CheckboxIndicator$1)`
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  color: currentColor;
-`;
-const CheckIcon = styled(Check)`
-  height: 1rem;
-  width: 1rem;
-`;
-const Checkbox = /*#__PURE__*/ React__namespace.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ React__namespace.createElement(CheckboxRoot, {
-        ref: ref,
-        ...props
-    }, /*#__PURE__*/ React__namespace.createElement(CheckboxIndicator, null, /*#__PURE__*/ React__namespace.createElement(CheckIcon, null))));
-Checkbox.displayName = Checkbox$1.displayName;
-
 function __insertCSS(code) {
     if (typeof document == 'undefined') return;
     let head = document.head || document.getElementsByTagName('head')[0];
@@ -26811,7 +27108,7 @@ const DrawerOverlay = /*#__PURE__*/ React__namespace.forwardRef(({ className, ..
             bottom: 0,
             left: 0,
             zIndex: 50,
-            backgroundColor: "rgba(0, 0, 0, 0.8)"
+            backgroundColor: "rgba(0, 0, 0, 0.3)"
         },
         className: className,
         ...props
@@ -26870,7 +27167,183 @@ const DrawerDescription = /*#__PURE__*/ React__namespace.forwardRef(({ className
 DrawerDescription.displayName = Drawer$1.Description.displayName;
 
 const GlobalStyles = ()=>{
-    return null;
+    const systemFontStack = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji"';
+    return /*#__PURE__*/ React.createElement(Global, {
+        styles: css`
+        * {
+          box-sizing: border-box;
+          border-color: #e5e7eb;
+          font-family: ${systemFontStack};
+        }
+
+        html,
+        body {
+          margin: 0;
+          padding: 0;
+          background-color: #ffffff;
+          color: #1f2937;
+          font-family: ${systemFontStack};
+          line-height: 1.5;
+          -webkit-font-smoothing: antialiased;
+          -moz-osx-font-smoothing: grayscale;
+          transition:
+            background-color 0.2s ease-in-out,
+            color 0.2s ease-in-out;
+        }
+
+        /* Dark theme styles */
+        html.dark,
+        html.dark body {
+          background-color: #0f172a;
+          color: #f1f5f9;
+        }
+
+        /* XYFlow overrides */
+        .react-flow__edge {
+          cursor: default !important;
+        }
+
+        .react-flow__edge-path {
+          cursor: default !important;
+        }
+
+        .react-flow__edge-label {
+          font-size: 10px;
+          background: white;
+          padding: 2px 4px;
+          border-radius: 4px;
+          border: 1px solid #e5e7eb;
+          max-width: 150px;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+        }
+
+        /* Dark theme XYFlow overrides */
+        html.dark .react-flow__edge-label {
+          background: #1e293b;
+          border: 1px solid #475569;
+          color: #f1f5f9;
+        }
+
+        /* Radix UI Select styles */
+        [data-radix-select-trigger],
+        .shadcn-select {
+          display: flex;
+          height: 2.5rem;
+          width: 100%;
+          align-items: center;
+          justify-content: space-between;
+          border-radius: 0.375rem;
+          border: 1px solid #e5e7eb;
+          background-color: #ffffff;
+          padding: 0.5rem 0.75rem;
+          font-size: 0.875rem;
+          line-height: 1.25rem;
+          outline: none;
+          transition: all 0.2s ease-in-out;
+        }
+
+        /* Dark theme select styles */
+        html.dark [data-radix-select-trigger],
+        html.dark .shadcn-select {
+          border: 1px solid #475569;
+          background-color: #1e293b;
+          color: #f1f5f9;
+        }
+
+        [data-radix-select-trigger]:focus,
+        .shadcn-select:focus {
+          outline: none;
+          box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.2);
+        }
+
+        [data-radix-select-trigger]:disabled,
+        .shadcn-select:disabled {
+          cursor: not-allowed;
+          opacity: 0.5;
+        }
+
+        /* File selector refresh button styles */
+        .file-selector-refresh-btn {
+          padding: 0.5rem;
+          border-radius: 0.375rem;
+          border: 1px solid #e5e7eb;
+          background-color: #ffffff;
+          transition: all 0.2s ease-in-out;
+        }
+
+        .file-selector-refresh-btn:hover {
+          background-color: #f3f4f6;
+          color: #374151;
+        }
+
+        .file-selector-refresh-btn:disabled {
+          opacity: 0.5;
+          cursor: not-allowed;
+        }
+
+        /* Dark theme file selector refresh button */
+        html.dark .file-selector-refresh-btn {
+          border: 1px solid #475569;
+          background-color: #1e293b;
+          color: #f1f5f9;
+        }
+
+        html.dark .file-selector-refresh-btn:hover {
+          background-color: #334155;
+          color: #f1f5f9;
+        }
+
+        /* CSS Variables for backward compatibility */
+        :root {
+          --background: #ffffff;
+          --foreground: #1f2937;
+          --card: #ffffff;
+          --card-foreground: #1f2937;
+          --popover: #ffffff;
+          --popover-foreground: #1f2937;
+          --primary: #6366f1;
+          --primary-foreground: #ffffff;
+          --secondary: #f3f4f6;
+          --secondary-foreground: #1f2937;
+          --muted: #f3f4f6;
+          --muted-foreground: #6b7280;
+          --accent: #f3f4f6;
+          --accent-foreground: #1f2937;
+          --destructive: #ef4444;
+          --destructive-foreground: #ffffff;
+          --border: #e5e7eb;
+          --input: #e5e7eb;
+          --ring: #6366f1;
+          --radius: 0.5rem;
+        }
+
+        /* Dark theme CSS variables */
+        html.dark {
+          --background: #0f172a;
+          --foreground: #f1f5f9;
+          --card: #1e293b;
+          --card-foreground: #f1f5f9;
+          --popover: #1e293b;
+          --popover-foreground: #f1f5f9;
+          --primary: #6366f1;
+          --primary-foreground: #ffffff;
+          --secondary: #334155;
+          --secondary-foreground: #f1f5f9;
+          --muted: #334155;
+          --muted-foreground: #94a3b8;
+          --accent: #334155;
+          --accent-foreground: #f1f5f9;
+          --destructive: #ef4444;
+          --destructive-foreground: #ffffff;
+          --border: #475569;
+          --input: #475569;
+          --ring: #6366f1;
+          --radius: 0.5rem;
+        }
+      `
+    });
 };
 
 /**
@@ -27012,7 +27485,6 @@ const GlobalStyles = ()=>{
 exports.AgenticFlowVisualizer = AgenticFlowVisualizer;
 exports.AnthropicIcon = AnthropicIcon;
 exports.Badge = Badge;
-exports.Checkbox = Checkbox;
 exports.Drawer = Drawer;
 exports.Edge = Edge;
 exports.FileSelector = FileSelector;