@almadar/ui 5.79.1 → 5.79.2

package/dist/hooks/index.js

@@ -0,0 +1,2738 @@
+import { createContext, useCallback, useState, useEffect, useMemo, useContext, useRef } from 'react';
+import { createLogger } from '@almadar/logger';
+import { EventBusContext, useTraitScope } from '@almadar/ui/providers';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+
+var log = createLogger("almadar:ui:orbital-history");
+function useOrbitalHistory(options) {
+  const { appId, authToken, userId, onHistoryChange, onRevertSuccess } = options;
+  const getHeaders = useCallback(() => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    if (userId) {
+      headers["x-user-id"] = userId;
+    }
+    return headers;
+  }, [authToken, userId]);
+  const [timeline, setTimeline] = useState([]);
+  const [currentVersion, setCurrentVersion] = useState(1);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    if (!appId) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const headers = getHeaders();
+      const [changesetsRes, snapshotsRes] = await Promise.all([
+        fetch(`/api/graphs/${appId}/history/changesets`, { headers }),
+        fetch(`/api/graphs/${appId}/history/snapshots`, { headers })
+      ]);
+      if (!changesetsRes.ok) {
+        throw new Error(`Failed to fetch changesets: ${changesetsRes.status}`);
+      }
+      if (!snapshotsRes.ok) {
+        throw new Error(`Failed to fetch snapshots: ${snapshotsRes.status}`);
+      }
+      const changesetsData = await changesetsRes.json();
+      const snapshotsData = await snapshotsRes.json();
+      const changesetItems = (changesetsData.changesets || []).map((cs) => ({
+        id: cs.id,
+        type: "changeset",
+        version: cs.version,
+        timestamp: cs.timestamp,
+        description: `Version ${cs.version}`,
+        source: cs.source,
+        summary: cs.summary
+      }));
+      const snapshotItems = (snapshotsData.snapshots || []).map((snap) => ({
+        id: snap.id,
+        type: "snapshot",
+        version: snap.version,
+        timestamp: snap.timestamp,
+        description: snap.reason || `Snapshot v${snap.version}`,
+        reason: snap.reason
+      }));
+      const mergedTimeline = [...changesetItems, ...snapshotItems].sort(
+        (a, b) => b.timestamp - a.timestamp
+      );
+      setTimeline(mergedTimeline);
+      if (mergedTimeline.length > 0) {
+        setCurrentVersion(mergedTimeline[0].version);
+      }
+    } catch (err) {
+      log.error("Failed to load history", { error: err instanceof Error ? err : String(err) });
+      setError(err instanceof Error ? err.message : "Failed to load history");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [appId, getHeaders]);
+  const revertToSnapshot = useCallback(async (snapshotId) => {
+    if (!appId) {
+      return { success: false, error: "No app ID provided" };
+    }
+    try {
+      const response = await fetch(`/api/graphs/${appId}/history/revert/${snapshotId}`, {
+        method: "POST",
+        headers: getHeaders()
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.error || `Failed to revert: ${response.status}`);
+      }
+      const data = await response.json();
+      if (data.success && data.schema) {
+        await refresh();
+        onRevertSuccess?.(data.schema);
+        return {
+          success: true,
+          restoredSchema: data.schema
+        };
+      }
+      return {
+        success: false,
+        error: data.error || "Unknown error during revert"
+      };
+    } catch (err) {
+      log.error("Failed to revert", { error: err instanceof Error ? err : String(err) });
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to revert"
+      };
+    }
+  }, [appId, getHeaders, refresh, onRevertSuccess]);
+  useEffect(() => {
+    if (appId && authToken && userId) {
+      refresh();
+    }
+  }, [appId, authToken, userId]);
+  useEffect(() => {
+    onHistoryChange?.(timeline);
+  }, [timeline]);
+  return {
+    timeline,
+    currentVersion,
+    isLoading,
+    error,
+    revertToSnapshot,
+    refresh
+  };
+}
+var log2 = 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 {
+      log2.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) {
+      log2.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) {
+      log2.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 () => {
+    log2.debug("Refreshing tree");
+  }, []);
+  const runCommand = useCallback(async (command) => {
+    log2.debug("Running command", { command });
+    return { exitCode: 0, output: "" };
+  }, []);
+  const startDevServer = useCallback(async () => {
+    log2.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 log3 = 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) => {
+    log3.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 log4 = createLogger("almadar:ui:file-editor");
+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) {
+      log4.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")) {
+        try {
+          const schema = JSON.parse(content);
+          await onSchemaUpdate?.(schema);
+          action = "updated_schema";
+        } catch {
+        }
+      } else if (path.includes("/extensions/")) {
+        action = path.endsWith(".new") ? "converted_extension" : "saved_extension";
+      }
+      return { success: true, action };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to save file"
+      };
+    }
+  }, [fileSystem, onSchemaUpdate]);
+  const saveFile = useCallback(async (path) => {
+    const file = openFiles.find((f) => f.path === path);
+    if (!file) return;
+    setIsSaving(true);
+    try {
+      await fileSystem.writeFile(path, file.content);
+      setOpenFiles(
+        (prev) => prev.map(
+          (f) => f.path === path ? { ...f, isDirty: false } : f
+        )
+      );
+      if (path.endsWith(".orb") || path.endsWith("schema.json")) {
+        try {
+          const schema = JSON.parse(file.content);
+          await onSchemaUpdate?.(schema);
+        } catch {
+        }
+      }
+    } catch (err) {
+      log4.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 log5 = 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 {
+      log5.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 log6 = 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;
+    }
+    log6.debug("Setting up preview for app", { appId });
+    setPreviewUrl(`/api/orbitals/${appId}`);
+    setIsLoading(false);
+  }, [options?.appId]);
+  const startPreview = useCallback(async () => {
+    log6.debug("startPreview called");
+  }, []);
+  const stopPreview = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      log6.debug("Stopping preview server");
+      setPreviewUrl(null);
+      setApp(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const refresh = useCallback(async () => {
+    if (!previewUrl) return;
+    log6.debug("Refreshing preview");
+    setPreviewUrl(`${previewUrl.split("?")[0]}?t=${Date.now()}`);
+  }, [previewUrl]);
+  const handleRefresh = useCallback(async () => {
+    log6.debug("Handle refresh");
+    await refresh();
+  }, [refresh]);
+  const handleReset = useCallback(async () => {
+    log6.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 log7 = 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]);
+      log7.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 {
+      log7.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) => {
+    log7.debug("Continue conversation", { message: Array.isArray(message) ? message : [message] });
+  }, []);
+  const resumeWithDecision = useCallback(async (decisions) => {
+    log7.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 log8 = 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 {
+      log8.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 log9 = 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 {
+      log9.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) => {
+    log9.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) => {
+    log9.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 log10 = createLogger("almadar:eventbus");
+var subLog = createLogger("almadar:eventbus:subscribe");
+var scopeLog = createLogger("almadar:ui:trait-scope");
+function getGlobalEventBus() {
+  if (typeof window !== "undefined") {
+    return window.__kflowEventBus ?? null;
+  }
+  return null;
+}
+var fallbackListeners = /* @__PURE__ */ new Map();
+var fallbackAnyListeners = /* @__PURE__ */ new Set();
+var fallbackEventBus = {
+  emit: (type, payload, source) => {
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now(),
+      source
+    };
+    const handlers = fallbackListeners.get(type);
+    log10.debug("emit", { type, payloadKeys: payload ? Object.keys(payload).length : 0, listenerCount: (handlers?.size ?? 0) + fallbackAnyListeners.size });
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          log10.error("Error in listener", { type, error: error instanceof Error ? error : String(error) });
+        }
+      });
+    }
+    fallbackAnyListeners.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (error) {
+        log10.error("Error in onAny listener", { type, error: error instanceof Error ? error : String(error) });
+      }
+    });
+  },
+  on: (type, listener) => {
+    if (!fallbackListeners.has(type)) {
+      fallbackListeners.set(type, /* @__PURE__ */ new Set());
+    }
+    fallbackListeners.get(type).add(listener);
+    subLog.debug("subscribe", { type, totalListeners: fallbackListeners.get(type).size });
+    return () => {
+      const handlers = fallbackListeners.get(type);
+      if (handlers) {
+        handlers.delete(listener);
+        if (handlers.size === 0) {
+          fallbackListeners.delete(type);
+        }
+      }
+    };
+  },
+  once: (type, listener) => {
+    const wrappedListener = (event) => {
+      fallbackListeners.get(type)?.delete(wrappedListener);
+      listener(event);
+    };
+    return fallbackEventBus.on(type, wrappedListener);
+  },
+  hasListeners: (type) => {
+    const handlers = fallbackListeners.get(type);
+    return handlers !== void 0 && handlers.size > 0;
+  },
+  onAny: (listener) => {
+    fallbackAnyListeners.add(listener);
+    subLog.debug("subscribe:any", { totalAnyListeners: fallbackAnyListeners.size });
+    return () => {
+      fallbackAnyListeners.delete(listener);
+    };
+  }
+};
+function useEventBus() {
+  const context = useContext(EventBusContext);
+  const baseBus = context ?? getGlobalEventBus() ?? fallbackEventBus;
+  const scope = useTraitScope();
+  return useMemo(() => {
+    if (!scope) {
+      return {
+        ...baseBus,
+        emit: (type, payload, source) => {
+          if (typeof type === "string" && type.startsWith("UI:") && !type.slice(3).includes(".")) {
+            scopeLog.warn("emit:bare-key-no-scope", { type });
+          }
+          baseBus.emit(type, payload, source);
+        }
+      };
+    }
+    return {
+      ...baseBus,
+      emit: (type, payload, source) => {
+        if (typeof type === "string" && type.startsWith("UI:")) {
+          const tail = type.slice(3);
+          const qualified = tail.includes(".") ? type : `UI:${scope.orbital}.${scope.trait}.${tail}`;
+          if (qualified !== type) {
+            scopeLog.info("emit:qualified", {
+              from: type,
+              to: qualified,
+              scopeOrbital: scope.orbital,
+              scopeTrait: scope.trait
+            });
+          }
+          baseBus.emit(qualified, payload, source);
+          return;
+        }
+        baseBus.emit(type, payload, source);
+      }
+    };
+  }, [baseBus, scope]);
+}
+function useEventListener(event, handler) {
+  const eventBus = useEventBus();
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+  useEffect(() => {
+    const wrappedHandler = (evt) => {
+      handlerRef.current(evt);
+    };
+    const unsub = eventBus.on(event, wrappedHandler);
+    return () => {
+      if (typeof unsub === "function") unsub();
+    };
+  }, [event, eventBus]);
+}
+function useEmitEvent() {
+  const eventBus = useEventBus();
+  return useCallback(
+    (type, payload, source) => {
+      eventBus.emit(type, payload, source);
+    },
+    [eventBus]
+  );
+}
+var log11 = createLogger("almadar:ui:ui-slots");
+var DEFAULT_SOURCE_KEY = "__default__";
+var MULTI_SOURCE_STACK_TRAIT = "__multi_source_stack__";
+var ALL_SLOTS = [
+  "main",
+  "sidebar",
+  "modal",
+  "drawer",
+  "overlay",
+  "center",
+  "toast",
+  "hud-top",
+  "hud-bottom",
+  "floating"
+];
+var DEFAULT_SLOTS = ALL_SLOTS.reduce(
+  (acc, slot) => {
+    acc[slot] = null;
+    return acc;
+  },
+  {}
+);
+var DEFAULT_SOURCES = ALL_SLOTS.reduce(
+  (acc, slot) => {
+    acc[slot] = {};
+    return acc;
+  },
+  {}
+);
+function aggregateSlot(sources) {
+  if (!sources) return null;
+  const entries = Object.entries(sources);
+  if (entries.length === 0) return null;
+  if (entries.length === 1) return entries[0][1];
+  const children = entries.map(([, entry]) => ({
+    type: entry.pattern,
+    ...entry.props
+  }));
+  const stackId = `slot-content-stack-${entries.map(([k]) => k).join("-")}`;
+  return {
+    id: stackId,
+    pattern: "stack",
+    props: {
+      direction: "vertical",
+      gap: "lg",
+      children
+    },
+    priority: 0,
+    animation: "fade",
+    sourceTrait: MULTI_SOURCE_STACK_TRAIT
+  };
+}
+function useUISlotManager() {
+  const [sources, setSources] = useState(DEFAULT_SOURCES);
+  const subscribersRef = useRef(/* @__PURE__ */ new Set());
+  const timersRef = useRef(/* @__PURE__ */ new Map());
+  const traitIndexRef = useRef(/* @__PURE__ */ new Map());
+  const traitSubscribersRef = useRef(/* @__PURE__ */ new Map());
+  const slots = useMemo(() => {
+    const out = { ...DEFAULT_SLOTS };
+    for (const slot of ALL_SLOTS) {
+      out[slot] = aggregateSlot(sources[slot]);
+    }
+    return out;
+  }, [sources]);
+  useEffect(() => {
+    return () => {
+      timersRef.current.forEach((timer) => clearTimeout(timer));
+      timersRef.current.clear();
+    };
+  }, []);
+  const notifySubscribers = useCallback((slot, content) => {
+    subscribersRef.current.forEach((callback) => {
+      try {
+        callback(slot, content);
+      } catch (error) {
+        log11.error("Subscriber error", { error: error instanceof Error ? error : String(error) });
+      }
+    });
+  }, []);
+  const notifyTraitSubscribers = useCallback(
+    (traitName, content) => {
+      const subs = traitSubscribersRef.current.get(traitName);
+      if (!subs) return;
+      subs.forEach((callback) => {
+        try {
+          callback(content);
+        } catch (error) {
+          log11.error("Trait subscriber error", { traitName, error: error instanceof Error ? error : String(error) });
+        }
+      });
+    },
+    []
+  );
+  const indexTraitRender = useCallback(
+    (traitName, content) => {
+      traitIndexRef.current.set(traitName, content);
+    },
+    []
+  );
+  const unindexTrait = useCallback((traitName) => {
+    traitIndexRef.current.delete(traitName);
+  }, []);
+  const render = useCallback(
+    (config) => {
+      const sourceKey = config.sourceTrait ?? DEFAULT_SOURCE_KEY;
+      const id = `slot-content-${config.target}-${sourceKey}`;
+      const content = {
+        id,
+        pattern: config.pattern,
+        props: config.props ?? {},
+        priority: config.priority ?? 0,
+        animation: config.animation ?? "fade",
+        onDismiss: config.onDismiss,
+        sourceTrait: config.sourceTrait,
+        slot: config.target,
+        transitionEvent: config.transitionEvent,
+        fromState: config.fromState,
+        entity: config.entity
+      };
+      if (config.autoDismissMs && config.autoDismissMs > 0) {
+        content.autoDismissAt = Date.now() + config.autoDismissMs;
+        const prevTimer = timersRef.current.get(id);
+        if (prevTimer) clearTimeout(prevTimer);
+        const timer = setTimeout(() => {
+          setSources((prev) => {
+            const slotSources = prev[config.target];
+            if (slotSources && slotSources[sourceKey] === content) {
+              content.onDismiss?.();
+              const next = { ...slotSources };
+              delete next[sourceKey];
+              const updated = { ...prev, [config.target]: next };
+              notifySubscribers(config.target, aggregateSlot(next));
+              return updated;
+            }
+            return prev;
+          });
+          timersRef.current.delete(id);
+        }, config.autoDismissMs);
+        timersRef.current.set(id, timer);
+      }
+      setSources((prev) => {
+        const slotSources = prev[config.target] ?? {};
+        const existing = slotSources[sourceKey];
+        if (existing && existing.priority > content.priority) {
+          log11.warn("Slot already has higher priority content", {
+            slot: config.target,
+            sourceKey,
+            existingPriority: existing.priority,
+            newPriority: content.priority
+          });
+          return prev;
+        }
+        const nextSources = {
+          ...slotSources,
+          [sourceKey]: content
+        };
+        const nextAll = { ...prev, [config.target]: nextSources };
+        if (content.sourceTrait) {
+          indexTraitRender(content.sourceTrait, content);
+          notifyTraitSubscribers(content.sourceTrait, content);
+        }
+        log11.info("slot:written", {
+          slot: config.target,
+          sourceKey,
+          sourceTrait: content.sourceTrait,
+          patternType: content.pattern,
+          priority: content.priority
+        });
+        notifySubscribers(config.target, aggregateSlot(nextSources));
+        return nextAll;
+      });
+      return id;
+    },
+    [notifySubscribers, notifyTraitSubscribers, indexTraitRender]
+  );
+  const clear = useCallback(
+    (slot) => {
+      setSources((prev) => {
+        const slotSources = prev[slot];
+        if (!slotSources || Object.keys(slotSources).length === 0) {
+          return prev;
+        }
+        for (const content of Object.values(slotSources)) {
+          const timer = timersRef.current.get(content.id);
+          if (timer) {
+            clearTimeout(timer);
+            timersRef.current.delete(content.id);
+          }
+          content.onDismiss?.();
+          if (content.sourceTrait) {
+            unindexTrait(content.sourceTrait);
+            notifyTraitSubscribers(content.sourceTrait, null);
+          }
+        }
+        notifySubscribers(slot, null);
+        return { ...prev, [slot]: {} };
+      });
+    },
+    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
+  );
+  const clearBySource = useCallback(
+    (slot, sourceTrait) => {
+      const sourceKey = sourceTrait;
+      setSources((prev) => {
+        const slotSources = prev[slot];
+        if (!slotSources || !(sourceKey in slotSources)) {
+          log11.debug("slot:clear-noop", { slot, sourceTrait, reason: !slotSources ? "no-slot" : "no-source" });
+          return prev;
+        }
+        const content = slotSources[sourceKey];
+        const timer = timersRef.current.get(content.id);
+        if (timer) {
+          clearTimeout(timer);
+          timersRef.current.delete(content.id);
+        }
+        content.onDismiss?.();
+        if (content.sourceTrait) {
+          unindexTrait(content.sourceTrait);
+          notifyTraitSubscribers(content.sourceTrait, null);
+        }
+        const nextSources = { ...slotSources };
+        delete nextSources[sourceKey];
+        log11.info("slot:cleared", { slot, sourceTrait, lastPatternType: content.pattern });
+        notifySubscribers(slot, aggregateSlot(nextSources));
+        return { ...prev, [slot]: nextSources };
+      });
+    },
+    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
+  );
+  const clearById = useCallback(
+    (id) => {
+      setSources((prev) => {
+        for (const slot of ALL_SLOTS) {
+          const slotSources = prev[slot];
+          if (!slotSources) continue;
+          const matchKey = Object.keys(slotSources).find(
+            (k) => slotSources[k].id === id
+          );
+          if (!matchKey) continue;
+          const content = slotSources[matchKey];
+          const timer = timersRef.current.get(id);
+          if (timer) {
+            clearTimeout(timer);
+            timersRef.current.delete(id);
+          }
+          content.onDismiss?.();
+          if (content.sourceTrait) {
+            unindexTrait(content.sourceTrait);
+            notifyTraitSubscribers(content.sourceTrait, null);
+          }
+          const nextSources = { ...slotSources };
+          delete nextSources[matchKey];
+          notifySubscribers(slot, aggregateSlot(nextSources));
+          return { ...prev, [slot]: nextSources };
+        }
+        return prev;
+      });
+    },
+    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
+  );
+  const clearAll = useCallback(() => {
+    timersRef.current.forEach((timer) => clearTimeout(timer));
+    timersRef.current.clear();
+    setSources((prev) => {
+      for (const slot of ALL_SLOTS) {
+        const slotSources = prev[slot];
+        if (!slotSources) continue;
+        for (const content of Object.values(slotSources)) {
+          content.onDismiss?.();
+          if (content.sourceTrait) {
+            notifyTraitSubscribers(content.sourceTrait, null);
+          }
+        }
+        notifySubscribers(slot, null);
+      }
+      return DEFAULT_SOURCES;
+    });
+    traitIndexRef.current.clear();
+  }, [notifySubscribers, notifyTraitSubscribers]);
+  const subscribe = useCallback((callback) => {
+    subscribersRef.current.add(callback);
+    return () => {
+      subscribersRef.current.delete(callback);
+    };
+  }, []);
+  const hasContent = useCallback(
+    (slot) => slots[slot] !== null,
+    [slots]
+  );
+  const getContent = useCallback(
+    (slot) => slots[slot] ?? null,
+    [slots]
+  );
+  const getTraitContent = useCallback(
+    (traitName) => traitIndexRef.current.get(traitName) ?? null,
+    []
+  );
+  const subscribeTrait = useCallback(
+    (traitName, callback) => {
+      let set = traitSubscribersRef.current.get(traitName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        traitSubscribersRef.current.set(traitName, set);
+      }
+      set.add(callback);
+      return () => {
+        const s = traitSubscribersRef.current.get(traitName);
+        if (!s) return;
+        s.delete(callback);
+        if (s.size === 0) {
+          traitSubscribersRef.current.delete(traitName);
+        }
+      };
+    },
+    []
+  );
+  const updateTraitContent = useCallback(
+    (traitName, content) => {
+      const id = `slot-content-trait-${traitName}`;
+      const fullContent = { ...content, id, sourceTrait: traitName };
+      indexTraitRender(traitName, fullContent);
+      notifyTraitSubscribers(traitName, fullContent);
+      return id;
+    },
+    [indexTraitRender, notifyTraitSubscribers]
+  );
+  return {
+    slots,
+    render,
+    clear,
+    clearBySource,
+    clearById,
+    clearAll,
+    subscribe,
+    hasContent,
+    getContent,
+    getTraitContent,
+    subscribeTrait,
+    updateTraitContent
+  };
+}
+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;
+        }
+        dispatch(smEvent, event.payload);
+      };
+      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 queryStores = /* @__PURE__ */ new Map();
+function getOrCreateStore(query) {
+  if (!queryStores.has(query)) {
+    queryStores.set(query, {
+      search: "",
+      filters: {},
+      sortField: void 0,
+      sortDirection: void 0,
+      listeners: /* @__PURE__ */ new Set()
+    });
+  }
+  return queryStores.get(query);
+}
+function useQuerySingleton(query) {
+  const [, forceUpdate] = useState({});
+  if (!query) {
+    return null;
+  }
+  const store = useMemo(() => getOrCreateStore(query), [query]);
+  useMemo(() => {
+    const listener = () => forceUpdate({});
+    store.listeners.add(listener);
+    return () => {
+      store.listeners.delete(listener);
+    };
+  }, [store]);
+  const notifyListeners = useCallback(() => {
+    store.listeners.forEach((listener) => listener());
+  }, [store]);
+  const setSearch = useCallback((value) => {
+    store.search = value;
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const setFilter = useCallback((key, value) => {
+    store.filters = { ...store.filters, [key]: value };
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const clearFilters = useCallback(() => {
+    store.filters = {};
+    store.search = "";
+    notifyListeners();
+  }, [store, notifyListeners]);
+  const setSort = useCallback((field, direction) => {
+    store.sortField = field;
+    store.sortDirection = direction;
+    notifyListeners();
+  }, [store, notifyListeners]);
+  return {
+    search: store.search,
+    setSearch,
+    filters: store.filters,
+    setFilter,
+    clearFilters,
+    sortField: store.sortField,
+    sortDirection: store.sortDirection,
+    setSort
+  };
+}
+function parseQueryBinding(binding) {
+  const cleaned = binding.startsWith("@") ? binding.slice(1) : binding;
+  const parts = cleaned.split(".");
+  return {
+    query: parts[0],
+    field: parts.length > 1 ? parts.slice(1).join(".") : void 0
+  };
+}
+
+// locales/en.json
+var en_default = {
+  $meta: {
+    locale: "en",
+    direction: "ltr"
+  },
+  "common.save": "Save",
+  "common.cancel": "Cancel",
+  "common.delete": "Delete",
+  "common.close": "Close",
+  "common.confirm": "Are you sure?",
+  "common.create": "Create",
+  "common.edit": "Edit",
+  "common.view": "View",
+  "common.add": "Add",
+  "common.remove": "Remove",
+  "common.search": "Search...",
+  "common.filter": "Filter",
+  "common.actions": "Actions",
+  "common.yes": "Yes",
+  "common.no": "No",
+  "common.selected": "selected",
+  "common.ok": "OK",
+  "common.done": "Done",
+  "common.apply": "Apply",
+  "common.reset": "Reset",
+  "common.refresh": "Refresh",
+  "common.export": "Export",
+  "common.import": "Import",
+  "common.copy": "Copy",
+  "common.settings": "Settings",
+  "nav.previous": "Previous",
+  "nav.next": "Next",
+  "nav.back": "Back",
+  "nav.home": "Home",
+  "form.submit": "Submit",
+  "form.saving": "Saving...",
+  "form.required": "This field is required",
+  "form.invalidEmail": "Enter a valid email address",
+  "form.selectPlaceholder": "Select {{label}}...",
+  "form.searchPlaceholder": "Search {{entity}}...",
+  "table.empty.title": "No items found",
+  "table.empty.description": "No items to display.",
+  "table.search.placeholder": "Search...",
+  "table.pagination.showing": "Showing {{start}} to {{end}} of {{total}} results",
+  "table.pagination.page": "Page {{page}} of {{totalPages}}",
+  "table.bulk.selected": "{{count}} selected",
+  "table.loading": "Loading...",
+  "status.loading": "Loading...",
+  "status.scheduled": "Scheduled",
+  "status.inProgress": "In Progress",
+  "status.completed": "Completed",
+  "status.cancelled": "Cancelled",
+  "status.pending": "Pending",
+  "status.active": "Active",
+  "status.inactive": "Inactive",
+  "status.draft": "Draft",
+  "status.archived": "Archived",
+  "error.generic": "Something went wrong",
+  "error.retry": "Try again",
+  "error.notFound": "Not found",
+  "error.loadFailed": "Failed to load: {{message}}",
+  "error.configMissing": "Configuration not found for: {{id}}",
+  "common.loading": "Loading...",
+  "common.showMore": "Show More",
+  "common.showLess": "Show Less",
+  "common.noResults": "No results found",
+  "common.saveChanges": "Save Changes",
+  "common.retry": "Retry",
+  "common.open": "Open",
+  "common.back": "Back",
+  "empty.noItems": "No items",
+  "empty.noData": "No data available",
+  "empty.noItemsYet": "No items yet",
+  "empty.noItemsAdded": "No items added yet",
+  "empty.noOptionsFound": "No options found",
+  "list.addItemPlaceholder": "Add new item...",
+  "error.occurred": "An error occurred",
+  "error.failedToLoad": "Failed to load data",
+  "wizard.back": "Back",
+  "wizard.next": "Next",
+  "wizard.complete": "Complete",
+  "wizard.stepOf": "Step {{current}} of {{total}}",
+  "pagination.previous": "Previous",
+  "pagination.next": "Next",
+  "pagination.total": "Total:",
+  "pagination.show": "Show:",
+  "pagination.goTo": "Go to:",
+  "pagination.go": "Go",
+  "auth.signIn": "Sign in",
+  "auth.signOut": "Sign out",
+  "dialog.confirm": "Confirm",
+  "dialog.cancel": "Cancel",
+  "dialog.loading": "Loading...",
+  "dialog.delete.title": "Delete {{item}}?",
+  "dialog.delete.message": "This action cannot be undone.",
+  "trait.availableActions": "Available Actions",
+  "trait.transitions": "Transitions",
+  "trait.availableNow": "Available now",
+  "book.startReading": "Start Reading",
+  "book.tableOfContents": "Table of Contents",
+  "book.partNumber": "Part {{number}}",
+  "book.print": "Print",
+  "book.previousPage": "Previous page",
+  "book.nextPage": "Next page",
+  "quiz.showAnswer": "Show answer",
+  "quiz.hideAnswer": "Hide answer",
+  "aria.closeModal": "Close modal",
+  "aria.closeToast": "Dismiss toast",
+  "aria.closeAlert": "Dismiss alert",
+  "aria.removeFilter": "Remove filter",
+  "aria.closeDrawer": "Close drawer",
+  "aria.closePanel": "Close panel",
+  "aria.previousImage": "Previous image",
+  "aria.nextImage": "Next image",
+  "aria.dismiss": "Dismiss",
+  "aria.previousSlide": "Previous slide",
+  "aria.nextSlide": "Next slide",
+  "aria.previousDays": "Previous days",
+  "aria.nextDays": "Next days",
+  "aria.decrease": "Decrease",
+  "aria.increase": "Increase",
+  "aria.breadcrumb": "Breadcrumb",
+  "aria.tableOfContents": "Table of contents",
+  "aria.docsSidebar": "Documentation sidebar",
+  "aria.selectAllRows": "Select all rows",
+  "aria.selectAll": "Select all",
+  "aria.upvote": "Upvote",
+  "aria.downvote": "Downvote",
+  "aria.qrScanner": "QR scanner",
+  "aria.mockScanDev": "Mock scan (dev)",
+  "aria.openMenu": "Open menu",
+  "aria.closeMenu": "Close menu",
+  "aria.openSidebar": "Open sidebar",
+  "sidebar.expand": "Expand sidebar",
+  "sidebar.collapse": "Collapse sidebar",
+  "sidebar.close": "Close sidebar",
+  "loading.items": "Loading items...",
+  "card.imageAlt": "Image",
+  "canvas.emptyMessage": "No content",
+  "canvas.errorTitle": "Canvas error",
+  "book.noData": "No data",
+  "common.notifications": "Notifications",
+  "common.remaining": "{{count}} remaining",
+  "error.somethingWentWrong": "Something went wrong",
+  "error.loadingItems": "Loading items...",
+  "error.noItemsFound": "No items found",
+  "debug.noEntityData": "No entity data",
+  "debug.noEntities": "No entities",
+  "debug.noTicks": "No ticks registered",
+  "debug.noActiveTraits": "No active traits",
+  "debug.noGuardEvaluations": "No guard evaluations",
+  "debug.noBridgeData": "No bridge data",
+  "debug.status": "Status",
+  "debug.eventsForwarded": "Events Forwarded (Client \u2192 Server)",
+  "debug.eventsReceived": "Events Received (Server \u2192 Client)",
+  "debug.lastHeartbeat": "Last Heartbeat",
+  "debug.noEventsYet": "No events yet",
+  "debug.noTransitionsRecorded": "No transitions recorded",
+  "debug.noVerificationChecks": "No verification checks yet",
+  "display.chartError": "Chart error",
+  "display.codeViewerError": "Code viewer error",
+  "display.noCode": "No code",
+  "display.documentError": "Document error",
+  "display.noDocument": "No document",
+  "display.graphError": "Graph error",
+  "display.noGraphData": "No graph data",
+  "display.galleryError": "Gallery error",
+  "display.noMedia": "No media",
+  "display.meterError": "Meter error",
+  "display.signaturePadError": "Signature pad error",
+  "display.timelineError": "Timeline error",
+  "display.noEvents": "No events",
+  "template.features": "Features",
+  "template.howItWorks": "How It Works",
+  "template.showcase": "Showcase",
+  "template.faq": "Frequently Asked Questions",
+  "template.ourTeam": "Our Team",
+  "template.caseStudies": "Case Studies",
+  "richBlockEditor.toolbar.text": "Text",
+  "richBlockEditor.toolbar.h1": "H1",
+  "richBlockEditor.toolbar.h2": "H2",
+  "richBlockEditor.toolbar.h3": "H3",
+  "richBlockEditor.toolbar.bulletList": "Bullet list",
+  "richBlockEditor.toolbar.numbered": "Numbered",
+  "richBlockEditor.toolbar.quote": "Quote",
+  "richBlockEditor.toolbar.code": "Code",
+  "richBlockEditor.toolbar.divider": "Divider",
+  "richBlockEditor.toolbar.image": "Image",
+  "richBlockEditor.blockType.paragraph": "Text",
+  "richBlockEditor.blockType.heading1": "Heading 1",
+  "richBlockEditor.blockType.heading2": "Heading 2",
+  "richBlockEditor.blockType.heading3": "Heading 3",
+  "richBlockEditor.blockType.bulletList": "Bullet list",
+  "richBlockEditor.blockType.numberedList": "Numbered list",
+  "richBlockEditor.blockType.quote": "Quote",
+  "richBlockEditor.blockType.code": "Code",
+  "richBlockEditor.blockType.divider": "Divider",
+  "richBlockEditor.blockType.image": "Image",
+  "richBlockEditor.blockActions": "Block actions",
+  "richBlockEditor.duplicate": "Duplicate",
+  "richBlockEditor.turnInto": "Turn into",
+  "richBlockEditor.placeholder.heading1": "Heading 1",
+  "richBlockEditor.placeholder.heading2": "Heading 2",
+  "richBlockEditor.placeholder.heading3": "Heading 3",
+  "richBlockEditor.placeholder.quote": "Quote",
+  "richBlockEditor.placeholder.code": "Enter code",
+  "richBlockEditor.placeholder.paragraph": "Start writing...",
+  "richBlockEditor.placeholder.listItem": "List item",
+  "richBlockEditor.placeholder.caption": "Caption (optional)",
+  "richBlockEditor.aria.heading1Block": "Heading 1 block",
+  "richBlockEditor.aria.heading2Block": "Heading 2 block",
+  "richBlockEditor.aria.heading3Block": "Heading 3 block",
+  "richBlockEditor.aria.quoteBlock": "Quote block",
+  "richBlockEditor.aria.codeBlock": "Code block",
+  "richBlockEditor.aria.codeLanguage": "Code language",
+  "richBlockEditor.aria.imageUrl": "Image URL",
+  "richBlockEditor.aria.imageCaption": "Image caption",
+  "richBlockEditor.aria.listItem": "List item",
+  "richBlockEditor.aria.removeListItem": "Remove list item",
+  "richBlockEditor.aria.paragraphBlock": "Paragraph block",
+  "richBlockEditor.embeddedImage": "Embedded image",
+  "richBlockEditor.noImageUrl": "No image URL set",
+  "richBlockEditor.addItem": "Add item",
+  "richBlockEditor.insertParagraphBelow": "Insert paragraph below",
+  "richBlockEditor.editorToolbar": "Block editor toolbar",
+  "richBlockEditor.insertEntry": "Insert {{label}}",
+  "versionDiff.compare": "Compare",
+  "versionDiff.to": "to",
+  "versionDiff.beforeRevision": "Before revision",
+  "versionDiff.afterRevision": "After revision",
+  "versionDiff.switchToInline": "Switch to inline view",
+  "versionDiff.switchToSideBySide": "Switch to side-by-side view",
+  "versionDiff.revert": "Revert",
+  "versionDiff.byAuthor": " by {{author}}",
+  "violationAlert.actionType.measure": "Corrective Measure",
+  "violationAlert.actionType.admin": "Administrative Action",
+  "violationAlert.actionType.penalty": "Penalty Proceedings",
+  "violationAlert.fallbackMessage": "Violation",
+  "violationAlert.adminLabel": "Admin:",
+  "violationAlert.penaltyLabel": "Penalty:",
+  "violationAlert.goToField": "Go to field",
+  "branchingLogic.title": "Branching logic",
+  "branchingLogic.if": "If",
+  "branchingLogic.goTo": "go to",
+  "branchingLogic.rules": "Rules",
+  "branchingLogic.logicGraph": "Logic graph",
+  "branchingLogic.addRule": "Add rule",
+  "branchingLogic.deleteRule": "Delete rule",
+  "branchingLogic.endOfSurvey": "End of survey",
+  "branchingLogic.brokenReference": "Broken reference",
+  "branchingLogic.selectQuestion": "Select question",
+  "branchingLogic.selectTarget": "Select target",
+  "branchingLogic.selectValue": "Select value",
+  "branchingLogic.addValue": "Add value",
+  "branchingLogic.value": "Value",
+  "branchingLogic.typeValuePressEnter": "Type value, press Enter",
+  "branchingLogic.operatorEquals": "equals",
+  "branchingLogic.operatorNotEquals": "does not equal",
+  "branchingLogic.operatorContains": "contains",
+  "branchingLogic.operatorIn": "is one of",
+  "branchingLogic.graphAriaLabel": "Branching logic graph",
+  "branchingLogic.ruleCountOne": "{{count}} rule",
+  "branchingLogic.ruleCountOther": "{{count}} rules",
+  "branchingLogic.brokenCount": "{{count}} broken",
+  "branchingLogic.emptyNoQuestions": "Add questions before building branching rules.",
+  "branchingLogic.emptyNoRules": "No rules yet. Add a rule to define branching logic.",
+  "filterGroup.filters": "Filters",
+  "filterGroup.all": "All",
+  "filterGroup.clear": "Clear",
+  "filterGroup.clearAll": "Clear all",
+  "filterGroup.from": "From",
+  "filterGroup.to": "To",
+  "filterGroup.allOf": "All {{label}}",
+  "filterGroup.activeCount": "{{count}} active",
+  "debug.guardEvaluationsHint": "Guard evaluations will appear when transitions or ticks with guards execute",
+  "debug.expression": "Expression",
+  "debug.inputs": "Inputs",
+  "debug.trait": "Trait",
+  "debug.filterAll": "All",
+  "debug.filterPassed": "Passed",
+  "debug.filterFailed": "Failed",
+  "debug.traitsInitHint": "Traits will appear when the state machine initializes",
+  "debug.traitsMountHint": "Traits will appear when components using them are mounted",
+  "debug.activeStates": "Active States",
+  "debug.availableEvents": "Available Events",
+  "debug.noTransitionsFromState": "No transitions from current state",
+  "debug.guarded": "guarded",
+  "debug.otherEvents": "Other Events (not available from current state)",
+  "debug.recentTransitions": "Recent Transitions",
+  "debug.transitionsCount": "{{count}} transitions",
+  "debug.states": "States",
+  "debug.transitions": "Transitions",
+  "debug.guards": "Guards",
+  "debug.debugModeHint": "Debug mode may not be enabled",
+  "debug.entitiesSpawnHint": "Entities will appear when spawned",
+  "debug.singleton": "Singleton",
+  "debug.singletonsCount": "Singletons ({{count}})",
+  "debug.runtimeCount": "Runtime ({{count}})",
+  "debug.moreEntities": "+{{count}} more entities",
+  "debug.persistent": "Persistent",
+  "debug.loadedCount": "{{count}} loaded",
+  "debug.notLoaded": "not loaded",
+  "debug.eventsExecuteHint": "Events will appear as traits, ticks, and other systems execute",
+  "debug.allCount": "All ({{count}})",
+  "debug.autoScroll": "Auto-scroll",
+  "debug.transitionsProcessHint": "Transitions will appear as the state machine processes events",
+  "debug.transitionsRecorded": "{{count}} transitions recorded",
+  "debug.guardLabel": "guard:",
+  "debug.effectsCount": "{{count}} effects",
+  "debug.bridgeInitHint": "The ServerBridge has not been initialized. Bridge health will appear once the runtime connects to the server.",
+  "debug.never": "Never",
+  "debug.connected": "Connected",
+  "debug.disconnected": "Disconnected",
+  "debug.lastError": "Last Error",
+  "debug.totalEventsProcessed": "{{count}} total events processed",
+  "debug.server": "server",
+  "debug.clientEffectsCount": "{{count}} clientEffects",
+  "debug.emitLabel": "emit:",
+  "debug.rowsCount": "{{count}} rows",
+  "debug.serverResponse": "server response",
+  "debug.collapseVerificationTimeline": "Collapse verification timeline",
+  "debug.expandVerificationTimeline": "Expand verification timeline",
+  "debug.failCount": "{{count}} fail",
+  "debug.ok": "OK",
+  "debug.localCount": "{{count}} local",
+  "debug.serverCount": "{{count}} server",
+  "debug.waitingForTransitions": "Waiting for transitions...",
+  "debug.tabDispatch": "Dispatch",
+  "debug.tabVerify": "Verify",
+  "debug.tabVerifyAlert": "Verify (!)",
+  "debug.tabTimeline": "Timeline",
+  "debug.tabBridge": "Bridge",
+  "debug.tabTraits": "Traits",
+  "debug.tabTicks": "Ticks",
+  "debug.tabEntities": "Entities",
+  "debug.tabEvents": "Events",
+  "debug.tabGuards": "Guards",
+  "debug.debugger": "Debugger",
+  "debug.failedCount": "{{count}} failed",
+  "debug.traitsCount": "{{count}} traits",
+  "debug.idle": "Idle",
+  "debug.openDebugger": "Open Debugger (`)",
+  "debug.kflowVerifier": "KFlow Verifier",
+  "debug.allPassing": "All passing",
+  "debug.runtime": "Runtime",
+  "debug.close": "Close (`)",
+  "debug.toggleHint": "Press ` to toggle | window.__orbitalVerification for automation",
+  "replyTree.expandReplies": "Expand replies",
+  "replyTree.collapseReplies": "Collapse replies",
+  "replyTree.voteOnReplyBy": "Vote on reply by {{author}}",
+  "replyTree.replyTo": "Reply to {{author}}",
+  "replyTree.replyToPlaceholder": "Reply to {{author}}\u2026",
+  "replyTree.reply": "Reply",
+  "replyTree.flagReplyBy": "Flag reply by {{author}}",
+  "replyTree.flag": "Flag",
+  "replyTree.send": "Send",
+  "replyTree.continueThread": "Continue thread",
+  "replyTree.noRepliesYet": "No replies yet.",
+  "signaturePad.label": "Signature",
+  "signaturePad.helperText": "Draw your signature above",
+  "signaturePad.clear": "Clear",
+  "signaturePad.confirm": "Confirm",
+  "qrScanner.cameraUnavailable": "Camera unavailable",
+  "qrScanner.paused": "Paused",
+  "qrScanner.resumeScanning": "Resume scanning",
+  "qrScanner.pauseScanning": "Pause scanning",
+  "qrScanner.switchToFrontCamera": "Switch to front camera",
+  "qrScanner.switchToRearCamera": "Switch to rear camera",
+  "qrScanner.mockScan": "Mock Scan",
+  "docSearch.placeholder": "Search documentation...",
+  "stateMachine.loading": "Loading state machine\u2026",
+  "stateMachine.noStateMachine": "No state machine to visualize",
+  "avl.trigger": "Trigger",
+  "avl.guard": "Guard",
+  "avl.effects": "Effects",
+  "avl.props": "Props",
+  "avl.entity": "Entity",
+  "avl.traits": "Traits",
+  "avl.transition": "Transition",
+  "avl.onEntity": "on {{entity}}",
+  "avl.linkedTo": "linked to {{entity}}",
+  "avl.pressEscToZoomOut": "Press Esc to zoom out",
+  "avl.zoomIn": "Zoom in",
+  "avl.zoomOut": "Zoom out",
+  "avl.orbitalLabel": "Orbital: {{name}}",
+  "avl.orbitalLabelHighlighted": "Orbital: {{name}} (highlighted)",
+  "avl.noTraitData": "No trait data",
+  "avl.computingLayout": "Computing layout...",
+  "avl.noStateMachine": "No state machine",
+  "avl.listensFor": "listens for {{event}}",
+  "avl.emits": "emits {{event}}",
+  "avl.pageLayout": "Page Layout",
+  "avl.overlaySuffix": "(overlay)",
+  "orbPreview.previewBadge": "Preview",
+  "orbPreview.doubleClickToOpen": "Double-click to open",
+  "orbPreview.dropToAddAndOpen": "Drop to add and open",
+  "orbPreview.dispatching": "Coordinator is dispatching to this orbital",
+  "orbPreview.noPreview": "No preview available",
+  "orbPreview.screensCount": "{{count}} screens",
+  "detailView.noTransitionData": "No transition data",
+  "orbInspector.required": "req",
+  "orbInspector.addField": "Add Field",
+  "orbInspector.serviceMode": "Service Mode",
+  "orbInspector.standalone": "Standalone",
+  "orbInspector.embedded": "Embedded",
+  "orbInspector.rendersOwnUi": "Renders its own UI",
+  "orbInspector.headless": "Headless, wired to other behaviors",
+  "orbInspector.addEffect": "Add Effect",
+  "orbInspector.guardExpression": "Guard expression",
+  "orbInspector.selectPatternForStyles": "Select a pattern to view its style tokens.",
+  "orbInspector.tokens": "Tokens",
+  "orbInspector.noTokenContract": "No token contract declared for this pattern.",
+  "orbInspector.variant": "Variant",
+  "orbInspector.size": "Size",
+  "orbInspector.statesCount": "{{count}} states",
+  "orbInspector.onEntity": " on {{entity}}",
+  "orbInspector.projectThemeTokens": "Project theme tokens",
+  "orbInspector.tokenGroup.colors": "Colors",
+  "orbInspector.tokenGroup.radii": "Radii",
+  "orbInspector.tokenGroup.spacing": "Spacing",
+  "orbInspector.tokenGroup.shadows": "Shadows",
+  "orbInspector.tab.inspector": "Inspector",
+  "orbInspector.tab.styles": "Styles",
+  "orbInspector.tab.code": "Code",
+  "canvas.goBackToOverview": "Go back to overview",
+  "canvas.overview": "Overview",
+  "canvas.expanded": "Expanded",
+  "canvas.modulesCount": "{{count}} modules",
+  "canvas.screensCount": "{{count}} screens",
+  "canvas.switchToView": "Switch to {{label}} view",
+  "lawReference.viewFullText": "View full law text",
+  "statCard.defaultLabel": "Stat",
+  "statCard.vsLastPeriod": "vs last period",
+  "mediaGallery.upload": "Upload",
+  "mediaGallery.noMediaDescription": "No media items to display.",
+  "pagination.jumpPlaceholder": "Page",
+  "table.selectRow": "Select row {{id}}",
+  "card.selectItem": "Select {{item}}",
+  "card.itemFallback": "item",
+  "fileTree.noFiles": "No files",
+  "masterDetail.selectItem": "Select an item to view details",
+  "empty.createFirst": "Create your first item to get started.",
+  "upload.dropOrBrowse": "Drop files here or click to browse",
+  "upload.dropFilesHere": "Drop files here",
+  "upload.accepted": "Accepted: {{accept}}",
+  "upload.maxSize": "Max size: {{size}}",
+  "upload.maxFiles": "Up to {{count}} files",
+  "upload.error.maxFiles": "Maximum {{count}} files allowed",
+  "upload.error.invalidType": "Invalid file type: {{name}}",
+  "upload.error.tooLarge": "File too large: {{name}} (max {{size}})",
+  "optionConstraint.requiredOne": "Required, pick 1",
+  "optionConstraint.optionalOne": "Optional, pick up to 1",
+  "optionConstraint.pickExactly": "Pick exactly {{count}}",
+  "optionConstraint.pickRange": "Pick {{min}}-{{max}}",
+  "optionConstraint.pickAtLeast": "Pick at least {{count}}",
+  "optionConstraint.pickUpTo": "Pick up to {{count}}",
+  "optionConstraint.optional": "Optional",
+  "optionConstraint.outOfStock": "Out of stock",
+  "optionConstraint.error.pickOne": "Pick 1 option",
+  "optionConstraint.error.pickOnlyOne": "Pick only 1 option",
+  "optionConstraint.error.pickMore": "Pick at least {{count}} more",
+  "optionConstraint.error.removeOptions": "Remove {{count}} options",
+  "stateMachine.pinned": "Pinned",
+  "stateMachine.eventCount": "{{count}} events",
+  "stateMachine.externalEffects": "External Effects",
+  "stateMachine.legend.initial": "Initial",
+  "stateMachine.legend.final": "Final",
+  "stateMachine.legend.state": "State",
+  "stateMachine.legend.multiEvent": "Multi-event",
+  "relationSelect.selectPlaceholder": "Select...",
+  "battle.cancel": "Cancel",
+  "battle.defeat": "Defeat",
+  "battle.endTurn": "End Turn",
+  "battle.playAgain": "Play Again",
+  "battle.turnsPlayed": "Turns Played",
+  "battle.victory": "Victory",
+  "builder.allPlaced": "All placed",
+  "builder.blueprint": "Blueprint",
+  "builder.build": "Build",
+  "builder.components": "Components",
+  "builder.empty": "Empty",
+  "builder.reset": "Reset",
+  "builder.success": "Success",
+  "classifier.allCorrect": "All correct!",
+  "classifier.check": "Check",
+  "classifier.correct": "correct",
+  "classifier.itemsToSort": "Items to sort",
+  "classifier.reset": "Reset",
+  "common.error": "Error",
+  "debugger.allFound": "All bugs found!",
+  "debugger.bugsFound": "bugs found",
+  "debugger.findBugs": "Find {{count}} bugs",
+  "debugger.reset": "Reset",
+  "debugger.submit": "Submit",
+  "error.genericLoad": "Failed to load",
+  "error.loadingData": "Loading data",
+  "eventHandler.addRule": "Add Rule",
+  "eventHandler.chainComplete": "Chain complete!",
+  "eventHandler.clickObject": "Click objects",
+  "eventHandler.eventLog": "Event Log",
+  "eventHandler.heardEvent": "{{object}} heard {{event}} \u2192 {{action}}",
+  "eventHandler.noEvents": "No events yet",
+  "eventHandler.noListeners": "No listeners for {{event}}",
+  "eventHandler.rules": "{{count}}/{{max}} rules",
+  "eventHandler.simulationStarted": "Simulating: {{events}}",
+  "eventHandler.state": "State",
+  "eventHandler.then": "then",
+  "eventHandler.when": "When",
+  "game.goal": "Goal",
+  "game.hint": "Hint",
+  "game.play": "Play",
+  "game.reset": "Reset",
+  "game.runTests": "Run Tests",
+  "negotiator.chooseAction": "Choose an action",
+  "negotiator.failed": "Negotiation failed",
+  "negotiator.finalScore": "Final score",
+  "negotiator.history": "History",
+  "negotiator.opponent": "Opponent",
+  "negotiator.playAgain": "Play Again",
+  "negotiator.round": "Round {{current}} of {{total}}",
+  "negotiator.success": "Negotiation successful",
+  "negotiator.target": "Target",
+  "negotiator.you": "You",
+  "platformer.level": "Level",
+  "platformer.lost": "Game Over",
+  "platformer.nextLevel": "Next Level",
+  "platformer.noLives": "No lives left",
+  "platformer.playAgain": "Play Again",
+  "platformer.score": "Score",
+  "platformer.won": "You won!",
+  "puzzle.tryAgainButton": "Try Again",
+  "roguelike.atk": "ATK",
+  "roguelike.cleared": "Dungeon cleared! Depth reached: {{depth}}",
+  "roguelike.defeat": "Defeated!",
+  "roguelike.depth": "Depth",
+  "roguelike.enemy": "Enemy",
+  "roguelike.hp": "HP",
+  "roguelike.phase": "Phase",
+  "roguelike.playAgain": "Play Again",
+  "roguelike.player": "Hero",
+  "roguelike.victory": "Victory!",
+  "sequencer.actions": "Actions",
+  "sequencer.dragActions": "Drag actions here",
+  "sequencer.levelComplete": "Level complete!",
+  "sequencer.yourSequence": "Your sequence",
+  "simulator.correct": "Correct",
+  "simulator.incorrect": "Incorrect",
+  "simulator.parameters": "Parameters",
+  "simulator.reset": "Reset",
+  "simulator.simulate": "Simulate",
+  "simulator.target": "Target",
+  "stateArchitect.addTransition": "Add transition from {{state}}",
+  "stateArchitect.addTransitionPrompt": "Click target state",
+  "stateArchitect.allPassed": "All tests passed!",
+  "stateArchitect.clickTarget": "Click a target state (current: {{state}})",
+  "stateArchitect.gotState": "Got state: {{state}}",
+  "stateArchitect.graph": "Graph",
+  "stateArchitect.hideJson": "Hide JSON",
+  "stateArchitect.showJson": "Show JSON",
+  "stateArchitect.testResults": "Test Results",
+  "stateArchitect.transitions": "{{count}} transitions",
+  "stateArchitect.variables": "Variables: {{name}}",
+  "stateArchitect.viewCode": "View Code",
+  "td.defeat": "Defeat",
+  "td.gold": "Gold",
+  "td.lives": "Lives",
+  "td.livesReachedZero": "Your base was overrun",
+  "td.placeTower": "Place tower",
+  "td.playAgain": "Play Again",
+  "td.startWave": "Start Wave",
+  "td.survivedAllWaves": "Survived all waves!",
+  "td.victory": "Victory!",
+  "td.wave": "Wave",
+  "td.waveInProgress": "Wave in progress\u2026"
+};
+
+// hooks/useTranslate.ts
+var { $meta: _meta, ...coreMessages } = en_default;
+var coreLocale = coreMessages;
+var I18nContext = createContext({
+  locale: "en",
+  direction: "ltr",
+  t: (key, params) => {
+    let msg = coreLocale[key] ?? key;
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        msg = msg.split(`{{${k}}}`).join(String(v));
+      }
+    }
+    return msg;
+  }
+});
+I18nContext.displayName = "I18nContext";
+var I18nProvider = I18nContext.Provider;
+function useTranslate() {
+  return useContext(I18nContext);
+}
+function createTranslate(messages) {
+  return (key, params) => {
+    let msg = messages[key] ?? coreLocale[key] ?? key;
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        msg = msg.split(`{{${k}}}`).join(String(v));
+      }
+    }
+    return msg;
+  };
+}
+
+// hooks/useAuthContext.ts
+function useAuthContext() {
+  return {
+    user: null,
+    loading: false,
+    signIn: void 0,
+    signOut: void 0
+  };
+}
+function useSwipeGesture(callbacks, options = {}) {
+  const { threshold = 50, velocityThreshold = 0.3, preventDefault = false } = options;
+  const startX = useRef(0);
+  const startY = useRef(0);
+  const startTime = useRef(0);
+  const currentX = useRef(0);
+  const tracking = useRef(false);
+  const offsetXRef = useRef(0);
+  const isSwipingRef = useRef(false);
+  const onPointerDown = useCallback((e) => {
+    startX.current = e.clientX;
+    startY.current = e.clientY;
+    currentX.current = e.clientX;
+    startTime.current = Date.now();
+    tracking.current = true;
+    isSwipingRef.current = false;
+    offsetXRef.current = 0;
+    e.target.setPointerCapture?.(e.pointerId);
+  }, []);
+  const onPointerMove = useCallback((e) => {
+    if (!tracking.current) return;
+    if (preventDefault) e.preventDefault();
+    currentX.current = e.clientX;
+    const dx = e.clientX - startX.current;
+    const dy = e.clientY - startY.current;
+    if (Math.abs(dx) > 10 && Math.abs(dx) > Math.abs(dy)) {
+      isSwipingRef.current = true;
+      offsetXRef.current = dx;
+    }
+  }, [preventDefault]);
+  const onPointerUp = useCallback((e) => {
+    if (!tracking.current) return;
+    tracking.current = false;
+    const dx = e.clientX - startX.current;
+    const dy = e.clientY - startY.current;
+    const elapsed = Date.now() - startTime.current;
+    const velocity = Math.abs(dx) / Math.max(elapsed, 1);
+    offsetXRef.current = 0;
+    isSwipingRef.current = false;
+    if (Math.abs(dx) < threshold && velocity < velocityThreshold) return;
+    if (Math.abs(dx) > Math.abs(dy)) {
+      if (dx < -threshold) callbacks.onSwipeLeft?.();
+      else if (dx > threshold) callbacks.onSwipeRight?.();
+    } else {
+      if (dy < -threshold) callbacks.onSwipeUp?.();
+      else if (dy > threshold) callbacks.onSwipeDown?.();
+    }
+  }, [threshold, velocityThreshold, callbacks]);
+  const onPointerCancel = useCallback(() => {
+    tracking.current = false;
+    offsetXRef.current = 0;
+    isSwipingRef.current = false;
+  }, []);
+  return {
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onPointerCancel,
+    offsetX: offsetXRef.current,
+    isSwiping: isSwipingRef.current
+  };
+}
+function useLongPress(onLongPress, options = {}) {
+  const { duration = 500, moveThreshold = 10 } = options;
+  const timerRef = useRef(null);
+  const startPos = useRef({ x: 0, y: 0 });
+  const isPressedRef = useRef(false);
+  const firedRef = useRef(false);
+  const cancel = useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    isPressedRef.current = false;
+  }, []);
+  const onPointerDown = useCallback((e) => {
+    firedRef.current = false;
+    startPos.current = { x: e.clientX, y: e.clientY };
+    isPressedRef.current = true;
+    timerRef.current = setTimeout(() => {
+      firedRef.current = true;
+      isPressedRef.current = false;
+      onLongPress();
+    }, duration);
+  }, [duration, onLongPress]);
+  const onPointerMove = useCallback((e) => {
+    if (!isPressedRef.current) return;
+    const dx = e.clientX - startPos.current.x;
+    const dy = e.clientY - startPos.current.y;
+    if (Math.sqrt(dx * dx + dy * dy) > moveThreshold) {
+      cancel();
+    }
+  }, [moveThreshold, cancel]);
+  const onPointerUp = useCallback(() => {
+    cancel();
+  }, [cancel]);
+  const onPointerCancel = useCallback(() => {
+    cancel();
+  }, [cancel]);
+  return {
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onPointerCancel,
+    isPressed: isPressedRef.current
+  };
+}
+function useDragReorder(initialItems, onReorder) {
+  const [items, setItems] = useState(initialItems);
+  const [dragIndex, setDragIndex] = useState(-1);
+  const [dragOverIndex, setDragOverIndex] = useState(-1);
+  const itemsRef = useRef(initialItems);
+  if (initialItems !== itemsRef.current) {
+    itemsRef.current = initialItems;
+    setItems(initialItems);
+  }
+  const isDragging = dragIndex >= 0;
+  const handleDragStart = useCallback((index) => (e) => {
+    e.preventDefault();
+    setDragIndex(index);
+    setDragOverIndex(index);
+    e.target.setPointerCapture?.(e.pointerId);
+  }, []);
+  const handleDragMove = useCallback((index) => (e) => {
+    if (dragIndex < 0) return;
+    const target = document.elementFromPoint(e.clientX, e.clientY);
+    if (!target) return;
+    let el = target;
+    while (el && !el.dataset.dragIndex) {
+      el = el.parentElement;
+    }
+    if (el?.dataset.dragIndex) {
+      const overIndex = parseInt(el.dataset.dragIndex, 10);
+      if (!isNaN(overIndex) && overIndex !== dragOverIndex) {
+        setDragOverIndex(overIndex);
+      }
+    }
+  }, [dragIndex, dragOverIndex]);
+  const handleDragEnd = useCallback(() => {
+    if (dragIndex >= 0 && dragOverIndex >= 0 && dragIndex !== dragOverIndex) {
+      const newItems = [...items];
+      const [movedItem] = newItems.splice(dragIndex, 1);
+      newItems.splice(dragOverIndex, 0, movedItem);
+      setItems(newItems);
+      onReorder(dragIndex, dragOverIndex, items[dragIndex]);
+    }
+    setDragIndex(-1);
+    setDragOverIndex(-1);
+  }, [dragIndex, dragOverIndex, items, onReorder]);
+  const getDragHandleProps = useCallback((index) => ({
+    onPointerDown: handleDragStart(index),
+    style: { cursor: "grab", touchAction: "none" },
+    "aria-grabbed": dragIndex === index,
+    role: "button"
+  }), [handleDragStart, dragIndex]);
+  const getItemProps = useCallback((index) => ({
+    onPointerMove: handleDragMove(index),
+    onPointerUp: handleDragEnd,
+    "aria-dropeffect": "move",
+    "data-drag-index": String(index),
+    style: {
+      opacity: dragIndex === index ? 0.5 : 1,
+      transition: isDragging ? "transform 150ms ease" : void 0,
+      transform: isDragging && dragOverIndex >= 0 ? index === dragIndex ? "scale(1.02)" : index > dragIndex && index <= dragOverIndex ? "translateY(-100%)" : index < dragIndex && index >= dragOverIndex ? "translateY(100%)" : void 0 : void 0
+    }
+  }), [handleDragMove, handleDragEnd, dragIndex, dragOverIndex, isDragging]);
+  return {
+    items,
+    dragIndex,
+    dragOverIndex,
+    isDragging,
+    getDragHandleProps,
+    getItemProps
+  };
+}
+function useInfiniteScroll(onLoadMore, options = {}) {
+  const { rootMargin = "200px", hasMore = true, isLoading = false } = options;
+  const observerRef = useRef(null);
+  const callbackRef = useRef(onLoadMore);
+  callbackRef.current = onLoadMore;
+  const hasMoreRef = useRef(hasMore);
+  hasMoreRef.current = hasMore;
+  const isLoadingRef = useRef(isLoading);
+  isLoadingRef.current = isLoading;
+  useEffect(() => {
+    return () => {
+      observerRef.current?.disconnect();
+    };
+  }, []);
+  const sentinelRef = useCallback((node) => {
+    observerRef.current?.disconnect();
+    if (!node) return;
+    observerRef.current = new IntersectionObserver(
+      (entries) => {
+        const entry = entries[0];
+        if (entry.isIntersecting && hasMoreRef.current && !isLoadingRef.current) {
+          callbackRef.current();
+        }
+      },
+      { rootMargin }
+    );
+    observerRef.current.observe(node);
+  }, [rootMargin]);
+  return { sentinelRef };
+}
+function usePullToRefresh(onRefresh, options = {}) {
+  const { threshold = 60, maxPull = 120 } = options;
+  const [pullDistance, setPullDistance] = useState(0);
+  const [isPulling, setIsPulling] = useState(false);
+  const [isRefreshing, setIsRefreshing] = useState(false);
+  const startY = useRef(0);
+  const scrollTopRef = useRef(0);
+  const onTouchStart = useCallback((e) => {
+    const container = e.currentTarget;
+    scrollTopRef.current = container.scrollTop;
+    if (scrollTopRef.current <= 0) {
+      startY.current = e.touches[0].clientY;
+      setIsPulling(true);
+    }
+  }, []);
+  const onTouchMove = useCallback((e) => {
+    if (!isPulling || isRefreshing) return;
+    const container = e.currentTarget;
+    if (container.scrollTop > 0) {
+      setPullDistance(0);
+      return;
+    }
+    const dy = e.touches[0].clientY - startY.current;
+    if (dy > 0) {
+      const distance = Math.min(dy * 0.5, maxPull);
+      setPullDistance(distance);
+    }
+  }, [isPulling, isRefreshing, maxPull]);
+  const onTouchEnd = useCallback(() => {
+    if (!isPulling) return;
+    setIsPulling(false);
+    if (pullDistance >= threshold && !isRefreshing) {
+      setIsRefreshing(true);
+      setPullDistance(threshold);
+      onRefresh();
+    } else {
+      setPullDistance(0);
+    }
+  }, [isPulling, pullDistance, threshold, isRefreshing, onRefresh]);
+  const endRefresh = useCallback(() => {
+    setIsRefreshing(false);
+    setPullDistance(0);
+  }, []);
+  const containerProps = {
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    style: {
+      transform: pullDistance > 0 ? `translateY(${pullDistance}px)` : void 0,
+      transition: isPulling ? "none" : "transform 300ms ease-out"
+    }
+  };
+  return {
+    pullDistance,
+    isPulling,
+    isRefreshing,
+    containerProps,
+    endRefresh
+  };
+}
+function localPoint(canvas, clientX, clientY) {
+  if (!canvas) return { x: clientX, y: clientY };
+  const rect = canvas.getBoundingClientRect();
+  return { x: clientX - rect.left, y: clientY - rect.top };
+}
+function useCanvasGestures(options) {
+  const {
+    canvasRef,
+    enabled = true,
+    wheelStep = 1.1,
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onZoom,
+    onPanDelta,
+    onMultiTouchStart
+  } = options;
+  const pointers = useRef(/* @__PURE__ */ new Map());
+  const pinch = useRef(null);
+  const computePinch = useCallback(() => {
+    const pts = [...pointers.current.values()];
+    const dx = pts[1].x - pts[0].x;
+    const dy = pts[1].y - pts[0].y;
+    return {
+      distance: Math.hypot(dx, dy) || 1,
+      centroid: { x: (pts[0].x + pts[1].x) / 2, y: (pts[0].y + pts[1].y) / 2 }
+    };
+  }, []);
+  const handlePointerDown = useCallback(
+    (e) => {
+      if (!enabled) return;
+      e.currentTarget.setPointerCapture(e.pointerId);
+      pointers.current.set(e.pointerId, localPoint(canvasRef.current, e.clientX, e.clientY));
+      if (pointers.current.size === 2) {
+        onMultiTouchStart?.();
+        pinch.current = computePinch();
+      } else if (pointers.current.size === 1) {
+        onPointerDown?.(e);
+      }
+    },
+    [enabled, canvasRef, onMultiTouchStart, computePinch, onPointerDown]
+  );
+  const handlePointerMove = useCallback(
+    (e) => {
+      if (!enabled) return;
+      if (pointers.current.has(e.pointerId)) {
+        pointers.current.set(e.pointerId, localPoint(canvasRef.current, e.clientX, e.clientY));
+      }
+      if (pointers.current.size >= 2 && pinch.current) {
+        const next = computePinch();
+        const prev = pinch.current;
+        if (next.distance !== prev.distance) {
+          onZoom?.(next.distance / prev.distance, next.centroid.x, next.centroid.y);
+        }
+        onPanDelta?.(next.centroid.x - prev.centroid.x, next.centroid.y - prev.centroid.y);
+        pinch.current = next;
+        return;
+      }
+      onPointerMove?.(e);
+    },
+    [enabled, canvasRef, computePinch, onZoom, onPanDelta, onPointerMove]
+  );
+  const endPointer = useCallback(
+    (e, fireUp) => {
+      const wasMulti = pointers.current.size >= 2;
+      pointers.current.delete(e.pointerId);
+      if (pointers.current.size < 2) pinch.current = null;
+      if (wasMulti && pointers.current.size === 1) return;
+      if (pointers.current.size === 0 && fireUp) onPointerUp?.(e);
+    },
+    [onPointerUp]
+  );
+  const handlePointerUp = useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, true);
+    },
+    [enabled, endPointer]
+  );
+  const handlePointerCancel = useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, false);
+    },
+    [enabled, endPointer]
+  );
+  const handleWheel = useCallback(
+    (e) => {
+      if (!enabled) return;
+      e.preventDefault();
+      const { x, y } = localPoint(canvasRef.current, e.clientX, e.clientY);
+      onZoom?.(e.deltaY < 0 ? wheelStep : 1 / wheelStep, x, y);
+    },
+    [enabled, canvasRef, wheelStep, onZoom]
+  );
+  return {
+    onPointerDown: handlePointerDown,
+    onPointerMove: handlePointerMove,
+    onPointerUp: handlePointerUp,
+    onPointerCancel: handlePointerCancel,
+    onWheel: handleWheel
+  };
+}
+function useTapReveal(options = {}) {
+  const { onReveal, onDismiss, refs, enabled = true } = options;
+  const [revealed, setRevealed] = useState(false);
+  const onRevealRef = useRef(onReveal);
+  const onDismissRef = useRef(onDismiss);
+  onRevealRef.current = onReveal;
+  onDismissRef.current = onDismiss;
+  const reveal = useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (!wasRevealed) onRevealRef.current?.();
+      return true;
+    });
+  }, []);
+  const dismiss = useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (wasRevealed) onDismissRef.current?.();
+      return false;
+    });
+  }, []);
+  const onPointerDown = useCallback(
+    (e) => {
+      if (!enabled || e.pointerType === "mouse") return;
+      if (revealed) dismiss();
+      else reveal();
+    },
+    [enabled, revealed, reveal, dismiss]
+  );
+  useEffect(() => {
+    if (!revealed || typeof document === "undefined") return;
+    const onDocDown = (ev) => {
+      const target = ev.target;
+      if (!(target instanceof Node)) return;
+      const inside = (refs ?? []).some((r) => r.current?.contains(target));
+      if (!inside) dismiss();
+    };
+    const id = setTimeout(() => document.addEventListener("pointerdown", onDocDown), 0);
+    return () => {
+      clearTimeout(id);
+      document.removeEventListener("pointerdown", onDocDown);
+    };
+  }, [revealed, refs, dismiss]);
+  return { revealed, triggerProps: { onPointerDown }, reveal, dismiss };
+}
+var ALMADAR_DND_MIME = "application/x-almadar-dnd";
+function useDraggable({ payload, disabled = false }) {
+  const [isDragging, setIsDragging] = useState(false);
+  const eventBus = useEventBus();
+  const handleDragStart = useCallback(
+    (e) => {
+      if (disabled) {
+        e.preventDefault();
+        return;
+      }
+      e.dataTransfer.setData(ALMADAR_DND_MIME, JSON.stringify(payload));
+      e.dataTransfer.effectAllowed = "copy";
+      setIsDragging(true);
+      eventBus.emit("UI:DRAG_START", { kind: payload.kind, data: payload.data });
+    },
+    [disabled, payload, eventBus]
+  );
+  const handleDragEnd = useCallback(
+    (e) => {
+      setIsDragging(false);
+      eventBus.emit("UI:DRAG_END", { kind: payload.kind, data: payload.data });
+    },
+    [payload, eventBus]
+  );
+  const dragProps = useMemo(
+    () => ({
+      draggable: !disabled,
+      onDragStart: handleDragStart,
+      onDragEnd: handleDragEnd,
+      "aria-grabbed": isDragging
+    }),
+    [disabled, handleDragStart, handleDragEnd, isDragging]
+  );
+  return { dragProps, isDragging };
+}
+function parsePayload(e) {
+  try {
+    const raw = e.dataTransfer.getData(ALMADAR_DND_MIME);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.kind !== "string" || !parsed.data) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function hasAlmadarPayload(e) {
+  return e.dataTransfer.types.includes(ALMADAR_DND_MIME);
+}
+function useDropZone({ accepts, onDrop, disabled = false }) {
+  const [isOver, setIsOver] = useState(false);
+  const eventBus = useEventBus();
+  const handleDragOver = useCallback(
+    (e) => {
+      if (disabled) return;
+      if (!hasAlmadarPayload(e)) return;
+      e.preventDefault();
+      e.dataTransfer.dropEffect = "copy";
+      setIsOver(true);
+    },
+    [disabled]
+  );
+  const handleDragLeave = useCallback(
+    (e) => {
+      setIsOver(false);
+    },
+    []
+  );
+  const handleDrop = useCallback(
+    (e) => {
+      e.preventDefault();
+      setIsOver(false);
+      if (disabled) return;
+      const payload = parsePayload(e);
+      if (!payload) return;
+      if (!accepts.includes(payload.kind)) return;
+      const position = { x: e.clientX, y: e.clientY };
+      onDrop(payload, position);
+      eventBus.emit("UI:DROP", { kind: payload.kind, data: payload.data, ...position });
+    },
+    [disabled, accepts, onDrop, eventBus]
+  );
+  const dropProps = useMemo(
+    () => ({
+      onDragOver: handleDragOver,
+      onDragLeave: handleDragLeave,
+      onDrop: handleDrop
+    }),
+    [handleDragOver, handleDragLeave, handleDrop]
+  );
+  return { dropProps, isOver };
+}
+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;
+      const loop = () => {
+        if (!active) return;
+        try {
+          draw(getInterpolated(performance.now()));
+        } catch {
+        }
+        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
+  });
+}
+
+export { ALMADAR_DND_MIME, DEFAULT_SLOTS, I18nProvider, createTranslate, parseQueryBinding, useAgentChat, useAuthContext, useCanvasGestures, useCompile, useConnectGitHub, useDeepAgentGeneration, useDisconnectGitHub, useDragReorder, useDraggable, useDropZone, useEmitEvent, useEventBus, useEventListener, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, useInfiniteScroll, useLongPress, useOrbitalHistory, usePreview, usePullToRefresh, useQuerySingleton, useRenderInterpolation, useSwipeGesture, useTapReveal, useTraitListens, useTranslate, useUIEvents, useUISlotManager, useValidation };