@almadar/ui 2.15.7 → 2.15.10

package/dist/hooks/index.cjs

@@ -0,0 +1,2606 @@
+'use strict';
+
+var React3 = require('react');
+require('react/jsx-runtime');
+var reactQuery = require('@tanstack/react-query');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React3__default = /*#__PURE__*/_interopDefault(React3);
+
+function useOrbitalHistory(options) {
+  const { appId, authToken, userId, onHistoryChange, onRevertSuccess } = options;
+  const getHeaders2 = React3.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] = React3.useState([]);
+  const [currentVersion, setCurrentVersion] = React3.useState(1);
+  const [isLoading, setIsLoading] = React3.useState(false);
+  const [error, setError] = React3.useState(null);
+  const refresh = React3.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 = React3.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]);
+  React3.useEffect(() => {
+    if (appId && authToken && userId) {
+      refresh();
+    }
+  }, [appId, authToken, userId]);
+  React3.useEffect(() => {
+    onHistoryChange?.(timeline);
+  }, [timeline]);
+  return {
+    timeline,
+    currentVersion,
+    isLoading,
+    error,
+    revertToSnapshot,
+    refresh
+  };
+}
+function useFileSystem() {
+  const [status, setStatus] = React3.useState("idle");
+  const [error, setError] = React3.useState(null);
+  const [isLoading, setIsLoading] = React3.useState(false);
+  const [files, setFiles] = React3.useState([]);
+  const [selectedFile, setSelectedFile] = React3.useState(null);
+  const [selectedPath, setSelectedPath] = React3.useState(null);
+  const [previewUrl, setPreviewUrl] = React3.useState(null);
+  const [fileContents, setFileContents] = React3.useState(/* @__PURE__ */ new Map());
+  const boot = React3.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 = React3.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 = React3.useCallback(async (path) => {
+    return fileContents.get(path) || "";
+  }, [fileContents]);
+  const writeFile = React3.useCallback(async (path, content) => {
+    setFileContents((prev) => {
+      const next = new Map(prev);
+      next.set(path, content);
+      return next;
+    });
+  }, []);
+  const selectFile = React3.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 = React3.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 = React3.useCallback((content) => {
+    setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
+  }, []);
+  const refreshTree = React3.useCallback(async () => {
+    console.log("[useFileSystem] Refreshing tree");
+  }, []);
+  const runCommand = React3.useCallback(async (command) => {
+    console.log("[useFileSystem] Running command:", command);
+    return { exitCode: 0, output: "" };
+  }, []);
+  const startDevServer = React3.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] = React3.useState([]);
+  const [manifest] = React3.useState(defaultManifest);
+  const [isLoading, setIsLoading] = React3.useState(false);
+  const [error, setError] = React3.useState(null);
+  const loadExtension = React3.useCallback(async (extensionId) => {
+    console.log("[useExtensions] Loading extension:", extensionId);
+  }, []);
+  const loadExtensions = React3.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 = React3.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]);
+  React3.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] = React3.useState([]);
+  const [activeFilePath, setActiveFilePath] = React3.useState(null);
+  const [isSaving, setIsSaving] = React3.useState(false);
+  const activeFile = openFiles.find((f) => f.path === activeFilePath) || null;
+  const openFile = React3.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 = React3.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 = React3.useCallback((path) => {
+    setActiveFilePath(path);
+  }, []);
+  const updateFileContent = React3.useCallback((path, content) => {
+    setOpenFiles(
+      (prev) => prev.map(
+        (f) => f.path === path ? { ...f, content, isDirty: true } : f
+      )
+    );
+  }, []);
+  const handleFileEdit = React3.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 = React3.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 = React3.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] = React3.useState(false);
+  const [stage, setStage] = React3.useState("idle");
+  const [lastResult, setLastResult] = React3.useState(null);
+  const [error, setError] = React3.useState(null);
+  const compileSchema = React3.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] = React3.useState(null);
+  const [isLoading, setIsLoading] = React3.useState(!!options?.appId);
+  const [error, setError] = React3.useState(null);
+  const [loadError, setLoadError] = React3.useState(null);
+  const [app, setApp] = React3.useState(null);
+  const [isFullscreen, setIsFullscreen] = React3.useState(false);
+  const [isExecutingEvent, setIsExecutingEvent] = React3.useState(false);
+  const [errorToast, setErrorToast] = React3.useState(null);
+  const [currentStateName, setCurrentStateName] = React3.useState(null);
+  const [notificationsList, setNotificationsList] = React3.useState([]);
+  const [isPanelOpen, setIsPanelOpen] = React3.useState(false);
+  const notifications = React3.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]);
+  React3.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 = React3.useCallback(async () => {
+    console.log("[usePreview] startPreview called");
+  }, []);
+  const stopPreview = React3.useCallback(async () => {
+    setIsLoading(true);
+    try {
+      console.log("[usePreview] Stopping preview server...");
+      setPreviewUrl(null);
+      setApp(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const refresh = React3.useCallback(async () => {
+    if (!previewUrl) return;
+    console.log("[usePreview] Refreshing preview...");
+    setPreviewUrl(`${previewUrl.split("?")[0]}?t=${Date.now()}`);
+  }, [previewUrl]);
+  const handleRefresh = React3.useCallback(async () => {
+    console.log("[usePreview] Handle refresh...");
+    await refresh();
+  }, [refresh]);
+  const handleReset = React3.useCallback(async () => {
+    console.log("[usePreview] Resetting preview...");
+    setError(null);
+    setLoadError(null);
+    setErrorToast(null);
+    setIsExecutingEvent(false);
+    setCurrentStateName(null);
+  }, []);
+  const toggleFullscreen = React3.useCallback(() => {
+    setIsFullscreen((prev) => !prev);
+  }, []);
+  const dismissErrorToast = React3.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] = React3.useState([]);
+  const [status, setStatus] = React3.useState("idle");
+  const [activities, setActivities] = React3.useState([]);
+  const [todos, setTodos] = React3.useState([]);
+  const [schemaDiffs, setSchemaDiffs] = React3.useState([]);
+  const [isLoading, setIsLoading] = React3.useState(false);
+  const [error, setError] = React3.useState(null);
+  const [threadId] = React3.useState(null);
+  const [interrupt, setInterrupt] = React3.useState(null);
+  const sendMessage = React3.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 = React3.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 = React3.useCallback(async (message) => {
+    console.log("[useAgentChat] Continue conversation", message);
+  }, []);
+  const resumeWithDecision = React3.useCallback(async (decisions) => {
+    console.log("[useAgentChat] Resume with decision:", decisions);
+    setInterrupt(null);
+  }, []);
+  const cancel = React3.useCallback(() => {
+    setStatus("idle");
+    setIsLoading(false);
+    setInterrupt(null);
+  }, []);
+  const clearMessages = React3.useCallback(() => {
+    setMessages([]);
+  }, []);
+  const clearHistory = React3.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] = React3.useState(null);
+  const [isValidating, setIsValidating] = React3.useState(false);
+  const [error, setError] = React3.useState(null);
+  const [stage, setStage] = React3.useState("idle");
+  const [isFixing, setIsFixing] = React3.useState(false);
+  const [progressMessage, setProgressMessage] = React3.useState(null);
+  const validate = React3.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 = React3.useCallback(() => {
+    setResult(null);
+    setError(null);
+  }, []);
+  const reset = React3.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] = React3.useState([]);
+  const [currentRequest, setCurrentRequest] = React3.useState(null);
+  const [isGenerating, setIsGenerating] = React3.useState(false);
+  const [isLoading, setIsLoading] = React3.useState(false);
+  const [isComplete, setIsComplete] = React3.useState(false);
+  const [progress, setProgress] = React3.useState({ stage: "idle", percent: 0, message: "" });
+  const [error, setError] = React3.useState(null);
+  const [interrupt, setInterrupt] = React3.useState(null);
+  const generate = React3.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 = React3.useCallback(async (skill, prompt, _options) => {
+    console.log("[useDeepAgentGeneration] Starting generation with skill:", skill);
+    await generate(prompt);
+  }, [generate]);
+  const cancelGeneration = React3.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 = React3.useCallback(() => {
+    setRequests([]);
+    setCurrentRequest(null);
+    setError(null);
+    setProgress({ stage: "idle", percent: 0, message: "" });
+    setIsComplete(false);
+  }, []);
+  const submitInterruptDecisions = React3.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 = React3.createContext(null);
+
+// hooks/useEventBus.ts
+function getGlobalEventBus() {
+  if (typeof window !== "undefined") {
+    return window.__kflowEventBus ?? null;
+  }
+  return null;
+}
+var fallbackListeners = /* @__PURE__ */ new Map();
+var fallbackAnyListeners = /* @__PURE__ */ new Set();
+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);
+        }
+      });
+    }
+    fallbackAnyListeners.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error(`[EventBus] Error in onAny 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;
+  },
+  onAny: (listener) => {
+    fallbackAnyListeners.add(listener);
+    return () => {
+      fallbackAnyListeners.delete(listener);
+    };
+  }
+};
+function useEventBus() {
+  const context = React3.useContext(EventBusContext);
+  return context ?? getGlobalEventBus() ?? fallbackEventBus;
+}
+function useEventListener(event, handler) {
+  const eventBus = useEventBus();
+  const handlerRef = React3.useRef(handler);
+  handlerRef.current = handler;
+  React3.useEffect(() => {
+    const wrappedHandler = (evt) => {
+      handlerRef.current(evt);
+    };
+    const unsub = eventBus.on(event, wrappedHandler);
+    return () => {
+      if (typeof unsub === "function") unsub();
+    };
+  }, [event, eventBus]);
+}
+function useEmitEvent() {
+  const eventBus = useEventBus();
+  return React3.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,
+  "hud-left": null,
+  "hud-right": null,
+  floating: null
+};
+var idCounter = 0;
+function generateId() {
+  return `slot-content-${++idCounter}-${Date.now()}`;
+}
+function useUISlotManager() {
+  const [slots, setSlots] = React3.useState(DEFAULT_SLOTS);
+  const subscribersRef = React3.useRef(/* @__PURE__ */ new Set());
+  const timersRef = React3.useRef(/* @__PURE__ */ new Map());
+  React3.useEffect(() => {
+    return () => {
+      timersRef.current.forEach((timer) => clearTimeout(timer));
+      timersRef.current.clear();
+    };
+  }, []);
+  const notifySubscribers = React3.useCallback((slot, content) => {
+    subscribersRef.current.forEach((callback) => {
+      try {
+        callback(slot, content);
+      } catch (error) {
+        console.error("[UISlots] Subscriber error:", error);
+      }
+    });
+  }, []);
+  const render = React3.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 = React3.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 = React3.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 = React3.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 = React3.useCallback((callback) => {
+    subscribersRef.current.add(callback);
+    return () => {
+      subscribersRef.current.delete(callback);
+    };
+  }, []);
+  const hasContent = React3.useCallback((slot) => {
+    return slots[slot] !== null;
+  }, [slots]);
+  const getContent = React3.useCallback((slot) => {
+    return slots[slot];
+  }, [slots]);
+  return {
+    slots,
+    render,
+    clear,
+    clearById,
+    clearAll,
+    subscribe: subscribe2,
+    hasContent,
+    getContent
+  };
+}
+var SelectionContext = React3.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 = React3.useMemo(
+    () => validEvents,
+    [validEventsKey]
+    // intentional — validEventsKey is the stable dep, not validEvents array ref
+  );
+  React3.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) => {
+        if (typeof unsub === "function") unsub();
+      });
+    };
+  }, [eventBus, dispatch, stableValidEvents]);
+}
+function useSelectedEntity(eventBusInstance) {
+  const defaultEventBus = useEventBus();
+  const eventBus = eventBusInstance ?? defaultEventBus;
+  const selectionContext = useSelectionContext();
+  const [localSelected, setLocalSelected] = React3.useState(null);
+  const usingContext = selectionContext !== null;
+  React3.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].forEach(
+        (unsub) => {
+          if (typeof unsub === "function") unsub();
+        }
+      );
+    };
+  }, [eventBus, usingContext]);
+  if (selectionContext) {
+    return [selectionContext.selected, selectionContext.setSelected];
+  }
+  return [localSelected, setLocalSelected];
+}
+function useSelectionContext() {
+  const context = React3.useContext(SelectionContext);
+  return context;
+}
+var EntityDataContext = React3.createContext(null);
+function EntityDataProvider({
+  adapter,
+  children
+}) {
+  return React3__default.default.createElement(
+    EntityDataContext.Provider,
+    { value: adapter },
+    children
+  );
+}
+function useEntityDataAdapter() {
+  return React3.useContext(EntityDataContext);
+}
+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 adapter = React3.useContext(EntityDataContext);
+  const adapterData = React3.useMemo(() => {
+    if (!adapter || !entity || skip) return [];
+    return adapter.getData(entity);
+  }, [adapter, entity, skip, adapter?.isLoading]);
+  const [stubData, setStubData] = React3.useState([]);
+  const [stubLoading, setStubLoading] = React3.useState(!skip && !!entity && !adapter);
+  const [stubError, setStubError] = React3.useState(null);
+  React3.useEffect(() => {
+    if (adapter || skip || !entity) {
+      setStubLoading(false);
+      return;
+    }
+    setStubLoading(true);
+    const t = setTimeout(() => {
+      setStubData([]);
+      setStubLoading(false);
+    }, 100);
+    return () => clearTimeout(t);
+  }, [entity, skip, adapter]);
+  if (adapter) {
+    return {
+      data: adapterData,
+      isLoading: adapter.isLoading,
+      error: adapter.error ? new Error(adapter.error) : null,
+      refetch: () => {
+      }
+    };
+  }
+  return { data: stubData, isLoading: stubLoading, error: stubError, refetch: () => {
+  } };
+}
+function useEntity(entity, id) {
+  const adapter = React3.useContext(EntityDataContext);
+  const adapterData = React3.useMemo(() => {
+    if (!adapter || !entity || !id) return null;
+    return adapter.getById(entity, id) ?? null;
+  }, [adapter, entity, id, adapter?.isLoading]);
+  const [stubData, setStubData] = React3.useState(null);
+  const [stubLoading, setStubLoading] = React3.useState(!!entity && !!id && !adapter);
+  const [stubError, setStubError] = React3.useState(null);
+  React3.useEffect(() => {
+    if (adapter || !entity || !id) {
+      setStubLoading(false);
+      return;
+    }
+    setStubLoading(true);
+    const t = setTimeout(() => {
+      setStubData(null);
+      setStubLoading(false);
+    }, 100);
+    return () => clearTimeout(t);
+  }, [entity, id, adapter]);
+  if (adapter) {
+    return {
+      data: adapterData,
+      isLoading: adapter.isLoading,
+      error: adapter.error ? new Error(adapter.error) : null
+    };
+  }
+  return { data: stubData, isLoading: stubLoading, error: stubError };
+}
+function useEntityDetail(entity, id) {
+  const result = useEntity(entity, id);
+  return { ...result, refetch: () => {
+  } };
+}
+var suspenseCache = /* @__PURE__ */ new Map();
+function getSuspenseCacheKey(entity, type, id) {
+  return id ? `${type}:${entity}:${id}` : `${type}:${entity}`;
+}
+function useEntityListSuspense(entity) {
+  const adapter = React3.useContext(EntityDataContext);
+  if (adapter) {
+    if (adapter.isLoading) {
+      const cacheKey2 = getSuspenseCacheKey(entity, "list");
+      let entry2 = suspenseCache.get(cacheKey2);
+      if (!entry2 || entry2.status === "resolved") {
+        let resolve;
+        const promise = new Promise((r) => {
+          resolve = r;
+        });
+        entry2 = { promise, status: "pending" };
+        suspenseCache.set(cacheKey2, entry2);
+        const check = setInterval(() => {
+          if (!adapter.isLoading) {
+            clearInterval(check);
+            entry2.status = "resolved";
+            resolve();
+          }
+        }, 50);
+      }
+      if (entry2.status === "pending") {
+        throw entry2.promise;
+      }
+    }
+    if (adapter.error) {
+      throw new Error(adapter.error);
+    }
+    return {
+      data: adapter.getData(entity),
+      refetch: () => {
+      }
+    };
+  }
+  const cacheKey = getSuspenseCacheKey(entity, "list");
+  let entry = suspenseCache.get(cacheKey);
+  if (!entry) {
+    let resolve;
+    const promise = new Promise((r) => {
+      resolve = r;
+      setTimeout(() => {
+        entry.status = "resolved";
+        resolve();
+      }, 100);
+    });
+    entry = { promise, status: "pending" };
+    suspenseCache.set(cacheKey, entry);
+  }
+  if (entry.status === "pending") {
+    throw entry.promise;
+  }
+  return { data: [], refetch: () => {
+  } };
+}
+function useEntitySuspense(entity, id) {
+  const adapter = React3.useContext(EntityDataContext);
+  if (adapter) {
+    if (adapter.isLoading) {
+      const cacheKey2 = getSuspenseCacheKey(entity, "detail", id);
+      let entry2 = suspenseCache.get(cacheKey2);
+      if (!entry2 || entry2.status === "resolved") {
+        let resolve;
+        const promise = new Promise((r) => {
+          resolve = r;
+        });
+        entry2 = { promise, status: "pending" };
+        suspenseCache.set(cacheKey2, entry2);
+        const check = setInterval(() => {
+          if (!adapter.isLoading) {
+            clearInterval(check);
+            entry2.status = "resolved";
+            resolve();
+          }
+        }, 50);
+      }
+      if (entry2.status === "pending") {
+        throw entry2.promise;
+      }
+    }
+    if (adapter.error) {
+      throw new Error(adapter.error);
+    }
+    return {
+      data: adapter.getById(entity, id) ?? null,
+      refetch: () => {
+      }
+    };
+  }
+  const cacheKey = getSuspenseCacheKey(entity, "detail", id);
+  let entry = suspenseCache.get(cacheKey);
+  if (!entry) {
+    let resolve;
+    const promise = new Promise((r) => {
+      resolve = r;
+      setTimeout(() => {
+        entry.status = "resolved";
+        resolve();
+      }, 100);
+    });
+    entry = { promise, status: "pending" };
+    suspenseCache.set(cacheKey, entry);
+  }
+  if (entry.status === "pending") {
+    throw entry.promise;
+  }
+  return { data: null, 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] = React3.useState({});
+  if (!query) {
+    return null;
+  }
+  const store = React3.useMemo(() => getOrCreateStore(query), [query]);
+  React3.useMemo(() => {
+    const listener = () => forceUpdate({});
+    store.listeners.add(listener);
+    return () => {
+      store.listeners.delete(listener);
+    };
+  }, [store]);
+  const notifyListeners = React3.useCallback(() => {
+    store.listeners.forEach((listener) => listener());
+  }, [store]);
+  const setSearch = React3.useCallback((value) => {
+    store.search = value;
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const setFilter = React3.useCallback((key, value) => {
+    store.filters = { ...store.filters, [key]: value };
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const clearFilters = React3.useCallback(() => {
+    store.filters = {};
+    store.search = "";
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const setSort = React3.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
+  };
+}
+
+// lib/api-client.ts
+var API_BASE_URL = typeof process !== "undefined" && process.env?.VITE_API_URL ? process.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);
+  }
+};
+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 = reactQuery.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 = reactQuery.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 = reactQuery.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 = reactQuery.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 = reactQuery.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 = reactQuery.useQueryClient();
+  const collection = entityToCollection(entityName);
+  return reactQuery.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 = reactQuery.useQueryClient();
+  const collection = entityToCollection(entityName);
+  return reactQuery.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 = reactQuery.useQueryClient();
+  const collection = entityToCollection(entityName);
+  return reactQuery.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 = reactQuery.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 = reactQuery.useMutation({
+    mutationFn: async (data) => {
+      return sendOrbitalMutation(options.orbitalName, events.create, void 0, {
+        data,
+        entityType: entityName
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: entityDataKeys.list(entityName) });
+    }
+  });
+  const orbitalUpdateMutation = reactQuery.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 = reactQuery.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 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return {
+    entities: entities2,
+    getEntity,
+    getByType,
+    getAllEntities,
+    getSingleton,
+    spawnEntity,
+    updateEntity,
+    updateSingleton,
+    removeEntity,
+    clearEntities
+  };
+}
+function useEntity2(id) {
+  const entities2 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return entities2.get(id);
+}
+function useEntitiesByType(type) {
+  const entities2 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return [...entities2.values()].filter((e) => e.type === type);
+}
+function useSingletonEntity(type) {
+  const entities2 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return [...entities2.values()].find((e) => e.type === type);
+}
+function usePlayer() {
+  const player = useSingletonEntity("Player");
+  const update = React3.useCallback((updates) => {
+    if (player) updateEntity(player.id, updates);
+  }, [player?.id]);
+  return { player, updatePlayer: update };
+}
+function usePhysics() {
+  const physics = useSingletonEntity("Physics");
+  const update = React3.useCallback((updates) => {
+    if (physics) updateEntity(physics.id, updates);
+  }, [physics?.id]);
+  return { physics, updatePhysics: update };
+}
+function useInput() {
+  const input = useSingletonEntity("Input");
+  const update = React3.useCallback((updates) => {
+    if (input) updateEntity(input.id, updates);
+  }, [input?.id]);
+  return { input, updateInput: update };
+}
+
+// locales/en.json
+var en_default = {
+  $meta: { locale: "en", direction: "ltr" },
+  "common.save": "Save",
+  "common.cancel": "Cancel",
+  "common.delete": "Delete",
+  "common.close": "Close",
+  "common.confirm": "Are you sure?",
+  "common.create": "Create",
+  "common.edit": "Edit",
+  "common.view": "View",
+  "common.add": "Add",
+  "common.remove": "Remove",
+  "common.search": "Search...",
+  "common.filter": "Filter",
+  "common.actions": "Actions",
+  "common.yes": "Yes",
+  "common.no": "No",
+  "common.selected": "selected",
+  "common.ok": "OK",
+  "common.done": "Done",
+  "common.apply": "Apply",
+  "common.reset": "Reset",
+  "common.refresh": "Refresh",
+  "common.export": "Export",
+  "common.import": "Import",
+  "common.copy": "Copy",
+  "common.settings": "Settings",
+  "nav.previous": "Previous",
+  "nav.next": "Next",
+  "nav.back": "Back",
+  "nav.home": "Home",
+  "form.submit": "Submit",
+  "form.saving": "Saving...",
+  "form.required": "This field is required",
+  "form.invalidEmail": "Enter a valid email address",
+  "form.selectPlaceholder": "Select {{label}}...",
+  "form.searchPlaceholder": "Search {{entity}}...",
+  "table.empty.title": "No items found",
+  "table.empty.description": "No items to display.",
+  "table.search.placeholder": "Search...",
+  "table.pagination.showing": "Showing {{start}} to {{end}} of {{total}} results",
+  "table.pagination.page": "Page {{page}} of {{totalPages}}",
+  "table.bulk.selected": "{{count}} selected",
+  "table.loading": "Loading...",
+  "status.loading": "Loading...",
+  "status.scheduled": "Scheduled",
+  "status.inProgress": "In Progress",
+  "status.completed": "Completed",
+  "status.cancelled": "Cancelled",
+  "status.pending": "Pending",
+  "status.active": "Active",
+  "status.inactive": "Inactive",
+  "status.draft": "Draft",
+  "status.archived": "Archived",
+  "error.generic": "Something went wrong",
+  "error.retry": "Try again",
+  "error.notFound": "Not found",
+  "error.loadFailed": "Failed to load: {{message}}",
+  "error.configMissing": "Configuration not found for: {{id}}",
+  "common.loading": "Loading...",
+  "common.showMore": "Show More",
+  "common.showLess": "Show Less",
+  "common.noResults": "No results found",
+  "common.saveChanges": "Save Changes",
+  "common.retry": "Retry",
+  "common.open": "Open",
+  "common.back": "Back",
+  "empty.noItems": "No items",
+  "empty.noData": "No data available",
+  "empty.noItemsYet": "No items yet",
+  "empty.noItemsAdded": "No items added yet",
+  "empty.noOptionsFound": "No options found",
+  "list.addItemPlaceholder": "Add new item...",
+  "error.occurred": "An error occurred",
+  "error.failedToLoad": "Failed to load data",
+  "wizard.back": "Back",
+  "wizard.next": "Next",
+  "wizard.complete": "Complete",
+  "wizard.stepOf": "Step {{current}} of {{total}}",
+  "pagination.previous": "Previous",
+  "pagination.next": "Next",
+  "pagination.total": "Total:",
+  "pagination.show": "Show:",
+  "pagination.goTo": "Go to:",
+  "pagination.go": "Go",
+  "auth.signIn": "Sign in",
+  "auth.signOut": "Sign out",
+  "dialog.confirm": "Confirm",
+  "dialog.cancel": "Cancel",
+  "dialog.loading": "Loading...",
+  "dialog.delete.title": "Delete {{item}}?",
+  "dialog.delete.message": "This action cannot be undone.",
+  "trait.availableActions": "Available Actions",
+  "trait.transitions": "Transitions",
+  "trait.availableNow": "Available now",
+  "book.startReading": "Start Reading",
+  "book.tableOfContents": "Table of Contents",
+  "book.partNumber": "Part {{number}}",
+  "book.print": "Print",
+  "book.previousPage": "Previous page",
+  "book.nextPage": "Next page",
+  "quiz.showAnswer": "Show answer",
+  "quiz.hideAnswer": "Hide answer"
+};
+
+// hooks/useTranslate.ts
+var { $meta: _meta, ...coreMessages } = en_default;
+var coreLocale = coreMessages;
+var I18nContext = React3.createContext({
+  locale: "en",
+  direction: "ltr",
+  t: (key) => coreLocale[key] ?? key
+  // core locale fallback
+});
+I18nContext.displayName = "I18nContext";
+var I18nProvider = I18nContext.Provider;
+function useTranslate() {
+  return React3.useContext(I18nContext);
+}
+function createTranslate(messages) {
+  return (key, params) => {
+    let msg = messages[key] ?? coreLocale[key] ?? key;
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        msg = msg.split(`{{${k}}}`).join(String(v));
+      }
+    }
+    return msg;
+  };
+}
+function useResolvedEntity(entity, data) {
+  const shouldFetch = !data && !!entity;
+  const fetched = useEntityList(entity, { skip: !shouldFetch });
+  return React3.useMemo(() => {
+    if (data) {
+      return {
+        data,
+        isLocal: true,
+        isLoading: false,
+        error: null
+      };
+    }
+    return {
+      data: fetched.data,
+      isLocal: false,
+      isLoading: fetched.isLoading,
+      error: fetched.error
+    };
+  }, [data, fetched.data, fetched.isLoading, fetched.error]);
+}
+
+// hooks/useAuthContext.ts
+function useAuthContext() {
+  return {
+    user: null,
+    loading: false,
+    signIn: void 0,
+    signOut: void 0
+  };
+}
+function useSwipeGesture(callbacks, options = {}) {
+  const { threshold = 50, velocityThreshold = 0.3, preventDefault = false } = options;
+  const startX = React3.useRef(0);
+  const startY = React3.useRef(0);
+  const startTime = React3.useRef(0);
+  const currentX = React3.useRef(0);
+  const tracking = React3.useRef(false);
+  const offsetXRef = React3.useRef(0);
+  const isSwipingRef = React3.useRef(false);
+  const onPointerDown = React3.useCallback((e) => {
+    startX.current = e.clientX;
+    startY.current = e.clientY;
+    currentX.current = e.clientX;
+    startTime.current = Date.now();
+    tracking.current = true;
+    isSwipingRef.current = false;
+    offsetXRef.current = 0;
+    e.target.setPointerCapture?.(e.pointerId);
+  }, []);
+  const onPointerMove = React3.useCallback((e) => {
+    if (!tracking.current) return;
+    if (preventDefault) e.preventDefault();
+    currentX.current = e.clientX;
+    const dx = e.clientX - startX.current;
+    const dy = e.clientY - startY.current;
+    if (Math.abs(dx) > 10 && Math.abs(dx) > Math.abs(dy)) {
+      isSwipingRef.current = true;
+      offsetXRef.current = dx;
+    }
+  }, [preventDefault]);
+  const onPointerUp = React3.useCallback((e) => {
+    if (!tracking.current) return;
+    tracking.current = false;
+    const dx = e.clientX - startX.current;
+    const dy = e.clientY - startY.current;
+    const elapsed = Date.now() - startTime.current;
+    const velocity = Math.abs(dx) / Math.max(elapsed, 1);
+    offsetXRef.current = 0;
+    isSwipingRef.current = false;
+    if (Math.abs(dx) < threshold && velocity < velocityThreshold) return;
+    if (Math.abs(dx) > Math.abs(dy)) {
+      if (dx < -threshold) callbacks.onSwipeLeft?.();
+      else if (dx > threshold) callbacks.onSwipeRight?.();
+    } else {
+      if (dy < -threshold) callbacks.onSwipeUp?.();
+      else if (dy > threshold) callbacks.onSwipeDown?.();
+    }
+  }, [threshold, velocityThreshold, callbacks]);
+  const onPointerCancel = React3.useCallback(() => {
+    tracking.current = false;
+    offsetXRef.current = 0;
+    isSwipingRef.current = false;
+  }, []);
+  return {
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onPointerCancel,
+    offsetX: offsetXRef.current,
+    isSwiping: isSwipingRef.current
+  };
+}
+function useLongPress(onLongPress, options = {}) {
+  const { duration = 500, moveThreshold = 10 } = options;
+  const timerRef = React3.useRef(null);
+  const startPos = React3.useRef({ x: 0, y: 0 });
+  const isPressedRef = React3.useRef(false);
+  const firedRef = React3.useRef(false);
+  const cancel = React3.useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    isPressedRef.current = false;
+  }, []);
+  const onPointerDown = React3.useCallback((e) => {
+    firedRef.current = false;
+    startPos.current = { x: e.clientX, y: e.clientY };
+    isPressedRef.current = true;
+    timerRef.current = setTimeout(() => {
+      firedRef.current = true;
+      isPressedRef.current = false;
+      onLongPress();
+    }, duration);
+  }, [duration, onLongPress]);
+  const onPointerMove = React3.useCallback((e) => {
+    if (!isPressedRef.current) return;
+    const dx = e.clientX - startPos.current.x;
+    const dy = e.clientY - startPos.current.y;
+    if (Math.sqrt(dx * dx + dy * dy) > moveThreshold) {
+      cancel();
+    }
+  }, [moveThreshold, cancel]);
+  const onPointerUp = React3.useCallback(() => {
+    cancel();
+  }, [cancel]);
+  const onPointerCancel = React3.useCallback(() => {
+    cancel();
+  }, [cancel]);
+  return {
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onPointerCancel,
+    isPressed: isPressedRef.current
+  };
+}
+function useDragReorder(initialItems, onReorder) {
+  const [items, setItems] = React3.useState(initialItems);
+  const [dragIndex, setDragIndex] = React3.useState(-1);
+  const [dragOverIndex, setDragOverIndex] = React3.useState(-1);
+  const itemsRef = React3.useRef(initialItems);
+  if (initialItems !== itemsRef.current) {
+    itemsRef.current = initialItems;
+    setItems(initialItems);
+  }
+  const isDragging = dragIndex >= 0;
+  const handleDragStart = React3.useCallback((index) => (e) => {
+    e.preventDefault();
+    setDragIndex(index);
+    setDragOverIndex(index);
+    e.target.setPointerCapture?.(e.pointerId);
+  }, []);
+  const handleDragMove = React3.useCallback((index) => (e) => {
+    if (dragIndex < 0) return;
+    const target = document.elementFromPoint(e.clientX, e.clientY);
+    if (!target) return;
+    let el = target;
+    while (el && !el.dataset.dragIndex) {
+      el = el.parentElement;
+    }
+    if (el?.dataset.dragIndex) {
+      const overIndex = parseInt(el.dataset.dragIndex, 10);
+      if (!isNaN(overIndex) && overIndex !== dragOverIndex) {
+        setDragOverIndex(overIndex);
+      }
+    }
+  }, [dragIndex, dragOverIndex]);
+  const handleDragEnd = React3.useCallback(() => {
+    if (dragIndex >= 0 && dragOverIndex >= 0 && dragIndex !== dragOverIndex) {
+      const newItems = [...items];
+      const [movedItem] = newItems.splice(dragIndex, 1);
+      newItems.splice(dragOverIndex, 0, movedItem);
+      setItems(newItems);
+      onReorder(dragIndex, dragOverIndex, items[dragIndex]);
+    }
+    setDragIndex(-1);
+    setDragOverIndex(-1);
+  }, [dragIndex, dragOverIndex, items, onReorder]);
+  const getDragHandleProps = React3.useCallback((index) => ({
+    onPointerDown: handleDragStart(index),
+    style: { cursor: "grab", touchAction: "none" },
+    "aria-grabbed": dragIndex === index,
+    role: "button"
+  }), [handleDragStart, dragIndex]);
+  const getItemProps = React3.useCallback((index) => ({
+    onPointerMove: handleDragMove(index),
+    onPointerUp: handleDragEnd,
+    "aria-dropeffect": "move",
+    "data-drag-index": String(index),
+    style: {
+      opacity: dragIndex === index ? 0.5 : 1,
+      transition: isDragging ? "transform 150ms ease" : void 0,
+      transform: isDragging && dragOverIndex >= 0 ? index === dragIndex ? "scale(1.02)" : index > dragIndex && index <= dragOverIndex ? "translateY(-100%)" : index < dragIndex && index >= dragOverIndex ? "translateY(100%)" : void 0 : void 0
+    }
+  }), [handleDragMove, handleDragEnd, dragIndex, dragOverIndex, isDragging]);
+  return {
+    items,
+    dragIndex,
+    dragOverIndex,
+    isDragging,
+    getDragHandleProps,
+    getItemProps
+  };
+}
+function useInfiniteScroll(onLoadMore, options = {}) {
+  const { rootMargin = "200px", hasMore = true, isLoading = false } = options;
+  const observerRef = React3.useRef(null);
+  const callbackRef = React3.useRef(onLoadMore);
+  callbackRef.current = onLoadMore;
+  const hasMoreRef = React3.useRef(hasMore);
+  hasMoreRef.current = hasMore;
+  const isLoadingRef = React3.useRef(isLoading);
+  isLoadingRef.current = isLoading;
+  React3.useEffect(() => {
+    return () => {
+      observerRef.current?.disconnect();
+    };
+  }, []);
+  const sentinelRef = React3.useCallback((node) => {
+    observerRef.current?.disconnect();
+    if (!node) return;
+    observerRef.current = new IntersectionObserver(
+      (entries) => {
+        const entry = entries[0];
+        if (entry.isIntersecting && hasMoreRef.current && !isLoadingRef.current) {
+          callbackRef.current();
+        }
+      },
+      { rootMargin }
+    );
+    observerRef.current.observe(node);
+  }, [rootMargin]);
+  return { sentinelRef };
+}
+function usePullToRefresh(onRefresh, options = {}) {
+  const { threshold = 60, maxPull = 120 } = options;
+  const [pullDistance, setPullDistance] = React3.useState(0);
+  const [isPulling, setIsPulling] = React3.useState(false);
+  const [isRefreshing, setIsRefreshing] = React3.useState(false);
+  const startY = React3.useRef(0);
+  const scrollTopRef = React3.useRef(0);
+  const onTouchStart = React3.useCallback((e) => {
+    const container = e.currentTarget;
+    scrollTopRef.current = container.scrollTop;
+    if (scrollTopRef.current <= 0) {
+      startY.current = e.touches[0].clientY;
+      setIsPulling(true);
+    }
+  }, []);
+  const onTouchMove = React3.useCallback((e) => {
+    if (!isPulling || isRefreshing) return;
+    const container = e.currentTarget;
+    if (container.scrollTop > 0) {
+      setPullDistance(0);
+      return;
+    }
+    const dy = e.touches[0].clientY - startY.current;
+    if (dy > 0) {
+      const distance = Math.min(dy * 0.5, maxPull);
+      setPullDistance(distance);
+    }
+  }, [isPulling, isRefreshing, maxPull]);
+  const onTouchEnd = React3.useCallback(() => {
+    if (!isPulling) return;
+    setIsPulling(false);
+    if (pullDistance >= threshold && !isRefreshing) {
+      setIsRefreshing(true);
+      setPullDistance(threshold);
+      onRefresh();
+    } else {
+      setPullDistance(0);
+    }
+  }, [isPulling, pullDistance, threshold, isRefreshing, onRefresh]);
+  const endRefresh = React3.useCallback(() => {
+    setIsRefreshing(false);
+    setPullDistance(0);
+  }, []);
+  const containerProps = {
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    style: {
+      transform: pullDistance > 0 ? `translateY(${pullDistance}px)` : void 0,
+      transition: isPulling ? "none" : "transform 300ms ease-out"
+    }
+  };
+  return {
+    pullDistance,
+    isPulling,
+    isRefreshing,
+    containerProps,
+    endRefresh
+  };
+}
+function getDistance(touches) {
+  const dx = touches[0].clientX - touches[1].clientX;
+  const dy = touches[0].clientY - touches[1].clientY;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function usePinchZoom(options = {}) {
+  const { minScale = 0.5, maxScale = 4 } = options;
+  const [scale, setScale] = React3.useState(1);
+  const [isPinching, setIsPinching] = React3.useState(false);
+  const initialDistance = React3.useRef(0);
+  const initialScale = React3.useRef(1);
+  const onTouchStart = React3.useCallback((e) => {
+    if (e.touches.length === 2) {
+      initialDistance.current = getDistance(e.touches);
+      initialScale.current = scale;
+      setIsPinching(true);
+    }
+  }, [scale]);
+  const onTouchMove = React3.useCallback((e) => {
+    if (e.touches.length !== 2 || !isPinching) return;
+    e.preventDefault();
+    const currentDistance = getDistance(e.touches);
+    const ratio = currentDistance / initialDistance.current;
+    const newScale = Math.min(maxScale, Math.max(minScale, initialScale.current * ratio));
+    setScale(newScale);
+  }, [isPinching, minScale, maxScale]);
+  const onTouchEnd = React3.useCallback(() => {
+    setIsPinching(false);
+  }, []);
+  const resetZoom = React3.useCallback(() => {
+    setScale(1);
+  }, []);
+  return {
+    scale,
+    isPinching,
+    gestureProps: {
+      onTouchStart,
+      onTouchMove,
+      onTouchEnd
+    },
+    resetZoom
+  };
+}
+var API_BASE = typeof process !== "undefined" && process.env?.VITE_API_URL ? process.env.VITE_API_URL : "http://localhost:3000";
+function getUserId() {
+  return localStorage.getItem("userId") || "anonymous";
+}
+async function fetchWithAuth(endpoint, options) {
+  const userId = getUserId();
+  const response = await fetch(`${API_BASE}${endpoint}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      "x-user-id": userId,
+      ...options?.headers
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: response.statusText }));
+    throw new Error(error.error || error.message || "Request failed");
+  }
+  return response.json();
+}
+function useGitHubStatus() {
+  return reactQuery.useQuery({
+    queryKey: ["github", "status"],
+    queryFn: () => fetchWithAuth("/api/github/status"),
+    staleTime: 6e4,
+    // 1 minute
+    retry: false
+  });
+}
+function useConnectGitHub() {
+  const connectGitHub = React3.useCallback(() => {
+    const userId = getUserId();
+    const state = btoa(JSON.stringify({ userId, returnUrl: window.location.href }));
+    window.location.href = `${API_BASE}/api/github/oauth/authorize?state=${state}`;
+  }, []);
+  return { connectGitHub };
+}
+function useDisconnectGitHub() {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: () => fetchWithAuth("/api/github/disconnect", { method: "POST" }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["github", "status"] });
+      queryClient.removeQueries({ queryKey: ["github", "repos"] });
+    }
+  });
+}
+function useGitHubRepos(page = 1, perPage = 30) {
+  return reactQuery.useQuery({
+    queryKey: ["github", "repos", page, perPage],
+    queryFn: () => fetchWithAuth(`/api/github/repos?page=${page}&per_page=${perPage}`),
+    enabled: true,
+    // Only fetch if user is connected
+    staleTime: 3e5
+    // 5 minutes
+  });
+}
+function useGitHubRepo(owner, repo, enabled = true) {
+  return reactQuery.useQuery({
+    queryKey: ["github", "repo", owner, repo],
+    queryFn: () => fetchWithAuth(`/api/github/repos/${owner}/${repo}`),
+    enabled: enabled && !!owner && !!repo,
+    staleTime: 3e5
+    // 5 minutes
+  });
+}
+function useGitHubBranches(owner, repo, enabled = true) {
+  return reactQuery.useQuery({
+    queryKey: ["github", "branches", owner, repo],
+    queryFn: () => fetchWithAuth(`/api/github/repos/${owner}/${repo}/branches`),
+    enabled: enabled && !!owner && !!repo,
+    staleTime: 6e4
+    // 1 minute
+  });
+}
+
+exports.DEFAULT_SLOTS = DEFAULT_SLOTS;
+exports.ENTITY_EVENTS = ENTITY_EVENTS;
+exports.EntityDataProvider = EntityDataProvider;
+exports.I18nProvider = I18nProvider;
+exports.clearEntities = clearEntities;
+exports.createTranslate = createTranslate;
+exports.entityDataKeys = entityDataKeys;
+exports.getAllEntities = getAllEntities;
+exports.getByType = getByType;
+exports.getEntity = getEntity;
+exports.getSingleton = getSingleton;
+exports.parseQueryBinding = parseQueryBinding;
+exports.removeEntity = removeEntity;
+exports.spawnEntity = spawnEntity;
+exports.updateEntity = updateEntity;
+exports.updateSingleton = updateSingleton;
+exports.useAgentChat = useAgentChat;
+exports.useAuthContext = useAuthContext;
+exports.useCompile = useCompile;
+exports.useConnectGitHub = useConnectGitHub;
+exports.useCreateEntity = useCreateEntity;
+exports.useDeepAgentGeneration = useDeepAgentGeneration;
+exports.useDeleteEntity = useDeleteEntity;
+exports.useDisconnectGitHub = useDisconnectGitHub;
+exports.useDragReorder = useDragReorder;
+exports.useEmitEvent = useEmitEvent;
+exports.useEntities = useEntities;
+exports.useEntitiesByType = useEntitiesByType;
+exports.useEntity = useEntity;
+exports.useEntityById = useEntity2;
+exports.useEntityDataAdapter = useEntityDataAdapter;
+exports.useEntityDetail = useEntityDetail;
+exports.useEntityList = useEntityList;
+exports.useEntityListSuspense = useEntityListSuspense;
+exports.useEntityMutations = useEntityMutations;
+exports.useEntitySuspense = useEntitySuspense;
+exports.useEventBus = useEventBus;
+exports.useEventListener = useEventListener;
+exports.useExtensions = useExtensions;
+exports.useFileEditor = useFileEditor;
+exports.useFileSystem = useFileSystem;
+exports.useGitHubBranches = useGitHubBranches;
+exports.useGitHubRepo = useGitHubRepo;
+exports.useGitHubRepos = useGitHubRepos;
+exports.useGitHubStatus = useGitHubStatus;
+exports.useInfiniteScroll = useInfiniteScroll;
+exports.useInput = useInput;
+exports.useLongPress = useLongPress;
+exports.useOrbitalHistory = useOrbitalHistory;
+exports.useOrbitalMutations = useOrbitalMutations;
+exports.usePhysics = usePhysics;
+exports.usePinchZoom = usePinchZoom;
+exports.usePlayer = usePlayer;
+exports.usePreview = usePreview;
+exports.usePullToRefresh = usePullToRefresh;
+exports.useQuerySingleton = useQuerySingleton;
+exports.useResolvedEntity = useResolvedEntity;
+exports.useSelectedEntity = useSelectedEntity;
+exports.useSendOrbitalEvent = useSendOrbitalEvent;
+exports.useSingletonEntity = useSingletonEntity;
+exports.useSwipeGesture = useSwipeGesture;
+exports.useTranslate = useTranslate;
+exports.useUIEvents = useUIEvents;
+exports.useUISlotManager = useUISlotManager;
+exports.useUpdateEntity = useUpdateEntity;
+exports.useValidation = useValidation;