@almadar/ui 2.17.0 → 2.18.0

package/dist/hooks/index.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
-var React3 = require('react');
+var React2 = 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);
+var React2__default = /*#__PURE__*/_interopDefault(React2);
 
 function useOrbitalHistory(options) {
   const { appId, authToken, userId, onHistoryChange, onRevertSuccess } = options;
-  const getHeaders2 = React3.useCallback(() => {
+  const getHeaders2 = React2.useCallback(() => {
     const headers = {
       "Content-Type": "application/json"
     };
@@ -22,11 +22,11 @@ function useOrbitalHistory(options) {
     }
     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 () => {
+  const [timeline, setTimeline] = React2.useState([]);
+  const [currentVersion, setCurrentVersion] = React2.useState(1);
+  const [isLoading, setIsLoading] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  const refresh = React2.useCallback(async () => {
     if (!appId) return;
     setIsLoading(true);
     setError(null);
@@ -75,7 +75,7 @@ function useOrbitalHistory(options) {
       setIsLoading(false);
     }
   }, [appId, getHeaders2]);
-  const revertToSnapshot = React3.useCallback(async (snapshotId) => {
+  const revertToSnapshot = React2.useCallback(async (snapshotId) => {
     if (!appId) {
       return { success: false, error: "No app ID provided" };
     }
@@ -109,12 +109,12 @@ function useOrbitalHistory(options) {
       };
     }
   }, [appId, getHeaders2, refresh, onRevertSuccess]);
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     if (appId && authToken && userId) {
       refresh();
     }
   }, [appId, authToken, userId]);
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     onHistoryChange?.(timeline);
   }, [timeline]);
   return {
@@ -127,15 +127,15 @@ function useOrbitalHistory(options) {
   };
 }
 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 () => {
+  const [status, setStatus] = React2.useState("idle");
+  const [error, setError] = React2.useState(null);
+  const [isLoading, setIsLoading] = React2.useState(false);
+  const [files, setFiles] = React2.useState([]);
+  const [selectedFile, setSelectedFile] = React2.useState(null);
+  const [selectedPath, setSelectedPath] = React2.useState(null);
+  const [previewUrl, setPreviewUrl] = React2.useState(null);
+  const [fileContents, setFileContents] = React2.useState(/* @__PURE__ */ new Map());
+  const boot = React2.useCallback(async () => {
     setStatus("booting");
     setError(null);
     setIsLoading(true);
@@ -150,7 +150,7 @@ function useFileSystem() {
       setIsLoading(false);
     }
   }, []);
-  const mountFiles = React3.useCallback(async (filesToMount) => {
+  const mountFiles = React2.useCallback(async (filesToMount) => {
     setIsLoading(true);
     try {
       let filesArray;
@@ -208,17 +208,17 @@ function useFileSystem() {
       setIsLoading(false);
     }
   }, []);
-  const readFile = React3.useCallback(async (path) => {
+  const readFile = React2.useCallback(async (path) => {
     return fileContents.get(path) || "";
   }, [fileContents]);
-  const writeFile = React3.useCallback(async (path, content) => {
+  const writeFile = React2.useCallback(async (path, content) => {
     setFileContents((prev) => {
       const next = new Map(prev);
       next.set(path, content);
       return next;
     });
   }, []);
-  const selectFile = React3.useCallback(async (path) => {
+  const selectFile = React2.useCallback(async (path) => {
     const content = fileContents.get(path) || "";
     const ext = path.split(".").pop()?.toLowerCase() || "";
     const languageMap = {
@@ -240,7 +240,7 @@ function useFileSystem() {
       isDirty: false
     });
   }, [fileContents]);
-  const updateContent = React3.useCallback((pathOrContent, contentArg) => {
+  const updateContent = React2.useCallback((pathOrContent, contentArg) => {
     const path = contentArg !== void 0 ? pathOrContent : selectedPath;
     const content = contentArg !== void 0 ? contentArg : pathOrContent;
     if (!path) {
@@ -256,17 +256,17 @@ function useFileSystem() {
       setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
     }
   }, [selectedPath]);
-  const updateSelectedContent = React3.useCallback((content) => {
+  const updateSelectedContent = React2.useCallback((content) => {
     setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
   }, []);
-  const refreshTree = React3.useCallback(async () => {
+  const refreshTree = React2.useCallback(async () => {
     console.log("[useFileSystem] Refreshing tree");
   }, []);
-  const runCommand = React3.useCallback(async (command) => {
+  const runCommand = React2.useCallback(async (command) => {
     console.log("[useFileSystem] Running command:", command);
     return { exitCode: 0, output: "" };
   }, []);
-  const startDevServer = React3.useCallback(async () => {
+  const startDevServer = React2.useCallback(async () => {
     console.log("[useFileSystem] Starting dev server");
     setPreviewUrl("http://localhost:5173");
   }, []);
@@ -303,14 +303,14 @@ var defaultManifest = {
 };
 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) => {
+  const [extensions, setExtensions] = React2.useState([]);
+  const [manifest] = React2.useState(defaultManifest);
+  const [isLoading, setIsLoading] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  const loadExtension = React2.useCallback(async (extensionId) => {
     console.log("[useExtensions] Loading extension:", extensionId);
   }, []);
-  const loadExtensions = React3.useCallback(async () => {
+  const loadExtensions = React2.useCallback(async () => {
     setIsLoading(true);
     setError(null);
     try {
@@ -329,7 +329,7 @@ function useExtensions(options) {
       setIsLoading(false);
     }
   }, []);
-  const getExtensionForFile = React3.useCallback((filename) => {
+  const getExtensionForFile = React2.useCallback((filename) => {
     const ext = filename.split(".").pop()?.toLowerCase();
     if (!ext) return null;
     const languageMap = {
@@ -347,7 +347,7 @@ function useExtensions(options) {
     if (!language) return null;
     return extensions.find((e) => e.language === language) || null;
   }, [extensions]);
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     if (!appId || !loadOnMount) return;
     const loadExtensions2 = async () => {
       setIsLoading(true);
@@ -382,11 +382,11 @@ function useExtensions(options) {
 }
 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 [openFiles, setOpenFiles] = React2.useState([]);
+  const [activeFilePath, setActiveFilePath] = React2.useState(null);
+  const [isSaving, setIsSaving] = React2.useState(false);
   const activeFile = openFiles.find((f) => f.path === activeFilePath) || null;
-  const openFile = React3.useCallback(async (path) => {
+  const openFile = React2.useCallback(async (path) => {
     const existing = openFiles.find((f) => f.path === path);
     if (existing) {
       setActiveFilePath(path);
@@ -407,24 +407,24 @@ function useFileEditor(options) {
       console.error("[useFileEditor] Failed to open file:", err);
     }
   }, [openFiles, fileSystem, extensions]);
-  const closeFile = React3.useCallback((path) => {
+  const closeFile = React2.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) => {
+  const setActiveFile = React2.useCallback((path) => {
     setActiveFilePath(path);
   }, []);
-  const updateFileContent = React3.useCallback((path, content) => {
+  const updateFileContent = React2.useCallback((path, content) => {
     setOpenFiles(
       (prev) => prev.map(
         (f) => f.path === path ? { ...f, content, isDirty: true } : f
       )
     );
   }, []);
-  const handleFileEdit = React3.useCallback(async (path, content) => {
+  const handleFileEdit = React2.useCallback(async (path, content) => {
     try {
       await fileSystem.writeFile(path, content);
       let action = "saved";
@@ -446,7 +446,7 @@ function useFileEditor(options) {
       };
     }
   }, [fileSystem, onSchemaUpdate]);
-  const saveFile = React3.useCallback(async (path) => {
+  const saveFile = React2.useCallback(async (path) => {
     const file = openFiles.find((f) => f.path === path);
     if (!file) return;
     setIsSaving(true);
@@ -470,7 +470,7 @@ function useFileEditor(options) {
       setIsSaving(false);
     }
   }, [openFiles, fileSystem, onSchemaUpdate]);
-  const saveAllFiles = React3.useCallback(async () => {
+  const saveAllFiles = React2.useCallback(async () => {
     setIsSaving(true);
     try {
       const dirtyFiles = openFiles.filter((f) => f.isDirty);
@@ -495,11 +495,11 @@ function useFileEditor(options) {
   };
 }
 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) => {
+  const [isCompiling, setIsCompiling] = React2.useState(false);
+  const [stage, setStage] = React2.useState("idle");
+  const [lastResult, setLastResult] = React2.useState(null);
+  const [error, setError] = React2.useState(null);
+  const compileSchema = React2.useCallback(async (schema) => {
     setIsCompiling(true);
     setStage("compiling");
     setError(null);
@@ -531,18 +531,18 @@ function useCompile() {
   };
 }
 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(() => ({
+  const [previewUrl, setPreviewUrl] = React2.useState(null);
+  const [isLoading, setIsLoading] = React2.useState(!!options?.appId);
+  const [error, setError] = React2.useState(null);
+  const [loadError, setLoadError] = React2.useState(null);
+  const [app, setApp] = React2.useState(null);
+  const [isFullscreen, setIsFullscreen] = React2.useState(false);
+  const [isExecutingEvent, setIsExecutingEvent] = React2.useState(false);
+  const [errorToast, setErrorToast] = React2.useState(null);
+  const [currentStateName, setCurrentStateName] = React2.useState(null);
+  const [notificationsList, setNotificationsList] = React2.useState([]);
+  const [isPanelOpen, setIsPanelOpen] = React2.useState(false);
+  const notifications = React2.useMemo(() => ({
     notifications: notificationsList,
     isPanelOpen,
     closePanel: () => setIsPanelOpen(false),
@@ -556,7 +556,7 @@ function usePreview(options) {
     },
     clearAll: () => setNotificationsList([])
   }), [notificationsList, isPanelOpen]);
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     const appId = options?.appId;
     if (!appId) {
       setApp(null);
@@ -567,10 +567,10 @@ function usePreview(options) {
     setPreviewUrl(`/api/orbitals/${appId}`);
     setIsLoading(false);
   }, [options?.appId]);
-  const startPreview = React3.useCallback(async () => {
+  const startPreview = React2.useCallback(async () => {
     console.log("[usePreview] startPreview called");
   }, []);
-  const stopPreview = React3.useCallback(async () => {
+  const stopPreview = React2.useCallback(async () => {
     setIsLoading(true);
     try {
       console.log("[usePreview] Stopping preview server...");
@@ -580,16 +580,16 @@ function usePreview(options) {
       setIsLoading(false);
     }
   }, []);
-  const refresh = React3.useCallback(async () => {
+  const refresh = React2.useCallback(async () => {
     if (!previewUrl) return;
     console.log("[usePreview] Refreshing preview...");
     setPreviewUrl(`${previewUrl.split("?")[0]}?t=${Date.now()}`);
   }, [previewUrl]);
-  const handleRefresh = React3.useCallback(async () => {
+  const handleRefresh = React2.useCallback(async () => {
     console.log("[usePreview] Handle refresh...");
     await refresh();
   }, [refresh]);
-  const handleReset = React3.useCallback(async () => {
+  const handleReset = React2.useCallback(async () => {
     console.log("[usePreview] Resetting preview...");
     setError(null);
     setLoadError(null);
@@ -597,10 +597,10 @@ function usePreview(options) {
     setIsExecutingEvent(false);
     setCurrentStateName(null);
   }, []);
-  const toggleFullscreen = React3.useCallback(() => {
+  const toggleFullscreen = React2.useCallback(() => {
     setIsFullscreen((prev) => !prev);
   }, []);
-  const dismissErrorToast = React3.useCallback(() => {
+  const dismissErrorToast = React2.useCallback(() => {
     setErrorToast(null);
   }, []);
   return {
@@ -625,16 +625,16 @@ function usePreview(options) {
   };
 }
 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) => {
+  const [messages, setMessages] = React2.useState([]);
+  const [status, setStatus] = React2.useState("idle");
+  const [activities, setActivities] = React2.useState([]);
+  const [todos, setTodos] = React2.useState([]);
+  const [schemaDiffs, setSchemaDiffs] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  const [threadId] = React2.useState(null);
+  const [interrupt, setInterrupt] = React2.useState(null);
+  const sendMessage = React2.useCallback(async (content) => {
     setIsLoading(true);
     setStatus("running");
     setError(null);
@@ -663,7 +663,7 @@ function useAgentChat(options) {
       setIsLoading(false);
     }
   }, [options]);
-  const startGeneration = React3.useCallback(async (skill, prompt, genOptions) => {
+  const startGeneration = React2.useCallback(async (skill, prompt, genOptions) => {
     setStatus("running");
     setIsLoading(true);
     setError(null);
@@ -680,22 +680,22 @@ function useAgentChat(options) {
       setIsLoading(false);
     }
   }, [options]);
-  const continueConversation = React3.useCallback(async (message) => {
+  const continueConversation = React2.useCallback(async (message) => {
     console.log("[useAgentChat] Continue conversation", message);
   }, []);
-  const resumeWithDecision = React3.useCallback(async (decisions) => {
+  const resumeWithDecision = React2.useCallback(async (decisions) => {
     console.log("[useAgentChat] Resume with decision:", decisions);
     setInterrupt(null);
   }, []);
-  const cancel = React3.useCallback(() => {
+  const cancel = React2.useCallback(() => {
     setStatus("idle");
     setIsLoading(false);
     setInterrupt(null);
   }, []);
-  const clearMessages = React3.useCallback(() => {
+  const clearMessages = React2.useCallback(() => {
     setMessages([]);
   }, []);
-  const clearHistory = React3.useCallback(() => {
+  const clearHistory = React2.useCallback(() => {
     setMessages([]);
     setActivities([]);
     setTodos([]);
@@ -722,13 +722,13 @@ function useAgentChat(options) {
   };
 }
 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) => {
+  const [result, setResult] = React2.useState(null);
+  const [isValidating, setIsValidating] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  const [stage, setStage] = React2.useState("idle");
+  const [isFixing, setIsFixing] = React2.useState(false);
+  const [progressMessage, setProgressMessage] = React2.useState(null);
+  const validate = React2.useCallback(async (appId) => {
     setIsValidating(true);
     setError(null);
     setStage("validating");
@@ -760,11 +760,11 @@ function useValidation() {
       setIsValidating(false);
     }
   }, []);
-  const clearResult = React3.useCallback(() => {
+  const clearResult = React2.useCallback(() => {
     setResult(null);
     setError(null);
   }, []);
-  const reset = React3.useCallback(() => {
+  const reset = React2.useCallback(() => {
     setResult(null);
     setError(null);
     setStage("idle");
@@ -788,15 +788,15 @@ function useValidation() {
   };
 }
 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) => {
+  const [requests, setRequests] = React2.useState([]);
+  const [currentRequest, setCurrentRequest] = React2.useState(null);
+  const [isGenerating, setIsGenerating] = React2.useState(false);
+  const [isLoading, setIsLoading] = React2.useState(false);
+  const [isComplete, setIsComplete] = React2.useState(false);
+  const [progress, setProgress] = React2.useState({ stage: "idle", percent: 0, message: "" });
+  const [error, setError] = React2.useState(null);
+  const [interrupt, setInterrupt] = React2.useState(null);
+  const generate = React2.useCallback(async (prompt) => {
     setIsGenerating(true);
     setIsLoading(true);
     setIsComplete(false);
@@ -829,11 +829,11 @@ function useDeepAgentGeneration() {
       setIsLoading(false);
     }
   }, []);
-  const startGeneration = React3.useCallback(async (skill, prompt, _options) => {
+  const startGeneration = React2.useCallback(async (skill, prompt, _options) => {
     console.log("[useDeepAgentGeneration] Starting generation with skill:", skill);
     await generate(prompt);
   }, [generate]);
-  const cancelGeneration = React3.useCallback(() => {
+  const cancelGeneration = React2.useCallback(() => {
     if (currentRequest) {
       currentRequest.status = "failed";
       currentRequest.error = "Cancelled by user";
@@ -844,14 +844,14 @@ function useDeepAgentGeneration() {
     setIsComplete(false);
     setProgress({ stage: "idle", percent: 0, message: "" });
   }, [currentRequest]);
-  const clearRequests = React3.useCallback(() => {
+  const clearRequests = React2.useCallback(() => {
     setRequests([]);
     setCurrentRequest(null);
     setError(null);
     setProgress({ stage: "idle", percent: 0, message: "" });
     setIsComplete(false);
   }, []);
-  const submitInterruptDecisions = React3.useCallback((decisions) => {
+  const submitInterruptDecisions = React2.useCallback((decisions) => {
     console.log("[useDeepAgentGeneration] Submitting interrupt decisions:", decisions);
     setInterrupt(null);
   }, []);
@@ -871,7 +871,7 @@ function useDeepAgentGeneration() {
     submitInterruptDecisions
   };
 }
-var EventBusContext = React3.createContext(null);
+var EventBusContext = React2.createContext(null);
 
 // hooks/useEventBus.ts
 function getGlobalEventBus() {
@@ -941,14 +941,14 @@ var fallbackEventBus = {
   }
 };
 function useEventBus() {
-  const context = React3.useContext(EventBusContext);
+  const context = React2.useContext(EventBusContext);
   return context ?? getGlobalEventBus() ?? fallbackEventBus;
 }
 function useEventListener(event, handler) {
   const eventBus = useEventBus();
-  const handlerRef = React3.useRef(handler);
+  const handlerRef = React2.useRef(handler);
   handlerRef.current = handler;
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     const wrappedHandler = (evt) => {
       handlerRef.current(evt);
     };
@@ -960,7 +960,7 @@ function useEventListener(event, handler) {
 }
 function useEmitEvent() {
   const eventBus = useEventBus();
-  return React3.useCallback(
+  return React2.useCallback(
     (type, payload) => {
       eventBus.emit(type, payload);
     },
@@ -986,16 +986,16 @@ 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(() => {
+  const [slots, setSlots] = React2.useState(DEFAULT_SLOTS);
+  const subscribersRef = React2.useRef(/* @__PURE__ */ new Set());
+  const timersRef = React2.useRef(/* @__PURE__ */ new Map());
+  React2.useEffect(() => {
     return () => {
       timersRef.current.forEach((timer) => clearTimeout(timer));
       timersRef.current.clear();
     };
   }, []);
-  const notifySubscribers = React3.useCallback((slot, content) => {
+  const notifySubscribers = React2.useCallback((slot, content) => {
     subscribersRef.current.forEach((callback) => {
       try {
         callback(slot, content);
@@ -1004,7 +1004,7 @@ function useUISlotManager() {
       }
     });
   }, []);
-  const render = React3.useCallback((config) => {
+  const render = React2.useCallback((config) => {
     const id = generateId();
     const content = {
       id,
@@ -1043,7 +1043,7 @@ function useUISlotManager() {
     });
     return id;
   }, [notifySubscribers]);
-  const clear = React3.useCallback((slot) => {
+  const clear = React2.useCallback((slot) => {
     setSlots((prev) => {
       const content = prev[slot];
       if (content) {
@@ -1058,7 +1058,7 @@ function useUISlotManager() {
       return { ...prev, [slot]: null };
     });
   }, [notifySubscribers]);
-  const clearById = React3.useCallback((id) => {
+  const clearById = React2.useCallback((id) => {
     setSlots((prev) => {
       const entry = Object.entries(prev).find(([, content]) => content?.id === id);
       if (entry) {
@@ -1075,7 +1075,7 @@ function useUISlotManager() {
       return prev;
     });
   }, [notifySubscribers]);
-  const clearAll = React3.useCallback(() => {
+  const clearAll = React2.useCallback(() => {
     timersRef.current.forEach((timer) => clearTimeout(timer));
     timersRef.current.clear();
     setSlots((prev) => {
@@ -1088,16 +1088,16 @@ function useUISlotManager() {
       return DEFAULT_SLOTS;
     });
   }, [notifySubscribers]);
-  const subscribe2 = React3.useCallback((callback) => {
+  const subscribe2 = React2.useCallback((callback) => {
     subscribersRef.current.add(callback);
     return () => {
       subscribersRef.current.delete(callback);
     };
   }, []);
-  const hasContent = React3.useCallback((slot) => {
+  const hasContent = React2.useCallback((slot) => {
     return slots[slot] !== null;
   }, [slots]);
-  const getContent = React3.useCallback((slot) => {
+  const getContent = React2.useCallback((slot) => {
     return slots[slot];
   }, [slots]);
   return {
@@ -1111,7 +1111,7 @@ function useUISlotManager() {
     getContent
   };
 }
-var SelectionContext = React3.createContext(null);
+var SelectionContext = React2.createContext(null);
 
 // hooks/useUIEvents.ts
 var UI_EVENT_MAP = {
@@ -1143,12 +1143,12 @@ function useUIEvents(dispatch, validEvents, eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
   const validEventsKey = validEvents ? validEvents.slice().sort().join(",") : "";
-  const stableValidEvents = React3.useMemo(
+  const stableValidEvents = React2.useMemo(
     () => validEvents,
     [validEventsKey]
     // intentional — validEventsKey is the stable dep, not validEvents array ref
   );
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     const unsubscribes = [];
     Object.entries(UI_EVENT_MAP).forEach(([uiEvent, smEvent]) => {
       const handler = (event) => {
@@ -1199,9 +1199,9 @@ function useSelectedEntity(eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
   const selectionContext = useSelectionContext();
-  const [localSelected, setLocalSelected] = React3.useState(null);
+  const [localSelected, setLocalSelected] = React2.useState(null);
   const usingContext = selectionContext !== null;
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     if (usingContext) return;
     const handleSelect = (event) => {
       const row = event.payload?.row;
@@ -1231,22 +1231,22 @@ function useSelectedEntity(eventBusInstance) {
   return [localSelected, setLocalSelected];
 }
 function useSelectionContext() {
-  const context = React3.useContext(SelectionContext);
+  const context = React2.useContext(SelectionContext);
   return context;
 }
-var EntityDataContext = React3.createContext(null);
+var EntityDataContext = React2.createContext(null);
 function EntityDataProvider({
   adapter,
   children
 }) {
-  return React3__default.default.createElement(
+  return React2__default.default.createElement(
     EntityDataContext.Provider,
     { value: adapter },
     children
   );
 }
 function useEntityDataAdapter() {
-  return React3.useContext(EntityDataContext);
+  return React2.useContext(EntityDataContext);
 }
 var entityDataKeys = {
   all: ["entities"],
@@ -1257,15 +1257,15 @@ var entityDataKeys = {
 };
 function useEntityList(entity, options = {}) {
   const { skip = false } = options;
-  const adapter = React3.useContext(EntityDataContext);
-  const adapterData = React3.useMemo(() => {
+  const adapter = React2.useContext(EntityDataContext);
+  const adapterData = React2.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(() => {
+  const [stubData, setStubData] = React2.useState([]);
+  const [stubLoading, setStubLoading] = React2.useState(!skip && !!entity && !adapter);
+  const [stubError, setStubError] = React2.useState(null);
+  React2.useEffect(() => {
     if (adapter || skip || !entity) {
       setStubLoading(false);
       return;
@@ -1290,15 +1290,15 @@ function useEntityList(entity, options = {}) {
   } };
 }
 function useEntity(entity, id) {
-  const adapter = React3.useContext(EntityDataContext);
-  const adapterData = React3.useMemo(() => {
+  const adapter = React2.useContext(EntityDataContext);
+  const adapterData = React2.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(() => {
+  const [stubData, setStubData] = React2.useState(null);
+  const [stubLoading, setStubLoading] = React2.useState(!!entity && !!id && !adapter);
+  const [stubError, setStubError] = React2.useState(null);
+  React2.useEffect(() => {
     if (adapter || !entity || !id) {
       setStubLoading(false);
       return;
@@ -1329,7 +1329,7 @@ function getSuspenseCacheKey(entity, type, id) {
   return id ? `${type}:${entity}:${id}` : `${type}:${entity}`;
 }
 function useEntityListSuspense(entity) {
-  const adapter = React3.useContext(EntityDataContext);
+  const adapter = React2.useContext(EntityDataContext);
   if (adapter) {
     if (adapter.isLoading) {
       const cacheKey2 = getSuspenseCacheKey(entity, "list");
@@ -1383,7 +1383,7 @@ function useEntityListSuspense(entity) {
   } };
 }
 function useEntitySuspense(entity, id) {
-  const adapter = React3.useContext(EntityDataContext);
+  const adapter = React2.useContext(EntityDataContext);
   if (adapter) {
     if (adapter.isLoading) {
       const cacheKey2 = getSuspenseCacheKey(entity, "detail", id);
@@ -1450,35 +1450,35 @@ function getOrCreateStore(query) {
   return queryStores.get(query);
 }
 function useQuerySingleton(query) {
-  const [, forceUpdate] = React3.useState({});
+  const [, forceUpdate] = React2.useState({});
   if (!query) {
     return null;
   }
-  const store = React3.useMemo(() => getOrCreateStore(query), [query]);
-  React3.useMemo(() => {
+  const store = React2.useMemo(() => getOrCreateStore(query), [query]);
+  React2.useMemo(() => {
     const listener = () => forceUpdate({});
     store.listeners.add(listener);
     return () => {
       store.listeners.delete(listener);
     };
   }, [store]);
-  const notifyListeners = React3.useCallback(() => {
+  const notifyListeners = React2.useCallback(() => {
     store.listeners.forEach((listener) => listener());
   }, [store]);
-  const setSearch = React3.useCallback((value) => {
+  const setSearch = React2.useCallback((value) => {
     store.search = value;
     notifyListeners();
   }, [store, notifyListeners]);
-  const setFilter = React3.useCallback((key, value) => {
+  const setFilter = React2.useCallback((key, value) => {
     store.filters = { ...store.filters, [key]: value };
     notifyListeners();
   }, [store, notifyListeners]);
-  const clearFilters = React3.useCallback(() => {
+  const clearFilters = React2.useCallback(() => {
     store.filters = {};
     store.search = "";
     notifyListeners();
   }, [store, notifyListeners]);
-  const setSort = React3.useCallback((field, direction) => {
+  const setSort = React2.useCallback((field, direction) => {
     store.sortField = field;
     store.sortDirection = direction;
     notifyListeners();
@@ -1945,7 +1945,7 @@ function getSnapshot() {
 
 // hooks/useEntities.ts
 function useEntities() {
-  const entities2 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = React2.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return {
     entities: entities2,
     getEntity,
@@ -1960,34 +1960,34 @@ function useEntities() {
   };
 }
 function useEntity2(id) {
-  const entities2 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = React2.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return entities2.get(id);
 }
 function useEntitiesByType(type) {
-  const entities2 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = React2.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return [...entities2.values()].filter((e) => e.type === type);
 }
 function useSingletonEntity(type) {
-  const entities2 = React3.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = React2.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return [...entities2.values()].find((e) => e.type === type);
 }
 function usePlayer() {
   const player = useSingletonEntity("Player");
-  const update = React3.useCallback((updates) => {
+  const update = React2.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) => {
+  const update = React2.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) => {
+  const update = React2.useCallback((updates) => {
     if (input) updateEntity(input.id, updates);
   }, [input?.id]);
   return { input, updateInput: update };
@@ -2102,7 +2102,7 @@ var en_default = {
 // hooks/useTranslate.ts
 var { $meta: _meta, ...coreMessages } = en_default;
 var coreLocale = coreMessages;
-var I18nContext = React3.createContext({
+var I18nContext = React2.createContext({
   locale: "en",
   direction: "ltr",
   t: (key) => coreLocale[key] ?? key
@@ -2111,7 +2111,7 @@ var I18nContext = React3.createContext({
 I18nContext.displayName = "I18nContext";
 var I18nProvider = I18nContext.Provider;
 function useTranslate() {
-  return React3.useContext(I18nContext);
+  return React2.useContext(I18nContext);
 }
 function createTranslate(messages) {
   return (key, params) => {
@@ -2127,7 +2127,7 @@ function createTranslate(messages) {
 function useResolvedEntity(entity, data) {
   const shouldFetch = !data && !!entity;
   const fetched = useEntityList(entity, { skip: !shouldFetch });
-  return React3.useMemo(() => {
+  return React2.useMemo(() => {
     if (data) {
       return {
         data,
@@ -2156,14 +2156,14 @@ function useAuthContext() {
 }
 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) => {
+  const startX = React2.useRef(0);
+  const startY = React2.useRef(0);
+  const startTime = React2.useRef(0);
+  const currentX = React2.useRef(0);
+  const tracking = React2.useRef(false);
+  const offsetXRef = React2.useRef(0);
+  const isSwipingRef = React2.useRef(false);
+  const onPointerDown = React2.useCallback((e) => {
     startX.current = e.clientX;
     startY.current = e.clientY;
     currentX.current = e.clientX;
@@ -2173,7 +2173,7 @@ function useSwipeGesture(callbacks, options = {}) {
     offsetXRef.current = 0;
     e.target.setPointerCapture?.(e.pointerId);
   }, []);
-  const onPointerMove = React3.useCallback((e) => {
+  const onPointerMove = React2.useCallback((e) => {
     if (!tracking.current) return;
     if (preventDefault) e.preventDefault();
     currentX.current = e.clientX;
@@ -2184,7 +2184,7 @@ function useSwipeGesture(callbacks, options = {}) {
       offsetXRef.current = dx;
     }
   }, [preventDefault]);
-  const onPointerUp = React3.useCallback((e) => {
+  const onPointerUp = React2.useCallback((e) => {
     if (!tracking.current) return;
     tracking.current = false;
     const dx = e.clientX - startX.current;
@@ -2202,7 +2202,7 @@ function useSwipeGesture(callbacks, options = {}) {
       else if (dy > threshold) callbacks.onSwipeDown?.();
     }
   }, [threshold, velocityThreshold, callbacks]);
-  const onPointerCancel = React3.useCallback(() => {
+  const onPointerCancel = React2.useCallback(() => {
     tracking.current = false;
     offsetXRef.current = 0;
     isSwipingRef.current = false;
@@ -2218,18 +2218,18 @@ function useSwipeGesture(callbacks, options = {}) {
 }
 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(() => {
+  const timerRef = React2.useRef(null);
+  const startPos = React2.useRef({ x: 0, y: 0 });
+  const isPressedRef = React2.useRef(false);
+  const firedRef = React2.useRef(false);
+  const cancel = React2.useCallback(() => {
     if (timerRef.current) {
       clearTimeout(timerRef.current);
       timerRef.current = null;
     }
     isPressedRef.current = false;
   }, []);
-  const onPointerDown = React3.useCallback((e) => {
+  const onPointerDown = React2.useCallback((e) => {
     firedRef.current = false;
     startPos.current = { x: e.clientX, y: e.clientY };
     isPressedRef.current = true;
@@ -2239,7 +2239,7 @@ function useLongPress(onLongPress, options = {}) {
       onLongPress();
     }, duration);
   }, [duration, onLongPress]);
-  const onPointerMove = React3.useCallback((e) => {
+  const onPointerMove = React2.useCallback((e) => {
     if (!isPressedRef.current) return;
     const dx = e.clientX - startPos.current.x;
     const dy = e.clientY - startPos.current.y;
@@ -2247,10 +2247,10 @@ function useLongPress(onLongPress, options = {}) {
       cancel();
     }
   }, [moveThreshold, cancel]);
-  const onPointerUp = React3.useCallback(() => {
+  const onPointerUp = React2.useCallback(() => {
     cancel();
   }, [cancel]);
-  const onPointerCancel = React3.useCallback(() => {
+  const onPointerCancel = React2.useCallback(() => {
     cancel();
   }, [cancel]);
   return {
@@ -2262,22 +2262,22 @@ function useLongPress(onLongPress, options = {}) {
   };
 }
 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);
+  const [items, setItems] = React2.useState(initialItems);
+  const [dragIndex, setDragIndex] = React2.useState(-1);
+  const [dragOverIndex, setDragOverIndex] = React2.useState(-1);
+  const itemsRef = React2.useRef(initialItems);
   if (initialItems !== itemsRef.current) {
     itemsRef.current = initialItems;
     setItems(initialItems);
   }
   const isDragging = dragIndex >= 0;
-  const handleDragStart = React3.useCallback((index) => (e) => {
+  const handleDragStart = React2.useCallback((index) => (e) => {
     e.preventDefault();
     setDragIndex(index);
     setDragOverIndex(index);
     e.target.setPointerCapture?.(e.pointerId);
   }, []);
-  const handleDragMove = React3.useCallback((index) => (e) => {
+  const handleDragMove = React2.useCallback((index) => (e) => {
     if (dragIndex < 0) return;
     const target = document.elementFromPoint(e.clientX, e.clientY);
     if (!target) return;
@@ -2292,7 +2292,7 @@ function useDragReorder(initialItems, onReorder) {
       }
     }
   }, [dragIndex, dragOverIndex]);
-  const handleDragEnd = React3.useCallback(() => {
+  const handleDragEnd = React2.useCallback(() => {
     if (dragIndex >= 0 && dragOverIndex >= 0 && dragIndex !== dragOverIndex) {
       const newItems = [...items];
       const [movedItem] = newItems.splice(dragIndex, 1);
@@ -2303,13 +2303,13 @@ function useDragReorder(initialItems, onReorder) {
     setDragIndex(-1);
     setDragOverIndex(-1);
   }, [dragIndex, dragOverIndex, items, onReorder]);
-  const getDragHandleProps = React3.useCallback((index) => ({
+  const getDragHandleProps = React2.useCallback((index) => ({
     onPointerDown: handleDragStart(index),
     style: { cursor: "grab", touchAction: "none" },
     "aria-grabbed": dragIndex === index,
     role: "button"
   }), [handleDragStart, dragIndex]);
-  const getItemProps = React3.useCallback((index) => ({
+  const getItemProps = React2.useCallback((index) => ({
     onPointerMove: handleDragMove(index),
     onPointerUp: handleDragEnd,
     "aria-dropeffect": "move",
@@ -2331,19 +2331,19 @@ function useDragReorder(initialItems, onReorder) {
 }
 function useInfiniteScroll(onLoadMore, options = {}) {
   const { rootMargin = "200px", hasMore = true, isLoading = false } = options;
-  const observerRef = React3.useRef(null);
-  const callbackRef = React3.useRef(onLoadMore);
+  const observerRef = React2.useRef(null);
+  const callbackRef = React2.useRef(onLoadMore);
   callbackRef.current = onLoadMore;
-  const hasMoreRef = React3.useRef(hasMore);
+  const hasMoreRef = React2.useRef(hasMore);
   hasMoreRef.current = hasMore;
-  const isLoadingRef = React3.useRef(isLoading);
+  const isLoadingRef = React2.useRef(isLoading);
   isLoadingRef.current = isLoading;
-  React3.useEffect(() => {
+  React2.useEffect(() => {
     return () => {
       observerRef.current?.disconnect();
     };
   }, []);
-  const sentinelRef = React3.useCallback((node) => {
+  const sentinelRef = React2.useCallback((node) => {
     observerRef.current?.disconnect();
     if (!node) return;
     observerRef.current = new IntersectionObserver(
@@ -2361,12 +2361,12 @@ function useInfiniteScroll(onLoadMore, options = {}) {
 }
 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 [pullDistance, setPullDistance] = React2.useState(0);
+  const [isPulling, setIsPulling] = React2.useState(false);
+  const [isRefreshing, setIsRefreshing] = React2.useState(false);
+  const startY = React2.useRef(0);
+  const scrollTopRef = React2.useRef(0);
+  const onTouchStart = React2.useCallback((e) => {
     const container = e.currentTarget;
     scrollTopRef.current = container.scrollTop;
     if (scrollTopRef.current <= 0) {
@@ -2374,7 +2374,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setIsPulling(true);
     }
   }, []);
-  const onTouchMove = React3.useCallback((e) => {
+  const onTouchMove = React2.useCallback((e) => {
     if (!isPulling || isRefreshing) return;
     const container = e.currentTarget;
     if (container.scrollTop > 0) {
@@ -2387,7 +2387,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setPullDistance(distance);
     }
   }, [isPulling, isRefreshing, maxPull]);
-  const onTouchEnd = React3.useCallback(() => {
+  const onTouchEnd = React2.useCallback(() => {
     if (!isPulling) return;
     setIsPulling(false);
     if (pullDistance >= threshold && !isRefreshing) {
@@ -2398,7 +2398,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setPullDistance(0);
     }
   }, [isPulling, pullDistance, threshold, isRefreshing, onRefresh]);
-  const endRefresh = React3.useCallback(() => {
+  const endRefresh = React2.useCallback(() => {
     setIsRefreshing(false);
     setPullDistance(0);
   }, []);
@@ -2426,18 +2426,18 @@ function getDistance(touches) {
 }
 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) => {
+  const [scale, setScale] = React2.useState(1);
+  const [isPinching, setIsPinching] = React2.useState(false);
+  const initialDistance = React2.useRef(0);
+  const initialScale = React2.useRef(1);
+  const onTouchStart = React2.useCallback((e) => {
     if (e.touches.length === 2) {
       initialDistance.current = getDistance(e.touches);
       initialScale.current = scale;
       setIsPinching(true);
     }
   }, [scale]);
-  const onTouchMove = React3.useCallback((e) => {
+  const onTouchMove = React2.useCallback((e) => {
     if (e.touches.length !== 2 || !isPinching) return;
     e.preventDefault();
     const currentDistance = getDistance(e.touches);
@@ -2445,10 +2445,10 @@ function usePinchZoom(options = {}) {
     const newScale = Math.min(maxScale, Math.max(minScale, initialScale.current * ratio));
     setScale(newScale);
   }, [isPinching, minScale, maxScale]);
-  const onTouchEnd = React3.useCallback(() => {
+  const onTouchEnd = React2.useCallback(() => {
     setIsPinching(false);
   }, []);
-  const resetZoom = React3.useCallback(() => {
+  const resetZoom = React2.useCallback(() => {
     setScale(1);
   }, []);
   return {
@@ -2492,7 +2492,7 @@ function useGitHubStatus() {
   });
 }
 function useConnectGitHub() {
-  const connectGitHub = React3.useCallback(() => {
+  const connectGitHub = React2.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}`;