@almadar/ui 2.48.4 → 2.48.5

package/dist/hooks/index.cjs

@@ -1,17 +1,16 @@
 'use strict';
 
-var React2 = require('react');
+var React = require('react');
 var providers = require('@almadar/ui/providers');
-require('react/jsx-runtime');
 var reactQuery = require('@tanstack/react-query');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React2__default = /*#__PURE__*/_interopDefault(React2);
+var React__default = /*#__PURE__*/_interopDefault(React);
 
 function useOrbitalHistory(options) {
   const { appId, authToken, userId, onHistoryChange, onRevertSuccess } = options;
-  const getHeaders2 = React2.useCallback(() => {
+  const getHeaders2 = React.useCallback(() => {
     const headers = {
       "Content-Type": "application/json"
     };
@@ -23,11 +22,11 @@ function useOrbitalHistory(options) {
     }
     return headers;
   }, [authToken, userId]);
-  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 () => {
+  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);
@@ -76,7 +75,7 @@ function useOrbitalHistory(options) {
       setIsLoading(false);
     }
   }, [appId, getHeaders2]);
-  const revertToSnapshot = React2.useCallback(async (snapshotId) => {
+  const revertToSnapshot = React.useCallback(async (snapshotId) => {
     if (!appId) {
       return { success: false, error: "No app ID provided" };
     }
@@ -110,12 +109,12 @@ function useOrbitalHistory(options) {
       };
     }
   }, [appId, getHeaders2, refresh, onRevertSuccess]);
-  React2.useEffect(() => {
+  React.useEffect(() => {
     if (appId && authToken && userId) {
       refresh();
     }
   }, [appId, authToken, userId]);
-  React2.useEffect(() => {
+  React.useEffect(() => {
     onHistoryChange?.(timeline);
   }, [timeline]);
   return {
@@ -128,15 +127,15 @@ function useOrbitalHistory(options) {
   };
 }
 function useFileSystem() {
-  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 () => {
+  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);
@@ -151,7 +150,7 @@ function useFileSystem() {
       setIsLoading(false);
     }
   }, []);
-  const mountFiles = React2.useCallback(async (filesToMount) => {
+  const mountFiles = React.useCallback(async (filesToMount) => {
     setIsLoading(true);
     try {
       let filesArray;
@@ -209,17 +208,17 @@ function useFileSystem() {
       setIsLoading(false);
     }
   }, []);
-  const readFile = React2.useCallback(async (path) => {
+  const readFile = React.useCallback(async (path) => {
     return fileContents.get(path) || "";
   }, [fileContents]);
-  const writeFile = React2.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 = React2.useCallback(async (path) => {
+  const selectFile = React.useCallback(async (path) => {
     const content = fileContents.get(path) || "";
     const ext = path.split(".").pop()?.toLowerCase() || "";
     const languageMap = {
@@ -241,7 +240,7 @@ function useFileSystem() {
       isDirty: false
     });
   }, [fileContents]);
-  const updateContent = React2.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) {
@@ -257,17 +256,17 @@ function useFileSystem() {
       setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
     }
   }, [selectedPath]);
-  const updateSelectedContent = React2.useCallback((content) => {
+  const updateSelectedContent = React.useCallback((content) => {
     setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
   }, []);
-  const refreshTree = React2.useCallback(async () => {
+  const refreshTree = React.useCallback(async () => {
     console.log("[useFileSystem] Refreshing tree");
   }, []);
-  const runCommand = React2.useCallback(async (command) => {
+  const runCommand = React.useCallback(async (command) => {
     console.log("[useFileSystem] Running command:", command);
     return { exitCode: 0, output: "" };
   }, []);
-  const startDevServer = React2.useCallback(async () => {
+  const startDevServer = React.useCallback(async () => {
     console.log("[useFileSystem] Starting dev server");
     setPreviewUrl("http://localhost:5173");
   }, []);
@@ -304,14 +303,14 @@ var defaultManifest = {
 };
 function useExtensions(options) {
   const { appId, loadOnMount = true } = options;
-  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) => {
+  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 = React2.useCallback(async () => {
+  const loadExtensions = React.useCallback(async () => {
     setIsLoading(true);
     setError(null);
     try {
@@ -330,7 +329,7 @@ function useExtensions(options) {
       setIsLoading(false);
     }
   }, []);
-  const getExtensionForFile = React2.useCallback((filename) => {
+  const getExtensionForFile = React.useCallback((filename) => {
     const ext = filename.split(".").pop()?.toLowerCase();
     if (!ext) return null;
     const languageMap = {
@@ -348,7 +347,7 @@ function useExtensions(options) {
     if (!language) return null;
     return extensions.find((e) => e.language === language) || null;
   }, [extensions]);
-  React2.useEffect(() => {
+  React.useEffect(() => {
     if (!appId || !loadOnMount) return;
     const loadExtensions2 = async () => {
       setIsLoading(true);
@@ -383,11 +382,11 @@ function useExtensions(options) {
 }
 function useFileEditor(options) {
   const { extensions, fileSystem, onSchemaUpdate } = options;
-  const [openFiles, setOpenFiles] = React2.useState([]);
-  const [activeFilePath, setActiveFilePath] = React2.useState(null);
-  const [isSaving, setIsSaving] = React2.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 = React2.useCallback(async (path) => {
+  const openFile = React.useCallback(async (path) => {
     const existing = openFiles.find((f) => f.path === path);
     if (existing) {
       setActiveFilePath(path);
@@ -408,24 +407,24 @@ function useFileEditor(options) {
       console.error("[useFileEditor] Failed to open file:", err);
     }
   }, [openFiles, fileSystem, extensions]);
-  const closeFile = React2.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 = React2.useCallback((path) => {
+  const setActiveFile = React.useCallback((path) => {
     setActiveFilePath(path);
   }, []);
-  const updateFileContent = React2.useCallback((path, content) => {
+  const updateFileContent = React.useCallback((path, content) => {
     setOpenFiles(
       (prev) => prev.map(
         (f) => f.path === path ? { ...f, content, isDirty: true } : f
       )
     );
   }, []);
-  const handleFileEdit = React2.useCallback(async (path, content) => {
+  const handleFileEdit = React.useCallback(async (path, content) => {
     try {
       await fileSystem.writeFile(path, content);
       let action = "saved";
@@ -447,7 +446,7 @@ function useFileEditor(options) {
       };
     }
   }, [fileSystem, onSchemaUpdate]);
-  const saveFile = React2.useCallback(async (path) => {
+  const saveFile = React.useCallback(async (path) => {
     const file = openFiles.find((f) => f.path === path);
     if (!file) return;
     setIsSaving(true);
@@ -471,7 +470,7 @@ function useFileEditor(options) {
       setIsSaving(false);
     }
   }, [openFiles, fileSystem, onSchemaUpdate]);
-  const saveAllFiles = React2.useCallback(async () => {
+  const saveAllFiles = React.useCallback(async () => {
     setIsSaving(true);
     try {
       const dirtyFiles = openFiles.filter((f) => f.isDirty);
@@ -496,11 +495,11 @@ function useFileEditor(options) {
   };
 }
 function useCompile() {
-  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) => {
+  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);
@@ -532,18 +531,18 @@ function useCompile() {
   };
 }
 function usePreview(options) {
-  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(() => ({
+  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),
@@ -557,7 +556,7 @@ function usePreview(options) {
     },
     clearAll: () => setNotificationsList([])
   }), [notificationsList, isPanelOpen]);
-  React2.useEffect(() => {
+  React.useEffect(() => {
     const appId = options?.appId;
     if (!appId) {
       setApp(null);
@@ -568,10 +567,10 @@ function usePreview(options) {
     setPreviewUrl(`/api/orbitals/${appId}`);
     setIsLoading(false);
   }, [options?.appId]);
-  const startPreview = React2.useCallback(async () => {
+  const startPreview = React.useCallback(async () => {
     console.log("[usePreview] startPreview called");
   }, []);
-  const stopPreview = React2.useCallback(async () => {
+  const stopPreview = React.useCallback(async () => {
     setIsLoading(true);
     try {
       console.log("[usePreview] Stopping preview server...");
@@ -581,16 +580,16 @@ function usePreview(options) {
       setIsLoading(false);
     }
   }, []);
-  const refresh = React2.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 = React2.useCallback(async () => {
+  const handleRefresh = React.useCallback(async () => {
     console.log("[usePreview] Handle refresh...");
     await refresh();
   }, [refresh]);
-  const handleReset = React2.useCallback(async () => {
+  const handleReset = React.useCallback(async () => {
     console.log("[usePreview] Resetting preview...");
     setError(null);
     setLoadError(null);
@@ -598,10 +597,10 @@ function usePreview(options) {
     setIsExecutingEvent(false);
     setCurrentStateName(null);
   }, []);
-  const toggleFullscreen = React2.useCallback(() => {
+  const toggleFullscreen = React.useCallback(() => {
     setIsFullscreen((prev) => !prev);
   }, []);
-  const dismissErrorToast = React2.useCallback(() => {
+  const dismissErrorToast = React.useCallback(() => {
     setErrorToast(null);
   }, []);
   return {
@@ -626,16 +625,16 @@ function usePreview(options) {
   };
 }
 function useAgentChat(options) {
-  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) => {
+  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);
@@ -664,7 +663,7 @@ function useAgentChat(options) {
       setIsLoading(false);
     }
   }, [options]);
-  const startGeneration = React2.useCallback(async (skill, prompt, genOptions) => {
+  const startGeneration = React.useCallback(async (skill, prompt, genOptions) => {
     setStatus("running");
     setIsLoading(true);
     setError(null);
@@ -681,22 +680,22 @@ function useAgentChat(options) {
       setIsLoading(false);
     }
   }, [options]);
-  const continueConversation = React2.useCallback(async (message) => {
+  const continueConversation = React.useCallback(async (message) => {
     console.log("[useAgentChat] Continue conversation", message);
   }, []);
-  const resumeWithDecision = React2.useCallback(async (decisions) => {
+  const resumeWithDecision = React.useCallback(async (decisions) => {
     console.log("[useAgentChat] Resume with decision:", decisions);
     setInterrupt(null);
   }, []);
-  const cancel = React2.useCallback(() => {
+  const cancel = React.useCallback(() => {
     setStatus("idle");
     setIsLoading(false);
     setInterrupt(null);
   }, []);
-  const clearMessages = React2.useCallback(() => {
+  const clearMessages = React.useCallback(() => {
     setMessages([]);
   }, []);
-  const clearHistory = React2.useCallback(() => {
+  const clearHistory = React.useCallback(() => {
     setMessages([]);
     setActivities([]);
     setTodos([]);
@@ -723,13 +722,13 @@ function useAgentChat(options) {
   };
 }
 function useValidation() {
-  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) => {
+  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");
@@ -761,11 +760,11 @@ function useValidation() {
       setIsValidating(false);
     }
   }, []);
-  const clearResult = React2.useCallback(() => {
+  const clearResult = React.useCallback(() => {
     setResult(null);
     setError(null);
   }, []);
-  const reset = React2.useCallback(() => {
+  const reset = React.useCallback(() => {
     setResult(null);
     setError(null);
     setStage("idle");
@@ -789,15 +788,15 @@ function useValidation() {
   };
 }
 function useDeepAgentGeneration() {
-  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) => {
+  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);
@@ -830,11 +829,11 @@ function useDeepAgentGeneration() {
       setIsLoading(false);
     }
   }, []);
-  const startGeneration = React2.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 = React2.useCallback(() => {
+  const cancelGeneration = React.useCallback(() => {
     if (currentRequest) {
       currentRequest.status = "failed";
       currentRequest.error = "Cancelled by user";
@@ -845,14 +844,14 @@ function useDeepAgentGeneration() {
     setIsComplete(false);
     setProgress({ stage: "idle", percent: 0, message: "" });
   }, [currentRequest]);
-  const clearRequests = React2.useCallback(() => {
+  const clearRequests = React.useCallback(() => {
     setRequests([]);
     setCurrentRequest(null);
     setError(null);
     setProgress({ stage: "idle", percent: 0, message: "" });
     setIsComplete(false);
   }, []);
-  const submitInterruptDecisions = React2.useCallback((decisions) => {
+  const submitInterruptDecisions = React.useCallback((decisions) => {
     console.log("[useDeepAgentGeneration] Submitting interrupt decisions:", decisions);
     setInterrupt(null);
   }, []);
@@ -876,22 +875,13 @@ function useDeepAgentGeneration() {
 // lib/logger.ts
 var LEVEL_PRIORITY = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
 var ENV = typeof process !== "undefined" && process.env ? process.env : {};
-var VITE_ENV = typeof globalThis !== "undefined" && globalThis.__vite_env__ ? globalThis.__vite_env__ : {};
-function getViteEnv(key) {
-  try {
-    const meta = (0, eval)('typeof import.meta !== "undefined" && import.meta');
-    return meta ? meta.env?.[key] : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function envGet(key, viteKey) {
-  return ENV[key] ?? (viteKey ? getViteEnv(viteKey) : void 0) ?? VITE_ENV[viteKey ?? key];
+function envGet(key) {
+  return ENV[key] ?? ENV[`VITE_${key}`];
 }
-var NODE_ENV = envGet("NODE_ENV", "VITE_NODE_ENV") ?? "development";
-var CONFIGURED_LEVEL = (envGet("LOG_LEVEL", "VITE_LOG_LEVEL") ?? (NODE_ENV === "production" ? "info" : "debug")).toUpperCase();
+var NODE_ENV = envGet("NODE_ENV") ?? "development";
+var CONFIGURED_LEVEL = (envGet("LOG_LEVEL") ?? (NODE_ENV === "production" ? "info" : "debug")).toUpperCase();
 var MIN_PRIORITY = LEVEL_PRIORITY[CONFIGURED_LEVEL] ?? 0;
-var DEBUG_FILTER = (envGet("ALMADAR_DEBUG", "VITE_ALMADAR_DEBUG") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+var DEBUG_FILTER = (envGet("ALMADAR_DEBUG") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
 function matchesNamespace(namespace) {
   if (DEBUG_FILTER.length === 0) return true;
   return DEBUG_FILTER.some((pattern) => {
@@ -1003,14 +993,14 @@ var fallbackEventBus = {
   }
 };
 function useEventBus() {
-  const context = React2.useContext(providers.EventBusContext);
+  const context = React.useContext(providers.EventBusContext);
   return context ?? getGlobalEventBus() ?? fallbackEventBus;
 }
 function useEventListener(event, handler) {
   const eventBus = useEventBus();
-  const handlerRef = React2.useRef(handler);
+  const handlerRef = React.useRef(handler);
   handlerRef.current = handler;
-  React2.useEffect(() => {
+  React.useEffect(() => {
     const wrappedHandler = (evt) => {
       handlerRef.current(evt);
     };
@@ -1022,7 +1012,7 @@ function useEventListener(event, handler) {
 }
 function useEmitEvent() {
   const eventBus = useEventBus();
-  return React2.useCallback(
+  return React.useCallback(
     (type, payload) => {
       eventBus.emit(type, payload);
     },
@@ -1048,16 +1038,16 @@ function generateId() {
   return `slot-content-${++idCounter}-${Date.now()}`;
 }
 function useUISlotManager() {
-  const [slots, setSlots] = React2.useState(DEFAULT_SLOTS);
-  const subscribersRef = React2.useRef(/* @__PURE__ */ new Set());
-  const timersRef = React2.useRef(/* @__PURE__ */ new Map());
-  React2.useEffect(() => {
+  const [slots, setSlots] = React.useState(DEFAULT_SLOTS);
+  const subscribersRef = React.useRef(/* @__PURE__ */ new Set());
+  const timersRef = React.useRef(/* @__PURE__ */ new Map());
+  React.useEffect(() => {
     return () => {
       timersRef.current.forEach((timer) => clearTimeout(timer));
       timersRef.current.clear();
     };
   }, []);
-  const notifySubscribers = React2.useCallback((slot, content) => {
+  const notifySubscribers = React.useCallback((slot, content) => {
     subscribersRef.current.forEach((callback) => {
       try {
         callback(slot, content);
@@ -1066,7 +1056,7 @@ function useUISlotManager() {
       }
     });
   }, []);
-  const render = React2.useCallback((config) => {
+  const render = React.useCallback((config) => {
     const id = generateId();
     const content = {
       id,
@@ -1105,7 +1095,7 @@ function useUISlotManager() {
     });
     return id;
   }, [notifySubscribers]);
-  const clear = React2.useCallback((slot) => {
+  const clear = React.useCallback((slot) => {
     setSlots((prev) => {
       const content = prev[slot];
       if (content) {
@@ -1120,7 +1110,7 @@ function useUISlotManager() {
       return { ...prev, [slot]: null };
     });
   }, [notifySubscribers]);
-  const clearById = React2.useCallback((id) => {
+  const clearById = React.useCallback((id) => {
     setSlots((prev) => {
       const entry = Object.entries(prev).find(([, content]) => content?.id === id);
       if (entry) {
@@ -1137,7 +1127,7 @@ function useUISlotManager() {
       return prev;
     });
   }, [notifySubscribers]);
-  const clearAll = React2.useCallback(() => {
+  const clearAll = React.useCallback(() => {
     timersRef.current.forEach((timer) => clearTimeout(timer));
     timersRef.current.clear();
     setSlots((prev) => {
@@ -1150,16 +1140,16 @@ function useUISlotManager() {
       return DEFAULT_SLOTS;
     });
   }, [notifySubscribers]);
-  const subscribe2 = React2.useCallback((callback) => {
+  const subscribe2 = React.useCallback((callback) => {
     subscribersRef.current.add(callback);
     return () => {
       subscribersRef.current.delete(callback);
     };
   }, []);
-  const hasContent = React2.useCallback((slot) => {
+  const hasContent = React.useCallback((slot) => {
     return slots[slot] !== null;
   }, [slots]);
-  const getContent = React2.useCallback((slot) => {
+  const getContent = React.useCallback((slot) => {
     return slots[slot];
   }, [slots]);
   return {
@@ -1173,20 +1163,17 @@ function useUISlotManager() {
     getContent
   };
 }
-var SelectionContext = React2.createContext(null);
-
-// hooks/useUIEvents.ts
 var UI_PREFIX = "UI:";
 function useUIEvents(dispatch, validEvents, eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
   const validEventsKey = validEvents ? validEvents.slice().sort().join(",") : "";
-  const stableValidEvents = React2.useMemo(
+  const stableValidEvents = React.useMemo(
     () => validEvents,
     [validEventsKey]
     // intentional — validEventsKey is the stable dep, not validEvents array ref
   );
-  React2.useEffect(() => {
+  React.useEffect(() => {
     const unsubscribes = [];
     if (stableValidEvents) {
       for (const smEvent of stableValidEvents) {
@@ -1221,9 +1208,9 @@ function useSelectedEntity(eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
   const selectionContext = useSelectionContext();
-  const [localSelected, setLocalSelected] = React2.useState(null);
+  const [localSelected, setLocalSelected] = React.useState(null);
   const usingContext = selectionContext !== null;
-  React2.useEffect(() => {
+  React.useEffect(() => {
     if (usingContext) return;
     const handleSelect = (event) => {
       const row = event.payload?.row;
@@ -1253,22 +1240,22 @@ function useSelectedEntity(eventBusInstance) {
   return [localSelected, setLocalSelected];
 }
 function useSelectionContext() {
-  const context = React2.useContext(SelectionContext);
+  const context = React.useContext(providers.SelectionContext);
   return context;
 }
-var EntityDataContext = React2.createContext(null);
+var EntityDataContext = React.createContext(null);
 function EntityDataProvider({
   adapter,
   children
 }) {
-  return React2__default.default.createElement(
+  return React__default.default.createElement(
     EntityDataContext.Provider,
     { value: adapter },
     children
   );
 }
 function useEntityDataAdapter() {
-  return React2.useContext(EntityDataContext);
+  return React.useContext(EntityDataContext);
 }
 var entityDataKeys = {
   all: ["entities"],
@@ -1279,15 +1266,15 @@ var entityDataKeys = {
 };
 function useEntityList(entity, options = {}) {
   const { skip = false } = options;
-  const adapter = React2.useContext(EntityDataContext);
-  const adapterData = React2.useMemo(() => {
+  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] = React2.useState([]);
-  const [stubLoading, setStubLoading] = React2.useState(!skip && !!entity && !adapter);
-  const [stubError, setStubError] = React2.useState(null);
-  React2.useEffect(() => {
+  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;
@@ -1312,15 +1299,15 @@ function useEntityList(entity, options = {}) {
   } };
 }
 function useEntity(entity, id) {
-  const adapter = React2.useContext(EntityDataContext);
-  const adapterData = React2.useMemo(() => {
+  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] = React2.useState(null);
-  const [stubLoading, setStubLoading] = React2.useState(!!entity && !!id && !adapter);
-  const [stubError, setStubError] = React2.useState(null);
-  React2.useEffect(() => {
+  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;
@@ -1351,7 +1338,7 @@ function getSuspenseCacheKey(entity, type, id) {
   return id ? `${type}:${entity}:${id}` : `${type}:${entity}`;
 }
 function useEntityListSuspense(entity) {
-  const adapter = React2.useContext(EntityDataContext);
+  const adapter = React.useContext(EntityDataContext);
   if (adapter) {
     if (adapter.isLoading) {
       const cacheKey2 = getSuspenseCacheKey(entity, "list");
@@ -1405,7 +1392,7 @@ function useEntityListSuspense(entity) {
   } };
 }
 function useEntitySuspense(entity, id) {
-  const adapter = React2.useContext(EntityDataContext);
+  const adapter = React.useContext(EntityDataContext);
   if (adapter) {
     if (adapter.isLoading) {
       const cacheKey2 = getSuspenseCacheKey(entity, "detail", id);
@@ -1472,35 +1459,35 @@ function getOrCreateStore(query) {
   return queryStores.get(query);
 }
 function useQuerySingleton(query) {
-  const [, forceUpdate] = React2.useState({});
+  const [, forceUpdate] = React.useState({});
   if (!query) {
     return null;
   }
-  const store = React2.useMemo(() => getOrCreateStore(query), [query]);
-  React2.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 = React2.useCallback(() => {
+  const notifyListeners = React.useCallback(() => {
     store.listeners.forEach((listener) => listener());
   }, [store]);
-  const setSearch = React2.useCallback((value) => {
+  const setSearch = React.useCallback((value) => {
     store.search = value;
     notifyListeners();
   }, [store, notifyListeners]);
-  const setFilter = React2.useCallback((key, value) => {
+  const setFilter = React.useCallback((key, value) => {
     store.filters = { ...store.filters, [key]: value };
     notifyListeners();
   }, [store, notifyListeners]);
-  const clearFilters = React2.useCallback(() => {
+  const clearFilters = React.useCallback(() => {
     store.filters = {};
     store.search = "";
     notifyListeners();
   }, [store, notifyListeners]);
-  const setSort = React2.useCallback((field, direction) => {
+  const setSort = React.useCallback((field, direction) => {
     store.sortField = field;
     store.sortDirection = direction;
     notifyListeners();
@@ -1967,7 +1954,7 @@ function getSnapshot() {
 
 // hooks/useEntities.ts
 function useEntities() {
-  const entities2 = React2.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return {
     entities: entities2,
     getEntity,
@@ -1982,34 +1969,34 @@ function useEntities() {
   };
 }
 function useEntity2(id) {
-  const entities2 = React2.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return entities2.get(id);
 }
 function useEntitiesByType(type) {
-  const entities2 = React2.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const entities2 = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return [...entities2.values()].filter((e) => e.type === type);
 }
 function useSingletonEntity(type) {
-  const entities2 = React2.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 = React2.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 = React2.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 = React2.useCallback((updates) => {
+  const update = React.useCallback((updates) => {
     if (input) updateEntity(input.id, updates);
   }, [input?.id]);
   return { input, updateInput: update };
@@ -2124,7 +2111,7 @@ var en_default = {
 // hooks/useTranslate.ts
 var { $meta: _meta, ...coreMessages } = en_default;
 var coreLocale = coreMessages;
-var I18nContext = React2.createContext({
+var I18nContext = React.createContext({
   locale: "en",
   direction: "ltr",
   t: (key) => coreLocale[key] ?? key
@@ -2133,7 +2120,7 @@ var I18nContext = React2.createContext({
 I18nContext.displayName = "I18nContext";
 var I18nProvider = I18nContext.Provider;
 function useTranslate() {
-  return React2.useContext(I18nContext);
+  return React.useContext(I18nContext);
 }
 function createTranslate(messages) {
   return (key, params) => {
@@ -2149,7 +2136,7 @@ function createTranslate(messages) {
 function useResolvedEntity(entity, data) {
   const shouldFetch = !data && !!entity;
   const fetched = useEntityList(entity, { skip: !shouldFetch });
-  return React2.useMemo(() => {
+  return React.useMemo(() => {
     if (data) {
       return {
         data,
@@ -2178,14 +2165,14 @@ function useAuthContext() {
 }
 function useSwipeGesture(callbacks, options = {}) {
   const { threshold = 50, velocityThreshold = 0.3, preventDefault = false } = options;
-  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) => {
+  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;
@@ -2195,7 +2182,7 @@ function useSwipeGesture(callbacks, options = {}) {
     offsetXRef.current = 0;
     e.target.setPointerCapture?.(e.pointerId);
   }, []);
-  const onPointerMove = React2.useCallback((e) => {
+  const onPointerMove = React.useCallback((e) => {
     if (!tracking.current) return;
     if (preventDefault) e.preventDefault();
     currentX.current = e.clientX;
@@ -2206,7 +2193,7 @@ function useSwipeGesture(callbacks, options = {}) {
       offsetXRef.current = dx;
     }
   }, [preventDefault]);
-  const onPointerUp = React2.useCallback((e) => {
+  const onPointerUp = React.useCallback((e) => {
     if (!tracking.current) return;
     tracking.current = false;
     const dx = e.clientX - startX.current;
@@ -2224,7 +2211,7 @@ function useSwipeGesture(callbacks, options = {}) {
       else if (dy > threshold) callbacks.onSwipeDown?.();
     }
   }, [threshold, velocityThreshold, callbacks]);
-  const onPointerCancel = React2.useCallback(() => {
+  const onPointerCancel = React.useCallback(() => {
     tracking.current = false;
     offsetXRef.current = 0;
     isSwipingRef.current = false;
@@ -2240,18 +2227,18 @@ function useSwipeGesture(callbacks, options = {}) {
 }
 function useLongPress(onLongPress, options = {}) {
   const { duration = 500, moveThreshold = 10 } = options;
-  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(() => {
+  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 = React2.useCallback((e) => {
+  const onPointerDown = React.useCallback((e) => {
     firedRef.current = false;
     startPos.current = { x: e.clientX, y: e.clientY };
     isPressedRef.current = true;
@@ -2261,7 +2248,7 @@ function useLongPress(onLongPress, options = {}) {
       onLongPress();
     }, duration);
   }, [duration, onLongPress]);
-  const onPointerMove = React2.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;
@@ -2269,10 +2256,10 @@ function useLongPress(onLongPress, options = {}) {
       cancel();
     }
   }, [moveThreshold, cancel]);
-  const onPointerUp = React2.useCallback(() => {
+  const onPointerUp = React.useCallback(() => {
     cancel();
   }, [cancel]);
-  const onPointerCancel = React2.useCallback(() => {
+  const onPointerCancel = React.useCallback(() => {
     cancel();
   }, [cancel]);
   return {
@@ -2284,22 +2271,22 @@ function useLongPress(onLongPress, options = {}) {
   };
 }
 function useDragReorder(initialItems, onReorder) {
-  const [items, setItems] = React2.useState(initialItems);
-  const [dragIndex, setDragIndex] = React2.useState(-1);
-  const [dragOverIndex, setDragOverIndex] = React2.useState(-1);
-  const itemsRef = React2.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 = React2.useCallback((index) => (e) => {
+  const handleDragStart = React.useCallback((index) => (e) => {
     e.preventDefault();
     setDragIndex(index);
     setDragOverIndex(index);
     e.target.setPointerCapture?.(e.pointerId);
   }, []);
-  const handleDragMove = React2.useCallback((index) => (e) => {
+  const handleDragMove = React.useCallback((index) => (e) => {
     if (dragIndex < 0) return;
     const target = document.elementFromPoint(e.clientX, e.clientY);
     if (!target) return;
@@ -2314,7 +2301,7 @@ function useDragReorder(initialItems, onReorder) {
       }
     }
   }, [dragIndex, dragOverIndex]);
-  const handleDragEnd = React2.useCallback(() => {
+  const handleDragEnd = React.useCallback(() => {
     if (dragIndex >= 0 && dragOverIndex >= 0 && dragIndex !== dragOverIndex) {
       const newItems = [...items];
       const [movedItem] = newItems.splice(dragIndex, 1);
@@ -2325,13 +2312,13 @@ function useDragReorder(initialItems, onReorder) {
     setDragIndex(-1);
     setDragOverIndex(-1);
   }, [dragIndex, dragOverIndex, items, onReorder]);
-  const getDragHandleProps = React2.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 = React2.useCallback((index) => ({
+  const getItemProps = React.useCallback((index) => ({
     onPointerMove: handleDragMove(index),
     onPointerUp: handleDragEnd,
     "aria-dropeffect": "move",
@@ -2353,19 +2340,19 @@ function useDragReorder(initialItems, onReorder) {
 }
 function useInfiniteScroll(onLoadMore, options = {}) {
   const { rootMargin = "200px", hasMore = true, isLoading = false } = options;
-  const observerRef = React2.useRef(null);
-  const callbackRef = React2.useRef(onLoadMore);
+  const observerRef = React.useRef(null);
+  const callbackRef = React.useRef(onLoadMore);
   callbackRef.current = onLoadMore;
-  const hasMoreRef = React2.useRef(hasMore);
+  const hasMoreRef = React.useRef(hasMore);
   hasMoreRef.current = hasMore;
-  const isLoadingRef = React2.useRef(isLoading);
+  const isLoadingRef = React.useRef(isLoading);
   isLoadingRef.current = isLoading;
-  React2.useEffect(() => {
+  React.useEffect(() => {
     return () => {
       observerRef.current?.disconnect();
     };
   }, []);
-  const sentinelRef = React2.useCallback((node) => {
+  const sentinelRef = React.useCallback((node) => {
     observerRef.current?.disconnect();
     if (!node) return;
     observerRef.current = new IntersectionObserver(
@@ -2383,12 +2370,12 @@ function useInfiniteScroll(onLoadMore, options = {}) {
 }
 function usePullToRefresh(onRefresh, options = {}) {
   const { threshold = 60, maxPull = 120 } = options;
-  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 [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) {
@@ -2396,7 +2383,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setIsPulling(true);
     }
   }, []);
-  const onTouchMove = React2.useCallback((e) => {
+  const onTouchMove = React.useCallback((e) => {
     if (!isPulling || isRefreshing) return;
     const container = e.currentTarget;
     if (container.scrollTop > 0) {
@@ -2409,7 +2396,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setPullDistance(distance);
     }
   }, [isPulling, isRefreshing, maxPull]);
-  const onTouchEnd = React2.useCallback(() => {
+  const onTouchEnd = React.useCallback(() => {
     if (!isPulling) return;
     setIsPulling(false);
     if (pullDistance >= threshold && !isRefreshing) {
@@ -2420,7 +2407,7 @@ function usePullToRefresh(onRefresh, options = {}) {
       setPullDistance(0);
     }
   }, [isPulling, pullDistance, threshold, isRefreshing, onRefresh]);
-  const endRefresh = React2.useCallback(() => {
+  const endRefresh = React.useCallback(() => {
     setIsRefreshing(false);
     setPullDistance(0);
   }, []);
@@ -2448,18 +2435,18 @@ function getDistance(touches) {
 }
 function usePinchZoom(options = {}) {
   const { minScale = 0.5, maxScale = 4 } = options;
-  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) => {
+  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 = React2.useCallback((e) => {
+  const onTouchMove = React.useCallback((e) => {
     if (e.touches.length !== 2 || !isPinching) return;
     e.preventDefault();
     const currentDistance = getDistance(e.touches);
@@ -2467,10 +2454,10 @@ function usePinchZoom(options = {}) {
     const newScale = Math.min(maxScale, Math.max(minScale, initialScale.current * ratio));
     setScale(newScale);
   }, [isPinching, minScale, maxScale]);
-  const onTouchEnd = React2.useCallback(() => {
+  const onTouchEnd = React.useCallback(() => {
     setIsPinching(false);
   }, []);
-  const resetZoom = React2.useCallback(() => {
+  const resetZoom = React.useCallback(() => {
     setScale(1);
   }, []);
   return {
@@ -2486,9 +2473,9 @@ function usePinchZoom(options = {}) {
 }
 var ALMADAR_DND_MIME = "application/x-almadar-dnd";
 function useDraggable({ payload, disabled = false }) {
-  const [isDragging, setIsDragging] = React2.useState(false);
+  const [isDragging, setIsDragging] = React.useState(false);
   const eventBus = useEventBus();
-  const handleDragStart = React2.useCallback(
+  const handleDragStart = React.useCallback(
     (e) => {
       if (disabled) {
         e.preventDefault();
@@ -2501,14 +2488,14 @@ function useDraggable({ payload, disabled = false }) {
     },
     [disabled, payload, eventBus]
   );
-  const handleDragEnd = React2.useCallback(
+  const handleDragEnd = React.useCallback(
     (e) => {
       setIsDragging(false);
       eventBus.emit("UI:DRAG_END", { kind: payload.kind, data: payload.data });
     },
     [payload, eventBus]
   );
-  const dragProps = React2.useMemo(
+  const dragProps = React.useMemo(
     () => ({
       draggable: !disabled,
       onDragStart: handleDragStart,
@@ -2534,9 +2521,9 @@ function hasAlmadarPayload(e) {
   return e.dataTransfer.types.includes(ALMADAR_DND_MIME);
 }
 function useDropZone({ accepts, onDrop, disabled = false }) {
-  const [isOver, setIsOver] = React2.useState(false);
+  const [isOver, setIsOver] = React.useState(false);
   const eventBus = useEventBus();
-  const handleDragOver = React2.useCallback(
+  const handleDragOver = React.useCallback(
     (e) => {
       if (disabled) return;
       if (!hasAlmadarPayload(e)) return;
@@ -2546,13 +2533,13 @@ function useDropZone({ accepts, onDrop, disabled = false }) {
     },
     [disabled]
   );
-  const handleDragLeave = React2.useCallback(
+  const handleDragLeave = React.useCallback(
     (e) => {
       setIsOver(false);
     },
     []
   );
-  const handleDrop = React2.useCallback(
+  const handleDrop = React.useCallback(
     (e) => {
       e.preventDefault();
       setIsOver(false);
@@ -2566,7 +2553,7 @@ function useDropZone({ accepts, onDrop, disabled = false }) {
     },
     [disabled, accepts, onDrop, eventBus]
   );
-  const dropProps = React2.useMemo(
+  const dropProps = React.useMemo(
     () => ({
       onDragOver: handleDragOver,
       onDragLeave: handleDragLeave,
@@ -2606,7 +2593,7 @@ function useGitHubStatus() {
   });
 }
 function useConnectGitHub() {
-  const connectGitHub = React2.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}`;