@almadar/ui 3.9.1 → 4.0.1

package/dist/hooks/index.cjs

@@ -1,19 +1,12 @@
 'use strict';
 
-var React = require('react');
+var react = require('react');
 var providers = require('@almadar/ui/providers');
 var reactQuery = require('@tanstack/react-query');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 function useOrbitalHistory(options) {
   const { appId, authToken, userId, onHistoryChange, onRevertSuccess } = options;
-  const getHeaders2 = React.useCallback(() => {
+  const getHeaders = react.useCallback(() => {
     const headers = {
       "Content-Type": "application/json"
     };
@@ -25,16 +18,16 @@ function useOrbitalHistory(options) {
     }
     return headers;
   }, [authToken, userId]);
-  const [timeline, setTimeline] = React.useState([]);
-  const [currentVersion, setCurrentVersion] = React.useState(1);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [error, setError] = React.useState(null);
-  const refresh = React.useCallback(async () => {
+  const [timeline, setTimeline] = react.useState([]);
+  const [currentVersion, setCurrentVersion] = react.useState(1);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const refresh = react.useCallback(async () => {
     if (!appId) return;
     setIsLoading(true);
     setError(null);
     try {
-      const headers = getHeaders2();
+      const headers = getHeaders();
       const [changesetsRes, snapshotsRes] = await Promise.all([
         fetch(`/api/graphs/${appId}/history/changesets`, { headers }),
         fetch(`/api/graphs/${appId}/history/snapshots`, { headers })
@@ -77,15 +70,15 @@ function useOrbitalHistory(options) {
     } finally {
       setIsLoading(false);
     }
-  }, [appId, getHeaders2]);
-  const revertToSnapshot = React.useCallback(async (snapshotId) => {
+  }, [appId, getHeaders]);
+  const revertToSnapshot = react.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()
+        headers: getHeaders()
       });
       if (!response.ok) {
         const errorData = await response.json().catch(() => ({}));
@@ -111,13 +104,13 @@ function useOrbitalHistory(options) {
         error: err instanceof Error ? err.message : "Failed to revert"
       };
     }
-  }, [appId, getHeaders2, refresh, onRevertSuccess]);
-  React.useEffect(() => {
+  }, [appId, getHeaders, refresh, onRevertSuccess]);
+  react.useEffect(() => {
     if (appId && authToken && userId) {
       refresh();
     }
   }, [appId, authToken, userId]);
-  React.useEffect(() => {
+  react.useEffect(() => {
     onHistoryChange?.(timeline);
   }, [timeline]);
   return {
@@ -130,15 +123,15 @@ function useOrbitalHistory(options) {
   };
 }
 function useFileSystem() {
-  const [status, setStatus] = React.useState("idle");
-  const [error, setError] = React.useState(null);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [files, setFiles] = React.useState([]);
-  const [selectedFile, setSelectedFile] = React.useState(null);
-  const [selectedPath, setSelectedPath] = React.useState(null);
-  const [previewUrl, setPreviewUrl] = React.useState(null);
-  const [fileContents, setFileContents] = React.useState(/* @__PURE__ */ new Map());
-  const boot = React.useCallback(async () => {
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [files, setFiles] = react.useState([]);
+  const [selectedFile, setSelectedFile] = react.useState(null);
+  const [selectedPath, setSelectedPath] = react.useState(null);
+  const [previewUrl, setPreviewUrl] = react.useState(null);
+  const [fileContents, setFileContents] = react.useState(/* @__PURE__ */ new Map());
+  const boot = react.useCallback(async () => {
     setStatus("booting");
     setError(null);
     setIsLoading(true);
@@ -153,7 +146,7 @@ function useFileSystem() {
       setIsLoading(false);
     }
   }, []);
-  const mountFiles = React.useCallback(async (filesToMount) => {
+  const mountFiles = react.useCallback(async (filesToMount) => {
     setIsLoading(true);
     try {
       let filesArray;
@@ -211,17 +204,17 @@ function useFileSystem() {
       setIsLoading(false);
     }
   }, []);
-  const readFile = React.useCallback(async (path) => {
+  const readFile = react.useCallback(async (path) => {
     return fileContents.get(path) || "";
   }, [fileContents]);
-  const writeFile = React.useCallback(async (path, content) => {
+  const writeFile = react.useCallback(async (path, content) => {
     setFileContents((prev) => {
       const next = new Map(prev);
       next.set(path, content);
       return next;
     });
   }, []);
-  const selectFile = React.useCallback(async (path) => {
+  const selectFile = react.useCallback(async (path) => {
     const content = fileContents.get(path) || "";
     const ext = path.split(".").pop()?.toLowerCase() || "";
     const languageMap = {
@@ -243,7 +236,7 @@ function useFileSystem() {
       isDirty: false
     });
   }, [fileContents]);
-  const updateContent = React.useCallback((pathOrContent, contentArg) => {
+  const updateContent = react.useCallback((pathOrContent, contentArg) => {
     const path = contentArg !== void 0 ? pathOrContent : selectedPath;
     const content = contentArg !== void 0 ? contentArg : pathOrContent;
     if (!path) {
@@ -259,17 +252,17 @@ function useFileSystem() {
       setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
     }
   }, [selectedPath]);
-  const updateSelectedContent = React.useCallback((content) => {
+  const updateSelectedContent = react.useCallback((content) => {
     setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
   }, []);
-  const refreshTree = React.useCallback(async () => {
+  const refreshTree = react.useCallback(async () => {
     console.log("[useFileSystem] Refreshing tree");
   }, []);
-  const runCommand = React.useCallback(async (command) => {
+  const runCommand = react.useCallback(async (command) => {
     console.log("[useFileSystem] Running command:", command);
     return { exitCode: 0, output: "" };
   }, []);
-  const startDevServer = React.useCallback(async () => {
+  const startDevServer = react.useCallback(async () => {
     console.log("[useFileSystem] Starting dev server");
     setPreviewUrl("http://localhost:5173");
   }, []);
@@ -306,14 +299,14 @@ var defaultManifest = {
 };
 function useExtensions(options) {
   const { appId, loadOnMount = true } = options;
-  const [extensions, setExtensions] = React.useState([]);
-  const [manifest] = React.useState(defaultManifest);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [error, setError] = React.useState(null);
-  const loadExtension = React.useCallback(async (extensionId) => {
+  const [extensions, setExtensions] = react.useState([]);
+  const [manifest] = react.useState(defaultManifest);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const loadExtension = react.useCallback(async (extensionId) => {
     console.log("[useExtensions] Loading extension:", extensionId);
   }, []);
-  const loadExtensions = React.useCallback(async () => {
+  const loadExtensions = react.useCallback(async () => {
     setIsLoading(true);
     setError(null);
     try {
@@ -332,7 +325,7 @@ function useExtensions(options) {
       setIsLoading(false);
     }
   }, []);
-  const getExtensionForFile = React.useCallback((filename) => {
+  const getExtensionForFile = react.useCallback((filename) => {
     const ext = filename.split(".").pop()?.toLowerCase();
     if (!ext) return null;
     const languageMap = {
@@ -350,7 +343,7 @@ function useExtensions(options) {
     if (!language) return null;
     return extensions.find((e) => e.language === language) || null;
   }, [extensions]);
-  React.useEffect(() => {
+  react.useEffect(() => {
     if (!appId || !loadOnMount) return;
     const loadExtensions2 = async () => {
       setIsLoading(true);
@@ -385,11 +378,11 @@ function useExtensions(options) {
 }
 function useFileEditor(options) {
   const { extensions, fileSystem, onSchemaUpdate } = options;
-  const [openFiles, setOpenFiles] = React.useState([]);
-  const [activeFilePath, setActiveFilePath] = React.useState(null);
-  const [isSaving, setIsSaving] = React.useState(false);
+  const [openFiles, setOpenFiles] = react.useState([]);
+  const [activeFilePath, setActiveFilePath] = react.useState(null);
+  const [isSaving, setIsSaving] = react.useState(false);
   const activeFile = openFiles.find((f) => f.path === activeFilePath) || null;
-  const openFile = React.useCallback(async (path) => {
+  const openFile = react.useCallback(async (path) => {
     const existing = openFiles.find((f) => f.path === path);
     if (existing) {
       setActiveFilePath(path);
@@ -410,24 +403,24 @@ function useFileEditor(options) {
       console.error("[useFileEditor] Failed to open file:", err);
     }
   }, [openFiles, fileSystem, extensions]);
-  const closeFile = React.useCallback((path) => {
+  const closeFile = react.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 = React.useCallback((path) => {
+  const setActiveFile = react.useCallback((path) => {
     setActiveFilePath(path);
   }, []);
-  const updateFileContent = React.useCallback((path, content) => {
+  const updateFileContent = react.useCallback((path, content) => {
     setOpenFiles(
       (prev) => prev.map(
         (f) => f.path === path ? { ...f, content, isDirty: true } : f
       )
     );
   }, []);
-  const handleFileEdit = React.useCallback(async (path, content) => {
+  const handleFileEdit = react.useCallback(async (path, content) => {
     try {
       await fileSystem.writeFile(path, content);
       let action = "saved";
@@ -449,7 +442,7 @@ function useFileEditor(options) {
       };
     }
   }, [fileSystem, onSchemaUpdate]);
-  const saveFile = React.useCallback(async (path) => {
+  const saveFile = react.useCallback(async (path) => {
     const file = openFiles.find((f) => f.path === path);
     if (!file) return;
     setIsSaving(true);
@@ -473,7 +466,7 @@ function useFileEditor(options) {
       setIsSaving(false);
     }
   }, [openFiles, fileSystem, onSchemaUpdate]);
-  const saveAllFiles = React.useCallback(async () => {
+  const saveAllFiles = react.useCallback(async () => {
     setIsSaving(true);
     try {
       const dirtyFiles = openFiles.filter((f) => f.isDirty);
@@ -498,11 +491,11 @@ function useFileEditor(options) {
   };
 }
 function useCompile() {
-  const [isCompiling, setIsCompiling] = React.useState(false);
-  const [stage, setStage] = React.useState("idle");
-  const [lastResult, setLastResult] = React.useState(null);
-  const [error, setError] = React.useState(null);
-  const compileSchema = React.useCallback(async (schema) => {
+  const [isCompiling, setIsCompiling] = react.useState(false);
+  const [stage, setStage] = react.useState("idle");
+  const [lastResult, setLastResult] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const compileSchema = react.useCallback(async (schema) => {
     setIsCompiling(true);
     setStage("compiling");
     setError(null);
@@ -534,18 +527,18 @@ function useCompile() {
   };
 }
 function usePreview(options) {
-  const [previewUrl, setPreviewUrl] = React.useState(null);
-  const [isLoading, setIsLoading] = React.useState(!!options?.appId);
-  const [error, setError] = React.useState(null);
-  const [loadError, setLoadError] = React.useState(null);
-  const [app, setApp] = React.useState(null);
-  const [isFullscreen, setIsFullscreen] = React.useState(false);
-  const [isExecutingEvent, setIsExecutingEvent] = React.useState(false);
-  const [errorToast, setErrorToast] = React.useState(null);
-  const [currentStateName, setCurrentStateName] = React.useState(null);
-  const [notificationsList, setNotificationsList] = React.useState([]);
-  const [isPanelOpen, setIsPanelOpen] = React.useState(false);
-  const notifications = React.useMemo(() => ({
+  const [previewUrl, setPreviewUrl] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(!!options?.appId);
+  const [error, setError] = react.useState(null);
+  const [loadError, setLoadError] = react.useState(null);
+  const [app, setApp] = react.useState(null);
+  const [isFullscreen, setIsFullscreen] = react.useState(false);
+  const [isExecutingEvent, setIsExecutingEvent] = react.useState(false);
+  const [errorToast, setErrorToast] = react.useState(null);
+  const [currentStateName, setCurrentStateName] = react.useState(null);
+  const [notificationsList, setNotificationsList] = react.useState([]);
+  const [isPanelOpen, setIsPanelOpen] = react.useState(false);
+  const notifications = react.useMemo(() => ({
     notifications: notificationsList,
     isPanelOpen,
     closePanel: () => setIsPanelOpen(false),
@@ -559,7 +552,7 @@ function usePreview(options) {
     },
     clearAll: () => setNotificationsList([])
   }), [notificationsList, isPanelOpen]);
-  React.useEffect(() => {
+  react.useEffect(() => {
     const appId = options?.appId;
     if (!appId) {
       setApp(null);
@@ -570,10 +563,10 @@ function usePreview(options) {
     setPreviewUrl(`/api/orbitals/${appId}`);
     setIsLoading(false);
   }, [options?.appId]);
-  const startPreview = React.useCallback(async () => {
+  const startPreview = react.useCallback(async () => {
     console.log("[usePreview] startPreview called");
   }, []);
-  const stopPreview = React.useCallback(async () => {
+  const stopPreview = react.useCallback(async () => {
     setIsLoading(true);
     try {
       console.log("[usePreview] Stopping preview server...");
@@ -583,16 +576,16 @@ function usePreview(options) {
       setIsLoading(false);
     }
   }, []);
-  const refresh = React.useCallback(async () => {
+  const refresh = react.useCallback(async () => {
     if (!previewUrl) return;
     console.log("[usePreview] Refreshing preview...");
     setPreviewUrl(`${previewUrl.split("?")[0]}?t=${Date.now()}`);
   }, [previewUrl]);
-  const handleRefresh = React.useCallback(async () => {
+  const handleRefresh = react.useCallback(async () => {
     console.log("[usePreview] Handle refresh...");
     await refresh();
   }, [refresh]);
-  const handleReset = React.useCallback(async () => {
+  const handleReset = react.useCallback(async () => {
     console.log("[usePreview] Resetting preview...");
     setError(null);
     setLoadError(null);
@@ -600,10 +593,10 @@ function usePreview(options) {
     setIsExecutingEvent(false);
     setCurrentStateName(null);
   }, []);
-  const toggleFullscreen = React.useCallback(() => {
+  const toggleFullscreen = react.useCallback(() => {
     setIsFullscreen((prev) => !prev);
   }, []);
-  const dismissErrorToast = React.useCallback(() => {
+  const dismissErrorToast = react.useCallback(() => {
     setErrorToast(null);
   }, []);
   return {
@@ -628,16 +621,16 @@ function usePreview(options) {
   };
 }
 function useAgentChat(options) {
-  const [messages, setMessages] = React.useState([]);
-  const [status, setStatus] = React.useState("idle");
-  const [activities, setActivities] = React.useState([]);
-  const [todos, setTodos] = React.useState([]);
-  const [schemaDiffs, setSchemaDiffs] = React.useState([]);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [error, setError] = React.useState(null);
-  const [threadId] = React.useState(null);
-  const [interrupt, setInterrupt] = React.useState(null);
-  const sendMessage = React.useCallback(async (content) => {
+  const [messages, setMessages] = react.useState([]);
+  const [status, setStatus] = react.useState("idle");
+  const [activities, setActivities] = react.useState([]);
+  const [todos, setTodos] = react.useState([]);
+  const [schemaDiffs, setSchemaDiffs] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [threadId] = react.useState(null);
+  const [interrupt, setInterrupt] = react.useState(null);
+  const sendMessage = react.useCallback(async (content) => {
     setIsLoading(true);
     setStatus("running");
     setError(null);
@@ -666,7 +659,7 @@ function useAgentChat(options) {
       setIsLoading(false);
     }
   }, [options]);
-  const startGeneration = React.useCallback(async (skill, prompt, genOptions) => {
+  const startGeneration = react.useCallback(async (skill, prompt, genOptions) => {
     setStatus("running");
     setIsLoading(true);
     setError(null);
@@ -683,22 +676,22 @@ function useAgentChat(options) {
       setIsLoading(false);
     }
   }, [options]);
-  const continueConversation = React.useCallback(async (message) => {
+  const continueConversation = react.useCallback(async (message) => {
     console.log("[useAgentChat] Continue conversation", message);
   }, []);
-  const resumeWithDecision = React.useCallback(async (decisions) => {
+  const resumeWithDecision = react.useCallback(async (decisions) => {
     console.log("[useAgentChat] Resume with decision:", decisions);
     setInterrupt(null);
   }, []);
-  const cancel = React.useCallback(() => {
+  const cancel = react.useCallback(() => {
     setStatus("idle");
     setIsLoading(false);
     setInterrupt(null);
   }, []);
-  const clearMessages = React.useCallback(() => {
+  const clearMessages = react.useCallback(() => {
     setMessages([]);
   }, []);
-  const clearHistory = React.useCallback(() => {
+  const clearHistory = react.useCallback(() => {
     setMessages([]);
     setActivities([]);
     setTodos([]);
@@ -725,13 +718,13 @@ function useAgentChat(options) {
   };
 }
 function useValidation() {
-  const [result, setResult] = React.useState(null);
-  const [isValidating, setIsValidating] = React.useState(false);
-  const [error, setError] = React.useState(null);
-  const [stage, setStage] = React.useState("idle");
-  const [isFixing, setIsFixing] = React.useState(false);
-  const [progressMessage, setProgressMessage] = React.useState(null);
-  const validate = React.useCallback(async (appId) => {
+  const [result, setResult] = react.useState(null);
+  const [isValidating, setIsValidating] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [stage, setStage] = react.useState("idle");
+  const [isFixing, setIsFixing] = react.useState(false);
+  const [progressMessage, setProgressMessage] = react.useState(null);
+  const validate = react.useCallback(async (appId) => {
     setIsValidating(true);
     setError(null);
     setStage("validating");
@@ -763,11 +756,11 @@ function useValidation() {
       setIsValidating(false);
     }
   }, []);
-  const clearResult = React.useCallback(() => {
+  const clearResult = react.useCallback(() => {
     setResult(null);
     setError(null);
   }, []);
-  const reset = React.useCallback(() => {
+  const reset = react.useCallback(() => {
     setResult(null);
     setError(null);
     setStage("idle");
@@ -791,15 +784,15 @@ function useValidation() {
   };
 }
 function useDeepAgentGeneration() {
-  const [requests, setRequests] = React.useState([]);
-  const [currentRequest, setCurrentRequest] = React.useState(null);
-  const [isGenerating, setIsGenerating] = React.useState(false);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [isComplete, setIsComplete] = React.useState(false);
-  const [progress, setProgress] = React.useState({ stage: "idle", percent: 0, message: "" });
-  const [error, setError] = React.useState(null);
-  const [interrupt, setInterrupt] = React.useState(null);
-  const generate = React.useCallback(async (prompt) => {
+  const [requests, setRequests] = react.useState([]);
+  const [currentRequest, setCurrentRequest] = react.useState(null);
+  const [isGenerating, setIsGenerating] = react.useState(false);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [isComplete, setIsComplete] = react.useState(false);
+  const [progress, setProgress] = react.useState({ stage: "idle", percent: 0, message: "" });
+  const [error, setError] = react.useState(null);
+  const [interrupt, setInterrupt] = react.useState(null);
+  const generate = react.useCallback(async (prompt) => {
     setIsGenerating(true);
     setIsLoading(true);
     setIsComplete(false);
@@ -832,11 +825,11 @@ function useDeepAgentGeneration() {
       setIsLoading(false);
     }
   }, []);
-  const startGeneration = React.useCallback(async (skill, prompt, _options) => {
+  const startGeneration = react.useCallback(async (skill, prompt, _options) => {
     console.log("[useDeepAgentGeneration] Starting generation with skill:", skill);
     await generate(prompt);
   }, [generate]);
-  const cancelGeneration = React.useCallback(() => {
+  const cancelGeneration = react.useCallback(() => {
     if (currentRequest) {
       currentRequest.status = "failed";
       currentRequest.error = "Cancelled by user";
@@ -847,14 +840,14 @@ function useDeepAgentGeneration() {
     setIsComplete(false);
     setProgress({ stage: "idle", percent: 0, message: "" });
   }, [currentRequest]);
-  const clearRequests = React.useCallback(() => {
+  const clearRequests = react.useCallback(() => {
     setRequests([]);
     setCurrentRequest(null);
     setError(null);
     setProgress({ stage: "idle", percent: 0, message: "" });
     setIsComplete(false);
   }, []);
-  const submitInterruptDecisions = React.useCallback((decisions) => {
+  const submitInterruptDecisions = react.useCallback((decisions) => {
     console.log("[useDeepAgentGeneration] Submitting interrupt decisions:", decisions);
     setInterrupt(null);
   }, []);
@@ -997,14 +990,14 @@ var fallbackEventBus = {
   }
 };
 function useEventBus() {
-  const context = React.useContext(providers.EventBusContext);
+  const context = react.useContext(providers.EventBusContext);
   return context ?? getGlobalEventBus() ?? fallbackEventBus;
 }
 function useEventListener(event, handler) {
   const eventBus = useEventBus();
-  const handlerRef = React.useRef(handler);
+  const handlerRef = react.useRef(handler);
   handlerRef.current = handler;
-  React.useEffect(() => {
+  react.useEffect(() => {
     const wrappedHandler = (evt) => {
       handlerRef.current(evt);
     };
@@ -1016,7 +1009,7 @@ function useEventListener(event, handler) {
 }
 function useEmitEvent() {
   const eventBus = useEventBus();
-  return React.useCallback(
+  return react.useCallback(
     (type, payload, source) => {
       eventBus.emit(type, payload, source);
     },
@@ -1042,18 +1035,18 @@ function generateId() {
   return `slot-content-${++idCounter}-${Date.now()}`;
 }
 function useUISlotManager() {
-  const [slots, setSlots] = React.useState(DEFAULT_SLOTS);
-  const subscribersRef = React.useRef(/* @__PURE__ */ new Set());
-  const timersRef = React.useRef(/* @__PURE__ */ new Map());
-  const traitIndexRef = React.useRef(/* @__PURE__ */ new Map());
-  const traitSubscribersRef = React.useRef(/* @__PURE__ */ new Map());
-  React.useEffect(() => {
+  const [slots, setSlots] = react.useState(DEFAULT_SLOTS);
+  const subscribersRef = react.useRef(/* @__PURE__ */ new Set());
+  const timersRef = react.useRef(/* @__PURE__ */ new Map());
+  const traitIndexRef = react.useRef(/* @__PURE__ */ new Map());
+  const traitSubscribersRef = react.useRef(/* @__PURE__ */ new Map());
+  react.useEffect(() => {
     return () => {
       timersRef.current.forEach((timer) => clearTimeout(timer));
       timersRef.current.clear();
     };
   }, []);
-  const notifySubscribers = React.useCallback((slot, content) => {
+  const notifySubscribers = react.useCallback((slot, content) => {
     subscribersRef.current.forEach((callback) => {
       try {
         callback(slot, content);
@@ -1062,7 +1055,7 @@ function useUISlotManager() {
       }
     });
   }, []);
-  const notifyTraitSubscribers = React.useCallback(
+  const notifyTraitSubscribers = react.useCallback(
     (traitName, content) => {
       const subs = traitSubscribersRef.current.get(traitName);
       if (!subs) return;
@@ -1076,16 +1069,16 @@ function useUISlotManager() {
     },
     []
   );
-  const indexTraitRender = React.useCallback(
+  const indexTraitRender = react.useCallback(
     (traitName, content) => {
       traitIndexRef.current.set(traitName, content);
     },
     []
   );
-  const unindexTrait = React.useCallback((traitName) => {
+  const unindexTrait = react.useCallback((traitName) => {
     traitIndexRef.current.delete(traitName);
   }, []);
-  const render = React.useCallback((config) => {
+  const render = react.useCallback((config) => {
     const id = generateId();
     const content = {
       id,
@@ -1128,7 +1121,7 @@ function useUISlotManager() {
     });
     return id;
   }, [notifySubscribers, notifyTraitSubscribers, indexTraitRender]);
-  const clear = React.useCallback((slot) => {
+  const clear = react.useCallback((slot) => {
     setSlots((prev) => {
       const content = prev[slot];
       if (content) {
@@ -1147,7 +1140,7 @@ function useUISlotManager() {
       return { ...prev, [slot]: null };
     });
   }, [notifySubscribers, notifyTraitSubscribers, unindexTrait]);
-  const clearById = React.useCallback((id) => {
+  const clearById = react.useCallback((id) => {
     setSlots((prev) => {
       const entry = Object.entries(prev).find(([, content]) => content?.id === id);
       if (entry) {
@@ -1168,7 +1161,7 @@ function useUISlotManager() {
       return prev;
     });
   }, [notifySubscribers, notifyTraitSubscribers, unindexTrait]);
-  const clearAll = React.useCallback(() => {
+  const clearAll = react.useCallback(() => {
     timersRef.current.forEach((timer) => clearTimeout(timer));
     timersRef.current.clear();
     setSlots((prev) => {
@@ -1185,25 +1178,25 @@ function useUISlotManager() {
     });
     traitIndexRef.current.clear();
   }, [notifySubscribers, notifyTraitSubscribers]);
-  const subscribe2 = React.useCallback((callback) => {
+  const subscribe2 = react.useCallback((callback) => {
     subscribersRef.current.add(callback);
     return () => {
       subscribersRef.current.delete(callback);
     };
   }, []);
-  const hasContent = React.useCallback((slot) => {
+  const hasContent = react.useCallback((slot) => {
     return slots[slot] !== null;
   }, [slots]);
-  const getContent = React.useCallback((slot) => {
+  const getContent = react.useCallback((slot) => {
     return slots[slot];
   }, [slots]);
-  const getTraitContent = React.useCallback(
+  const getTraitContent = react.useCallback(
     (traitName) => {
       return traitIndexRef.current.get(traitName) ?? null;
     },
     []
   );
-  const subscribeTrait = React.useCallback(
+  const subscribeTrait = react.useCallback(
     (traitName, callback) => {
       let set = traitSubscribersRef.current.get(traitName);
       if (!set) {
@@ -1240,12 +1233,12 @@ function useUIEvents(dispatch, validEvents, eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
   const validEventsKey = validEvents ? validEvents.slice().sort().join(",") : "";
-  const stableValidEvents = React.useMemo(
+  const stableValidEvents = react.useMemo(
     () => validEvents,
     [validEventsKey]
     // intentional — validEventsKey is the stable dep, not validEvents array ref
   );
-  React.useEffect(() => {
+  react.useEffect(() => {
     const unsubscribes = [];
     if (stableValidEvents) {
       for (const smEvent of stableValidEvents) {
@@ -1283,9 +1276,9 @@ function useSelectedEntity(eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
   const selectionContext = useSelectionContext();
-  const [localSelected, setLocalSelected] = React.useState(null);
+  const [localSelected, setLocalSelected] = react.useState(null);
   const usingContext = selectionContext !== null;
-  React.useEffect(() => {
+  react.useEffect(() => {
     if (usingContext) return;
     const handleSelect = (event) => {
       const row = event.payload?.row;
@@ -1315,211 +1308,9 @@ function useSelectedEntity(eventBusInstance) {
   return [localSelected, setLocalSelected];
 }
 function useSelectionContext() {
-  const context = React.useContext(providers.SelectionContext);
+  const context = react.useContext(providers.SelectionContext);
   return context;
 }
-var EntityDataContext = React.createContext(null);
-function EntityDataProvider({
-  adapter,
-  children
-}) {
-  return React__default.default.createElement(
-    EntityDataContext.Provider,
-    { value: adapter },
-    children
-  );
-}
-function useEntityDataAdapter() {
-  return React.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 = React.useContext(EntityDataContext);
-  const adapterData = React.useMemo(() => {
-    if (!adapter || !entity || skip) return [];
-    return adapter.getData(entity);
-  }, [adapter, entity, skip, adapter?.isLoading]);
-  const [stubData, setStubData] = React.useState([]);
-  const [stubLoading, setStubLoading] = React.useState(!skip && !!entity && !adapter);
-  const [stubError, setStubError] = React.useState(null);
-  React.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 = React.useContext(EntityDataContext);
-  const adapterData = React.useMemo(() => {
-    if (!adapter || !entity || !id) return null;
-    return adapter.getById(entity, id) ?? null;
-  }, [adapter, entity, id, adapter?.isLoading]);
-  const [stubData, setStubData] = React.useState(null);
-  const [stubLoading, setStubLoading] = React.useState(!!entity && !!id && !adapter);
-  const [stubError, setStubError] = React.useState(null);
-  React.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 = React.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 = React.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)) {
@@ -1534,35 +1325,35 @@ function getOrCreateStore(query) {
   return queryStores.get(query);
 }
 function useQuerySingleton(query) {
-  const [, forceUpdate] = React.useState({});
+  const [, forceUpdate] = react.useState({});
   if (!query) {
     return null;
   }
-  const store = React.useMemo(() => getOrCreateStore(query), [query]);
-  React.useMemo(() => {
+  const store = react.useMemo(() => getOrCreateStore(query), [query]);
+  react.useMemo(() => {
     const listener = () => forceUpdate({});
     store.listeners.add(listener);
     return () => {
       store.listeners.delete(listener);
     };
   }, [store]);
-  const notifyListeners = React.useCallback(() => {
+  const notifyListeners = react.useCallback(() => {
     store.listeners.forEach((listener) => listener());
   }, [store]);
-  const setSearch = React.useCallback((value) => {
+  const setSearch = react.useCallback((value) => {
     store.search = value;
     notifyListeners();
   }, [store, notifyListeners]);
-  const setFilter = React.useCallback((key, value) => {
+  const setFilter = react.useCallback((key, value) => {
     store.filters = { ...store.filters, [key]: value };
     notifyListeners();
   }, [store, notifyListeners]);
-  const clearFilters = React.useCallback(() => {
+  const clearFilters = react.useCallback(() => {
     store.filters = {};
     store.search = "";
     notifyListeners();
   }, [store, notifyListeners]);
-  const setSort = React.useCallback((field, direction) => {
+  const setSort = react.useCallback((field, direction) => {
     store.sortField = field;
     store.sortDirection = direction;
     notifyListeners();
@@ -1587,385 +1378,6 @@ function parseQueryBinding(binding) {
   };
 }
 
-// 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}`);
-    __publicField(this, "status", status);
-    __publicField(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 log2 = (message, data) => {
-    if (options?.debug) {
-      console.log(`[useOrbitalMutations:${orbitalName}] ${message}`, data ?? "");
-    }
-  };
-  const createMutation = reactQuery.useMutation({
-    mutationFn: async (data) => {
-      log2("Creating entity", data);
-      return sendOrbitalEvent(orbitalName, {
-        event: events.create,
-        payload: { data, entityType: entityName }
-      });
-    },
-    onSuccess: (response) => {
-      log2("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
-    }) => {
-      log2(`Updating entity ${id}`, data);
-      return sendOrbitalEvent(orbitalName, {
-        event: events.update,
-        entityId: id,
-        payload: { data, entityType: entityName }
-      });
-    },
-    onSuccess: (response, variables) => {
-      log2("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) => {
-      log2(`Deleting entity ${id}`);
-      return sendOrbitalEvent(orbitalName, {
-        event: events.delete,
-        entityId: id,
-        payload: { entityType: entityName }
-      });
-    },
-    onSuccess: (response, id) => {
-      log2("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();
@@ -2029,7 +1441,7 @@ function getSnapshot() {
 
 // hooks/useEntities.ts
 function useEntities() {
-  const entities2 = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return {
     entities: entities2,
     getEntity,
@@ -2043,35 +1455,35 @@ function useEntities() {
     clearEntities
   };
 }
-function useEntity2(id) {
-  const entities2 = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+function useEntity(id) {
+  const entities2 = react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return entities2.get(id);
 }
 function useEntitiesByType(type) {
-  const entities2 = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return [...entities2.values()].filter((e) => e.type === type);
 }
 function useSingletonEntity(type) {
-  const entities2 = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return [...entities2.values()].find((e) => e.type === type);
 }
 function usePlayer() {
   const player = useSingletonEntity("Player");
-  const update = React.useCallback((updates) => {
+  const update = react.useCallback((updates) => {
     if (player) updateEntity(player.id, updates);
   }, [player?.id]);
   return { player, updatePlayer: update };
 }
 function usePhysics() {
   const physics = useSingletonEntity("Physics");
-  const update = React.useCallback((updates) => {
+  const update = react.useCallback((updates) => {
     if (physics) updateEntity(physics.id, updates);
   }, [physics?.id]);
   return { physics, updatePhysics: update };
 }
 function useInput() {
   const input = useSingletonEntity("Input");
-  const update = React.useCallback((updates) => {
+  const update = react.useCallback((updates) => {
     if (input) updateEntity(input.id, updates);
   }, [input?.id]);
   return { input, updateInput: update };
@@ -2186,7 +1598,7 @@ var en_default = {
 // hooks/useTranslate.ts
 var { $meta: _meta, ...coreMessages } = en_default;
 var coreLocale = coreMessages;
-var I18nContext = React.createContext({
+var I18nContext = react.createContext({
   locale: "en",
   direction: "ltr",
   t: (key) => coreLocale[key] ?? key
@@ -2195,7 +1607,7 @@ var I18nContext = React.createContext({
 I18nContext.displayName = "I18nContext";
 var I18nProvider = I18nContext.Provider;
 function useTranslate() {
-  return React.useContext(I18nContext);
+  return react.useContext(I18nContext);
 }
 function createTranslate(messages) {
   return (key, params) => {
@@ -2208,26 +1620,6 @@ function createTranslate(messages) {
     return msg;
   };
 }
-function useResolvedEntity(entity, data) {
-  const shouldFetch = !data && !!entity;
-  const fetched = useEntityList(entity, { skip: !shouldFetch });
-  return React.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() {
@@ -2240,14 +1632,14 @@ function useAuthContext() {
 }
 function useSwipeGesture(callbacks, options = {}) {
   const { threshold = 50, velocityThreshold = 0.3, preventDefault = false } = options;
-  const startX = React.useRef(0);
-  const startY = React.useRef(0);
-  const startTime = React.useRef(0);
-  const currentX = React.useRef(0);
-  const tracking = React.useRef(false);
-  const offsetXRef = React.useRef(0);
-  const isSwipingRef = React.useRef(false);
-  const onPointerDown = React.useCallback((e) => {
+  const startX = react.useRef(0);
+  const startY = react.useRef(0);
+  const startTime = react.useRef(0);
+  const currentX = react.useRef(0);
+  const tracking = react.useRef(false);
+  const offsetXRef = react.useRef(0);
+  const isSwipingRef = react.useRef(false);
+  const onPointerDown = react.useCallback((e) => {
     startX.current = e.clientX;
     startY.current = e.clientY;
     currentX.current = e.clientX;
@@ -2257,7 +1649,7 @@ function useSwipeGesture(callbacks, options = {}) {
     offsetXRef.current = 0;
     e.target.setPointerCapture?.(e.pointerId);
   }, []);
-  const onPointerMove = React.useCallback((e) => {
+  const onPointerMove = react.useCallback((e) => {
     if (!tracking.current) return;
     if (preventDefault) e.preventDefault();
     currentX.current = e.clientX;
@@ -2268,7 +1660,7 @@ function useSwipeGesture(callbacks, options = {}) {
       offsetXRef.current = dx;
     }
   }, [preventDefault]);
-  const onPointerUp = React.useCallback((e) => {
+  const onPointerUp = react.useCallback((e) => {
     if (!tracking.current) return;
     tracking.current = false;
     const dx = e.clientX - startX.current;
@@ -2286,7 +1678,7 @@ function useSwipeGesture(callbacks, options = {}) {
       else if (dy > threshold) callbacks.onSwipeDown?.();
     }
   }, [threshold, velocityThreshold, callbacks]);
-  const onPointerCancel = React.useCallback(() => {
+  const onPointerCancel = react.useCallback(() => {
     tracking.current = false;
     offsetXRef.current = 0;
     isSwipingRef.current = false;
@@ -2302,18 +1694,18 @@ function useSwipeGesture(callbacks, options = {}) {
 }
 function useLongPress(onLongPress, options = {}) {
   const { duration = 500, moveThreshold = 10 } = options;
-  const timerRef = React.useRef(null);
-  const startPos = React.useRef({ x: 0, y: 0 });
-  const isPressedRef = React.useRef(false);
-  const firedRef = React.useRef(false);
-  const cancel = React.useCallback(() => {
+  const timerRef = react.useRef(null);
+  const startPos = react.useRef({ x: 0, y: 0 });
+  const isPressedRef = react.useRef(false);
+  const firedRef = react.useRef(false);
+  const cancel = react.useCallback(() => {
     if (timerRef.current) {
       clearTimeout(timerRef.current);
       timerRef.current = null;
     }
     isPressedRef.current = false;
   }, []);
-  const onPointerDown = React.useCallback((e) => {
+  const onPointerDown = react.useCallback((e) => {
     firedRef.current = false;
     startPos.current = { x: e.clientX, y: e.clientY };
     isPressedRef.current = true;
@@ -2323,7 +1715,7 @@ function useLongPress(onLongPress, options = {}) {
       onLongPress();
     }, duration);
   }, [duration, onLongPress]);
-  const onPointerMove = React.useCallback((e) => {
+  const onPointerMove = react.useCallback((e) => {
     if (!isPressedRef.current) return;
     const dx = e.clientX - startPos.current.x;
     const dy = e.clientY - startPos.current.y;
@@ -2331,10 +1723,10 @@ function useLongPress(onLongPress, options = {}) {
       cancel();
     }
   }, [moveThreshold, cancel]);
-  const onPointerUp = React.useCallback(() => {
+  const onPointerUp = react.useCallback(() => {
     cancel();
   }, [cancel]);
-  const onPointerCancel = React.useCallback(() => {
+  const onPointerCancel = react.useCallback(() => {
     cancel();
   }, [cancel]);
   return {
@@ -2346,22 +1738,22 @@ function useLongPress(onLongPress, options = {}) {
   };
 }
 function useDragReorder(initialItems, onReorder) {
-  const [items, setItems] = React.useState(initialItems);
-  const [dragIndex, setDragIndex] = React.useState(-1);
-  const [dragOverIndex, setDragOverIndex] = React.useState(-1);
-  const itemsRef = React.useRef(initialItems);
+  const [items, setItems] = react.useState(initialItems);
+  const [dragIndex, setDragIndex] = react.useState(-1);
+  const [dragOverIndex, setDragOverIndex] = react.useState(-1);
+  const itemsRef = react.useRef(initialItems);
   if (initialItems !== itemsRef.current) {
     itemsRef.current = initialItems;
     setItems(initialItems);
   }
   const isDragging = dragIndex >= 0;
-  const handleDragStart = React.useCallback((index) => (e) => {
+  const handleDragStart = react.useCallback((index) => (e) => {
     e.preventDefault();
     setDragIndex(index);
     setDragOverIndex(index);
     e.target.setPointerCapture?.(e.pointerId);
   }, []);
-  const handleDragMove = React.useCallback((index) => (e) => {
+  const handleDragMove = react.useCallback((index) => (e) => {
     if (dragIndex < 0) return;
     const target = document.elementFromPoint(e.clientX, e.clientY);
     if (!target) return;
@@ -2376,7 +1768,7 @@ function useDragReorder(initialItems, onReorder) {
       }
     }
   }, [dragIndex, dragOverIndex]);
-  const handleDragEnd = React.useCallback(() => {
+  const handleDragEnd = react.useCallback(() => {
     if (dragIndex >= 0 && dragOverIndex >= 0 && dragIndex !== dragOverIndex) {
       const newItems = [...items];
       const [movedItem] = newItems.splice(dragIndex, 1);
@@ -2387,13 +1779,13 @@ function useDragReorder(initialItems, onReorder) {
     setDragIndex(-1);
     setDragOverIndex(-1);
   }, [dragIndex, dragOverIndex, items, onReorder]);
-  const getDragHandleProps = React.useCallback((index) => ({
+  const getDragHandleProps = react.useCallback((index) => ({
     onPointerDown: handleDragStart(index),
     style: { cursor: "grab", touchAction: "none" },
     "aria-grabbed": dragIndex === index,
     role: "button"
   }), [handleDragStart, dragIndex]);
-  const getItemProps = React.useCallback((index) => ({
+  const getItemProps = react.useCallback((index) => ({
     onPointerMove: handleDragMove(index),
     onPointerUp: handleDragEnd,
     "aria-dropeffect": "move",
@@ -2415,19 +1807,19 @@ function useDragReorder(initialItems, onReorder) {
 }
 function useInfiniteScroll(onLoadMore, options = {}) {
   const { rootMargin = "200px", hasMore = true, isLoading = false } = options;
-  const observerRef = React.useRef(null);
-  const callbackRef = React.useRef(onLoadMore);
+  const observerRef = react.useRef(null);
+  const callbackRef = react.useRef(onLoadMore);
   callbackRef.current = onLoadMore;
-  const hasMoreRef = React.useRef(hasMore);
+  const hasMoreRef = react.useRef(hasMore);
   hasMoreRef.current = hasMore;
-  const isLoadingRef = React.useRef(isLoading);
+  const isLoadingRef = react.useRef(isLoading);
   isLoadingRef.current = isLoading;
-  React.useEffect(() => {
+  react.useEffect(() => {
     return () => {
       observerRef.current?.disconnect();
     };
   }, []);
-  const sentinelRef = React.useCallback((node) => {
+  const sentinelRef = react.useCallback((node) => {
     observerRef.current?.disconnect();
     if (!node) return;
     observerRef.current = new IntersectionObserver(
@@ -2445,12 +1837,12 @@ function useInfiniteScroll(onLoadMore, options = {}) {
 }
 function usePullToRefresh(onRefresh, options = {}) {
   const { threshold = 60, maxPull = 120 } = options;
-  const [pullDistance, setPullDistance] = React.useState(0);
-  const [isPulling, setIsPulling] = React.useState(false);
-  const [isRefreshing, setIsRefreshing] = React.useState(false);
-  const startY = React.useRef(0);
-  const scrollTopRef = React.useRef(0);
-  const onTouchStart = React.useCallback((e) => {
+  const [pullDistance, setPullDistance] = react.useState(0);
+  const [isPulling, setIsPulling] = react.useState(false);
+  const [isRefreshing, setIsRefreshing] = react.useState(false);
+  const startY = react.useRef(0);
+  const scrollTopRef = react.useRef(0);
+  const onTouchStart = react.useCallback((e) => {
     const container = e.currentTarget;
     scrollTopRef.current = container.scrollTop;
     if (scrollTopRef.current <= 0) {
@@ -2458,7 +1850,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setIsPulling(true);
     }
   }, []);
-  const onTouchMove = React.useCallback((e) => {
+  const onTouchMove = react.useCallback((e) => {
     if (!isPulling || isRefreshing) return;
     const container = e.currentTarget;
     if (container.scrollTop > 0) {
@@ -2471,7 +1863,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setPullDistance(distance);
     }
   }, [isPulling, isRefreshing, maxPull]);
-  const onTouchEnd = React.useCallback(() => {
+  const onTouchEnd = react.useCallback(() => {
     if (!isPulling) return;
     setIsPulling(false);
     if (pullDistance >= threshold && !isRefreshing) {
@@ -2482,7 +1874,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setPullDistance(0);
     }
   }, [isPulling, pullDistance, threshold, isRefreshing, onRefresh]);
-  const endRefresh = React.useCallback(() => {
+  const endRefresh = react.useCallback(() => {
     setIsRefreshing(false);
     setPullDistance(0);
   }, []);
@@ -2510,18 +1902,18 @@ function getDistance(touches) {
 }
 function usePinchZoom(options = {}) {
   const { minScale = 0.5, maxScale = 4 } = options;
-  const [scale, setScale] = React.useState(1);
-  const [isPinching, setIsPinching] = React.useState(false);
-  const initialDistance = React.useRef(0);
-  const initialScale = React.useRef(1);
-  const onTouchStart = React.useCallback((e) => {
+  const [scale, setScale] = react.useState(1);
+  const [isPinching, setIsPinching] = react.useState(false);
+  const initialDistance = react.useRef(0);
+  const initialScale = react.useRef(1);
+  const onTouchStart = react.useCallback((e) => {
     if (e.touches.length === 2) {
       initialDistance.current = getDistance(e.touches);
       initialScale.current = scale;
       setIsPinching(true);
     }
   }, [scale]);
-  const onTouchMove = React.useCallback((e) => {
+  const onTouchMove = react.useCallback((e) => {
     if (e.touches.length !== 2 || !isPinching) return;
     e.preventDefault();
     const currentDistance = getDistance(e.touches);
@@ -2529,10 +1921,10 @@ function usePinchZoom(options = {}) {
     const newScale = Math.min(maxScale, Math.max(minScale, initialScale.current * ratio));
     setScale(newScale);
   }, [isPinching, minScale, maxScale]);
-  const onTouchEnd = React.useCallback(() => {
+  const onTouchEnd = react.useCallback(() => {
     setIsPinching(false);
   }, []);
-  const resetZoom = React.useCallback(() => {
+  const resetZoom = react.useCallback(() => {
     setScale(1);
   }, []);
   return {
@@ -2548,9 +1940,9 @@ function usePinchZoom(options = {}) {
 }
 var ALMADAR_DND_MIME = "application/x-almadar-dnd";
 function useDraggable({ payload, disabled = false }) {
-  const [isDragging, setIsDragging] = React.useState(false);
+  const [isDragging, setIsDragging] = react.useState(false);
   const eventBus = useEventBus();
-  const handleDragStart = React.useCallback(
+  const handleDragStart = react.useCallback(
     (e) => {
       if (disabled) {
         e.preventDefault();
@@ -2563,14 +1955,14 @@ function useDraggable({ payload, disabled = false }) {
     },
     [disabled, payload, eventBus]
   );
-  const handleDragEnd = React.useCallback(
+  const handleDragEnd = react.useCallback(
     (e) => {
       setIsDragging(false);
       eventBus.emit("UI:DRAG_END", { kind: payload.kind, data: payload.data });
     },
     [payload, eventBus]
   );
-  const dragProps = React.useMemo(
+  const dragProps = react.useMemo(
     () => ({
       draggable: !disabled,
       onDragStart: handleDragStart,
@@ -2596,9 +1988,9 @@ function hasAlmadarPayload(e) {
   return e.dataTransfer.types.includes(ALMADAR_DND_MIME);
 }
 function useDropZone({ accepts, onDrop, disabled = false }) {
-  const [isOver, setIsOver] = React.useState(false);
+  const [isOver, setIsOver] = react.useState(false);
   const eventBus = useEventBus();
-  const handleDragOver = React.useCallback(
+  const handleDragOver = react.useCallback(
     (e) => {
       if (disabled) return;
       if (!hasAlmadarPayload(e)) return;
@@ -2608,13 +2000,13 @@ function useDropZone({ accepts, onDrop, disabled = false }) {
     },
     [disabled]
   );
-  const handleDragLeave = React.useCallback(
+  const handleDragLeave = react.useCallback(
     (e) => {
       setIsOver(false);
     },
     []
   );
-  const handleDrop = React.useCallback(
+  const handleDrop = react.useCallback(
     (e) => {
       e.preventDefault();
       setIsOver(false);
@@ -2628,7 +2020,7 @@ function useDropZone({ accepts, onDrop, disabled = false }) {
     },
     [disabled, accepts, onDrop, eventBus]
   );
-  const dropProps = React.useMemo(
+  const dropProps = react.useMemo(
     () => ({
       onDragOver: handleDragOver,
       onDragLeave: handleDragLeave,
@@ -2668,7 +2060,7 @@ function useGitHubStatus() {
   });
 }
 function useConnectGitHub() {
-  const connectGitHub = React.useCallback(() => {
+  const connectGitHub = react.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}`;
@@ -2716,12 +2108,9 @@ function useGitHubBranches(owner, repo, enabled = true) {
 
 exports.ALMADAR_DND_MIME = ALMADAR_DND_MIME;
 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;
@@ -2735,9 +2124,7 @@ 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.useDraggable = useDraggable;
@@ -2745,14 +2132,7 @@ exports.useDropZone = useDropZone;
 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.useEntityById = useEntity;
 exports.useEventBus = useEventBus;
 exports.useEventListener = useEventListener;
 exports.useExtensions = useExtensions;
@@ -2766,20 +2146,16 @@ 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;