@almadar/ui 2.16.0 → 2.17.0

package/dist/runtime/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var React113 = require('react');
+var React110 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 require('@tanstack/react-query');
 require('react-dom');
@@ -20,12 +20,6 @@ var remarkMath = require('remark-math');
 var rehypeKatex = require('rehype-katex');
 var SyntaxHighlighter = require('react-syntax-highlighter/dist/esm/prism');
 var dark = require('react-syntax-highlighter/dist/esm/styles/prism/vsc-dark-plus');
-var fiber = require('@react-three/fiber');
-var drei = require('@react-three/drei');
-var THREE = require('three');
-var GLTFLoader = require('three/examples/jsm/loaders/GLTFLoader');
-var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
-var OBJLoader_js = require('three/examples/jsm/loaders/OBJLoader.js');
 var core = require('@almadar/core');
 var runtime = require('@almadar/runtime');
 
@@ -49,7 +43,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React113__namespace = /*#__PURE__*/_interopNamespace(React113);
+var React110__namespace = /*#__PURE__*/_interopNamespace(React110);
 var LucideIcons__namespace = /*#__PURE__*/_interopNamespace(LucideIcons);
 var L__default = /*#__PURE__*/_interopDefault(L);
 var ReactMarkdown__default = /*#__PURE__*/_interopDefault(ReactMarkdown);
@@ -58,12 +52,11 @@ var remarkMath__default = /*#__PURE__*/_interopDefault(remarkMath);
 var rehypeKatex__default = /*#__PURE__*/_interopDefault(rehypeKatex);
 var SyntaxHighlighter__default = /*#__PURE__*/_interopDefault(SyntaxHighlighter);
 var dark__default = /*#__PURE__*/_interopDefault(dark);
-var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var EventBusContext = React113.createContext(null);
+var EventBusContext = React110.createContext(null);
 function getGlobalEventBus() {
   if (typeof window !== "undefined") {
     return window.__kflowEventBus ?? null;
@@ -131,20 +124,11 @@ var fallbackEventBus = {
   }
 };
 function useEventBus() {
-  const context = React113.useContext(EventBusContext);
+  const context = React110.useContext(EventBusContext);
   return context ?? getGlobalEventBus() ?? fallbackEventBus;
 }
-function useEmitEvent() {
-  const eventBus = useEventBus();
-  return React113.useCallback(
-    (type, payload) => {
-      eventBus.emit(type, payload);
-    },
-    [eventBus]
-  );
-}
-React113.createContext(null);
-React113.createContext(null);
+React110.createContext(null);
+React110.createContext(null);
 
 // lib/api-client.ts
 typeof process !== "undefined" && process.env?.VITE_API_URL ? process.env.VITE_API_URL : "/api";
@@ -258,7 +242,7 @@ var en_default = {
 // hooks/useTranslate.ts
 var { $meta: _meta, ...coreMessages } = en_default;
 var coreLocale = coreMessages;
-var I18nContext = React113.createContext({
+var I18nContext = React110.createContext({
   locale: "en",
   direction: "ltr",
   t: (key) => coreLocale[key] ?? key
@@ -267,13 +251,13 @@ var I18nContext = React113.createContext({
 I18nContext.displayName = "I18nContext";
 I18nContext.Provider;
 function useTranslate() {
-  return React113.useContext(I18nContext);
+  return React110.useContext(I18nContext);
 }
 typeof process !== "undefined" && process.env?.VITE_API_URL ? process.env.VITE_API_URL : "http://localhost:3000";
-React113.createContext(void 0);
-var FetchedDataContext = React113.createContext(null);
+React110.createContext(void 0);
+var FetchedDataContext = React110.createContext(null);
 function useFetchedDataContext() {
-  return React113.useContext(FetchedDataContext);
+  return React110.useContext(FetchedDataContext);
 }
 function cn(...inputs) {
   return tailwindMerge.twMerge(clsx.clsx(inputs));
@@ -415,7 +399,7 @@ var positionStyles = {
   fixed: "fixed",
   sticky: "sticky"
 };
-var Box = React113__namespace.default.forwardRef(
+var Box = React110__namespace.default.forwardRef(
   ({
     padding,
     paddingX,
@@ -434,7 +418,7 @@ var Box = React113__namespace.default.forwardRef(
     position,
     className,
     children,
-    as: Component2 = "div",
+    as: Component = "div",
     action,
     actionPayload,
     hoverEvent,
@@ -444,27 +428,27 @@ var Box = React113__namespace.default.forwardRef(
     ...rest
   }, ref) => {
     const eventBus = useEventBus();
-    const handleClick = React113.useCallback((e) => {
+    const handleClick = React110.useCallback((e) => {
       if (action) {
         e.stopPropagation();
         eventBus.emit(`UI:${action}`, actionPayload ?? {});
       }
       onClick?.(e);
     }, [action, actionPayload, eventBus, onClick]);
-    const handleMouseEnter = React113.useCallback((e) => {
+    const handleMouseEnter = React110.useCallback((e) => {
       if (hoverEvent) {
         eventBus.emit(`UI:${hoverEvent}`, { hovered: true });
       }
       onMouseEnter?.(e);
     }, [hoverEvent, eventBus, onMouseEnter]);
-    const handleMouseLeave = React113.useCallback((e) => {
+    const handleMouseLeave = React110.useCallback((e) => {
       if (hoverEvent) {
         eventBus.emit(`UI:${hoverEvent}`, { hovered: false });
       }
       onMouseLeave?.(e);
     }, [hoverEvent, eventBus, onMouseLeave]);
     const isClickable = action || onClick;
-    const Comp = Component2;
+    const Comp = Component;
     return /* @__PURE__ */ jsxRuntime.jsx(
       Comp,
       {
@@ -594,8 +578,8 @@ var Typography = ({
   children
 }) => {
   const variant = variantProp ?? (level ? `h${level}` : "body1");
-  const Component2 = as || defaultElements[variant];
-  const Comp = Component2;
+  const Component = as || defaultElements[variant];
+  const Comp = Component;
   return /* @__PURE__ */ jsxRuntime.jsx(
     Comp,
     {
@@ -685,7 +669,7 @@ function resolveIconProp(value, sizeClass) {
     const IconComp = value;
     return /* @__PURE__ */ jsxRuntime.jsx(IconComp, { className: sizeClass });
   }
-  if (React113__namespace.default.isValidElement(value)) {
+  if (React110__namespace.default.isValidElement(value)) {
     return value;
   }
   if (typeof value === "object" && value !== null && "render" in value) {
@@ -694,7 +678,7 @@ function resolveIconProp(value, sizeClass) {
   }
   return value;
 }
-var Button = React113__namespace.default.forwardRef(
+var Button = React110__namespace.default.forwardRef(
   ({
     className,
     variant = "primary",
@@ -789,7 +773,7 @@ var sizeStyles3 = {
   md: "px-2.5 py-1 text-sm",
   lg: "px-3 py-1.5 text-base"
 };
-var Badge = React113__namespace.default.forwardRef(
+var Badge = React110__namespace.default.forwardRef(
   ({ className, variant = "default", size = "sm", amount, label, icon, children, ...props }, ref) => {
     const iconSizes2 = { sm: "w-3 h-3", md: "w-3.5 h-3.5", lg: "w-4 h-4" };
     const resolvedIcon = typeof icon === "string" ? (() => {
@@ -816,7 +800,7 @@ var Badge = React113__namespace.default.forwardRef(
   }
 );
 Badge.displayName = "Badge";
-var Input = React113__namespace.default.forwardRef(
+var Input = React110__namespace.default.forwardRef(
   ({
     className,
     inputType,
@@ -928,7 +912,7 @@ var Input = React113__namespace.default.forwardRef(
   }
 );
 Input.displayName = "Input";
-var Label = React113__namespace.default.forwardRef(
+var Label = React110__namespace.default.forwardRef(
   ({ className, required, children, ...props }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsxs(
       "label",
@@ -948,7 +932,7 @@ var Label = React113__namespace.default.forwardRef(
   }
 );
 Label.displayName = "Label";
-var Textarea = React113__namespace.default.forwardRef(
+var Textarea = React110__namespace.default.forwardRef(
   ({ className, error, ...props }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       "textarea",
@@ -971,7 +955,7 @@ var Textarea = React113__namespace.default.forwardRef(
   }
 );
 Textarea.displayName = "Textarea";
-var Select = React113__namespace.default.forwardRef(
+var Select = React110__namespace.default.forwardRef(
   ({ className, options, placeholder, error, ...props }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(
@@ -1007,7 +991,7 @@ var Select = React113__namespace.default.forwardRef(
   }
 );
 Select.displayName = "Select";
-var Checkbox = React113__namespace.default.forwardRef(
+var Checkbox = React110__namespace.default.forwardRef(
   ({ className, label, id, ...props }, ref) => {
     const inputId = id || `checkbox-${Math.random().toString(36).substr(2, 9)}`;
     return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center", children: [
@@ -1081,7 +1065,7 @@ var shadowStyles2 = {
   md: "shadow-[var(--shadow-main)]",
   lg: "shadow-[var(--shadow-lg)]"
 };
-var Card = React113__namespace.default.forwardRef(
+var Card = React110__namespace.default.forwardRef(
   ({
     className,
     variant = "bordered",
@@ -1117,9 +1101,9 @@ var Card = React113__namespace.default.forwardRef(
   }
 );
 Card.displayName = "Card";
-var CardHeader = React113__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("mb-4", className), ...props }));
+var CardHeader = React110__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("mb-4", className), ...props }));
 CardHeader.displayName = "CardHeader";
-var CardTitle = React113__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var CardTitle = React110__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "h3",
   {
     ref,
@@ -1132,11 +1116,11 @@ var CardTitle = React113__namespace.default.forwardRef(({ className, ...props },
   }
 ));
 CardTitle.displayName = "CardTitle";
-var CardContent = React113__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("", className), ...props }));
+var CardContent = React110__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("", className), ...props }));
 CardContent.displayName = "CardContent";
 var CardBody = CardContent;
 CardBody.displayName = "CardBody";
-var CardFooter = React113__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var CardFooter = React110__namespace.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "div",
   {
     ref,
@@ -1151,7 +1135,7 @@ var sizeStyles4 = {
   md: "h-6 w-6",
   lg: "h-8 w-8"
 };
-var Spinner = React113__namespace.default.forwardRef(
+var Spinner = React110__namespace.default.forwardRef(
   ({ className, size = "md", ...props }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       "div",
@@ -1165,7 +1149,7 @@ var Spinner = React113__namespace.default.forwardRef(
   }
 );
 Spinner.displayName = "Spinner";
-var Radio = React113__namespace.default.forwardRef(
+var Radio = React110__namespace.default.forwardRef(
   ({
     label,
     helperText,
@@ -1269,7 +1253,7 @@ var Radio = React113__namespace.default.forwardRef(
   }
 );
 Radio.displayName = "Radio";
-var Switch = React113__namespace.forwardRef(
+var Switch = React110__namespace.forwardRef(
   ({
     checked,
     defaultChecked = false,
@@ -1280,10 +1264,10 @@ var Switch = React113__namespace.forwardRef(
     name,
     className
   }, ref) => {
-    const [isChecked, setIsChecked] = React113__namespace.useState(
+    const [isChecked, setIsChecked] = React110__namespace.useState(
       checked !== void 0 ? checked : defaultChecked
     );
-    React113__namespace.useEffect(() => {
+    React110__namespace.useEffect(() => {
       if (checked !== void 0) {
         setIsChecked(checked);
       }
@@ -1377,7 +1361,7 @@ var Stack = ({
   className,
   style,
   children,
-  as: Component2 = "div",
+  as: Component = "div",
   onClick,
   onKeyDown,
   role,
@@ -1395,7 +1379,7 @@ var Stack = ({
   };
   const isHorizontal = direction === "horizontal";
   const directionClass = responsive && isHorizontal ? reverse ? "flex-col-reverse md:flex-row-reverse" : "flex-col md:flex-row" : isHorizontal ? reverse ? "flex-row-reverse" : "flex-row" : reverse ? "flex-col-reverse" : "flex-col";
-  const Comp = Component2;
+  const Comp = Component;
   return /* @__PURE__ */ jsxRuntime.jsx(
     Comp,
     {
@@ -1441,7 +1425,7 @@ var sizeStyles5 = {
   md: "w-2.5 h-2.5",
   lg: "w-3 h-3"
 };
-var StatusDot = React113__namespace.default.forwardRef(
+var StatusDot = React110__namespace.default.forwardRef(
   ({ className, status = "offline", pulse = false, size = "md", label, ...props }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       "span",
@@ -1488,7 +1472,7 @@ var iconMap2 = {
   down: LucideIcons.TrendingDown,
   flat: LucideIcons.ArrowRight
 };
-var TrendIndicator = React113__namespace.default.forwardRef(
+var TrendIndicator = React110__namespace.default.forwardRef(
   ({
     className,
     value,
@@ -1547,7 +1531,7 @@ var thumbSizes = {
   md: "w-4 h-4",
   lg: "w-5 h-5"
 };
-var RangeSlider = React113__namespace.default.forwardRef(
+var RangeSlider = React110__namespace.default.forwardRef(
   ({
     className,
     min = 0,
@@ -1565,14 +1549,14 @@ var RangeSlider = React113__namespace.default.forwardRef(
     formatValue: formatValue5,
     ...props
   }, ref) => {
-    const [isDragging, setIsDragging] = React113.useState(false);
-    const [showTip, setShowTip] = React113.useState(false);
-    const inputRef = React113.useRef(null);
+    const [isDragging, setIsDragging] = React110.useState(false);
+    const [showTip, setShowTip] = React110.useState(false);
+    const inputRef = React110.useRef(null);
     const eventBus = useSafeEventBus();
     const percentage = max !== min ? (value - min) / (max - min) * 100 : 0;
     const bufferedPercentage = buffered !== void 0 ? Math.min(buffered, 100) : void 0;
     const displayValue = formatValue5 ? formatValue5(value) : String(value);
-    const handleChange = React113.useCallback(
+    const handleChange = React110.useCallback(
       (e) => {
         const newValue = Number(e.target.value);
         onChange?.(newValue);
@@ -1750,7 +1734,7 @@ var paddingClasses = {
   md: "py-16",
   lg: "py-24"
 };
-var ContentSection = React113__namespace.default.forwardRef(
+var ContentSection = React110__namespace.default.forwardRef(
   ({ children, background = "default", padding = "lg", id, className }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       Box,
@@ -1803,7 +1787,7 @@ var ErrorState = ({
   );
 };
 ErrorState.displayName = "ErrorState";
-var ErrorBoundary = class extends React113__namespace.default.Component {
+var ErrorBoundary = class extends React110__namespace.default.Component {
   constructor(props) {
     super(props);
     __publicField(this, "reset", () => {
@@ -1844,9 +1828,9 @@ var ErrorBoundary = class extends React113__namespace.default.Component {
   }
 };
 __publicField(ErrorBoundary, "displayName", "ErrorBoundary");
-var ClientEffectConfigContext = React113.createContext(null);
+var ClientEffectConfigContext = React110.createContext(null);
 ClientEffectConfigContext.Provider;
-React113.createContext(null);
+React110.createContext(null);
 var defaultIcon = L__default.default.icon({
   iconUrl: "https://unpkg.com/leaflet@1.9.4/dist/images/marker-icon.png",
   iconRetinaUrl: "https://unpkg.com/leaflet@1.9.4/dist/images/marker-icon-2x.png",
@@ -1978,7 +1962,7 @@ function waitForTransition(event, timeoutMs = 1e4) {
   });
 }
 exposeOnWindow();
-var MarkdownContent = React113__namespace.default.memo(
+var MarkdownContent = React110__namespace.default.memo(
   ({ content, direction, className }) => {
     const { t: _t } = useTranslate();
     return /* @__PURE__ */ jsxRuntime.jsx(
@@ -2079,7 +2063,7 @@ var MarkdownContent = React113__namespace.default.memo(
   (prev, next) => prev.content === next.content && prev.className === next.className && prev.direction === next.direction
 );
 MarkdownContent.displayName = "MarkdownContent";
-var CodeBlock = React113__namespace.default.memo(
+var CodeBlock = React110__namespace.default.memo(
   ({
     code,
     language = "text",
@@ -2090,20 +2074,20 @@ var CodeBlock = React113__namespace.default.memo(
   }) => {
     const eventBus = useEventBus();
     const { t: _t } = useTranslate();
-    const scrollRef = React113.useRef(null);
-    const savedScrollLeftRef = React113.useRef(0);
-    const [copied, setCopied] = React113.useState(false);
-    React113.useLayoutEffect(() => {
+    const scrollRef = React110.useRef(null);
+    const savedScrollLeftRef = React110.useRef(0);
+    const [copied, setCopied] = React110.useState(false);
+    React110.useLayoutEffect(() => {
       const el = scrollRef.current;
       return () => {
         if (el) savedScrollLeftRef.current = el.scrollLeft;
       };
     }, [language, code]);
-    React113.useLayoutEffect(() => {
+    React110.useLayoutEffect(() => {
       const el = scrollRef.current;
       if (el) el.scrollLeft = savedScrollLeftRef.current;
     }, [language, code]);
-    React113.useEffect(() => {
+    React110.useEffect(() => {
       const el = scrollRef.current;
       if (!el) return;
       const handle = () => {
@@ -2186,1394 +2170,12 @@ var CodeBlock = React113__namespace.default.memo(
   (prev, next) => prev.language === next.language && prev.code === next.code && prev.showCopyButton === next.showCopyButton && prev.maxHeight === next.maxHeight
 );
 CodeBlock.displayName = "CodeBlock";
-var Camera3D = React113.forwardRef(
-  ({
-    mode = "isometric",
-    position = [10, 10, 10],
-    target = [0, 0, 0],
-    zoom = 1,
-    fov = 45,
-    enableOrbit = true,
-    minDistance = 2,
-    maxDistance = 100,
-    onChange
-  }, ref) => {
-    const { camera, set, viewport } = fiber.useThree();
-    const controlsRef = React113.useRef(null);
-    const initialPosition = React113.useRef(new THREE__namespace.Vector3(...position));
-    const initialTarget = React113.useRef(new THREE__namespace.Vector3(...target));
-    React113.useEffect(() => {
-      let newCamera;
-      if (mode === "isometric") {
-        const aspect = viewport.aspect;
-        const size = 10 / zoom;
-        newCamera = new THREE__namespace.OrthographicCamera(
-          -size * aspect,
-          size * aspect,
-          size,
-          -size,
-          0.1,
-          1e3
-        );
-      } else {
-        newCamera = new THREE__namespace.PerspectiveCamera(fov, viewport.aspect, 0.1, 1e3);
-      }
-      newCamera.position.copy(initialPosition.current);
-      newCamera.lookAt(initialTarget.current);
-      set({ camera: newCamera });
-      if (mode === "top-down") {
-        newCamera.position.set(0, 20 / zoom, 0);
-        newCamera.lookAt(0, 0, 0);
-      }
-      return () => {
-      };
-    }, [mode, fov, zoom, viewport.aspect, set]);
-    fiber.useFrame(() => {
-      if (onChange) {
-        onChange(camera);
-      }
-    });
-    React113.useImperativeHandle(ref, () => ({
-      getCamera: () => camera,
-      setPosition: (x, y, z) => {
-        camera.position.set(x, y, z);
-        if (controlsRef.current) {
-          controlsRef.current.update();
-        }
-      },
-      lookAt: (x, y, z) => {
-        camera.lookAt(x, y, z);
-        if (controlsRef.current) {
-          controlsRef.current.target.set(x, y, z);
-          controlsRef.current.update();
-        }
-      },
-      reset: () => {
-        camera.position.copy(initialPosition.current);
-        camera.lookAt(initialTarget.current);
-        if (controlsRef.current) {
-          controlsRef.current.target.copy(initialTarget.current);
-          controlsRef.current.update();
-        }
-      },
-      getViewBounds: () => {
-        const min = new THREE__namespace.Vector3(-10, -10, -10);
-        const max = new THREE__namespace.Vector3(10, 10, 10);
-        return { min, max };
-      }
-    }));
-    const maxPolarAngle = mode === "top-down" ? 0.1 : Math.PI / 2 - 0.1;
-    return /* @__PURE__ */ jsxRuntime.jsx(
-      drei.OrbitControls,
-      {
-        ref: controlsRef,
-        camera,
-        enabled: enableOrbit,
-        target: initialTarget.current,
-        minDistance,
-        maxDistance,
-        maxPolarAngle,
-        enableDamping: true,
-        dampingFactor: 0.05
-      }
-    );
-  }
-);
-Camera3D.displayName = "Camera3D";
-var Canvas3DErrorBoundary = class extends React113.Component {
-  constructor(props) {
-    super(props);
-    __publicField(this, "handleReset", () => {
-      this.setState({
-        hasError: false,
-        error: null,
-        errorInfo: null
-      });
-      this.props.onReset?.();
-    });
-    this.state = {
-      hasError: false,
-      error: null,
-      errorInfo: null
-    };
-  }
-  static getDerivedStateFromError(error) {
-    return {
-      hasError: true,
-      error,
-      errorInfo: null
-    };
-  }
-  componentDidCatch(error, errorInfo) {
-    this.setState({ errorInfo });
-    this.props.onError?.(error, errorInfo);
-    console.error("[Canvas3DErrorBoundary] Error caught:", error);
-    console.error("[Canvas3DErrorBoundary] Component stack:", errorInfo.componentStack);
-  }
-  render() {
-    if (this.state.hasError) {
-      if (this.props.fallback) {
-        return this.props.fallback;
-      }
-      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-error", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-error__content", children: [
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-error__icon", children: "\u26A0\uFE0F" }),
-        /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "canvas-3d-error__title", children: "3D Scene Error" }),
-        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "canvas-3d-error__message", children: "Something went wrong while rendering the 3D scene." }),
-        this.state.error && /* @__PURE__ */ jsxRuntime.jsxs("details", { className: "canvas-3d-error__details", children: [
-          /* @__PURE__ */ jsxRuntime.jsx("summary", { children: "Error Details" }),
-          /* @__PURE__ */ jsxRuntime.jsxs("pre", { className: "error__stack", children: [
-            this.state.error.message,
-            "\n",
-            this.state.error.stack
-          ] }),
-          this.state.errorInfo && /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "error__component-stack", children: this.state.errorInfo.componentStack })
-        ] }),
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-error__actions", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "button",
-            {
-              className: "error__button error__button--primary",
-              onClick: this.handleReset,
-              children: "Try Again"
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "button",
-            {
-              className: "error__button error__button--secondary",
-              onClick: () => window.location.reload(),
-              children: "Reload Page"
-            }
-          )
-        ] })
-      ] }) });
-    }
-    return this.props.children;
-  }
-};
-function Canvas3DLoadingState({
-  progress = 0,
-  loaded = 0,
-  total = 0,
-  message = "Loading 3D Scene...",
-  details,
-  showSpinner = true,
-  className
-}) {
-  const clampedProgress = Math.max(0, Math.min(100, progress));
-  const hasProgress = total > 0;
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `canvas-3d-loading ${className || ""}`, children: [
-    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-loading__content", children: [
-      showSpinner && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-loading__spinner", children: [
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "spinner__ring" }),
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "spinner__ring spinner__ring--secondary" })
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-loading__message", children: message }),
-      details && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-loading__details", children: details }),
-      hasProgress && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-loading__progress", children: [
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "progress__bar", children: /* @__PURE__ */ jsxRuntime.jsx(
-          "div",
-          {
-            className: "progress__fill",
-            style: { width: `${clampedProgress}%` }
-          }
-        ) }),
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "progress__text", children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "progress__percentage", children: [
-            clampedProgress,
-            "%"
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "progress__count", children: [
-            "(",
-            loaded,
-            "/",
-            total,
-            ")"
-          ] })
-        ] })
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-loading__background", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg__grid" }) })
-  ] });
-}
 
 // lib/debug.ts
 typeof window !== "undefined" && (localStorage.getItem("debug") === "true" || process.env.NODE_ENV === "development");
-React113.lazy(() => import('react-markdown'));
-var GameAudioContext = React113.createContext(null);
+React110.lazy(() => import('react-markdown'));
+var GameAudioContext = React110.createContext(null);
 GameAudioContext.displayName = "GameAudioContext";
-function detectAssetRoot2(modelUrl) {
-  const idx = modelUrl.indexOf("/3d/");
-  if (idx !== -1) {
-    return modelUrl.substring(0, idx + 4);
-  }
-  return modelUrl.substring(0, modelUrl.lastIndexOf("/") + 1);
-}
-function createGLTFLoaderForUrl(url) {
-  const loader = new GLTFLoader_js.GLTFLoader();
-  loader.setResourcePath(detectAssetRoot2(url));
-  return loader;
-}
-var AssetLoader = class {
-  constructor() {
-    __publicField(this, "objLoader");
-    __publicField(this, "textureLoader");
-    __publicField(this, "modelCache");
-    __publicField(this, "textureCache");
-    __publicField(this, "loadingPromises");
-    this.objLoader = new OBJLoader_js.OBJLoader();
-    this.textureLoader = new THREE__namespace.TextureLoader();
-    this.modelCache = /* @__PURE__ */ new Map();
-    this.textureCache = /* @__PURE__ */ new Map();
-    this.loadingPromises = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Load a GLB/GLTF model
-   * @param url - URL to the .glb or .gltf file
-   * @returns Promise with loaded model scene and animations
-   */
-  async loadModel(url) {
-    if (this.modelCache.has(url)) {
-      return this.modelCache.get(url);
-    }
-    if (this.loadingPromises.has(url)) {
-      return this.loadingPromises.get(url);
-    }
-    const loader = createGLTFLoaderForUrl(url);
-    const loadPromise = loader.loadAsync(url).then((gltf) => {
-      const result = {
-        scene: gltf.scene,
-        animations: gltf.animations || []
-      };
-      this.modelCache.set(url, result);
-      this.loadingPromises.delete(url);
-      return result;
-    }).catch((error) => {
-      this.loadingPromises.delete(url);
-      throw new Error(`Failed to load model ${url}: ${error.message}`);
-    });
-    this.loadingPromises.set(url, loadPromise);
-    return loadPromise;
-  }
-  /**
-   * Load an OBJ model (fallback for non-GLB assets)
-   * @param url - URL to the .obj file
-   * @returns Promise with loaded object group
-   */
-  async loadOBJ(url) {
-    if (this.modelCache.has(url)) {
-      return this.modelCache.get(url).scene;
-    }
-    if (this.loadingPromises.has(url)) {
-      const result = await this.loadingPromises.get(url);
-      return result.scene;
-    }
-    const loadPromise = this.objLoader.loadAsync(url).then((group) => {
-      const result = {
-        scene: group,
-        animations: []
-      };
-      this.modelCache.set(url, result);
-      this.loadingPromises.delete(url);
-      return result;
-    }).catch((error) => {
-      this.loadingPromises.delete(url);
-      throw new Error(`Failed to load OBJ ${url}: ${error.message}`);
-    });
-    this.loadingPromises.set(url, loadPromise);
-    return (await loadPromise).scene;
-  }
-  /**
-   * Load a texture
-   * @param url - URL to the texture image
-   * @returns Promise with loaded texture
-   */
-  async loadTexture(url) {
-    if (this.textureCache.has(url)) {
-      return this.textureCache.get(url);
-    }
-    if (this.loadingPromises.has(`texture:${url}`)) {
-      return this.loadingPromises.get(`texture:${url}`);
-    }
-    const loadPromise = this.textureLoader.loadAsync(url).then((texture) => {
-      texture.colorSpace = THREE__namespace.SRGBColorSpace;
-      this.textureCache.set(url, texture);
-      this.loadingPromises.delete(`texture:${url}`);
-      return texture;
-    }).catch((error) => {
-      this.loadingPromises.delete(`texture:${url}`);
-      throw new Error(`Failed to load texture ${url}: ${error.message}`);
-    });
-    this.loadingPromises.set(`texture:${url}`, loadPromise);
-    return loadPromise;
-  }
-  /**
-   * Preload multiple assets
-   * @param urls - Array of asset URLs to preload
-   * @returns Promise that resolves when all assets are loaded
-   */
-  async preload(urls) {
-    const promises = urls.map((url) => {
-      if (url.endsWith(".glb") || url.endsWith(".gltf")) {
-        return this.loadModel(url).catch(() => null);
-      } else if (url.endsWith(".obj")) {
-        return this.loadOBJ(url).catch(() => null);
-      } else if (/\.(png|jpg|jpeg|webp)$/i.test(url)) {
-        return this.loadTexture(url).catch(() => null);
-      }
-      return Promise.resolve(null);
-    });
-    await Promise.all(promises);
-  }
-  /**
-   * Check if a model is cached
-   * @param url - Model URL
-   */
-  hasModel(url) {
-    return this.modelCache.has(url);
-  }
-  /**
-   * Check if a texture is cached
-   * @param url - Texture URL
-   */
-  hasTexture(url) {
-    return this.textureCache.has(url);
-  }
-  /**
-   * Get cached model (throws if not cached)
-   * @param url - Model URL
-   */
-  getModel(url) {
-    const model = this.modelCache.get(url);
-    if (!model) {
-      throw new Error(`Model ${url} not in cache`);
-    }
-    return model;
-  }
-  /**
-   * Get cached texture (throws if not cached)
-   * @param url - Texture URL
-   */
-  getTexture(url) {
-    const texture = this.textureCache.get(url);
-    if (!texture) {
-      throw new Error(`Texture ${url} not in cache`);
-    }
-    return texture;
-  }
-  /**
-   * Clear all caches
-   */
-  clearCache() {
-    this.textureCache.forEach((texture) => {
-      texture.dispose();
-    });
-    this.modelCache.forEach((model) => {
-      model.scene.traverse((child) => {
-        if (child instanceof THREE__namespace.Mesh) {
-          child.geometry.dispose();
-          if (Array.isArray(child.material)) {
-            child.material.forEach((m) => m.dispose());
-          } else {
-            child.material.dispose();
-          }
-        }
-      });
-    });
-    this.modelCache.clear();
-    this.textureCache.clear();
-    this.loadingPromises.clear();
-  }
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    return {
-      models: this.modelCache.size,
-      textures: this.textureCache.size,
-      loading: this.loadingPromises.size
-    };
-  }
-};
-new AssetLoader();
-function useAssetLoader(options = {}) {
-  const { preloadUrls = [], loader: customLoader } = options;
-  const loaderRef = React113.useRef(customLoader || new AssetLoader());
-  const [state, setState] = React113.useState({
-    isLoading: false,
-    progress: 0,
-    loaded: 0,
-    total: 0,
-    errors: []
-  });
-  React113.useEffect(() => {
-    if (preloadUrls.length > 0) {
-      preload(preloadUrls);
-    }
-  }, []);
-  const updateProgress = React113.useCallback((loaded, total) => {
-    setState((prev) => ({
-      ...prev,
-      loaded,
-      total,
-      progress: total > 0 ? Math.round(loaded / total * 100) : 0
-    }));
-  }, []);
-  const loadModel = React113.useCallback(
-    async (url) => {
-      setState((prev) => ({ ...prev, isLoading: true }));
-      try {
-        const model = await loaderRef.current.loadModel(url);
-        setState((prev) => ({
-          ...prev,
-          isLoading: false,
-          loaded: prev.loaded + 1
-        }));
-        return model;
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        setState((prev) => ({
-          ...prev,
-          isLoading: false,
-          errors: [...prev.errors, errorMsg]
-        }));
-        throw error;
-      }
-    },
-    []
-  );
-  const loadOBJ = React113.useCallback(
-    async (url) => {
-      setState((prev) => ({ ...prev, isLoading: true }));
-      try {
-        const model = await loaderRef.current.loadOBJ(url);
-        setState((prev) => ({
-          ...prev,
-          isLoading: false,
-          loaded: prev.loaded + 1
-        }));
-        return model;
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        setState((prev) => ({
-          ...prev,
-          isLoading: false,
-          errors: [...prev.errors, errorMsg]
-        }));
-        throw error;
-      }
-    },
-    []
-  );
-  const loadTexture = React113.useCallback(
-    async (url) => {
-      setState((prev) => ({ ...prev, isLoading: true }));
-      try {
-        const texture = await loaderRef.current.loadTexture(url);
-        setState((prev) => ({
-          ...prev,
-          isLoading: false,
-          loaded: prev.loaded + 1
-        }));
-        return texture;
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        setState((prev) => ({
-          ...prev,
-          isLoading: false,
-          errors: [...prev.errors, errorMsg]
-        }));
-        throw error;
-      }
-    },
-    []
-  );
-  const preload = React113.useCallback(
-    async (urls) => {
-      setState((prev) => ({
-        ...prev,
-        isLoading: true,
-        total: urls.length,
-        loaded: 0,
-        errors: []
-      }));
-      let completed = 0;
-      const errors = [];
-      await Promise.all(
-        urls.map(async (url) => {
-          try {
-            if (url.endsWith(".glb") || url.endsWith(".gltf")) {
-              await loaderRef.current.loadModel(url);
-            } else if (url.endsWith(".obj")) {
-              await loaderRef.current.loadOBJ(url);
-            } else if (/\.(png|jpg|jpeg|webp)$/i.test(url)) {
-              await loaderRef.current.loadTexture(url);
-            }
-            completed++;
-            updateProgress(completed, urls.length);
-          } catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            errors.push(`${url}: ${errorMsg}`);
-            completed++;
-            updateProgress(completed, urls.length);
-          }
-        })
-      );
-      setState((prev) => ({
-        ...prev,
-        isLoading: false,
-        errors
-      }));
-    },
-    [updateProgress]
-  );
-  const hasModel = React113.useCallback((url) => {
-    return loaderRef.current.hasModel(url);
-  }, []);
-  const hasTexture = React113.useCallback((url) => {
-    return loaderRef.current.hasTexture(url);
-  }, []);
-  const getModel = React113.useCallback((url) => {
-    try {
-      return loaderRef.current.getModel(url);
-    } catch {
-      return void 0;
-    }
-  }, []);
-  const getTexture = React113.useCallback((url) => {
-    try {
-      return loaderRef.current.getTexture(url);
-    } catch {
-      return void 0;
-    }
-  }, []);
-  const clearCache = React113.useCallback(() => {
-    loaderRef.current.clearCache();
-    setState({
-      isLoading: false,
-      progress: 0,
-      loaded: 0,
-      total: 0,
-      errors: []
-    });
-  }, []);
-  return {
-    ...state,
-    loadModel,
-    loadOBJ,
-    loadTexture,
-    preload,
-    hasModel,
-    hasTexture,
-    getModel,
-    getTexture,
-    clearCache
-  };
-}
-function useGameCanvas3DEvents(options) {
-  const {
-    tileClickEvent,
-    unitClickEvent,
-    featureClickEvent,
-    canvasClickEvent,
-    tileHoverEvent,
-    tileLeaveEvent,
-    unitAnimationEvent,
-    cameraChangeEvent,
-    onTileClick,
-    onUnitClick,
-    onFeatureClick,
-    onCanvasClick,
-    onTileHover,
-    onUnitAnimation
-  } = options;
-  const emit = useEmitEvent();
-  const optionsRef = React113.useRef(options);
-  optionsRef.current = options;
-  const handleTileClick = React113.useCallback(
-    (tile, event) => {
-      if (tileClickEvent) {
-        emit(tileClickEvent, {
-          tileId: tile.id,
-          x: tile.x,
-          z: tile.z ?? tile.y ?? 0,
-          type: tile.type,
-          terrain: tile.terrain,
-          elevation: tile.elevation
-        });
-      }
-      optionsRef.current.onTileClick?.(tile, event);
-    },
-    [tileClickEvent, emit]
-  );
-  const handleUnitClick = React113.useCallback(
-    (unit, event) => {
-      if (unitClickEvent) {
-        emit(unitClickEvent, {
-          unitId: unit.id,
-          x: unit.x,
-          z: unit.z ?? unit.y ?? 0,
-          unitType: unit.unitType,
-          name: unit.name,
-          team: unit.team,
-          faction: unit.faction,
-          health: unit.health,
-          maxHealth: unit.maxHealth
-        });
-      }
-      optionsRef.current.onUnitClick?.(unit, event);
-    },
-    [unitClickEvent, emit]
-  );
-  const handleFeatureClick = React113.useCallback(
-    (feature, event) => {
-      if (featureClickEvent) {
-        emit(featureClickEvent, {
-          featureId: feature.id,
-          x: feature.x,
-          z: feature.z ?? feature.y ?? 0,
-          type: feature.type,
-          elevation: feature.elevation
-        });
-      }
-      optionsRef.current.onFeatureClick?.(feature, event);
-    },
-    [featureClickEvent, emit]
-  );
-  const handleCanvasClick = React113.useCallback(
-    (event) => {
-      if (canvasClickEvent) {
-        emit(canvasClickEvent, {
-          clientX: event.clientX,
-          clientY: event.clientY,
-          button: event.button
-        });
-      }
-      optionsRef.current.onCanvasClick?.(event);
-    },
-    [canvasClickEvent, emit]
-  );
-  const handleTileHover = React113.useCallback(
-    (tile, event) => {
-      if (tile) {
-        if (tileHoverEvent) {
-          emit(tileHoverEvent, {
-            tileId: tile.id,
-            x: tile.x,
-            z: tile.z ?? tile.y ?? 0,
-            type: tile.type
-          });
-        }
-      } else {
-        if (tileLeaveEvent) {
-          emit(tileLeaveEvent, {});
-        }
-      }
-      optionsRef.current.onTileHover?.(tile, event);
-    },
-    [tileHoverEvent, tileLeaveEvent, emit]
-  );
-  const handleUnitAnimation = React113.useCallback(
-    (unitId, state) => {
-      if (unitAnimationEvent) {
-        emit(unitAnimationEvent, {
-          unitId,
-          state,
-          timestamp: Date.now()
-        });
-      }
-      optionsRef.current.onUnitAnimation?.(unitId, state);
-    },
-    [unitAnimationEvent, emit]
-  );
-  const handleCameraChange = React113.useCallback(
-    (position) => {
-      if (cameraChangeEvent) {
-        emit(cameraChangeEvent, {
-          position,
-          timestamp: Date.now()
-        });
-      }
-    },
-    [cameraChangeEvent, emit]
-  );
-  return {
-    handleTileClick,
-    handleUnitClick,
-    handleFeatureClick,
-    handleCanvasClick,
-    handleTileHover,
-    handleUnitAnimation,
-    handleCameraChange
-  };
-}
-function detectAssetRoot3(modelUrl) {
-  const idx = modelUrl.indexOf("/3d/");
-  if (idx !== -1) {
-    return modelUrl.substring(0, idx + 4);
-  }
-  return modelUrl.substring(0, modelUrl.lastIndexOf("/") + 1);
-}
-function useGLTFModel2(url, resourceBasePath) {
-  const [state, setState] = React113.useState({
-    model: null,
-    isLoading: false,
-    error: null
-  });
-  React113.useEffect(() => {
-    if (!url) {
-      setState({ model: null, isLoading: false, error: null });
-      return;
-    }
-    console.log("[ModelLoader] Loading:", url);
-    setState((prev) => ({ ...prev, isLoading: true, error: null }));
-    const assetRoot = resourceBasePath || detectAssetRoot3(url);
-    const loader = new GLTFLoader.GLTFLoader();
-    loader.setResourcePath(assetRoot);
-    loader.load(
-      url,
-      (gltf) => {
-        console.log("[ModelLoader] Loaded:", url);
-        setState({
-          model: gltf.scene,
-          isLoading: false,
-          error: null
-        });
-      },
-      void 0,
-      (err) => {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        console.warn("[ModelLoader] Failed:", url, errorMsg);
-        setState({
-          model: null,
-          isLoading: false,
-          error: err instanceof Error ? err : new Error(String(err))
-        });
-      }
-    );
-  }, [url, resourceBasePath]);
-  return state;
-}
-function ModelLoader({
-  url,
-  position = [0, 0, 0],
-  scale = 1,
-  rotation = [0, 0, 0],
-  isSelected = false,
-  isHovered = false,
-  onClick,
-  onHover,
-  fallbackGeometry = "box",
-  castShadow = true,
-  receiveShadow = true,
-  resourceBasePath
-}) {
-  const { model: loadedModel, isLoading, error } = useGLTFModel2(url, resourceBasePath);
-  const model = React113.useMemo(() => {
-    if (!loadedModel) return null;
-    const cloned = loadedModel.clone();
-    cloned.traverse((child) => {
-      if (child instanceof THREE__namespace.Mesh) {
-        child.castShadow = castShadow;
-        child.receiveShadow = receiveShadow;
-      }
-    });
-    return cloned;
-  }, [loadedModel, castShadow, receiveShadow]);
-  const scaleArray = React113.useMemo(() => {
-    if (typeof scale === "number") {
-      return [scale, scale, scale];
-    }
-    return scale;
-  }, [scale]);
-  const rotationRad = React113.useMemo(() => {
-    return [
-      rotation[0] * Math.PI / 180,
-      rotation[1] * Math.PI / 180,
-      rotation[2] * Math.PI / 180
-    ];
-  }, [rotation]);
-  if (isLoading) {
-    return /* @__PURE__ */ jsxRuntime.jsx("group", { position, children: /* @__PURE__ */ jsxRuntime.jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [
-      /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.3, 0.35, 16] }),
-      /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#4a90d9", transparent: true, opacity: 0.8 })
-    ] }) });
-  }
-  if (error || !model) {
-    if (fallbackGeometry === "none") {
-      return /* @__PURE__ */ jsxRuntime.jsx("group", { position });
-    }
-    const fallbackProps = {
-      onClick,
-      onPointerOver: () => onHover?.(true),
-      onPointerOut: () => onHover?.(false)
-    };
-    return /* @__PURE__ */ jsxRuntime.jsxs("group", { position, children: [
-      (isSelected || isHovered) && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.02, 0], rotation: [-Math.PI / 2, 0, 0], children: [
-        /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.6, 0.7, 32] }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          "meshBasicMaterial",
-          {
-            color: isSelected ? 16755200 : 16777215,
-            transparent: true,
-            opacity: 0.5
-          }
-        )
-      ] }),
-      fallbackGeometry === "box" && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { ...fallbackProps, position: [0, 0.5, 0], children: [
-        /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [0.8, 0.8, 0.8] }),
-        /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: error ? 16729156 : 8947848 })
-      ] }),
-      fallbackGeometry === "sphere" && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { ...fallbackProps, position: [0, 0.5, 0], children: [
-        /* @__PURE__ */ jsxRuntime.jsx("sphereGeometry", { args: [0.4, 16, 16] }),
-        /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: error ? 16729156 : 8947848 })
-      ] }),
-      fallbackGeometry === "cylinder" && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { ...fallbackProps, position: [0, 0.5, 0], children: [
-        /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.3, 0.3, 0.8, 16] }),
-        /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: error ? 16729156 : 8947848 })
-      ] })
-    ] });
-  }
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "group",
-    {
-      position,
-      rotation: rotationRad,
-      onClick,
-      onPointerOver: () => onHover?.(true),
-      onPointerOut: () => onHover?.(false),
-      children: [
-        (isSelected || isHovered) && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.02, 0], rotation: [-Math.PI / 2, 0, 0], children: [
-          /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.6, 0.7, 32] }),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "meshBasicMaterial",
-            {
-              color: isSelected ? 16755200 : 16777215,
-              transparent: true,
-              opacity: 0.5
-            }
-          )
-        ] }),
-        /* @__PURE__ */ jsxRuntime.jsx("primitive", { object: model, scale: scaleArray })
-      ]
-    }
-  );
-}
-var DEFAULT_GRID_CONFIG = {
-  cellSize: 1,
-  offsetX: 0,
-  offsetZ: 0
-};
-function CameraController({
-  onCameraChange
-}) {
-  const { camera } = fiber.useThree();
-  React113.useEffect(() => {
-    if (onCameraChange) {
-      onCameraChange({
-        x: camera.position.x,
-        y: camera.position.y,
-        z: camera.position.z
-      });
-    }
-  }, [camera.position, onCameraChange]);
-  return null;
-}
-var GameCanvas3D = React113.forwardRef(
-  ({
-    tiles = [],
-    units = [],
-    features = [],
-    events: events2 = [],
-    orientation = "standard",
-    cameraMode = "isometric",
-    showGrid = true,
-    showCoordinates = false,
-    showTileInfo = false,
-    overlay = "default",
-    shadows = true,
-    backgroundColor = "#1a1a2e",
-    onTileClick,
-    onUnitClick,
-    onFeatureClick,
-    onCanvasClick,
-    onTileHover,
-    onUnitAnimation,
-    assetLoader: customAssetLoader,
-    tileRenderer: CustomTileRenderer,
-    unitRenderer: CustomUnitRenderer,
-    featureRenderer: CustomFeatureRenderer,
-    className,
-    isLoading: externalLoading,
-    error: externalError,
-    entity,
-    preloadAssets = [],
-    tileClickEvent,
-    unitClickEvent,
-    featureClickEvent,
-    canvasClickEvent,
-    tileHoverEvent,
-    tileLeaveEvent,
-    unitAnimationEvent,
-    cameraChangeEvent,
-    loadingMessage = "Loading 3D Scene...",
-    useInstancing = true,
-    validMoves = [],
-    attackTargets = [],
-    selectedTileIds = [],
-    selectedUnitId = null,
-    children
-  }, ref) => {
-    const containerRef = React113.useRef(null);
-    const controlsRef = React113.useRef(null);
-    const [hoveredTile, setHoveredTile] = React113.useState(null);
-    const [internalError, setInternalError] = React113.useState(null);
-    const { isLoading: assetsLoading, progress, loaded, total } = useAssetLoader({
-      preloadUrls: preloadAssets,
-      loader: customAssetLoader
-    });
-    const eventHandlers = useGameCanvas3DEvents({
-      tileClickEvent,
-      unitClickEvent,
-      featureClickEvent,
-      canvasClickEvent,
-      tileHoverEvent,
-      tileLeaveEvent,
-      unitAnimationEvent,
-      cameraChangeEvent,
-      onTileClick,
-      onUnitClick,
-      onFeatureClick,
-      onCanvasClick,
-      onTileHover,
-      onUnitAnimation
-    });
-    const gridBounds = React113.useMemo(() => {
-      if (tiles.length === 0) {
-        return { minX: 0, maxX: 10, minZ: 0, maxZ: 10 };
-      }
-      const xs = tiles.map((t) => t.x);
-      const zs = tiles.map((t) => t.z || t.y || 0);
-      return {
-        minX: Math.min(...xs),
-        maxX: Math.max(...xs),
-        minZ: Math.min(...zs),
-        maxZ: Math.max(...zs)
-      };
-    }, [tiles]);
-    const cameraTarget = React113.useMemo(() => {
-      return [
-        (gridBounds.minX + gridBounds.maxX) / 2,
-        0,
-        (gridBounds.minZ + gridBounds.maxZ) / 2
-      ];
-    }, [gridBounds]);
-    const gridConfig = React113.useMemo(
-      () => ({
-        ...DEFAULT_GRID_CONFIG,
-        offsetX: -(gridBounds.maxX - gridBounds.minX) / 2,
-        offsetZ: -(gridBounds.maxZ - gridBounds.minZ) / 2
-      }),
-      [gridBounds]
-    );
-    const gridToWorld = React113.useCallback(
-      (x, z, y = 0) => {
-        const worldX = (x - gridBounds.minX) * gridConfig.cellSize;
-        const worldZ = (z - gridBounds.minZ) * gridConfig.cellSize;
-        return [worldX, y * gridConfig.cellSize, worldZ];
-      },
-      [gridBounds, gridConfig]
-    );
-    React113.useImperativeHandle(ref, () => ({
-      getCameraPosition: () => {
-        if (controlsRef.current) {
-          const pos = controlsRef.current.object.position;
-          return new THREE__namespace.Vector3(pos.x, pos.y, pos.z);
-        }
-        return null;
-      },
-      setCameraPosition: (x, y, z) => {
-        if (controlsRef.current) {
-          controlsRef.current.object.position.set(x, y, z);
-          controlsRef.current.update();
-        }
-      },
-      lookAt: (x, y, z) => {
-        if (controlsRef.current) {
-          controlsRef.current.target.set(x, y, z);
-          controlsRef.current.update();
-        }
-      },
-      resetCamera: () => {
-        if (controlsRef.current) {
-          controlsRef.current.reset();
-        }
-      },
-      screenshot: () => {
-        const canvas = containerRef.current?.querySelector("canvas");
-        if (canvas) {
-          return canvas.toDataURL("image/png");
-        }
-        return null;
-      },
-      export: () => ({
-        tiles,
-        units,
-        features
-      })
-    }));
-    const handleTileClick = React113.useCallback(
-      (tile, event) => {
-        eventHandlers.handleTileClick(tile, event);
-      },
-      [eventHandlers]
-    );
-    const handleUnitClick = React113.useCallback(
-      (unit, event) => {
-        eventHandlers.handleUnitClick(unit, event);
-      },
-      [eventHandlers]
-    );
-    const handleFeatureClick = React113.useCallback(
-      (feature, event) => {
-        if (event) {
-          eventHandlers.handleFeatureClick(feature, event);
-        }
-      },
-      [eventHandlers]
-    );
-    const handleTileHover = React113.useCallback(
-      (tile, event) => {
-        setHoveredTile(tile);
-        if (event) {
-          eventHandlers.handleTileHover(tile, event);
-        }
-      },
-      [eventHandlers]
-    );
-    const cameraConfig = React113.useMemo(() => {
-      const size = Math.max(
-        gridBounds.maxX - gridBounds.minX,
-        gridBounds.maxZ - gridBounds.minZ
-      );
-      const distance = size * 1.5;
-      switch (cameraMode) {
-        case "isometric":
-          return {
-            position: [distance, distance * 0.8, distance],
-            fov: 45
-          };
-        case "top-down":
-          return {
-            position: [0, distance * 2, 0],
-            fov: 45
-          };
-        case "perspective":
-        default:
-          return {
-            position: [distance, distance, distance],
-            fov: 45
-          };
-      }
-    }, [cameraMode, gridBounds]);
-    const DefaultTileRenderer = React113.useCallback(
-      ({ tile, position }) => {
-        const isSelected = tile.id ? selectedTileIds.includes(tile.id) : false;
-        const isHovered = hoveredTile?.id === tile.id;
-        const isValidMove = validMoves.some(
-          (m) => m.x === tile.x && m.z === (tile.z ?? tile.y ?? 0)
-        );
-        const isAttackTarget = attackTargets.some(
-          (m) => m.x === tile.x && m.z === (tile.z ?? tile.y ?? 0)
-        );
-        let color = 8421504;
-        if (tile.type === "water") color = 4491468;
-        else if (tile.type === "grass") color = 4500036;
-        else if (tile.type === "sand") color = 14535816;
-        else if (tile.type === "rock") color = 8947848;
-        else if (tile.type === "snow") color = 15658734;
-        let emissive = 0;
-        if (isSelected) emissive = 4473924;
-        else if (isAttackTarget) emissive = 4456448;
-        else if (isValidMove) emissive = 17408;
-        else if (isHovered) emissive = 2236962;
-        return /* @__PURE__ */ jsxRuntime.jsxs(
-          "mesh",
-          {
-            position,
-            onClick: (e) => handleTileClick(tile, e),
-            onPointerEnter: (e) => handleTileHover(tile, e),
-            onPointerLeave: (e) => handleTileHover(null, e),
-            userData: { type: "tile", tileId: tile.id, gridX: tile.x, gridZ: tile.z ?? tile.y },
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [0.95, 0.2, 0.95] }),
-              /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color, emissive })
-            ]
-          }
-        );
-      },
-      [selectedTileIds, hoveredTile, validMoves, attackTargets, handleTileClick, handleTileHover]
-    );
-    const DefaultUnitRenderer = React113.useCallback(
-      ({ unit, position }) => {
-        const isSelected = selectedUnitId === unit.id;
-        const color = unit.faction === "player" ? 4491519 : unit.faction === "enemy" ? 16729156 : 16777028;
-        return /* @__PURE__ */ jsxRuntime.jsxs(
-          "group",
-          {
-            position,
-            onClick: (e) => handleUnitClick(unit, e),
-            userData: { type: "unit", unitId: unit.id },
-            children: [
-              isSelected && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.05, 0], rotation: [-Math.PI / 2, 0, 0], children: [
-                /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.4, 0.5, 32] }),
-                /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#ffff00", transparent: true, opacity: 0.8 })
-              ] }),
-              /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.3, 0], children: [
-                /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.3, 0.3, 0.1, 8] }),
-                /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
-              ] }),
-              /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.6, 0], children: [
-                /* @__PURE__ */ jsxRuntime.jsx("capsuleGeometry", { args: [0.2, 0.4, 4, 8] }),
-                /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
-              ] }),
-              /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.9, 0], children: [
-                /* @__PURE__ */ jsxRuntime.jsx("sphereGeometry", { args: [0.12, 8, 8] }),
-                /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
-              ] }),
-              unit.health !== void 0 && unit.maxHealth !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("group", { position: [0, 1.2, 0], children: [
-                /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [-0.25, 0, 0], children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [0.5, 0.05] }),
-                  /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: 3355443 })
-                ] }),
-                /* @__PURE__ */ jsxRuntime.jsxs(
-                  "mesh",
-                  {
-                    position: [
-                      -0.25 + 0.5 * (unit.health / unit.maxHealth) / 2,
-                      0,
-                      0.01
-                    ],
-                    children: [
-                      /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [0.5 * (unit.health / unit.maxHealth), 0.05] }),
-                      /* @__PURE__ */ jsxRuntime.jsx(
-                        "meshBasicMaterial",
-                        {
-                          color: unit.health / unit.maxHealth > 0.5 ? 4500036 : unit.health / unit.maxHealth > 0.25 ? 11184708 : 16729156
-                        }
-                      )
-                    ]
-                  }
-                )
-              ] })
-            ]
-          }
-        );
-      },
-      [selectedUnitId, handleUnitClick]
-    );
-    const DefaultFeatureRenderer = React113.useCallback(
-      ({
-        feature,
-        position
-      }) => {
-        if (feature.assetUrl) {
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            ModelLoader,
-            {
-              url: feature.assetUrl,
-              position,
-              scale: 0.5,
-              rotation: [0, feature.rotation ?? 0, 0],
-              onClick: () => handleFeatureClick(feature, null),
-              fallbackGeometry: "box"
-            },
-            feature.id
-          );
-        }
-        if (feature.type === "tree") {
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            "group",
-            {
-              position,
-              onClick: (e) => handleFeatureClick(feature, e),
-              userData: { type: "feature", featureId: feature.id },
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.4, 0], children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.1, 0.15, 0.8, 6] }),
-                  /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: 9127187 })
-                ] }),
-                /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.9, 0], children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("coneGeometry", { args: [0.5, 0.8, 8] }),
-                  /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: 2263842 })
-                ] })
-              ]
-            }
-          );
-        }
-        if (feature.type === "rock") {
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            "mesh",
-            {
-              position: [position[0], position[1] + 0.3, position[2]],
-              onClick: (e) => handleFeatureClick(feature, e),
-              userData: { type: "feature", featureId: feature.id },
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx("dodecahedronGeometry", { args: [0.3, 0] }),
-                /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: 8421504 })
-              ]
-            }
-          );
-        }
-        return null;
-      },
-      [handleFeatureClick]
-    );
-    if (externalLoading || assetsLoading && preloadAssets.length > 0) {
-      return /* @__PURE__ */ jsxRuntime.jsx(
-        Canvas3DLoadingState,
-        {
-          progress,
-          loaded,
-          total,
-          message: loadingMessage,
-          className
-        }
-      );
-    }
-    const displayError = externalError || internalError;
-    if (displayError) {
-      return /* @__PURE__ */ jsxRuntime.jsx(Canvas3DErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "game-canvas-3d game-canvas-3d--error", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "game-canvas-3d__error", children: [
-        "Error: ",
-        displayError
-      ] }) }) });
-    }
-    return /* @__PURE__ */ jsxRuntime.jsx(
-      Canvas3DErrorBoundary,
-      {
-        onError: (err) => setInternalError(err.message),
-        onReset: () => setInternalError(null),
-        children: /* @__PURE__ */ jsxRuntime.jsxs(
-          "div",
-          {
-            ref: containerRef,
-            className: `game-canvas-3d ${className || ""}`,
-            "data-orientation": orientation,
-            "data-camera-mode": cameraMode,
-            "data-overlay": overlay,
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsxs(
-                fiber.Canvas,
-                {
-                  shadows,
-                  camera: {
-                    position: cameraConfig.position,
-                    fov: cameraConfig.fov,
-                    near: 0.1,
-                    far: 1e3
-                  },
-                  style: { background: backgroundColor },
-                  onClick: (e) => {
-                    if (e.target === e.currentTarget) {
-                      eventHandlers.handleCanvasClick(e);
-                    }
-                  },
-                  children: [
-                    /* @__PURE__ */ jsxRuntime.jsx(CameraController, { onCameraChange: eventHandlers.handleCameraChange }),
-                    /* @__PURE__ */ jsxRuntime.jsx("ambientLight", { intensity: 0.6 }),
-                    /* @__PURE__ */ jsxRuntime.jsx(
-                      "directionalLight",
-                      {
-                        position: [10, 20, 10],
-                        intensity: 0.8,
-                        castShadow: shadows,
-                        "shadow-mapSize": [2048, 2048]
-                      }
-                    ),
-                    /* @__PURE__ */ jsxRuntime.jsx("hemisphereLight", { intensity: 0.3, color: "#87ceeb", groundColor: "#362d1d" }),
-                    showGrid && /* @__PURE__ */ jsxRuntime.jsx(
-                      drei.Grid,
-                      {
-                        args: [
-                          Math.max(gridBounds.maxX - gridBounds.minX + 2, 10),
-                          Math.max(gridBounds.maxZ - gridBounds.minZ + 2, 10)
-                        ],
-                        position: [
-                          (gridBounds.maxX - gridBounds.minX) / 2 - 0.5,
-                          0,
-                          (gridBounds.maxZ - gridBounds.minZ) / 2 - 0.5
-                        ],
-                        cellSize: 1,
-                        cellThickness: 1,
-                        cellColor: "#444444",
-                        sectionSize: 5,
-                        sectionThickness: 1.5,
-                        sectionColor: "#666666",
-                        fadeDistance: 50,
-                        fadeStrength: 1
-                      }
-                    ),
-                    tiles.map((tile, index) => {
-                      const position = gridToWorld(
-                        tile.x,
-                        tile.z ?? tile.y ?? 0,
-                        tile.elevation ?? 0
-                      );
-                      const Renderer = CustomTileRenderer || DefaultTileRenderer;
-                      return /* @__PURE__ */ jsxRuntime.jsx(Renderer, { tile, position }, tile.id ?? `tile-${index}`);
-                    }),
-                    features.map((feature, index) => {
-                      const position = gridToWorld(
-                        feature.x,
-                        feature.z ?? feature.y ?? 0,
-                        (feature.elevation ?? 0) + 0.5
-                      );
-                      const Renderer = CustomFeatureRenderer || DefaultFeatureRenderer;
-                      return /* @__PURE__ */ jsxRuntime.jsx(Renderer, { feature, position }, feature.id ?? `feature-${index}`);
-                    }),
-                    units.map((unit) => {
-                      const position = gridToWorld(
-                        unit.x ?? 0,
-                        unit.z ?? unit.y ?? 0,
-                        (unit.elevation ?? 0) + 0.5
-                      );
-                      const Renderer = CustomUnitRenderer || DefaultUnitRenderer;
-                      return /* @__PURE__ */ jsxRuntime.jsx(Renderer, { unit, position }, unit.id);
-                    }),
-                    children,
-                    /* @__PURE__ */ jsxRuntime.jsx(
-                      drei.OrbitControls,
-                      {
-                        ref: controlsRef,
-                        target: cameraTarget,
-                        enableDamping: true,
-                        dampingFactor: 0.05,
-                        minDistance: 2,
-                        maxDistance: 100,
-                        maxPolarAngle: Math.PI / 2 - 0.1
-                      }
-                    )
-                  ]
-                }
-              ),
-              showCoordinates && hoveredTile && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "game-canvas-3d__coordinates", children: [
-                "X: ",
-                hoveredTile.x,
-                ", Z: ",
-                hoveredTile.z ?? hoveredTile.y ?? 0
-              ] }),
-              showTileInfo && hoveredTile && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "game-canvas-3d__tile-info", children: [
-                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "tile-info__type", children: hoveredTile.type }),
-                hoveredTile.terrain && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "tile-info__terrain", children: hoveredTile.terrain })
-              ] })
-            ]
-          }
-        )
-      }
-    );
-  }
-);
-GameCanvas3D.displayName = "GameCanvas3D";
 
 // lib/traitRegistry.ts
 var traits = /* @__PURE__ */ new Map();
@@ -3597,9 +2199,38 @@ function unregisterTrait(id) {
   traits.delete(id);
   notifyListeners2();
 }
-React113.createContext({ enabled: false });
-React113.createContext(false);
-React113.createContext(null);
+
+// components/organisms/component-registry.generated.ts
+function lazyThree(name, loader) {
+  const Lazy = React110__namespace.default.lazy(() => loader().then((m) => ({ default: m[name] })));
+  function ThreeWrapper(props) {
+    return React110__namespace.default.createElement(
+      React110__namespace.default.Suspense,
+      { fallback: null },
+      React110__namespace.default.createElement(Lazy, props)
+    );
+  }
+  ThreeWrapper.displayName = `Lazy(${name})`;
+  return ThreeWrapper;
+}
+lazyThree("Camera3D", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("Canvas3DErrorBoundary", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("Canvas3DLoadingState", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("FeatureRenderer", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("FeatureRenderer3D", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("GameCanvas3D", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("GameCanvas3DBattleTemplate", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("GameCanvas3DCastleTemplate", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("GameCanvas3DWorldMapTemplate", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("Lighting3D", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("ModelLoader", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("PhysicsObject3D", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("Scene3D", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("TileRenderer", () => import('@almadar/ui/components/organisms/game/three'));
+lazyThree("UnitRenderer", () => import('@almadar/ui/components/organisms/game/three'));
+React110.createContext({ enabled: false });
+React110.createContext(false);
+React110.createContext(null);
 
 // runtime/createClientEffectHandlers.ts
 function createClientEffectHandlers(options) {
@@ -3635,19 +2266,19 @@ function createClientEffectHandlers(options) {
     })
   };
 }
-var EntitySchemaContext = React113.createContext(null);
+var EntitySchemaContext = React110.createContext(null);
 function EntitySchemaProvider({
   entities,
   children
 }) {
-  const entitiesMap = React113.useMemo(() => {
+  const entitiesMap = React110.useMemo(() => {
     const map = /* @__PURE__ */ new Map();
     for (const entity of entities) {
       map.set(entity.name, entity);
     }
     return map;
   }, [entities]);
-  const contextValue = React113.useMemo(
+  const contextValue = React110.useMemo(
     () => ({
       entities: entitiesMap
     }),
@@ -3656,7 +2287,7 @@ function EntitySchemaProvider({
   return /* @__PURE__ */ jsxRuntime.jsx(EntitySchemaContext.Provider, { value: contextValue, children });
 }
 function useEntitySchema() {
-  const context = React113.useContext(EntitySchemaContext);
+  const context = React110.useContext(EntitySchemaContext);
   if (!context) {
     throw new Error("useEntitySchema must be used within an EntitySchemaProvider");
   }
@@ -3683,41 +2314,41 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
   const eventBus = useEventBus();
   const { entities } = useEntitySchema();
   const fetchedDataContext = useFetchedDataContext();
-  const manager = React113.useMemo(() => {
+  const manager = React110.useMemo(() => {
     const traitDefs = traitBindings.map(toTraitDefinition);
     return new runtime.StateMachineManager(traitDefs);
   }, [traitBindings]);
-  const [traitStates, setTraitStates] = React113.useState(() => {
+  const [traitStates, setTraitStates] = React110.useState(() => {
     return manager.getAllStates();
   });
-  const eventQueueRef = React113.useRef([]);
-  const processingRef = React113.useRef(false);
-  const traitBindingsRef = React113.useRef(traitBindings);
-  const managerRef = React113.useRef(manager);
-  const slotsActionsRef = React113.useRef(slotsActions);
-  const optionsRef = React113.useRef(options);
-  React113.useEffect(() => {
+  const eventQueueRef = React110.useRef([]);
+  const processingRef = React110.useRef(false);
+  const traitBindingsRef = React110.useRef(traitBindings);
+  const managerRef = React110.useRef(manager);
+  const slotsActionsRef = React110.useRef(slotsActions);
+  const optionsRef = React110.useRef(options);
+  React110.useEffect(() => {
     traitBindingsRef.current = traitBindings;
   }, [traitBindings]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     managerRef.current = manager;
     setTraitStates(manager.getAllStates());
   }, [manager]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     slotsActionsRef.current = slotsActions;
   }, [slotsActions]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     optionsRef.current = options;
   }, [options]);
-  const traitStatesRef = React113.useRef(traitStates);
-  const fetchedDataContextRef = React113.useRef(fetchedDataContext);
-  React113.useEffect(() => {
+  const traitStatesRef = React110.useRef(traitStates);
+  const fetchedDataContextRef = React110.useRef(fetchedDataContext);
+  React110.useEffect(() => {
     traitStatesRef.current = traitStates;
   }, [traitStates]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     fetchedDataContextRef.current = fetchedDataContext;
   }, [fetchedDataContext]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     const mgr = managerRef.current;
     const bindings = traitBindingsRef.current;
     const ids = [];
@@ -3750,7 +2381,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
       }
     };
   }, [traitBindings]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     const newManager = managerRef.current;
     newManager.resetAll();
     setTraitStates(newManager.getAllStates());
@@ -3759,7 +2390,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
       Array.from(newManager.getAllStates().keys()).join(", ")
     );
   }, [traitBindings]);
-  const runTickEffects = React113.useCallback((tick, binding) => {
+  const runTickEffects = React110.useCallback((tick, binding) => {
     const fdc = fetchedDataContextRef.current;
     const actions = slotsActionsRef.current;
     const linkedEntity = binding.linkedEntity ?? "";
@@ -3858,7 +2489,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
       }
     }
   }, []);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     const hasFrameTicks = traitBindingsRef.current.some(
       (b) => b.trait.ticks?.some((t) => t.interval === "frame")
     );
@@ -3881,7 +2512,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
       cancelAnimationFrame(rafId);
     };
   }, [traitBindings, runTickEffects]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     const intervals = [];
     for (const binding of traitBindings) {
       for (const tick of binding.trait.ticks ?? []) {
@@ -3896,7 +2527,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
       for (const id of intervals) clearInterval(id);
     };
   }, [traitBindings, runTickEffects]);
-  const processEventQueued = React113.useCallback(async (eventKey, payload) => {
+  const processEventQueued = React110.useCallback(async (eventKey, payload) => {
     const normalizedEvent = normalizeEventKey(eventKey);
     const bindings = traitBindingsRef.current;
     const currentManager = managerRef.current;
@@ -4163,7 +2794,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
       onEventProcessed(normalizedEvent, payload);
     }
   }, [entities, fetchedDataContext, eventBus]);
-  const drainEventQueue = React113.useCallback(async () => {
+  const drainEventQueue = React110.useCallback(async () => {
     if (processingRef.current) return;
     processingRef.current = true;
     try {
@@ -4175,24 +2806,24 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
       processingRef.current = false;
     }
   }, [processEventQueued]);
-  const enqueueAndDrain = React113.useCallback((eventKey, payload) => {
+  const enqueueAndDrain = React110.useCallback((eventKey, payload) => {
     eventQueueRef.current.push({ eventKey, payload });
     void drainEventQueue();
   }, [drainEventQueue]);
-  React113.useCallback((eventKey, payload) => {
+  React110.useCallback((eventKey, payload) => {
     enqueueAndDrain(eventKey, payload);
   }, [enqueueAndDrain]);
-  const sendEvent = React113.useCallback((eventKey, payload) => {
+  const sendEvent = React110.useCallback((eventKey, payload) => {
     enqueueAndDrain(eventKey, payload);
   }, [enqueueAndDrain]);
-  const getTraitState = React113.useCallback((traitName) => {
+  const getTraitState = React110.useCallback((traitName) => {
     return managerRef.current.getState(traitName);
   }, []);
-  const canHandleEvent = React113.useCallback((traitName, eventKey) => {
+  const canHandleEvent = React110.useCallback((traitName, eventKey) => {
     const normalizedEvent = normalizeEventKey(eventKey);
     return managerRef.current.canHandleEvent(traitName, normalizedEvent);
   }, []);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     const allEvents = /* @__PURE__ */ new Set();
     for (const binding of traitBindings) {
       for (const event of binding.trait.events) {
@@ -4228,9 +2859,9 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
   };
 }
 function useResolvedSchema(schema, pageName) {
-  const [loading, setLoading] = React113.useState(true);
-  const [error, setError] = React113.useState(null);
-  const ir = React113.useMemo(() => {
+  const [loading, setLoading] = React110.useState(true);
+  const [error, setError] = React110.useState(null);
+  const ir = React110.useMemo(() => {
     if (!schema) return null;
     try {
       return core.schemaToIR(schema);
@@ -4239,10 +2870,10 @@ function useResolvedSchema(schema, pageName) {
       return null;
     }
   }, [schema]);
-  React113.useEffect(() => {
+  React110.useEffect(() => {
     setLoading(false);
   }, [ir]);
-  const result = React113.useMemo(() => {
+  const result = React110.useMemo(() => {
     if (!ir) {
       return {
         page: void 0,
@@ -4280,12 +2911,12 @@ function useResolvedSchema(schema, pageName) {
 function clearSchemaCache() {
   core.clearSchemaCache();
 }
-var TraitContext = React113.createContext(null);
+var TraitContext = React110.createContext(null);
 function TraitProvider({
   traits: traitBindings,
   children
 }) {
-  const traitInstances = React113.useMemo(() => {
+  const traitInstances = React110.useMemo(() => {
     const map = /* @__PURE__ */ new Map();
     for (const binding of traitBindings) {
       const trait = binding.trait;
@@ -4309,7 +2940,7 @@ function TraitProvider({
     }
     return map;
   }, [traitBindings]);
-  const contextValue = React113.useMemo(() => {
+  const contextValue = React110.useMemo(() => {
     return {
       traits: traitInstances,
       getTrait: (name) => traitInstances.get(name),
@@ -4328,7 +2959,7 @@ function TraitProvider({
   return /* @__PURE__ */ jsxRuntime.jsx(TraitContext.Provider, { value: contextValue, children });
 }
 function useTraitContext() {
-  const context = React113.useContext(TraitContext);
+  const context = React110.useContext(TraitContext);
   if (!context) {
     throw new Error("useTraitContext must be used within a TraitProvider");
   }
@@ -4338,17 +2969,17 @@ function useTrait(traitName) {
   const context = useTraitContext();
   return context.getTrait(traitName);
 }
-var SlotsStateContext = React113.createContext({});
-var SlotsActionsContext = React113.createContext(null);
+var SlotsStateContext = React110.createContext({});
+var SlotsActionsContext = React110.createContext(null);
 function SlotsProvider({ children }) {
-  const [slots, setSlots] = React113.useState({});
-  const setSlotPatterns = React113.useCallback((slot, patterns, source) => {
+  const [slots, setSlots] = React110.useState({});
+  const setSlotPatterns = React110.useCallback((slot, patterns, source) => {
     setSlots((prev) => ({
       ...prev,
       [slot]: { patterns, source }
     }));
   }, []);
-  const clearSlot = React113.useCallback((slot) => {
+  const clearSlot = React110.useCallback((slot) => {
     setSlots((prev) => {
       if (!(slot in prev)) return prev;
       const next = { ...prev };
@@ -4356,12 +2987,12 @@ function SlotsProvider({ children }) {
       return next;
     });
   }, []);
-  const clearAllSlots = React113.useCallback(() => {
+  const clearAllSlots = React110.useCallback(() => {
     setSlots({});
   }, []);
-  const actionsRef = React113.useRef({ setSlotPatterns, clearSlot, clearAllSlots });
+  const actionsRef = React110.useRef({ setSlotPatterns, clearSlot, clearAllSlots });
   actionsRef.current = { setSlotPatterns, clearSlot, clearAllSlots };
-  const [stableActions] = React113.useState(() => ({
+  const [stableActions] = React110.useState(() => ({
     setSlotPatterns: (...args) => actionsRef.current.setSlotPatterns(...args),
     clearSlot: (...args) => actionsRef.current.clearSlot(...args),
     clearAllSlots: () => actionsRef.current.clearAllSlots()
@@ -4369,14 +3000,14 @@ function SlotsProvider({ children }) {
   return /* @__PURE__ */ jsxRuntime.jsx(SlotsActionsContext.Provider, { value: stableActions, children: /* @__PURE__ */ jsxRuntime.jsx(SlotsStateContext.Provider, { value: slots, children }) });
 }
 function useSlots() {
-  return React113.useContext(SlotsStateContext);
+  return React110.useContext(SlotsStateContext);
 }
 function useSlotContent(slotName) {
-  const slots = React113.useContext(SlotsStateContext);
+  const slots = React110.useContext(SlotsStateContext);
   return slots[slotName] || null;
 }
 function useSlotsActions() {
-  const actions = React113.useContext(SlotsActionsContext);
+  const actions = React110.useContext(SlotsActionsContext);
   if (!actions) {
     throw new Error("useSlotsActions must be used within a SlotsProvider");
   }