@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-73SRAB4P.js

@@ -0,0 +1,1053 @@
+import { claimDelivery } from './chunk-R5O5AUPI.js';
+import { useEventBus, getTraitPresence, beginPending, endPending } from './chunk-MBQAMMSE.js';
+import { createContext, useState, useCallback, useEffect, useMemo, useRef, useContext, useSyncExternalStore } from 'react';
+import { createLogger } from '@almadar/logger';
+import { mergeEntityFrame } from '@almadar/core';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+
+var log = createLogger("almadar:ui:filesystem");
+function useFileSystem() {
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [files, setFiles] = useState([]);
+  const [selectedFile, setSelectedFile] = useState(null);
+  const [selectedPath, setSelectedPath] = useState(null);
+  const [previewUrl, setPreviewUrl] = useState(null);
+  const [fileContents, setFileContents] = useState(/* @__PURE__ */ new Map());
+  const boot = useCallback(async () => {
+    setStatus("booting");
+    setError(null);
+    setIsLoading(true);
+    try {
+      log.debug("Booting WebContainer");
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      setStatus("ready");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to boot");
+      setStatus("error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const mountFiles = useCallback(async (filesToMount) => {
+    setIsLoading(true);
+    try {
+      let filesArray;
+      if (Array.isArray(filesToMount)) {
+        filesArray = filesToMount;
+      } else {
+        filesArray = [];
+        const flattenTree = (obj, basePath = "") => {
+          for (const [key, value] of Object.entries(obj)) {
+            const path = basePath ? `${basePath}/${key}` : key;
+            if (value && "file" in value) {
+              filesArray.push({ path, content: value.file.contents || "" });
+            } else if (value && "directory" in value) {
+              flattenTree(value.directory, path);
+            }
+          }
+        };
+        flattenTree(filesToMount);
+      }
+      const newContents = /* @__PURE__ */ new Map();
+      for (const file of filesArray) {
+        newContents.set(file.path, file.content);
+      }
+      setFileContents(newContents);
+      const newTree = [];
+      for (const file of filesArray) {
+        const parts = file.path.split("/").filter(Boolean);
+        let current = newTree;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          const isFile = i === parts.length - 1;
+          const currentPath = "/" + parts.slice(0, i + 1).join("/");
+          let node = current.find((n) => n.name === part);
+          if (!node) {
+            node = {
+              path: currentPath,
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? void 0 : []
+            };
+            current.push(node);
+          }
+          if (!isFile && node && node.children) {
+            current = node.children;
+          }
+        }
+      }
+      setFiles(newTree);
+      setStatus("running");
+    } catch (err) {
+      log.error("Failed to mount files", { error: err instanceof Error ? err : String(err) });
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const readFile = useCallback(async (path) => {
+    return fileContents.get(path) || "";
+  }, [fileContents]);
+  const writeFile = useCallback(async (path, content) => {
+    setFileContents((prev) => {
+      const next = new Map(prev);
+      next.set(path, content);
+      return next;
+    });
+  }, []);
+  const selectFile = useCallback(async (path) => {
+    const content = fileContents.get(path) || "";
+    const ext = path.split(".").pop()?.toLowerCase() || "";
+    const languageMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      json: "json",
+      md: "markdown",
+      css: "css",
+      html: "html",
+      orb: "json"
+    };
+    setSelectedPath(path);
+    setSelectedFile({
+      path,
+      content,
+      language: languageMap[ext] || "plaintext",
+      isDirty: false
+    });
+  }, [fileContents]);
+  const updateContent = useCallback((pathOrContent, contentArg) => {
+    const path = contentArg !== void 0 ? pathOrContent : selectedPath;
+    const content = contentArg !== void 0 ? contentArg : pathOrContent;
+    if (!path) {
+      log.warn("updateContent called without path and no file selected");
+      return;
+    }
+    setFileContents((prev) => {
+      const next = new Map(prev);
+      next.set(path, content);
+      return next;
+    });
+    if (selectedPath === path) {
+      setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
+    }
+  }, [selectedPath]);
+  const updateSelectedContent = useCallback((content) => {
+    setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
+  }, []);
+  const refreshTree = useCallback(async () => {
+    log.debug("Refreshing tree");
+  }, []);
+  const runCommand = useCallback(async (command) => {
+    log.debug("Running command", { command });
+    return { exitCode: 0, output: "" };
+  }, []);
+  const startDevServer = useCallback(async () => {
+    log.debug("Starting dev server");
+    setPreviewUrl("http://localhost:5173");
+  }, []);
+  return {
+    status,
+    error,
+    isLoading,
+    files,
+    selectedFile,
+    selectedPath,
+    previewUrl,
+    boot,
+    mountFiles,
+    readFile,
+    writeFile,
+    selectFile,
+    updateContent,
+    updateSelectedContent,
+    refreshTree,
+    runCommand,
+    startDevServer
+  };
+}
+var log2 = createLogger("almadar:ui:extensions");
+var defaultManifest = {
+  languages: {
+    typescript: { extensions: [".ts", ".tsx"], icon: "ts", color: "#3178c6" },
+    javascript: { extensions: [".js", ".jsx"], icon: "js", color: "#f7df1e" },
+    json: { extensions: [".json", ".orb"], icon: "json", color: "#000000" },
+    css: { extensions: [".css"], icon: "css", color: "#264de4" },
+    html: { extensions: [".html"], icon: "html", color: "#e34c26" },
+    markdown: { extensions: [".md", ".mdx"], icon: "md", color: "#083fa1" }
+  },
+  extensions: []
+};
+function useExtensions(options) {
+  const { appId, loadOnMount = true } = options;
+  const [extensions, setExtensions] = useState([]);
+  const [manifest] = useState(defaultManifest);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadExtension = useCallback(async (extensionId) => {
+    log2.debug("Loading extension", { extensionId });
+  }, []);
+  const loadExtensions = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const defaultExtensions = [
+        { id: "typescript", name: "TypeScript", language: "typescript", loaded: true },
+        { id: "javascript", name: "JavaScript", language: "javascript", loaded: true },
+        { id: "json", name: "JSON", language: "json", loaded: true },
+        { id: "css", name: "CSS", language: "css", loaded: true },
+        { id: "html", name: "HTML", language: "html", loaded: true },
+        { id: "markdown", name: "Markdown", language: "markdown", loaded: true }
+      ];
+      setExtensions(defaultExtensions);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load extensions");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const getExtensionForFile = useCallback((filename) => {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    if (!ext) return null;
+    const languageMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      json: "json",
+      md: "markdown",
+      css: "css",
+      html: "html",
+      orb: "json"
+    };
+    const language = languageMap[ext];
+    if (!language) return null;
+    return extensions.find((e) => e.language === language) || null;
+  }, [extensions]);
+  useEffect(() => {
+    if (!appId || !loadOnMount) return;
+    const loadExtensions2 = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const defaultExtensions = [
+          { id: "typescript", name: "TypeScript", language: "typescript", loaded: true },
+          { id: "javascript", name: "JavaScript", language: "javascript", loaded: true },
+          { id: "json", name: "JSON", language: "json", loaded: true },
+          { id: "css", name: "CSS", language: "css", loaded: true },
+          { id: "html", name: "HTML", language: "html", loaded: true },
+          { id: "markdown", name: "Markdown", language: "markdown", loaded: true }
+        ];
+        setExtensions(defaultExtensions);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load extensions");
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    loadExtensions2();
+  }, [appId, loadOnMount]);
+  return {
+    extensions,
+    manifest,
+    isLoading,
+    error,
+    loadExtension,
+    loadExtensions,
+    getExtensionForFile
+  };
+}
+var log3 = createLogger("almadar:ui:file-editor");
+function parseSchemaText(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function useFileEditor(options) {
+  const { extensions, fileSystem, onSchemaUpdate } = options;
+  const [openFiles, setOpenFiles] = useState([]);
+  const [activeFilePath, setActiveFilePath] = useState(null);
+  const [isSaving, setIsSaving] = useState(false);
+  const activeFile = openFiles.find((f) => f.path === activeFilePath) || null;
+  const openFile = useCallback(async (path) => {
+    const existing = openFiles.find((f) => f.path === path);
+    if (existing) {
+      setActiveFilePath(path);
+      return;
+    }
+    try {
+      const content = await fileSystem.readFile(path);
+      const ext = extensions.getExtensionForFile(path);
+      const newFile = {
+        path,
+        content,
+        isDirty: false,
+        language: ext?.language
+      };
+      setOpenFiles((prev) => [...prev, newFile]);
+      setActiveFilePath(path);
+    } catch (err) {
+      log3.error("Failed to open file", { error: err instanceof Error ? err : String(err) });
+    }
+  }, [openFiles, fileSystem, extensions]);
+  const closeFile = useCallback((path) => {
+    setOpenFiles((prev) => prev.filter((f) => f.path !== path));
+    if (activeFilePath === path) {
+      const remaining = openFiles.filter((f) => f.path !== path);
+      setActiveFilePath(remaining.length > 0 ? remaining[0].path : null);
+    }
+  }, [activeFilePath, openFiles]);
+  const setActiveFile = useCallback((path) => {
+    setActiveFilePath(path);
+  }, []);
+  const updateFileContent = useCallback((path, content) => {
+    setOpenFiles(
+      (prev) => prev.map(
+        (f) => f.path === path ? { ...f, content, isDirty: true } : f
+      )
+    );
+  }, []);
+  const handleFileEdit = useCallback(async (path, content) => {
+    try {
+      await fileSystem.writeFile(path, content);
+      let action = "saved";
+      if (path.endsWith(".orb") || path.endsWith("schema.json")) {
+        const schema = parseSchemaText(content);
+        if (schema !== null) {
+          await onSchemaUpdate?.(schema);
+          action = "updated_schema";
+        } else {
+          log3.warn("schema-file-not-json", { path });
+        }
+      } else if (path.includes("/extensions/")) {
+        action = path.endsWith(".new") ? "converted_extension" : "saved_extension";
+      }
+      return { success: true, action };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to save file"
+      };
+    }
+  }, [fileSystem, onSchemaUpdate]);
+  const saveFile = useCallback(async (path) => {
+    const file = openFiles.find((f) => f.path === path);
+    if (!file) return;
+    setIsSaving(true);
+    try {
+      await fileSystem.writeFile(path, file.content);
+      setOpenFiles(
+        (prev) => prev.map(
+          (f) => f.path === path ? { ...f, isDirty: false } : f
+        )
+      );
+      if (path.endsWith(".orb") || path.endsWith("schema.json")) {
+        const schema = parseSchemaText(file.content);
+        if (schema !== null) await onSchemaUpdate?.(schema);
+        else log3.warn("schema-file-not-json", { path });
+      }
+    } catch (err) {
+      log3.error("Failed to save file", { error: err instanceof Error ? err : String(err) });
+    } finally {
+      setIsSaving(false);
+    }
+  }, [openFiles, fileSystem, onSchemaUpdate]);
+  const saveAllFiles = useCallback(async () => {
+    setIsSaving(true);
+    try {
+      const dirtyFiles = openFiles.filter((f) => f.isDirty);
+      for (const file of dirtyFiles) {
+        await saveFile(file.path);
+      }
+    } finally {
+      setIsSaving(false);
+    }
+  }, [openFiles, saveFile]);
+  return {
+    openFiles,
+    activeFile,
+    isSaving,
+    openFile,
+    closeFile,
+    setActiveFile,
+    updateFileContent,
+    handleFileEdit,
+    saveFile,
+    saveAllFiles
+  };
+}
+var log4 = createLogger("almadar:ui:compile");
+function useCompile() {
+  const [isCompiling, setIsCompiling] = useState(false);
+  const [stage, setStage] = useState("idle");
+  const [lastResult, setLastResult] = useState(null);
+  const [error, setError] = useState(null);
+  const compileSchema = useCallback(async (schema) => {
+    setIsCompiling(true);
+    setStage("compiling");
+    setError(null);
+    try {
+      log4.debug("Compiling schema", { name: schema.name });
+      const result = {
+        success: true,
+        files: []
+      };
+      setLastResult(result);
+      setStage("done");
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Compilation failed";
+      setError(errorMessage);
+      setStage("error");
+      setLastResult({ success: false, errors: [errorMessage] });
+      return null;
+    } finally {
+      setIsCompiling(false);
+    }
+  }, []);
+  return {
+    isCompiling,
+    stage,
+    lastResult,
+    error,
+    compileSchema
+  };
+}
+var log5 = createLogger("almadar:ui:preview");
+function usePreview(options) {
+  const [previewUrl, setPreviewUrl] = useState(null);
+  const [isLoading, setIsLoading] = useState(!!options?.appId);
+  const [error, setError] = useState(null);
+  const [loadError, setLoadError] = useState(null);
+  const [app, setApp] = useState(null);
+  const [isFullscreen, setIsFullscreen] = useState(false);
+  const [isExecutingEvent, setIsExecutingEvent] = useState(false);
+  const [errorToast, setErrorToast] = useState(null);
+  const [currentStateName, setCurrentStateName] = useState(null);
+  const [notificationsList, setNotificationsList] = useState([]);
+  const [isPanelOpen, setIsPanelOpen] = useState(false);
+  const notifications = useMemo(() => ({
+    notifications: notificationsList,
+    isPanelOpen,
+    closePanel: () => setIsPanelOpen(false),
+    dismissNotification: (id) => {
+      setNotificationsList((prev) => prev.filter((n) => n.id !== id));
+    },
+    markAsRead: (id) => {
+      setNotificationsList(
+        (prev) => prev.map((n) => n.id === id ? { ...n, read: true } : n)
+      );
+    },
+    clearAll: () => setNotificationsList([])
+  }), [notificationsList, isPanelOpen]);
+  useEffect(() => {
+    const appId = options?.appId;
+    if (!appId) {
+      setApp(null);
+      setIsLoading(false);
+      return;
+    }
+    log5.debug("Setting up preview for app", { appId });
+    setPreviewUrl(`/api/orbitals/${appId}`);
+    setIsLoading(false);
+  }, [options?.appId]);
+  const startPreview = useCallback(async () => {
+    log5.debug("startPreview called");
+  }, []);
+  const stopPreview = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      log5.debug("Stopping preview server");
+      setPreviewUrl(null);
+      setApp(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const refresh = useCallback(async () => {
+    if (!previewUrl) return;
+    log5.debug("Refreshing preview");
+    setPreviewUrl(`${previewUrl.split("?")[0]}?t=${Date.now()}`);
+  }, [previewUrl]);
+  const handleRefresh = useCallback(async () => {
+    log5.debug("Handle refresh");
+    await refresh();
+  }, [refresh]);
+  const handleReset = useCallback(async () => {
+    log5.debug("Resetting preview");
+    setError(null);
+    setLoadError(null);
+    setErrorToast(null);
+    setIsExecutingEvent(false);
+    setCurrentStateName(null);
+  }, []);
+  const toggleFullscreen = useCallback(() => {
+    setIsFullscreen((prev) => !prev);
+  }, []);
+  const dismissErrorToast = useCallback(() => {
+    setErrorToast(null);
+  }, []);
+  return {
+    previewUrl,
+    isLoading,
+    error,
+    loadError,
+    app,
+    isFullscreen,
+    isExecutingEvent,
+    errorToast,
+    currentStateName,
+    notifications,
+    startPreview,
+    stopPreview,
+    refresh,
+    handleRefresh,
+    handleReset,
+    toggleFullscreen,
+    setErrorToast,
+    dismissErrorToast
+  };
+}
+var log6 = createLogger("almadar:ui:agent-chat");
+function useAgentChat(options) {
+  const [messages, setMessages] = useState([]);
+  const [status, setStatus] = useState("idle");
+  const [activities, setActivities] = useState([]);
+  const [todos, setTodos] = useState([]);
+  const [schemaDiffs, setSchemaDiffs] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [threadId] = useState(null);
+  const [interrupt, setInterrupt] = useState(null);
+  const sendMessage = useCallback(async (content) => {
+    setIsLoading(true);
+    setStatus("running");
+    setError(null);
+    try {
+      const userMessage = {
+        id: Date.now().toString(),
+        role: "user",
+        content,
+        timestamp: Date.now()
+      };
+      setMessages((prev) => [...prev, userMessage]);
+      log6.debug("Sending message", { content });
+      const assistantMessage = {
+        id: (Date.now() + 1).toString(),
+        role: "assistant",
+        content: "Agent chat is not yet implemented.",
+        timestamp: Date.now()
+      };
+      setMessages((prev) => [...prev, assistantMessage]);
+      setStatus("idle");
+      options?.onComplete?.();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to send message");
+      setStatus("error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options]);
+  const startGeneration = useCallback(async (skill, prompt, genOptions) => {
+    setStatus("running");
+    setIsLoading(true);
+    setError(null);
+    const skillName = Array.isArray(skill) ? skill[0] : skill;
+    try {
+      log6.debug("Starting generation", () => ({ skillName, prompt, genOptions: JSON.stringify(genOptions) }));
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      setStatus("complete");
+      options?.onComplete?.();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Generation failed");
+      setStatus("error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options]);
+  const continueConversation = useCallback(async (message) => {
+    log6.debug("Continue conversation", { message: Array.isArray(message) ? message : [message] });
+  }, []);
+  const resumeWithDecision = useCallback(async (decisions) => {
+    log6.debug("Resume with decision", () => ({ decisions: JSON.stringify(decisions), count: decisions.length }));
+    setInterrupt(null);
+  }, []);
+  const cancel = useCallback(() => {
+    setStatus("idle");
+    setIsLoading(false);
+    setInterrupt(null);
+  }, []);
+  const clearMessages = useCallback(() => {
+    setMessages([]);
+  }, []);
+  const clearHistory = useCallback(() => {
+    setMessages([]);
+    setActivities([]);
+    setTodos([]);
+    setSchemaDiffs([]);
+    setError(null);
+  }, []);
+  return {
+    messages,
+    status,
+    activities,
+    todos,
+    schemaDiffs,
+    isLoading,
+    error,
+    threadId,
+    interrupt,
+    sendMessage,
+    startGeneration,
+    continueConversation,
+    resumeWithDecision,
+    cancel,
+    clearMessages,
+    clearHistory
+  };
+}
+var log7 = createLogger("almadar:ui:validation");
+function useValidation() {
+  const [result, setResult] = useState(null);
+  const [isValidating, setIsValidating] = useState(false);
+  const [error, setError] = useState(null);
+  const [stage, setStage] = useState("idle");
+  const [isFixing, setIsFixing] = useState(false);
+  const [progressMessage, setProgressMessage] = useState(null);
+  const validate = useCallback(async (appId) => {
+    setIsValidating(true);
+    setError(null);
+    setStage("validating");
+    setProgressMessage("Validating schema...");
+    try {
+      log7.debug("Validating app", { appId });
+      const validationResult = {
+        valid: true,
+        errors: [],
+        warnings: []
+      };
+      setResult(validationResult);
+      setStage("complete");
+      setProgressMessage(null);
+      return validationResult;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Validation failed";
+      setError(errorMessage);
+      const failedResult = {
+        valid: false,
+        errors: [{ code: "VALIDATION_ERROR", message: errorMessage, severity: "error" }],
+        warnings: []
+      };
+      setResult(failedResult);
+      setStage("complete");
+      setProgressMessage(null);
+      return failedResult;
+    } finally {
+      setIsValidating(false);
+    }
+  }, []);
+  const clearResult = useCallback(() => {
+    setResult(null);
+    setError(null);
+  }, []);
+  const reset = useCallback(() => {
+    setResult(null);
+    setError(null);
+    setStage("idle");
+    setIsFixing(false);
+    setProgressMessage(null);
+    setIsValidating(false);
+  }, []);
+  return {
+    result,
+    isValidating,
+    error,
+    stage,
+    isFixing,
+    progressMessage,
+    errors: result?.errors ?? [],
+    warnings: result?.warnings ?? [],
+    isValid: result?.valid ?? false,
+    validate,
+    clearResult,
+    reset
+  };
+}
+var log8 = createLogger("almadar:ui:deep-agent");
+function useDeepAgentGeneration() {
+  const [requests, setRequests] = useState([]);
+  const [currentRequest, setCurrentRequest] = useState(null);
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isComplete, setIsComplete] = useState(false);
+  const [progress, setProgress] = useState({ stage: "idle", percent: 0, message: "" });
+  const [error, setError] = useState(null);
+  const [interrupt, setInterrupt] = useState(null);
+  const generate = useCallback(async (prompt) => {
+    setIsGenerating(true);
+    setIsLoading(true);
+    setIsComplete(false);
+    setError(null);
+    setProgress({ stage: "starting", percent: 0, message: "Starting generation..." });
+    const request = {
+      id: Date.now().toString(),
+      prompt,
+      status: "running"
+    };
+    setCurrentRequest(request);
+    setRequests((prev) => [...prev, request]);
+    try {
+      log8.debug("Generating from prompt", { prompt });
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      request.status = "completed";
+      setCurrentRequest(request);
+      setIsComplete(true);
+      setProgress({ stage: "complete", percent: 100, message: "Generation complete" });
+      return null;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Generation failed";
+      setError(errorMessage);
+      request.status = "failed";
+      request.error = errorMessage;
+      setCurrentRequest(request);
+      return null;
+    } finally {
+      setIsGenerating(false);
+      setIsLoading(false);
+    }
+  }, []);
+  const startGeneration = useCallback(async (skill, prompt, _options) => {
+    log8.debug("Starting generation with skill", { skill });
+    await generate(prompt);
+  }, [generate]);
+  const cancelGeneration = useCallback(() => {
+    if (currentRequest) {
+      currentRequest.status = "failed";
+      currentRequest.error = "Cancelled by user";
+      setCurrentRequest(null);
+    }
+    setIsGenerating(false);
+    setIsLoading(false);
+    setIsComplete(false);
+    setProgress({ stage: "idle", percent: 0, message: "" });
+  }, [currentRequest]);
+  const clearRequests = useCallback(() => {
+    setRequests([]);
+    setCurrentRequest(null);
+    setError(null);
+    setProgress({ stage: "idle", percent: 0, message: "" });
+    setIsComplete(false);
+  }, []);
+  const submitInterruptDecisions = useCallback((decisions) => {
+    log8.debug("Submitting interrupt decisions", () => ({ decisions: JSON.stringify(decisions), count: decisions.length }));
+    setInterrupt(null);
+  }, []);
+  return {
+    requests,
+    currentRequest,
+    isGenerating,
+    isLoading,
+    isComplete,
+    progress,
+    error,
+    interrupt,
+    generate,
+    startGeneration,
+    cancelGeneration,
+    clearRequests,
+    submitInterruptDecisions
+  };
+}
+var UI_PREFIX = "UI:";
+function useUIEvents(dispatch, traitName, validEvents, eventBusInstance) {
+  const defaultEventBus = useEventBus();
+  const eventBus = eventBusInstance ?? defaultEventBus;
+  const validEventsKey = validEvents.slice().sort().join(",");
+  const stableValidEvents = useMemo(
+    () => validEvents,
+    [validEventsKey]
+    // intentional — validEventsKey is the stable dep
+  );
+  useEffect(() => {
+    const unsubscribes = [];
+    for (const smEvent of stableValidEvents) {
+      const handler = (event) => {
+        if (event.source && event.source.dispatched) {
+          return;
+        }
+        if (!claimDelivery(event.source, traitName, smEvent)) return;
+        const pendingKey = event.source?.pendingKey;
+        const settled = dispatch(smEvent, event.payload);
+        if (pendingKey !== void 0 && settled instanceof Promise) {
+          beginPending(pendingKey);
+          void settled.finally(() => endPending(pendingKey));
+        }
+      };
+      unsubscribes.push(
+        eventBus.on(`${UI_PREFIX}${traitName}.${smEvent}`, handler)
+      );
+    }
+    return () => {
+      for (const unsub of unsubscribes) {
+        if (typeof unsub === "function") unsub();
+      }
+    };
+  }, [eventBus, dispatch, traitName, stableValidEvents]);
+}
+function useTraitListens(dispatch, listens, eventBusInstance) {
+  const defaultEventBus = useEventBus();
+  const eventBus = eventBusInstance ?? defaultEventBus;
+  const stableKey = listens.map((l) => `${l.sourceKey}->${l.trigger}`).sort().join("|");
+  const stableListens = useMemo(
+    () => listens,
+    [stableKey]
+    // intentional
+  );
+  useEffect(() => {
+    const unsubscribes = [];
+    for (const spec of stableListens) {
+      const handler = (event) => {
+        dispatch(spec.trigger, event.payload);
+      };
+      unsubscribes.push(eventBus.on(`${UI_PREFIX}${spec.sourceKey}`, handler));
+    }
+    return () => {
+      for (const unsub of unsubscribes) {
+        if (typeof unsub === "function") unsub();
+      }
+    };
+  }, [eventBus, dispatch, stableListens]);
+}
+var log9 = createLogger("almadar:ui:shared-entity-store");
+var EMPTY_ENTITY_STATE = {};
+function createSharedEntityStore() {
+  const states = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  const getSnapshot = (entityId) => states.get(entityId) ?? EMPTY_ENTITY_STATE;
+  const subscribe = (entityId, callback) => {
+    let set = subscribers.get(entityId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      subscribers.set(entityId, set);
+    }
+    set.add(callback);
+    return () => {
+      const current = subscribers.get(entityId);
+      if (!current) return;
+      current.delete(callback);
+      if (current.size === 0) {
+        subscribers.delete(entityId);
+      }
+    };
+  };
+  const commit = (entityId, nextState) => {
+    states.set(entityId, nextState);
+    const set = subscribers.get(entityId);
+    if (!set) return;
+    set.forEach((callback) => {
+      try {
+        callback();
+      } catch (error) {
+        log9.error("Shared entity subscriber error", {
+          entityId,
+          error: error instanceof Error ? error : String(error)
+        });
+      }
+    });
+  };
+  const seed = (entityId, initialState) => {
+    if (!states.has(entityId)) {
+      states.set(entityId, initialState);
+    }
+  };
+  return { getSnapshot, subscribe, commit, seed };
+}
+function useSharedEntityStore() {
+  const storeRef = useRef(null);
+  if (storeRef.current === null) {
+    storeRef.current = createSharedEntityStore();
+  }
+  return storeRef.current;
+}
+var SharedEntityStoreContext = createContext(null);
+function useSharedEntityStoreContext() {
+  const store = useContext(SharedEntityStoreContext);
+  if (!store) {
+    throw new Error(
+      "useSharedEntityStoreContext: no SharedEntityStoreContext.Provider found in the component tree"
+    );
+  }
+  return store;
+}
+function useSharedEntitySnapshot(store, entityId) {
+  return useSyncExternalStore(
+    (onStoreChange) => store.subscribe(entityId, onStoreChange),
+    () => store.getSnapshot(entityId)
+  );
+}
+function runTickFrame(entityId, orderedWriters, store) {
+  let scratch = store.getSnapshot(entityId);
+  for (const writer of orderedWriters) {
+    const writes = writer(scratch);
+    scratch = mergeEntityFrame(scratch, writes);
+  }
+  store.commit(entityId, scratch);
+  return scratch;
+}
+var log10 = createLogger("almadar:ui:render-interpolation");
+function useRenderInterpolation(options = {}) {
+  const tickIntervalMs = options.tickIntervalMs ?? 1e3 / 30;
+  const prevRef = useRef(null);
+  const currRef = useRef(null);
+  const rafRef = useRef(null);
+  const onSnapshot = useCallback((entities) => {
+    prevRef.current = currRef.current;
+    currRef.current = { entities, arrivedAt: performance.now() };
+  }, []);
+  const getInterpolated = useCallback((now) => {
+    const out = /* @__PURE__ */ new Map();
+    const curr = currRef.current;
+    if (!curr) return out;
+    const prev = prevRef.current;
+    if (!prev) {
+      for (const e of curr.entities) out.set(e.id, { x: e.x, y: e.y });
+      return out;
+    }
+    const rawAlpha = (now - curr.arrivedAt) / tickIntervalMs;
+    const alpha = rawAlpha < 0 ? 0 : rawAlpha > 1 ? 1 : rawAlpha;
+    const prevMap = /* @__PURE__ */ new Map();
+    for (const e of prev.entities) prevMap.set(e.id, e);
+    for (const c of curr.entities) {
+      const p = prevMap.get(c.id);
+      if (!p) {
+        out.set(c.id, { x: c.x, y: c.y });
+      } else {
+        out.set(c.id, {
+          x: p.x + (c.x - p.x) * alpha,
+          y: p.y + (c.y - p.y) * alpha
+        });
+      }
+    }
+    return out;
+  }, [tickIntervalMs]);
+  const startLoop = useCallback(
+    (draw) => {
+      let active = true;
+      let reported = false;
+      const loop = () => {
+        if (!active) return;
+        try {
+          draw(getInterpolated(performance.now()));
+        } catch (error) {
+          if (!reported) log10.error("draw-failed", { error: error instanceof Error ? error.message : String(error) });
+          reported = true;
+        }
+        rafRef.current = requestAnimationFrame(loop);
+      };
+      rafRef.current = requestAnimationFrame(loop);
+      return () => {
+        active = false;
+        if (rafRef.current !== null) {
+          cancelAnimationFrame(rafRef.current);
+          rafRef.current = null;
+        }
+      };
+    },
+    [getInterpolated]
+  );
+  useEffect(() => {
+    return () => {
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+    };
+  }, []);
+  return { onSnapshot, getInterpolated, startLoop };
+}
+var API_BASE = typeof process !== "undefined" && process.env?.VITE_API_URL ? process.env.VITE_API_URL : "http://localhost:3000";
+function getUserId() {
+  return localStorage.getItem("userId") || "anonymous";
+}
+async function fetchWithAuth(endpoint, options) {
+  const userId = getUserId();
+  const response = await fetch(`${API_BASE}${endpoint}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      "x-user-id": userId,
+      ...options?.headers
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: response.statusText }));
+    throw new Error(error.error || error.message || "Request failed");
+  }
+  return response.json();
+}
+function useGitHubStatus() {
+  return useQuery({
+    queryKey: ["github", "status"],
+    queryFn: () => fetchWithAuth("/api/github/status"),
+    staleTime: 6e4,
+    // 1 minute
+    retry: false
+  });
+}
+function useConnectGitHub() {
+  const connectGitHub = useCallback(() => {
+    const userId = getUserId();
+    const state = btoa(JSON.stringify({ userId, returnUrl: window.location.href }));
+    window.location.href = `${API_BASE}/api/github/oauth/authorize?state=${state}`;
+  }, []);
+  return { connectGitHub };
+}
+function useDisconnectGitHub() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: () => fetchWithAuth("/api/github/disconnect", { method: "POST" }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["github", "status"] });
+      queryClient.removeQueries({ queryKey: ["github", "repos"] });
+    }
+  });
+}
+function useGitHubRepos(page = 1, perPage = 30) {
+  return useQuery({
+    queryKey: ["github", "repos", page, perPage],
+    queryFn: () => fetchWithAuth(`/api/github/repos?page=${page}&per_page=${perPage}`),
+    enabled: true,
+    // Only fetch if user is connected
+    staleTime: 3e5
+    // 5 minutes
+  });
+}
+function useGitHubRepo(owner, repo, enabled = true) {
+  return useQuery({
+    queryKey: ["github", "repo", owner, repo],
+    queryFn: () => fetchWithAuth(`/api/github/repos/${owner}/${repo}`),
+    enabled: enabled && !!owner && !!repo,
+    staleTime: 3e5
+    // 5 minutes
+  });
+}
+function useGitHubBranches(owner, repo, enabled = true) {
+  return useQuery({
+    queryKey: ["github", "branches", owner, repo],
+    queryFn: () => fetchWithAuth(`/api/github/repos/${owner}/${repo}/branches`),
+    enabled: enabled && !!owner && !!repo,
+    staleTime: 6e4
+    // 1 minute
+  });
+}
+function useTickVisibility(traits) {
+  const key = traits.join("\0");
+  useEffect(() => getTraitPresence().watch(key.split("\0")), [key]);
+  return useCallback(() => getTraitPresence().state(key.split("\0")) !== "off-screen", [key]);
+}
+
+export { SharedEntityStoreContext, createSharedEntityStore, runTickFrame, useAgentChat, useCompile, useConnectGitHub, useDeepAgentGeneration, useDisconnectGitHub, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, usePreview, useRenderInterpolation, useSharedEntitySnapshot, useSharedEntityStore, useSharedEntityStoreContext, useTickVisibility, useTraitListens, useUIEvents, useValidation };