@almadar/ui 1.0.0

package/dist/hooks/index.js

@@ -0,0 +1,2262 @@
+import * as React4 from 'react';
+import { createContext, useCallback, useState, useEffect, useMemo, useContext, useRef, useSyncExternalStore } from 'react';
+import 'react/jsx-runtime';
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+function useOrbitalHistory(options) {
+  const { appId, authToken, userId, onHistoryChange, onRevertSuccess } = options;
+  const getHeaders2 = useCallback(() => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    if (userId) {
+      headers["x-user-id"] = userId;
+    }
+    return headers;
+  }, [authToken, userId]);
+  const [timeline, setTimeline] = useState([]);
+  const [currentVersion, setCurrentVersion] = useState(1);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    if (!appId) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const headers = getHeaders2();
+      const [changesetsRes, snapshotsRes] = await Promise.all([
+        fetch(`/api/graphs/${appId}/history/changesets`, { headers }),
+        fetch(`/api/graphs/${appId}/history/snapshots`, { headers })
+      ]);
+      if (!changesetsRes.ok) {
+        throw new Error(`Failed to fetch changesets: ${changesetsRes.status}`);
+      }
+      if (!snapshotsRes.ok) {
+        throw new Error(`Failed to fetch snapshots: ${snapshotsRes.status}`);
+      }
+      const changesetsData = await changesetsRes.json();
+      const snapshotsData = await snapshotsRes.json();
+      const changesetItems = (changesetsData.changesets || []).map((cs) => ({
+        id: cs.id,
+        type: "changeset",
+        version: cs.version,
+        timestamp: cs.timestamp,
+        description: `Version ${cs.version}`,
+        source: cs.source,
+        summary: cs.summary
+      }));
+      const snapshotItems = (snapshotsData.snapshots || []).map((snap) => ({
+        id: snap.id,
+        type: "snapshot",
+        version: snap.version,
+        timestamp: snap.timestamp,
+        description: snap.reason || `Snapshot v${snap.version}`,
+        reason: snap.reason
+      }));
+      const mergedTimeline = [...changesetItems, ...snapshotItems].sort(
+        (a, b) => b.timestamp - a.timestamp
+      );
+      setTimeline(mergedTimeline);
+      if (mergedTimeline.length > 0) {
+        setCurrentVersion(mergedTimeline[0].version);
+      }
+    } catch (err) {
+      console.error("[useOrbitalHistory] Failed to load history:", err);
+      setError(err instanceof Error ? err.message : "Failed to load history");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [appId, getHeaders2]);
+  const revertToSnapshot = useCallback(async (snapshotId) => {
+    if (!appId) {
+      return { success: false, error: "No app ID provided" };
+    }
+    try {
+      const response = await fetch(`/api/graphs/${appId}/history/revert/${snapshotId}`, {
+        method: "POST",
+        headers: getHeaders2()
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.error || `Failed to revert: ${response.status}`);
+      }
+      const data = await response.json();
+      if (data.success && data.schema) {
+        await refresh();
+        onRevertSuccess?.(data.schema);
+        return {
+          success: true,
+          restoredSchema: data.schema
+        };
+      }
+      return {
+        success: false,
+        error: data.error || "Unknown error during revert"
+      };
+    } catch (err) {
+      console.error("[useOrbitalHistory] Failed to revert:", err);
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to revert"
+      };
+    }
+  }, [appId, getHeaders2, refresh, onRevertSuccess]);
+  useEffect(() => {
+    if (appId && authToken && userId) {
+      refresh();
+    }
+  }, [appId, authToken, userId]);
+  useEffect(() => {
+    onHistoryChange?.(timeline);
+  }, [timeline]);
+  return {
+    timeline,
+    currentVersion,
+    isLoading,
+    error,
+    revertToSnapshot,
+    refresh
+  };
+}
+function useFileSystem() {
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [files, setFiles] = useState([]);
+  const [selectedFile, setSelectedFile] = useState(null);
+  const [selectedPath, setSelectedPath] = useState(null);
+  const [previewUrl, setPreviewUrl] = useState(null);
+  const [fileContents, setFileContents] = useState(/* @__PURE__ */ new Map());
+  const boot = useCallback(async () => {
+    setStatus("booting");
+    setError(null);
+    setIsLoading(true);
+    try {
+      console.log("[useFileSystem] Booting WebContainer...");
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      setStatus("ready");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to boot");
+      setStatus("error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const mountFiles = useCallback(async (filesToMount) => {
+    setIsLoading(true);
+    try {
+      let filesArray;
+      if (Array.isArray(filesToMount)) {
+        filesArray = filesToMount;
+      } else {
+        filesArray = [];
+        const flattenTree = (obj, basePath = "") => {
+          for (const [key, value] of Object.entries(obj)) {
+            const path = basePath ? `${basePath}/${key}` : key;
+            if (value && typeof value === "object" && "file" in value) {
+              const fileObj = value;
+              filesArray.push({ path, content: fileObj.file.contents || "" });
+            } else if (value && typeof value === "object" && "directory" in value) {
+              const dirObj = value;
+              flattenTree(dirObj.directory, path);
+            }
+          }
+        };
+        flattenTree(filesToMount);
+      }
+      const newContents = /* @__PURE__ */ new Map();
+      for (const file of filesArray) {
+        newContents.set(file.path, file.content);
+      }
+      setFileContents(newContents);
+      const newTree = [];
+      for (const file of filesArray) {
+        const parts = file.path.split("/").filter(Boolean);
+        let current = newTree;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          const isFile = i === parts.length - 1;
+          const currentPath = "/" + parts.slice(0, i + 1).join("/");
+          let node = current.find((n) => n.name === part);
+          if (!node) {
+            node = {
+              path: currentPath,
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? void 0 : []
+            };
+            current.push(node);
+          }
+          if (!isFile && node && node.children) {
+            current = node.children;
+          }
+        }
+      }
+      setFiles(newTree);
+      setStatus("running");
+    } catch (err) {
+      console.error("[useFileSystem] Failed to mount files:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const readFile = useCallback(async (path) => {
+    return fileContents.get(path) || "";
+  }, [fileContents]);
+  const writeFile = useCallback(async (path, content) => {
+    setFileContents((prev) => {
+      const next = new Map(prev);
+      next.set(path, content);
+      return next;
+    });
+  }, []);
+  const selectFile = useCallback(async (path) => {
+    const content = fileContents.get(path) || "";
+    const ext = path.split(".").pop()?.toLowerCase() || "";
+    const languageMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      json: "json",
+      md: "markdown",
+      css: "css",
+      html: "html",
+      orb: "json"
+    };
+    setSelectedPath(path);
+    setSelectedFile({
+      path,
+      content,
+      language: languageMap[ext] || "plaintext",
+      isDirty: false
+    });
+  }, [fileContents]);
+  const updateContent = useCallback((pathOrContent, contentArg) => {
+    const path = contentArg !== void 0 ? pathOrContent : selectedPath;
+    const content = contentArg !== void 0 ? contentArg : pathOrContent;
+    if (!path) {
+      console.warn("[useFileSystem] updateContent called without path and no file selected");
+      return;
+    }
+    setFileContents((prev) => {
+      const next = new Map(prev);
+      next.set(path, content);
+      return next;
+    });
+    if (selectedPath === path) {
+      setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
+    }
+  }, [selectedPath]);
+  const updateSelectedContent = useCallback((content) => {
+    setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
+  }, []);
+  const refreshTree = useCallback(async () => {
+    console.log("[useFileSystem] Refreshing tree");
+  }, []);
+  const runCommand = useCallback(async (command) => {
+    console.log("[useFileSystem] Running command:", command);
+    return { exitCode: 0, output: "" };
+  }, []);
+  const startDevServer = useCallback(async () => {
+    console.log("[useFileSystem] Starting dev server");
+    setPreviewUrl("http://localhost:5173");
+  }, []);
+  return {
+    status,
+    error,
+    isLoading,
+    files,
+    selectedFile,
+    selectedPath,
+    previewUrl,
+    boot,
+    mountFiles,
+    readFile,
+    writeFile,
+    selectFile,
+    updateContent,
+    updateSelectedContent,
+    refreshTree,
+    runCommand,
+    startDevServer
+  };
+}
+var defaultManifest = {
+  languages: {
+    typescript: { extensions: [".ts", ".tsx"], icon: "ts", color: "#3178c6" },
+    javascript: { extensions: [".js", ".jsx"], icon: "js", color: "#f7df1e" },
+    json: { extensions: [".json", ".orb"], icon: "json", color: "#000000" },
+    css: { extensions: [".css"], icon: "css", color: "#264de4" },
+    html: { extensions: [".html"], icon: "html", color: "#e34c26" },
+    markdown: { extensions: [".md", ".mdx"], icon: "md", color: "#083fa1" }
+  },
+  extensions: []
+};
+function useExtensions(options) {
+  const { appId, loadOnMount = true } = options;
+  const [extensions, setExtensions] = useState([]);
+  const [manifest] = useState(defaultManifest);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadExtension = useCallback(async (extensionId) => {
+    console.log("[useExtensions] Loading extension:", extensionId);
+  }, []);
+  const loadExtensions = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const defaultExtensions = [
+        { id: "typescript", name: "TypeScript", language: "typescript", loaded: true },
+        { id: "javascript", name: "JavaScript", language: "javascript", loaded: true },
+        { id: "json", name: "JSON", language: "json", loaded: true },
+        { id: "css", name: "CSS", language: "css", loaded: true },
+        { id: "html", name: "HTML", language: "html", loaded: true },
+        { id: "markdown", name: "Markdown", language: "markdown", loaded: true }
+      ];
+      setExtensions(defaultExtensions);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load extensions");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const getExtensionForFile = useCallback((filename) => {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    if (!ext) return null;
+    const languageMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      json: "json",
+      md: "markdown",
+      css: "css",
+      html: "html",
+      orb: "json"
+    };
+    const language = languageMap[ext];
+    if (!language) return null;
+    return extensions.find((e) => e.language === language) || null;
+  }, [extensions]);
+  useEffect(() => {
+    if (!appId || !loadOnMount) return;
+    const loadExtensions2 = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const defaultExtensions = [
+          { id: "typescript", name: "TypeScript", language: "typescript", loaded: true },
+          { id: "javascript", name: "JavaScript", language: "javascript", loaded: true },
+          { id: "json", name: "JSON", language: "json", loaded: true },
+          { id: "css", name: "CSS", language: "css", loaded: true },
+          { id: "html", name: "HTML", language: "html", loaded: true },
+          { id: "markdown", name: "Markdown", language: "markdown", loaded: true }
+        ];
+        setExtensions(defaultExtensions);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load extensions");
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    loadExtensions2();
+  }, [appId, loadOnMount]);
+  return {
+    extensions,
+    manifest,
+    isLoading,
+    error,
+    loadExtension,
+    loadExtensions,
+    getExtensionForFile
+  };
+}
+function useFileEditor(options) {
+  const { extensions, fileSystem, onSchemaUpdate } = options;
+  const [openFiles, setOpenFiles] = useState([]);
+  const [activeFilePath, setActiveFilePath] = useState(null);
+  const [isSaving, setIsSaving] = useState(false);
+  const activeFile = openFiles.find((f) => f.path === activeFilePath) || null;
+  const openFile = useCallback(async (path) => {
+    const existing = openFiles.find((f) => f.path === path);
+    if (existing) {
+      setActiveFilePath(path);
+      return;
+    }
+    try {
+      const content = await fileSystem.readFile(path);
+      const ext = extensions.getExtensionForFile(path);
+      const newFile = {
+        path,
+        content,
+        isDirty: false,
+        language: ext?.language
+      };
+      setOpenFiles((prev) => [...prev, newFile]);
+      setActiveFilePath(path);
+    } catch (err) {
+      console.error("[useFileEditor] Failed to open file:", err);
+    }
+  }, [openFiles, fileSystem, extensions]);
+  const closeFile = useCallback((path) => {
+    setOpenFiles((prev) => prev.filter((f) => f.path !== path));
+    if (activeFilePath === path) {
+      const remaining = openFiles.filter((f) => f.path !== path);
+      setActiveFilePath(remaining.length > 0 ? remaining[0].path : null);
+    }
+  }, [activeFilePath, openFiles]);
+  const setActiveFile = useCallback((path) => {
+    setActiveFilePath(path);
+  }, []);
+  const updateFileContent = useCallback((path, content) => {
+    setOpenFiles(
+      (prev) => prev.map(
+        (f) => f.path === path ? { ...f, content, isDirty: true } : f
+      )
+    );
+  }, []);
+  const handleFileEdit = useCallback(async (path, content) => {
+    try {
+      await fileSystem.writeFile(path, content);
+      let action = "saved";
+      if (path.endsWith(".orb") || path.endsWith("schema.json")) {
+        try {
+          const schema = JSON.parse(content);
+          await onSchemaUpdate?.(schema);
+          action = "updated_schema";
+        } catch {
+        }
+      } else if (path.includes("/extensions/")) {
+        action = path.endsWith(".new") ? "converted_extension" : "saved_extension";
+      }
+      return { success: true, action };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to save file"
+      };
+    }
+  }, [fileSystem, onSchemaUpdate]);
+  const saveFile = useCallback(async (path) => {
+    const file = openFiles.find((f) => f.path === path);
+    if (!file) return;
+    setIsSaving(true);
+    try {
+      await fileSystem.writeFile(path, file.content);
+      setOpenFiles(
+        (prev) => prev.map(
+          (f) => f.path === path ? { ...f, isDirty: false } : f
+        )
+      );
+      if (path.endsWith(".orb") || path.endsWith("schema.json")) {
+        try {
+          const schema = JSON.parse(file.content);
+          await onSchemaUpdate?.(schema);
+        } catch {
+        }
+      }
+    } catch (err) {
+      console.error("[useFileEditor] Failed to save file:", err);
+    } finally {
+      setIsSaving(false);
+    }
+  }, [openFiles, fileSystem, onSchemaUpdate]);
+  const saveAllFiles = useCallback(async () => {
+    setIsSaving(true);
+    try {
+      const dirtyFiles = openFiles.filter((f) => f.isDirty);
+      for (const file of dirtyFiles) {
+        await saveFile(file.path);
+      }
+    } finally {
+      setIsSaving(false);
+    }
+  }, [openFiles, saveFile]);
+  return {
+    openFiles,
+    activeFile,
+    isSaving,
+    openFile,
+    closeFile,
+    setActiveFile,
+    updateFileContent,
+    handleFileEdit,
+    saveFile,
+    saveAllFiles
+  };
+}
+function useCompile() {
+  const [isCompiling, setIsCompiling] = useState(false);
+  const [stage, setStage] = useState("idle");
+  const [lastResult, setLastResult] = useState(null);
+  const [error, setError] = useState(null);
+  const compileSchema = useCallback(async (schema) => {
+    setIsCompiling(true);
+    setStage("compiling");
+    setError(null);
+    try {
+      console.log("[useCompile] Compiling schema:", schema.name);
+      const result = {
+        success: true,
+        files: []
+      };
+      setLastResult(result);
+      setStage("done");
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Compilation failed";
+      setError(errorMessage);
+      setStage("error");
+      setLastResult({ success: false, errors: [errorMessage] });
+      return null;
+    } finally {
+      setIsCompiling(false);
+    }
+  }, []);
+  return {
+    isCompiling,
+    stage,
+    lastResult,
+    error,
+    compileSchema
+  };
+}
+function usePreview(options) {
+  const [previewUrl, setPreviewUrl] = useState(null);
+  const [isLoading, setIsLoading] = useState(!!options?.appId);
+  const [error, setError] = useState(null);
+  const [loadError, setLoadError] = useState(null);
+  const [app, setApp] = useState(null);
+  const [isFullscreen, setIsFullscreen] = useState(false);
+  const [isExecutingEvent, setIsExecutingEvent] = useState(false);
+  const [errorToast, setErrorToast] = useState(null);
+  const [currentStateName, setCurrentStateName] = useState(null);
+  const [notificationsList, setNotificationsList] = useState([]);
+  const [isPanelOpen, setIsPanelOpen] = useState(false);
+  const notifications = useMemo(() => ({
+    notifications: notificationsList,
+    isPanelOpen,
+    closePanel: () => setIsPanelOpen(false),
+    dismissNotification: (id) => {
+      setNotificationsList((prev) => prev.filter((n) => n.id !== id));
+    },
+    markAsRead: (id) => {
+      setNotificationsList(
+        (prev) => prev.map((n) => n.id === id ? { ...n, read: true } : n)
+      );
+    },
+    clearAll: () => setNotificationsList([])
+  }), [notificationsList, isPanelOpen]);
+  useEffect(() => {
+    const appId = options?.appId;
+    if (!appId) {
+      setApp(null);
+      setIsLoading(false);
+      return;
+    }
+    console.log("[usePreview] Setting up preview for app:", appId);
+    setPreviewUrl(`/api/orbitals/${appId}`);
+    setIsLoading(false);
+  }, [options?.appId]);
+  const startPreview = useCallback(async () => {
+    console.log("[usePreview] startPreview called");
+  }, []);
+  const stopPreview = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      console.log("[usePreview] Stopping preview server...");
+      setPreviewUrl(null);
+      setApp(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const refresh = useCallback(async () => {
+    if (!previewUrl) return;
+    console.log("[usePreview] Refreshing preview...");
+    setPreviewUrl(`${previewUrl.split("?")[0]}?t=${Date.now()}`);
+  }, [previewUrl]);
+  const handleRefresh = useCallback(async () => {
+    console.log("[usePreview] Handle refresh...");
+    await refresh();
+  }, [refresh]);
+  const handleReset = useCallback(async () => {
+    console.log("[usePreview] Resetting preview...");
+    setError(null);
+    setLoadError(null);
+    setErrorToast(null);
+    setIsExecutingEvent(false);
+    setCurrentStateName(null);
+  }, []);
+  const toggleFullscreen = useCallback(() => {
+    setIsFullscreen((prev) => !prev);
+  }, []);
+  const dismissErrorToast = useCallback(() => {
+    setErrorToast(null);
+  }, []);
+  return {
+    previewUrl,
+    isLoading,
+    error,
+    loadError,
+    app,
+    isFullscreen,
+    isExecutingEvent,
+    errorToast,
+    currentStateName,
+    notifications,
+    startPreview,
+    stopPreview,
+    refresh,
+    handleRefresh,
+    handleReset,
+    toggleFullscreen,
+    setErrorToast,
+    dismissErrorToast
+  };
+}
+function useAgentChat(options) {
+  const [messages, setMessages] = useState([]);
+  const [status, setStatus] = useState("idle");
+  const [activities, setActivities] = useState([]);
+  const [todos, setTodos] = useState([]);
+  const [schemaDiffs, setSchemaDiffs] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [threadId] = useState(null);
+  const [interrupt, setInterrupt] = useState(null);
+  const sendMessage = useCallback(async (content) => {
+    setIsLoading(true);
+    setStatus("running");
+    setError(null);
+    try {
+      const userMessage = {
+        id: Date.now().toString(),
+        role: "user",
+        content,
+        timestamp: Date.now()
+      };
+      setMessages((prev) => [...prev, userMessage]);
+      console.log("[useAgentChat] Sending message:", content);
+      const assistantMessage = {
+        id: (Date.now() + 1).toString(),
+        role: "assistant",
+        content: "Agent chat is not yet implemented.",
+        timestamp: Date.now()
+      };
+      setMessages((prev) => [...prev, assistantMessage]);
+      setStatus("idle");
+      options?.onComplete?.();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to send message");
+      setStatus("error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options]);
+  const startGeneration = useCallback(async (skill, prompt, genOptions) => {
+    setStatus("running");
+    setIsLoading(true);
+    setError(null);
+    const skillName = Array.isArray(skill) ? skill[0] : skill;
+    try {
+      console.log("[useAgentChat] Starting generation:", skillName, prompt, genOptions);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      setStatus("complete");
+      options?.onComplete?.();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Generation failed");
+      setStatus("error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options]);
+  const continueConversation = useCallback(async (message) => {
+    console.log("[useAgentChat] Continue conversation", message);
+  }, []);
+  const resumeWithDecision = useCallback(async (decisions) => {
+    console.log("[useAgentChat] Resume with decision:", decisions);
+    setInterrupt(null);
+  }, []);
+  const cancel = useCallback(() => {
+    setStatus("idle");
+    setIsLoading(false);
+    setInterrupt(null);
+  }, []);
+  const clearMessages = useCallback(() => {
+    setMessages([]);
+  }, []);
+  const clearHistory = useCallback(() => {
+    setMessages([]);
+    setActivities([]);
+    setTodos([]);
+    setSchemaDiffs([]);
+    setError(null);
+  }, []);
+  return {
+    messages,
+    status,
+    activities,
+    todos,
+    schemaDiffs,
+    isLoading,
+    error,
+    threadId,
+    interrupt,
+    sendMessage,
+    startGeneration,
+    continueConversation,
+    resumeWithDecision,
+    cancel,
+    clearMessages,
+    clearHistory
+  };
+}
+function useValidation() {
+  const [result, setResult] = useState(null);
+  const [isValidating, setIsValidating] = useState(false);
+  const [error, setError] = useState(null);
+  const [stage, setStage] = useState("idle");
+  const [isFixing, setIsFixing] = useState(false);
+  const [progressMessage, setProgressMessage] = useState(null);
+  const validate = useCallback(async (appId) => {
+    setIsValidating(true);
+    setError(null);
+    setStage("validating");
+    setProgressMessage("Validating schema...");
+    try {
+      console.log("[useValidation] Validating app:", appId);
+      const validationResult = {
+        valid: true,
+        errors: [],
+        warnings: []
+      };
+      setResult(validationResult);
+      setStage("complete");
+      setProgressMessage(null);
+      return validationResult;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Validation failed";
+      setError(errorMessage);
+      const failedResult = {
+        valid: false,
+        errors: [{ code: "VALIDATION_ERROR", message: errorMessage, severity: "error" }],
+        warnings: []
+      };
+      setResult(failedResult);
+      setStage("complete");
+      setProgressMessage(null);
+      return failedResult;
+    } finally {
+      setIsValidating(false);
+    }
+  }, []);
+  const clearResult = useCallback(() => {
+    setResult(null);
+    setError(null);
+  }, []);
+  const reset = useCallback(() => {
+    setResult(null);
+    setError(null);
+    setStage("idle");
+    setIsFixing(false);
+    setProgressMessage(null);
+    setIsValidating(false);
+  }, []);
+  return {
+    result,
+    isValidating,
+    error,
+    stage,
+    isFixing,
+    progressMessage,
+    errors: result?.errors ?? [],
+    warnings: result?.warnings ?? [],
+    isValid: result?.valid ?? false,
+    validate,
+    clearResult,
+    reset
+  };
+}
+function useDeepAgentGeneration() {
+  const [requests, setRequests] = useState([]);
+  const [currentRequest, setCurrentRequest] = useState(null);
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isComplete, setIsComplete] = useState(false);
+  const [progress, setProgress] = useState({ stage: "idle", percent: 0, message: "" });
+  const [error, setError] = useState(null);
+  const [interrupt, setInterrupt] = useState(null);
+  const generate = useCallback(async (prompt) => {
+    setIsGenerating(true);
+    setIsLoading(true);
+    setIsComplete(false);
+    setError(null);
+    setProgress({ stage: "starting", percent: 0, message: "Starting generation..." });
+    const request = {
+      id: Date.now().toString(),
+      prompt,
+      status: "running"
+    };
+    setCurrentRequest(request);
+    setRequests((prev) => [...prev, request]);
+    try {
+      console.log("[useDeepAgentGeneration] Generating from prompt:", prompt);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      request.status = "completed";
+      setCurrentRequest(request);
+      setIsComplete(true);
+      setProgress({ stage: "complete", percent: 100, message: "Generation complete" });
+      return null;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Generation failed";
+      setError(errorMessage);
+      request.status = "failed";
+      request.error = errorMessage;
+      setCurrentRequest(request);
+      return null;
+    } finally {
+      setIsGenerating(false);
+      setIsLoading(false);
+    }
+  }, []);
+  const startGeneration = useCallback(async (skill, prompt, _options) => {
+    console.log("[useDeepAgentGeneration] Starting generation with skill:", skill);
+    await generate(prompt);
+  }, [generate]);
+  const cancelGeneration = useCallback(() => {
+    if (currentRequest) {
+      currentRequest.status = "failed";
+      currentRequest.error = "Cancelled by user";
+      setCurrentRequest(null);
+    }
+    setIsGenerating(false);
+    setIsLoading(false);
+    setIsComplete(false);
+    setProgress({ stage: "idle", percent: 0, message: "" });
+  }, [currentRequest]);
+  const clearRequests = useCallback(() => {
+    setRequests([]);
+    setCurrentRequest(null);
+    setError(null);
+    setProgress({ stage: "idle", percent: 0, message: "" });
+    setIsComplete(false);
+  }, []);
+  const submitInterruptDecisions = useCallback((decisions) => {
+    console.log("[useDeepAgentGeneration] Submitting interrupt decisions:", decisions);
+    setInterrupt(null);
+  }, []);
+  return {
+    requests,
+    currentRequest,
+    isGenerating,
+    isLoading,
+    isComplete,
+    progress,
+    error,
+    interrupt,
+    generate,
+    startGeneration,
+    cancelGeneration,
+    clearRequests,
+    submitInterruptDecisions
+  };
+}
+var EventBusContext = createContext(null);
+
+// hooks/useEventBus.ts
+var globalEventBus = null;
+var fallbackListeners = /* @__PURE__ */ new Map();
+var fallbackEventBus = {
+  emit: (type, payload) => {
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now()
+    };
+    const handlers = fallbackListeners.get(type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(`[EventBus] Error in listener for '${type}':`, error);
+        }
+      });
+    }
+  },
+  on: (type, listener) => {
+    if (!fallbackListeners.has(type)) {
+      fallbackListeners.set(type, /* @__PURE__ */ new Set());
+    }
+    fallbackListeners.get(type).add(listener);
+    return () => {
+      const handlers = fallbackListeners.get(type);
+      if (handlers) {
+        handlers.delete(listener);
+        if (handlers.size === 0) {
+          fallbackListeners.delete(type);
+        }
+      }
+    };
+  },
+  once: (type, listener) => {
+    const wrappedListener = (event) => {
+      fallbackListeners.get(type)?.delete(wrappedListener);
+      listener(event);
+    };
+    return fallbackEventBus.on(type, wrappedListener);
+  },
+  hasListeners: (type) => {
+    const handlers = fallbackListeners.get(type);
+    return handlers !== void 0 && handlers.size > 0;
+  }
+};
+function useEventBus() {
+  const context = useContext(EventBusContext);
+  return context ?? globalEventBus ?? fallbackEventBus;
+}
+function useEventListener(event, handler) {
+  const eventBus = useEventBus();
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+  useEffect(() => {
+    const wrappedHandler = (evt) => {
+      handlerRef.current(evt);
+    };
+    return eventBus.on(event, wrappedHandler);
+  }, [event, eventBus]);
+}
+function useEmitEvent() {
+  const eventBus = useEventBus();
+  return useCallback(
+    (type, payload) => {
+      eventBus.emit(type, payload);
+    },
+    [eventBus]
+  );
+}
+var DEFAULT_SLOTS = {
+  main: null,
+  sidebar: null,
+  modal: null,
+  drawer: null,
+  overlay: null,
+  center: null,
+  toast: null,
+  "hud-top": null,
+  "hud-bottom": null,
+  floating: null
+};
+var idCounter = 0;
+function generateId() {
+  return `slot-content-${++idCounter}-${Date.now()}`;
+}
+function useUISlotManager() {
+  const [slots, setSlots] = useState(DEFAULT_SLOTS);
+  const subscribersRef = useRef(/* @__PURE__ */ new Set());
+  const timersRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    return () => {
+      timersRef.current.forEach((timer) => clearTimeout(timer));
+      timersRef.current.clear();
+    };
+  }, []);
+  const notifySubscribers = useCallback((slot, content) => {
+    subscribersRef.current.forEach((callback) => {
+      try {
+        callback(slot, content);
+      } catch (error) {
+        console.error("[UISlots] Subscriber error:", error);
+      }
+    });
+  }, []);
+  const render = useCallback((config) => {
+    const id = generateId();
+    const content = {
+      id,
+      pattern: config.pattern,
+      props: config.props ?? {},
+      priority: config.priority ?? 0,
+      animation: config.animation ?? "fade",
+      onDismiss: config.onDismiss,
+      sourceTrait: config.sourceTrait
+    };
+    if (config.autoDismissMs && config.autoDismissMs > 0) {
+      content.autoDismissAt = Date.now() + config.autoDismissMs;
+      const timer = setTimeout(() => {
+        setSlots((prev) => {
+          if (prev[config.target]?.id === id) {
+            content.onDismiss?.();
+            notifySubscribers(config.target, null);
+            return { ...prev, [config.target]: null };
+          }
+          return prev;
+        });
+        timersRef.current.delete(id);
+      }, config.autoDismissMs);
+      timersRef.current.set(id, timer);
+    }
+    setSlots((prev) => {
+      const existing = prev[config.target];
+      if (existing && existing.priority > content.priority) {
+        console.warn(
+          `[UISlots] Slot "${config.target}" already has higher priority content (${existing.priority} > ${content.priority})`
+        );
+        return prev;
+      }
+      notifySubscribers(config.target, content);
+      return { ...prev, [config.target]: content };
+    });
+    return id;
+  }, [notifySubscribers]);
+  const clear = useCallback((slot) => {
+    setSlots((prev) => {
+      const content = prev[slot];
+      if (content) {
+        const timer = timersRef.current.get(content.id);
+        if (timer) {
+          clearTimeout(timer);
+          timersRef.current.delete(content.id);
+        }
+        content.onDismiss?.();
+        notifySubscribers(slot, null);
+      }
+      return { ...prev, [slot]: null };
+    });
+  }, [notifySubscribers]);
+  const clearById = useCallback((id) => {
+    setSlots((prev) => {
+      const entry = Object.entries(prev).find(([, content]) => content?.id === id);
+      if (entry) {
+        const [slot, content] = entry;
+        const timer = timersRef.current.get(id);
+        if (timer) {
+          clearTimeout(timer);
+          timersRef.current.delete(id);
+        }
+        content.onDismiss?.();
+        notifySubscribers(slot, null);
+        return { ...prev, [slot]: null };
+      }
+      return prev;
+    });
+  }, [notifySubscribers]);
+  const clearAll = useCallback(() => {
+    timersRef.current.forEach((timer) => clearTimeout(timer));
+    timersRef.current.clear();
+    setSlots((prev) => {
+      Object.entries(prev).forEach(([slot, content]) => {
+        if (content) {
+          content.onDismiss?.();
+          notifySubscribers(slot, null);
+        }
+      });
+      return DEFAULT_SLOTS;
+    });
+  }, [notifySubscribers]);
+  const subscribe2 = useCallback((callback) => {
+    subscribersRef.current.add(callback);
+    return () => {
+      subscribersRef.current.delete(callback);
+    };
+  }, []);
+  const hasContent = useCallback((slot) => {
+    return slots[slot] !== null;
+  }, [slots]);
+  const getContent = useCallback((slot) => {
+    return slots[slot];
+  }, [slots]);
+  return {
+    slots,
+    render,
+    clear,
+    clearById,
+    clearAll,
+    subscribe: subscribe2,
+    hasContent,
+    getContent
+  };
+}
+var SelectionContext = createContext(null);
+
+// hooks/useUIEvents.ts
+var UI_EVENT_MAP = {
+  // Form/CRUD events
+  "UI:SAVE": "SAVE",
+  "UI:CANCEL": "CANCEL",
+  "UI:CLOSE": "CLOSE",
+  "UI:VIEW": "VIEW",
+  "UI:EDIT": "EDIT",
+  "UI:DELETE": "DELETE",
+  "UI:CREATE": "CREATE",
+  "UI:SELECT": "SELECT",
+  "UI:DESELECT": "DESELECT",
+  "UI:SUBMIT": "SAVE",
+  "UI:UPDATE_STATUS": "UPDATE_STATUS",
+  "UI:SEARCH": "SEARCH",
+  "UI:CLEAR_SEARCH": "CLEAR_SEARCH",
+  "UI:ADD": "CREATE",
+  // Game events (for closed circuit with GameMenu, GamePauseOverlay, GameOverScreen)
+  "UI:PAUSE": "PAUSE",
+  "UI:RESUME": "RESUME",
+  "UI:RESTART": "RESTART",
+  "UI:GAME_OVER": "GAME_OVER",
+  "UI:START": "START",
+  "UI:QUIT": "QUIT",
+  "UI:INIT": "INIT"
+};
+function useUIEvents(dispatch, validEvents, eventBusInstance) {
+  const defaultEventBus = useEventBus();
+  const eventBus = eventBusInstance ?? defaultEventBus;
+  const validEventsKey = validEvents ? validEvents.slice().sort().join(",") : "";
+  const stableValidEvents = useMemo(
+    () => validEvents,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [validEventsKey]
+  );
+  useEffect(() => {
+    const unsubscribes = [];
+    Object.entries(UI_EVENT_MAP).forEach(([uiEvent, smEvent]) => {
+      const handler = (event) => {
+        if (!stableValidEvents || stableValidEvents.includes(smEvent)) {
+          dispatch(smEvent, event.payload);
+        }
+      };
+      const unsubscribe = eventBus.on(uiEvent, handler);
+      unsubscribes.push(unsubscribe);
+    });
+    const genericHandler = (event) => {
+      const eventName = event.payload?.event;
+      if (eventName) {
+        const smEvent = eventName;
+        if (!stableValidEvents || stableValidEvents.includes(smEvent)) {
+          dispatch(smEvent, event.payload);
+        }
+      }
+    };
+    const genericUnsubscribe = eventBus.on("UI:DISPATCH", genericHandler);
+    unsubscribes.push(genericUnsubscribe);
+    if (stableValidEvents) {
+      stableValidEvents.forEach((smEvent) => {
+        const uiPrefixedEvent = `UI:${smEvent}`;
+        const alreadyMapped = Object.keys(UI_EVENT_MAP).includes(uiPrefixedEvent);
+        if (!alreadyMapped) {
+          const directHandler = (event) => {
+            dispatch(smEvent, event.payload);
+          };
+          const unsubscribePrefixed = eventBus.on(
+            uiPrefixedEvent,
+            directHandler
+          );
+          unsubscribes.push(unsubscribePrefixed);
+          const unsubscribeDirect = eventBus.on(smEvent, directHandler);
+          unsubscribes.push(unsubscribeDirect);
+        }
+      });
+    }
+    return () => {
+      unsubscribes.forEach((unsub) => unsub());
+    };
+  }, [eventBus, dispatch, stableValidEvents]);
+}
+function useSelectedEntity(eventBusInstance) {
+  const defaultEventBus = useEventBus();
+  const eventBus = eventBusInstance ?? defaultEventBus;
+  const selectionContext = useSelectionContext();
+  const [localSelected, setLocalSelected] = useState(null);
+  const usingContext = selectionContext !== null;
+  useEffect(() => {
+    if (usingContext) return;
+    const handleSelect = (event) => {
+      const row = event.payload?.row;
+      if (row) {
+        setLocalSelected(row);
+      }
+    };
+    const handleDeselect = () => {
+      setLocalSelected(null);
+    };
+    const unsubSelect = eventBus.on("UI:SELECT", handleSelect);
+    const unsubView = eventBus.on("UI:VIEW", handleSelect);
+    const unsubDeselect = eventBus.on("UI:DESELECT", handleDeselect);
+    const unsubClose = eventBus.on("UI:CLOSE", handleDeselect);
+    const unsubCancel = eventBus.on("UI:CANCEL", handleDeselect);
+    return () => {
+      unsubSelect();
+      unsubView();
+      unsubDeselect();
+      unsubClose();
+      unsubCancel();
+    };
+  }, [eventBus, usingContext]);
+  if (selectionContext) {
+    return [selectionContext.selected, selectionContext.setSelected];
+  }
+  return [localSelected, setLocalSelected];
+}
+function useSelectionContext() {
+  const context = useContext(SelectionContext);
+  return context;
+}
+var entityDataKeys = {
+  all: ["entities"],
+  lists: () => [...entityDataKeys.all, "list"],
+  list: (entity, filters) => [...entityDataKeys.lists(), entity, filters],
+  details: () => [...entityDataKeys.all, "detail"],
+  detail: (entity, id) => [...entityDataKeys.details(), entity, id]
+};
+function useEntityList(entity, options = {}) {
+  const { skip = false } = options;
+  const [data, setData] = useState([]);
+  const [isLoading, setIsLoading] = useState(!skip && !!entity);
+  const [error, setError] = useState(null);
+  const refetch = () => {
+    if (!entity || skip) return;
+    setIsLoading(true);
+    setError(null);
+    setTimeout(() => {
+      setData([]);
+      setIsLoading(false);
+    }, 100);
+  };
+  useEffect(() => {
+    if (skip || !entity) {
+      setIsLoading(false);
+      return;
+    }
+    refetch();
+  }, [entity, skip]);
+  return { data, isLoading, error, refetch };
+}
+function useEntity(entity, id) {
+  const [data, setData] = useState(null);
+  const [isLoading, setIsLoading] = useState(!!entity && !!id);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (!entity || !id) {
+      setIsLoading(false);
+      return;
+    }
+    setIsLoading(true);
+    setTimeout(() => {
+      setData(null);
+      setIsLoading(false);
+    }, 100);
+  }, [entity, id]);
+  return { data, isLoading, error };
+}
+function useEntityDetail(entity, id) {
+  const [data, setData] = useState(null);
+  const [isLoading, setIsLoading] = useState(!!entity && !!id);
+  const [error, setError] = useState(null);
+  const refetch = () => {
+    if (!entity || !id) return;
+    setIsLoading(true);
+    setError(null);
+    setTimeout(() => {
+      setData(null);
+      setIsLoading(false);
+    }, 100);
+  };
+  useEffect(() => {
+    if (!entity || !id) {
+      setIsLoading(false);
+      return;
+    }
+    refetch();
+  }, [entity, id]);
+  return { data, isLoading, error, refetch };
+}
+var queryStores = /* @__PURE__ */ new Map();
+function getOrCreateStore(query) {
+  if (!queryStores.has(query)) {
+    queryStores.set(query, {
+      search: "",
+      filters: {},
+      sortField: void 0,
+      sortDirection: void 0,
+      listeners: /* @__PURE__ */ new Set()
+    });
+  }
+  return queryStores.get(query);
+}
+function useQuerySingleton(query) {
+  const [, forceUpdate] = useState({});
+  if (!query) {
+    return null;
+  }
+  const store = useMemo(() => getOrCreateStore(query), [query]);
+  useMemo(() => {
+    const listener = () => forceUpdate({});
+    store.listeners.add(listener);
+    return () => {
+      store.listeners.delete(listener);
+    };
+  }, [store]);
+  const notifyListeners = useCallback(() => {
+    store.listeners.forEach((listener) => listener());
+  }, [store]);
+  const setSearch = useCallback((value) => {
+    store.search = value;
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const setFilter = useCallback((key, value) => {
+    store.filters = { ...store.filters, [key]: value };
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const clearFilters = useCallback(() => {
+    store.filters = {};
+    store.search = "";
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const setSort = useCallback((field, direction) => {
+    store.sortField = field;
+    store.sortDirection = direction;
+    notifyListeners();
+  }, [store, notifyListeners]);
+  return {
+    search: store.search,
+    setSearch,
+    filters: store.filters,
+    setFilter,
+    clearFilters,
+    sortField: store.sortField,
+    sortDirection: store.sortDirection,
+    setSort
+  };
+}
+function parseQueryBinding(binding) {
+  const cleaned = binding.startsWith("@") ? binding.slice(1) : binding;
+  const parts = cleaned.split(".");
+  return {
+    query: parts[0],
+    field: parts.length > 1 ? parts.slice(1).join(".") : void 0
+  };
+}
+
+// ../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/subscribable.js
+var Subscribable = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.onSubscribe();
+    return () => {
+      this.listeners.delete(listener);
+      this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+};
+
+// ../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+var defaultTimeoutProvider = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (callback, delay) => setTimeout(callback, delay),
+  clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+  setInterval: (callback, delay) => setInterval(callback, delay),
+  clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var _provider, _providerCalled, _a;
+var TimeoutManager = (_a = class {
+  constructor() {
+    // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+    // type at app boot; and if we leave that type, then any new timer provider
+    // would need to support ReturnType<typeof setTimeout>, which is infeasible.
+    //
+    // We settle for type safety for the TimeoutProvider type, and accept that
+    // this class is unsafe internally to allow for extension.
+    __privateAdd(this, _provider, defaultTimeoutProvider);
+    __privateAdd(this, _providerCalled, false);
+  }
+  setTimeoutProvider(provider) {
+    if (process.env.NODE_ENV !== "production") {
+      if (__privateGet(this, _providerCalled) && provider !== __privateGet(this, _provider)) {
+        console.error(
+          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
+          { previous: __privateGet(this, _provider), provider }
+        );
+      }
+    }
+    __privateSet(this, _provider, provider);
+    if (process.env.NODE_ENV !== "production") {
+      __privateSet(this, _providerCalled, false);
+    }
+  }
+  setTimeout(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      __privateSet(this, _providerCalled, true);
+    }
+    return __privateGet(this, _provider).setTimeout(callback, delay);
+  }
+  clearTimeout(timeoutId) {
+    __privateGet(this, _provider).clearTimeout(timeoutId);
+  }
+  setInterval(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      __privateSet(this, _providerCalled, true);
+    }
+    return __privateGet(this, _provider).setInterval(callback, delay);
+  }
+  clearInterval(intervalId) {
+    __privateGet(this, _provider).clearInterval(intervalId);
+  }
+}, _provider = new WeakMap(), _providerCalled = new WeakMap(), _a);
+new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}
+function noop() {
+}
+function hashKey(queryKey) {
+  return JSON.stringify(
+    queryKey,
+    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+      result[key] = val[key];
+      return result;
+    }, {}) : val
+  );
+}
+function shallowEqualObjects(a, b) {
+  if (!b || Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  }
+  if (!prot.hasOwnProperty("isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(o) !== Object.prototype) {
+    return false;
+  }
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function shouldThrowError(throwOnError, params) {
+  if (typeof throwOnError === "function") {
+    return throwOnError(...params);
+  }
+  return !!throwOnError;
+}
+
+// ../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+  let notifyFn = (callback) => {
+    callback();
+  };
+  let batchNotifyFn = (callback) => {
+    callback();
+  };
+  let scheduleFn = defaultScheduler;
+  const schedule = (callback) => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleFn(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+    if (originalQueue.length) {
+      scheduleFn(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach((callback) => {
+            notifyFn(callback);
+          });
+        });
+      });
+    }
+  };
+  return {
+    batch: (callback) => {
+      let result;
+      transactions++;
+      try {
+        result = callback();
+      } finally {
+        transactions--;
+        if (!transactions) {
+          flush();
+        }
+      }
+      return result;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (callback) => {
+      return (...args) => {
+        schedule(() => {
+          callback(...args);
+        });
+      };
+    },
+    schedule,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (fn) => {
+      notifyFn = fn;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (fn) => {
+      batchNotifyFn = fn;
+    },
+    setScheduler: (fn) => {
+      scheduleFn = fn;
+    }
+  };
+}
+var notifyManager = createNotifyManager();
+
+// ../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/mutation.js
+function getDefaultState() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: false,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+
+// ../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/mutationObserver.js
+var _client, _currentResult, _currentMutation, _mutateOptions, _MutationObserver_instances, updateResult_fn, notify_fn, _a2;
+var MutationObserver = (_a2 = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    __privateAdd(this, _MutationObserver_instances);
+    __privateAdd(this, _client);
+    __privateAdd(this, _currentResult);
+    __privateAdd(this, _currentMutation);
+    __privateAdd(this, _mutateOptions);
+    __privateSet(this, _client, client);
+    this.setOptions(options);
+    this.bindMethods();
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this);
+    this.reset = this.reset.bind(this);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    this.options = __privateGet(this, _client).defaultMutationOptions(options);
+    if (!shallowEqualObjects(this.options, prevOptions)) {
+      __privateGet(this, _client).getMutationCache().notify({
+        type: "observerOptionsUpdated",
+        mutation: __privateGet(this, _currentMutation),
+        observer: this
+      });
+    }
+    if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) {
+      this.reset();
+    } else if (__privateGet(this, _currentMutation)?.state.status === "pending") {
+      __privateGet(this, _currentMutation).setOptions(this.options);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      __privateGet(this, _currentMutation)?.removeObserver(this);
+    }
+  }
+  onMutationUpdate(action) {
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+    __privateMethod(this, _MutationObserver_instances, notify_fn).call(this, action);
+  }
+  getCurrentResult() {
+    return __privateGet(this, _currentResult);
+  }
+  reset() {
+    __privateGet(this, _currentMutation)?.removeObserver(this);
+    __privateSet(this, _currentMutation, void 0);
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+    __privateMethod(this, _MutationObserver_instances, notify_fn).call(this);
+  }
+  mutate(variables, options) {
+    __privateSet(this, _mutateOptions, options);
+    __privateGet(this, _currentMutation)?.removeObserver(this);
+    __privateSet(this, _currentMutation, __privateGet(this, _client).getMutationCache().build(__privateGet(this, _client), this.options));
+    __privateGet(this, _currentMutation).addObserver(this);
+    return __privateGet(this, _currentMutation).execute(variables);
+  }
+}, _client = new WeakMap(), _currentResult = new WeakMap(), _currentMutation = new WeakMap(), _mutateOptions = new WeakMap(), _MutationObserver_instances = new WeakSet(), updateResult_fn = function() {
+  const state = __privateGet(this, _currentMutation)?.state ?? getDefaultState();
+  __privateSet(this, _currentResult, {
+    ...state,
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success",
+    isError: state.status === "error",
+    isIdle: state.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, notify_fn = function(action) {
+  notifyManager.batch(() => {
+    if (__privateGet(this, _mutateOptions) && this.hasListeners()) {
+      const variables = __privateGet(this, _currentResult).variables;
+      const onMutateResult = __privateGet(this, _currentResult).context;
+      const context = {
+        client: __privateGet(this, _client),
+        meta: this.options.meta,
+        mutationKey: this.options.mutationKey
+      };
+      if (action?.type === "success") {
+        try {
+          __privateGet(this, _mutateOptions).onSuccess?.(
+            action.data,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+        try {
+          __privateGet(this, _mutateOptions).onSettled?.(
+            action.data,
+            null,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+      } else if (action?.type === "error") {
+        try {
+          __privateGet(this, _mutateOptions).onError?.(
+            action.error,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+        try {
+          __privateGet(this, _mutateOptions).onSettled?.(
+            void 0,
+            action.error,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+      }
+    }
+    this.listeners.forEach((listener) => {
+      listener(__privateGet(this, _currentResult));
+    });
+  });
+}, _a2);
+var QueryClientContext = React4.createContext(
+  void 0
+);
+var useQueryClient = (queryClient) => {
+  const client = React4.useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+function useMutation(options, queryClient) {
+  const client = useQueryClient();
+  const [observer] = React4.useState(
+    () => new MutationObserver(
+      client,
+      options
+    )
+  );
+  React4.useEffect(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const result = React4.useSyncExternalStore(
+    React4.useCallback(
+      (onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)),
+      [observer]
+    ),
+    () => observer.getCurrentResult(),
+    () => observer.getCurrentResult()
+  );
+  const mutate = React4.useCallback(
+    (variables, mutateOptions) => {
+      observer.mutate(variables, mutateOptions).catch(noop);
+    },
+    [observer]
+  );
+  if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) {
+    throw result.error;
+  }
+  return { ...result, mutate, mutateAsync: result.mutate };
+}
+
+// lib/api-client.ts
+var API_BASE_URL = typeof import.meta !== "undefined" && import.meta.env?.VITE_API_URL ? import.meta.env.VITE_API_URL : "/api";
+var ApiError = class extends Error {
+  constructor(status, statusText, message) {
+    super(message || `API Error: ${status} ${statusText}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.name = "ApiError";
+  }
+};
+async function handleResponse(response) {
+  if (!response.ok) {
+    let message;
+    try {
+      const errorData = await response.json();
+      message = errorData.message || errorData.error;
+    } catch {
+    }
+    throw new ApiError(response.status, response.statusText, message);
+  }
+  const text = await response.text();
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+function getHeaders() {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const token = typeof localStorage !== "undefined" ? localStorage.getItem("authToken") : null;
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
+var apiClient = {
+  /**
+   * GET request
+   */
+  async get(endpoint) {
+    const response = await fetch(`${API_BASE_URL}${endpoint}`, {
+      method: "GET",
+      headers: getHeaders()
+    });
+    return handleResponse(response);
+  },
+  /**
+   * POST request
+   */
+  async post(endpoint, data) {
+    const response = await fetch(`${API_BASE_URL}${endpoint}`, {
+      method: "POST",
+      headers: getHeaders(),
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return handleResponse(response);
+  },
+  /**
+   * PUT request
+   */
+  async put(endpoint, data) {
+    const response = await fetch(`${API_BASE_URL}${endpoint}`, {
+      method: "PUT",
+      headers: getHeaders(),
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return handleResponse(response);
+  },
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, data) {
+    const response = await fetch(`${API_BASE_URL}${endpoint}`, {
+      method: "PATCH",
+      headers: getHeaders(),
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return handleResponse(response);
+  },
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    const response = await fetch(`${API_BASE_URL}${endpoint}`, {
+      method: "DELETE",
+      headers: getHeaders()
+    });
+    return handleResponse(response);
+  }
+};
+
+// hooks/useOrbitalMutations.ts
+var ENTITY_EVENTS = {
+  CREATE: "ENTITY_CREATE",
+  UPDATE: "ENTITY_UPDATE",
+  DELETE: "ENTITY_DELETE"
+};
+async function sendOrbitalEvent(orbitalName, eventPayload) {
+  const response = await apiClient.post(
+    `/orbitals/${orbitalName}/events`,
+    eventPayload
+  );
+  return response;
+}
+function useOrbitalMutations(entityName, orbitalName, options) {
+  const queryClient = useQueryClient();
+  const events = {
+    create: options?.events?.create || ENTITY_EVENTS.CREATE,
+    update: options?.events?.update || ENTITY_EVENTS.UPDATE,
+    delete: options?.events?.delete || ENTITY_EVENTS.DELETE
+  };
+  const log = (message, data) => {
+    if (options?.debug) {
+      console.log(`[useOrbitalMutations:${orbitalName}] ${message}`, data ?? "");
+    }
+  };
+  const createMutation = useMutation({
+    mutationFn: async (data) => {
+      log("Creating entity", data);
+      return sendOrbitalEvent(orbitalName, {
+        event: events.create,
+        payload: { data, entityType: entityName }
+      });
+    },
+    onSuccess: (response) => {
+      log("Create succeeded", response);
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+    },
+    onError: (error) => {
+      console.error(`[useOrbitalMutations] Create failed:`, error);
+    }
+  });
+  const updateMutation = useMutation({
+    mutationFn: async ({
+      id,
+      data
+    }) => {
+      log(`Updating entity ${id}`, data);
+      return sendOrbitalEvent(orbitalName, {
+        event: events.update,
+        entityId: id,
+        payload: { data, entityType: entityName }
+      });
+    },
+    onSuccess: (response, variables) => {
+      log("Update succeeded", response);
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+      queryClient.invalidateQueries({
+        queryKey: entityDataKeys.detail(entityName, variables.id)
+      });
+    },
+    onError: (error) => {
+      console.error(`[useOrbitalMutations] Update failed:`, error);
+    }
+  });
+  const deleteMutation = useMutation({
+    mutationFn: async (id) => {
+      log(`Deleting entity ${id}`);
+      return sendOrbitalEvent(orbitalName, {
+        event: events.delete,
+        entityId: id,
+        payload: { entityType: entityName }
+      });
+    },
+    onSuccess: (response, id) => {
+      log("Delete succeeded", response);
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+      queryClient.removeQueries({ queryKey: entityDataKeys.detail(entityName, id) });
+    },
+    onError: (error) => {
+      console.error(`[useOrbitalMutations] Delete failed:`, error);
+    }
+  });
+  return {
+    // Async functions
+    createEntity: async (data) => {
+      return createMutation.mutateAsync(data);
+    },
+    updateEntity: async (id, data) => {
+      if (!id) {
+        console.warn("[useOrbitalMutations] Cannot update without ID");
+        return;
+      }
+      return updateMutation.mutateAsync({ id, data });
+    },
+    deleteEntity: async (id) => {
+      if (!id) {
+        console.warn("[useOrbitalMutations] Cannot delete without ID");
+        return;
+      }
+      return deleteMutation.mutateAsync(id);
+    },
+    // Mutation objects for fine-grained control
+    createMutation,
+    updateMutation,
+    deleteMutation,
+    // Aggregate states
+    isCreating: createMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    isMutating: createMutation.isPending || updateMutation.isPending || deleteMutation.isPending,
+    // Errors
+    createError: createMutation.error,
+    updateError: updateMutation.error,
+    deleteError: deleteMutation.error
+  };
+}
+function useSendOrbitalEvent(orbitalName) {
+  const mutation = useMutation({
+    mutationFn: async (payload) => {
+      return sendOrbitalEvent(orbitalName, payload);
+    }
+  });
+  return {
+    sendEvent: async (event, payload, entityId) => {
+      return mutation.mutateAsync({ event, payload, entityId });
+    },
+    isPending: mutation.isPending,
+    error: mutation.error,
+    data: mutation.data
+  };
+}
+
+// hooks/useEntityMutations.ts
+function entityToCollection(entityName) {
+  return entityName.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase() + "-list";
+}
+function useCreateEntity(entityName) {
+  const queryClient = useQueryClient();
+  const collection = entityToCollection(entityName);
+  return useMutation({
+    mutationFn: async (data) => {
+      console.log(`[useCreateEntity] Creating ${entityName}:`, data);
+      const response = await apiClient.post(
+        `/${collection}`,
+        data
+      );
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+    },
+    onError: (error) => {
+      console.error(`[useCreateEntity] Failed to create ${entityName}:`, error);
+    }
+  });
+}
+function useUpdateEntity(entityName) {
+  const queryClient = useQueryClient();
+  const collection = entityToCollection(entityName);
+  return useMutation({
+    mutationFn: async ({ id, data }) => {
+      console.log(`[useUpdateEntity] Updating ${entityName} ${id}:`, data);
+      const response = await apiClient.patch(
+        `/${collection}/${id}`,
+        data
+      );
+      return response.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.detail(entityName, variables.id) });
+    },
+    onError: (error) => {
+      console.error(`[useUpdateEntity] Failed to update ${entityName}:`, error);
+    }
+  });
+}
+function useDeleteEntity(entityName) {
+  const queryClient = useQueryClient();
+  const collection = entityToCollection(entityName);
+  return useMutation({
+    mutationFn: async (id) => {
+      console.log(`[useDeleteEntity] Deleting ${entityName} ${id}`);
+      await apiClient.delete(`/${collection}/${id}`);
+      return { id };
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+      queryClient.removeQueries({ queryKey: entityDataKeys.detail(entityName, id) });
+    },
+    onError: (error) => {
+      console.error(`[useDeleteEntity] Failed to delete ${entityName}:`, error);
+    }
+  });
+}
+async function sendOrbitalMutation(orbitalName, event, entityId, payload) {
+  const response = await apiClient.post(
+    `/orbitals/${orbitalName}/events`,
+    { event, entityId, payload }
+  );
+  return response;
+}
+function useEntityMutations(entityName, options) {
+  const queryClient = useQueryClient();
+  const useOrbitalRoute = !!options?.orbitalName;
+  const events = {
+    create: options?.events?.create || ENTITY_EVENTS.CREATE,
+    update: options?.events?.update || ENTITY_EVENTS.UPDATE,
+    delete: options?.events?.delete || ENTITY_EVENTS.DELETE
+  };
+  const createMutation = useCreateEntity(entityName);
+  const updateMutation = useUpdateEntity(entityName);
+  const deleteMutation = useDeleteEntity(entityName);
+  const orbitalCreateMutation = useMutation({
+    mutationFn: async (data) => {
+      return sendOrbitalMutation(options.orbitalName, events.create, void 0, {
+        data,
+        entityType: entityName
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+    }
+  });
+  const orbitalUpdateMutation = useMutation({
+    mutationFn: async ({ id, data }) => {
+      return sendOrbitalMutation(options.orbitalName, events.update, id, {
+        data,
+        entityType: entityName
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+      queryClient.invalidateQueries({
+        queryKey: entityDataKeys.detail(entityName, variables.id)
+      });
+    }
+  });
+  const orbitalDeleteMutation = useMutation({
+    mutationFn: async (id) => {
+      return sendOrbitalMutation(options.orbitalName, events.delete, id, {
+        entityType: entityName
+      });
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+      queryClient.removeQueries({ queryKey: entityDataKeys.detail(entityName, id) });
+    }
+  });
+  const activeMutations = {
+    create: useOrbitalRoute ? orbitalCreateMutation : createMutation,
+    update: useOrbitalRoute ? orbitalUpdateMutation : updateMutation,
+    delete: useOrbitalRoute ? orbitalDeleteMutation : deleteMutation
+  };
+  return {
+    // Async functions that can be called directly
+    // Accepts either (data) or (entityName, data) for compiler compatibility
+    createEntity: async (entityOrData, data) => {
+      const actualData = typeof entityOrData === "string" ? data : entityOrData;
+      if (!actualData) {
+        console.warn("[useEntityMutations] Cannot create entity without data");
+        return;
+      }
+      return activeMutations.create.mutateAsync(actualData);
+    },
+    updateEntity: async (id, data) => {
+      if (!id) {
+        console.warn("[useEntityMutations] Cannot update entity without ID");
+        return;
+      }
+      return activeMutations.update.mutateAsync({ id, data });
+    },
+    deleteEntity: async (id) => {
+      if (!id) {
+        console.warn("[useEntityMutations] Cannot delete entity without ID");
+        return;
+      }
+      return activeMutations.delete.mutateAsync(id);
+    },
+    // Mutation states for UI feedback
+    isCreating: activeMutations.create.isPending,
+    isUpdating: activeMutations.update.isPending,
+    isDeleting: activeMutations.delete.isPending,
+    createError: activeMutations.create.error,
+    updateError: activeMutations.update.error,
+    deleteError: activeMutations.delete.error
+  };
+}
+
+// stores/entityStore.ts
+var entities = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+var idCounter2 = 0;
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function notify() {
+  listeners.forEach((listener) => listener());
+}
+function getEntity(id) {
+  return entities.get(id);
+}
+function getByType(type) {
+  const types = Array.isArray(type) ? type : [type];
+  return [...entities.values()].filter((e) => types.includes(e.type));
+}
+function getAllEntities() {
+  return [...entities.values()];
+}
+function getSingleton(type) {
+  return [...entities.values()].find((e) => e.type === type);
+}
+function spawnEntity(config) {
+  const id = config.id ?? `entity_${++idCounter2}`;
+  const entity = { ...config, id };
+  entities = new Map(entities);
+  entities.set(id, entity);
+  notify();
+  return id;
+}
+function updateEntity(id, updates) {
+  const entity = entities.get(id);
+  if (entity) {
+    entities = new Map(entities);
+    entities.set(id, { ...entity, ...updates });
+    notify();
+  }
+}
+function updateSingleton(type, updates) {
+  const entity = getSingleton(type);
+  if (entity) {
+    updateEntity(entity.id, updates);
+  }
+}
+function removeEntity(id) {
+  if (entities.has(id)) {
+    entities = new Map(entities);
+    entities.delete(id);
+    notify();
+  }
+}
+function clearEntities() {
+  entities = /* @__PURE__ */ new Map();
+  notify();
+}
+function getSnapshot() {
+  return entities;
+}
+
+// hooks/useEntities.ts
+function useEntities() {
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return {
+    entities: entities2,
+    getEntity,
+    getByType,
+    getAllEntities,
+    getSingleton,
+    spawnEntity,
+    updateEntity,
+    updateSingleton,
+    removeEntity,
+    clearEntities
+  };
+}
+function useEntity2(id) {
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return entities2.get(id);
+}
+function useEntitiesByType(type) {
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return [...entities2.values()].filter((e) => e.type === type);
+}
+function useSingletonEntity(type) {
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return [...entities2.values()].find((e) => e.type === type);
+}
+function usePlayer() {
+  const player = useSingletonEntity("Player");
+  const update = useCallback((updates) => {
+    if (player) updateEntity(player.id, updates);
+  }, [player?.id]);
+  return { player, updatePlayer: update };
+}
+function usePhysics() {
+  const physics = useSingletonEntity("Physics");
+  const update = useCallback((updates) => {
+    if (physics) updateEntity(physics.id, updates);
+  }, [physics?.id]);
+  return { physics, updatePhysics: update };
+}
+function useInput() {
+  const input = useSingletonEntity("Input");
+  const update = useCallback((updates) => {
+    if (input) updateEntity(input.id, updates);
+  }, [input?.id]);
+  return { input, updateInput: update };
+}
+
+// hooks/useAuthContext.ts
+function useAuthContext() {
+  return {
+    user: null,
+    loading: false,
+    signIn: void 0,
+    signOut: void 0
+  };
+}
+
+export { DEFAULT_SLOTS, ENTITY_EVENTS, clearEntities, entityDataKeys, getAllEntities, getByType, getEntity, getSingleton, parseQueryBinding, removeEntity, spawnEntity, updateEntity, updateSingleton, useAgentChat, useAuthContext, useCompile, useCreateEntity, useDeepAgentGeneration, useDeleteEntity, useEmitEvent, useEntities, useEntitiesByType, useEntity, useEntity2 as useEntityById, useEntityDetail, useEntityList, useEntityMutations, useEventBus, useEventListener, useExtensions, useFileEditor, useFileSystem, useInput, useOrbitalHistory, useOrbitalMutations, usePhysics, usePlayer, usePreview, useQuerySingleton, useSelectedEntity, useSendOrbitalEvent, useSingletonEntity, useUIEvents, useUISlotManager, useUpdateEntity, useValidation };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map