@almadar/ui 1.0.1 → 1.0.11

package/dist/hooks/index.js

@@ -1,2267 +1,6 @@
-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
-function getGlobalEventBus() {
-  if (typeof window !== "undefined") {
-    return window.__kflowEventBus ?? null;
-  }
-  return 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 ?? getGlobalEventBus() ?? 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
+export { ENTITY_EVENTS, entityDataKeys, parseQueryBinding, useAgentChat, useAuthContext, useCompile, useConnectGitHub, useCreateEntity, useDeepAgentGeneration, useDeleteEntity, useDisconnectGitHub, useEntities, useEntitiesByType, useEntity, useEntity2 as useEntityById, useEntityDetail, useEntityList, useEntityMutations, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, useInput, useOrbitalHistory, useOrbitalMutations, usePhysics, usePlayer, usePreview, useQuerySingleton, useSelectedEntity, useSendOrbitalEvent, useSingletonEntity, useUIEvents, useUpdateEntity, useValidation } from '../chunk-4AIGHVQK.js';
+import '../chunk-XSEDIUM6.js';
+export { useEmitEvent, useEventBus, useEventListener } from '../chunk-TTXKOHDO.js';
+export { DEFAULT_SLOTS, useUISlotManager } from '../chunk-7NEWMNNU.js';
+export { clearEntities, getAllEntities, getByType, getEntity, getSingleton, removeEntity, spawnEntity, updateEntity, updateSingleton } from '../chunk-N7MVUW4R.js';
+import '../chunk-S7EYY36U.js';