@almadar/ui 5.78.0 → 5.79.1

package/dist/hooks/index.cjs

@@ -1,2778 +0,0 @@
-'use strict';
-
-var react = require('react');
-var logger = require('@almadar/logger');
-var providers = require('@almadar/ui/providers');
-var reactQuery = require('@tanstack/react-query');
-
-var log = logger.createLogger("almadar:ui:orbital-history");
-function useOrbitalHistory(options) {
-  const { appId, authToken, userId, onHistoryChange, onRevertSuccess } = options;
-  const getHeaders = react.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] = react.useState([]);
-  const [currentVersion, setCurrentVersion] = react.useState(1);
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const refresh = react.useCallback(async () => {
-    if (!appId) return;
-    setIsLoading(true);
-    setError(null);
-    try {
-      const headers = 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 = react.useCallback(async (snapshotId) => {
-    if (!appId) {
-      return { success: false, error: "No app ID provided" };
-    }
-    try {
-      const response = await fetch(`/api/graphs/${appId}/history/revert/${snapshotId}`, {
-        method: "POST",
-        headers: 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]);
-  react.useEffect(() => {
-    if (appId && authToken && userId) {
-      refresh();
-    }
-  }, [appId, authToken, userId]);
-  react.useEffect(() => {
-    onHistoryChange?.(timeline);
-  }, [timeline]);
-  return {
-    timeline,
-    currentVersion,
-    isLoading,
-    error,
-    revertToSnapshot,
-    refresh
-  };
-}
-var log2 = logger.createLogger("almadar:ui:filesystem");
-function useFileSystem() {
-  const [status, setStatus] = react.useState("idle");
-  const [error, setError] = react.useState(null);
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [files, setFiles] = react.useState([]);
-  const [selectedFile, setSelectedFile] = react.useState(null);
-  const [selectedPath, setSelectedPath] = react.useState(null);
-  const [previewUrl, setPreviewUrl] = react.useState(null);
-  const [fileContents, setFileContents] = react.useState(/* @__PURE__ */ new Map());
-  const boot = react.useCallback(async () => {
-    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 = react.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 = react.useCallback(async (path) => {
-    return fileContents.get(path) || "";
-  }, [fileContents]);
-  const writeFile = react.useCallback(async (path, content) => {
-    setFileContents((prev) => {
-      const next = new Map(prev);
-      next.set(path, content);
-      return next;
-    });
-  }, []);
-  const selectFile = react.useCallback(async (path) => {
-    const 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 = react.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 = react.useCallback((content) => {
-    setSelectedFile((prev) => prev ? { ...prev, content, isDirty: true } : null);
-  }, []);
-  const refreshTree = react.useCallback(async () => {
-    log2.debug("Refreshing tree");
-  }, []);
-  const runCommand = react.useCallback(async (command) => {
-    log2.debug("Running command", { command });
-    return { exitCode: 0, output: "" };
-  }, []);
-  const startDevServer = react.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 = logger.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] = react.useState([]);
-  const [manifest] = react.useState(defaultManifest);
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const loadExtension = react.useCallback(async (extensionId) => {
-    log3.debug("Loading extension", { extensionId });
-  }, []);
-  const loadExtensions = react.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 = react.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]);
-  react.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 = logger.createLogger("almadar:ui:file-editor");
-function useFileEditor(options) {
-  const { extensions, fileSystem, onSchemaUpdate } = options;
-  const [openFiles, setOpenFiles] = react.useState([]);
-  const [activeFilePath, setActiveFilePath] = react.useState(null);
-  const [isSaving, setIsSaving] = react.useState(false);
-  const activeFile = openFiles.find((f) => f.path === activeFilePath) || null;
-  const openFile = react.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 = react.useCallback((path) => {
-    setOpenFiles((prev) => prev.filter((f) => f.path !== path));
-    if (activeFilePath === path) {
-      const remaining = openFiles.filter((f) => f.path !== path);
-      setActiveFilePath(remaining.length > 0 ? remaining[0].path : null);
-    }
-  }, [activeFilePath, openFiles]);
-  const setActiveFile = react.useCallback((path) => {
-    setActiveFilePath(path);
-  }, []);
-  const updateFileContent = react.useCallback((path, content) => {
-    setOpenFiles(
-      (prev) => prev.map(
-        (f) => f.path === path ? { ...f, content, isDirty: true } : f
-      )
-    );
-  }, []);
-  const handleFileEdit = react.useCallback(async (path, content) => {
-    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 = react.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 = react.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 = logger.createLogger("almadar:ui:compile");
-function useCompile() {
-  const [isCompiling, setIsCompiling] = react.useState(false);
-  const [stage, setStage] = react.useState("idle");
-  const [lastResult, setLastResult] = react.useState(null);
-  const [error, setError] = react.useState(null);
-  const compileSchema = react.useCallback(async (schema) => {
-    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 = logger.createLogger("almadar:ui:preview");
-function usePreview(options) {
-  const [previewUrl, setPreviewUrl] = react.useState(null);
-  const [isLoading, setIsLoading] = react.useState(!!options?.appId);
-  const [error, setError] = react.useState(null);
-  const [loadError, setLoadError] = react.useState(null);
-  const [app, setApp] = react.useState(null);
-  const [isFullscreen, setIsFullscreen] = react.useState(false);
-  const [isExecutingEvent, setIsExecutingEvent] = react.useState(false);
-  const [errorToast, setErrorToast] = react.useState(null);
-  const [currentStateName, setCurrentStateName] = react.useState(null);
-  const [notificationsList, setNotificationsList] = react.useState([]);
-  const [isPanelOpen, setIsPanelOpen] = react.useState(false);
-  const notifications = react.useMemo(() => ({
-    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]);
-  react.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 = react.useCallback(async () => {
-    log6.debug("startPreview called");
-  }, []);
-  const stopPreview = react.useCallback(async () => {
-    setIsLoading(true);
-    try {
-      log6.debug("Stopping preview server");
-      setPreviewUrl(null);
-      setApp(null);
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-  const refresh = react.useCallback(async () => {
-    if (!previewUrl) return;
-    log6.debug("Refreshing preview");
-    setPreviewUrl(`${previewUrl.split("?")[0]}?t=${Date.now()}`);
-  }, [previewUrl]);
-  const handleRefresh = react.useCallback(async () => {
-    log6.debug("Handle refresh");
-    await refresh();
-  }, [refresh]);
-  const handleReset = react.useCallback(async () => {
-    log6.debug("Resetting preview");
-    setError(null);
-    setLoadError(null);
-    setErrorToast(null);
-    setIsExecutingEvent(false);
-    setCurrentStateName(null);
-  }, []);
-  const toggleFullscreen = react.useCallback(() => {
-    setIsFullscreen((prev) => !prev);
-  }, []);
-  const dismissErrorToast = react.useCallback(() => {
-    setErrorToast(null);
-  }, []);
-  return {
-    previewUrl,
-    isLoading,
-    error,
-    loadError,
-    app,
-    isFullscreen,
-    isExecutingEvent,
-    errorToast,
-    currentStateName,
-    notifications,
-    startPreview,
-    stopPreview,
-    refresh,
-    handleRefresh,
-    handleReset,
-    toggleFullscreen,
-    setErrorToast,
-    dismissErrorToast
-  };
-}
-var log7 = logger.createLogger("almadar:ui:agent-chat");
-function useAgentChat(options) {
-  const [messages, setMessages] = react.useState([]);
-  const [status, setStatus] = react.useState("idle");
-  const [activities, setActivities] = react.useState([]);
-  const [todos, setTodos] = react.useState([]);
-  const [schemaDiffs, setSchemaDiffs] = react.useState([]);
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const [threadId] = react.useState(null);
-  const [interrupt, setInterrupt] = react.useState(null);
-  const sendMessage = react.useCallback(async (content) => {
-    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 = react.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 = react.useCallback(async (message) => {
-    log7.debug("Continue conversation", { message: Array.isArray(message) ? message : [message] });
-  }, []);
-  const resumeWithDecision = react.useCallback(async (decisions) => {
-    log7.debug("Resume with decision", () => ({ decisions: JSON.stringify(decisions), count: decisions.length }));
-    setInterrupt(null);
-  }, []);
-  const cancel = react.useCallback(() => {
-    setStatus("idle");
-    setIsLoading(false);
-    setInterrupt(null);
-  }, []);
-  const clearMessages = react.useCallback(() => {
-    setMessages([]);
-  }, []);
-  const clearHistory = react.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 = logger.createLogger("almadar:ui:validation");
-function useValidation() {
-  const [result, setResult] = react.useState(null);
-  const [isValidating, setIsValidating] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const [stage, setStage] = react.useState("idle");
-  const [isFixing, setIsFixing] = react.useState(false);
-  const [progressMessage, setProgressMessage] = react.useState(null);
-  const validate = react.useCallback(async (appId) => {
-    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 = react.useCallback(() => {
-    setResult(null);
-    setError(null);
-  }, []);
-  const reset = react.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 = logger.createLogger("almadar:ui:deep-agent");
-function useDeepAgentGeneration() {
-  const [requests, setRequests] = react.useState([]);
-  const [currentRequest, setCurrentRequest] = react.useState(null);
-  const [isGenerating, setIsGenerating] = react.useState(false);
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [isComplete, setIsComplete] = react.useState(false);
-  const [progress, setProgress] = react.useState({ stage: "idle", percent: 0, message: "" });
-  const [error, setError] = react.useState(null);
-  const [interrupt, setInterrupt] = react.useState(null);
-  const generate = react.useCallback(async (prompt) => {
-    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 = react.useCallback(async (skill, prompt, _options) => {
-    log9.debug("Starting generation with skill", { skill });
-    await generate(prompt);
-  }, [generate]);
-  const cancelGeneration = react.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 = react.useCallback(() => {
-    setRequests([]);
-    setCurrentRequest(null);
-    setError(null);
-    setProgress({ stage: "idle", percent: 0, message: "" });
-    setIsComplete(false);
-  }, []);
-  const submitInterruptDecisions = react.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 = logger.createLogger("almadar:eventbus");
-var subLog = logger.createLogger("almadar:eventbus:subscribe");
-var scopeLog = logger.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 = react.useContext(providers.EventBusContext);
-  const baseBus = context ?? getGlobalEventBus() ?? fallbackEventBus;
-  const scope = providers.useTraitScope();
-  return react.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 = react.useRef(handler);
-  handlerRef.current = handler;
-  react.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 react.useCallback(
-    (type, payload, source) => {
-      eventBus.emit(type, payload, source);
-    },
-    [eventBus]
-  );
-}
-var log11 = logger.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] = react.useState(DEFAULT_SOURCES);
-  const subscribersRef = react.useRef(/* @__PURE__ */ new Set());
-  const timersRef = react.useRef(/* @__PURE__ */ new Map());
-  const traitIndexRef = react.useRef(/* @__PURE__ */ new Map());
-  const traitSubscribersRef = react.useRef(/* @__PURE__ */ new Map());
-  const slots = react.useMemo(() => {
-    const out = { ...DEFAULT_SLOTS };
-    for (const slot of ALL_SLOTS) {
-      out[slot] = aggregateSlot(sources[slot]);
-    }
-    return out;
-  }, [sources]);
-  react.useEffect(() => {
-    return () => {
-      timersRef.current.forEach((timer) => clearTimeout(timer));
-      timersRef.current.clear();
-    };
-  }, []);
-  const notifySubscribers = react.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 = react.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 = react.useCallback(
-    (traitName, content) => {
-      traitIndexRef.current.set(traitName, content);
-    },
-    []
-  );
-  const unindexTrait = react.useCallback((traitName) => {
-    traitIndexRef.current.delete(traitName);
-  }, []);
-  const render = react.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 = react.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 = react.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 = react.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 = react.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 = react.useCallback((callback) => {
-    subscribersRef.current.add(callback);
-    return () => {
-      subscribersRef.current.delete(callback);
-    };
-  }, []);
-  const hasContent = react.useCallback(
-    (slot) => slots[slot] !== null,
-    [slots]
-  );
-  const getContent = react.useCallback(
-    (slot) => slots[slot] ?? null,
-    [slots]
-  );
-  const getTraitContent = react.useCallback(
-    (traitName) => traitIndexRef.current.get(traitName) ?? null,
-    []
-  );
-  const subscribeTrait = react.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 = react.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 = react.useMemo(
-    () => validEvents,
-    [validEventsKey]
-    // intentional — validEventsKey is the stable dep
-  );
-  react.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 = react.useMemo(
-    () => listens,
-    [stableKey]
-    // intentional
-  );
-  react.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] = react.useState({});
-  if (!query) {
-    return null;
-  }
-  const store = react.useMemo(() => getOrCreateStore(query), [query]);
-  react.useMemo(() => {
-    const listener = () => forceUpdate({});
-    store.listeners.add(listener);
-    return () => {
-      store.listeners.delete(listener);
-    };
-  }, [store]);
-  const notifyListeners = react.useCallback(() => {
-    store.listeners.forEach((listener) => listener());
-  }, [store]);
-  const setSearch = react.useCallback((value) => {
-    store.search = value;
-    notifyListeners();
-  }, [store, notifyListeners]);
-  const setFilter = react.useCallback((key, value) => {
-    store.filters = { ...store.filters, [key]: value };
-    notifyListeners();
-  }, [store, notifyListeners]);
-  const clearFilters = react.useCallback(() => {
-    store.filters = {};
-    store.search = "";
-    notifyListeners();
-  }, [store, notifyListeners]);
-  const setSort = react.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 = react.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 react.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 = react.useRef(0);
-  const startY = react.useRef(0);
-  const startTime = react.useRef(0);
-  const currentX = react.useRef(0);
-  const tracking = react.useRef(false);
-  const offsetXRef = react.useRef(0);
-  const isSwipingRef = react.useRef(false);
-  const onPointerDown = react.useCallback((e) => {
-    startX.current = e.clientX;
-    startY.current = e.clientY;
-    currentX.current = e.clientX;
-    startTime.current = Date.now();
-    tracking.current = true;
-    isSwipingRef.current = false;
-    offsetXRef.current = 0;
-    e.target.setPointerCapture?.(e.pointerId);
-  }, []);
-  const onPointerMove = react.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 = react.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 = react.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 = react.useRef(null);
-  const startPos = react.useRef({ x: 0, y: 0 });
-  const isPressedRef = react.useRef(false);
-  const firedRef = react.useRef(false);
-  const cancel = react.useCallback(() => {
-    if (timerRef.current) {
-      clearTimeout(timerRef.current);
-      timerRef.current = null;
-    }
-    isPressedRef.current = false;
-  }, []);
-  const onPointerDown = react.useCallback((e) => {
-    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 = react.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 = react.useCallback(() => {
-    cancel();
-  }, [cancel]);
-  const onPointerCancel = react.useCallback(() => {
-    cancel();
-  }, [cancel]);
-  return {
-    onPointerDown,
-    onPointerMove,
-    onPointerUp,
-    onPointerCancel,
-    isPressed: isPressedRef.current
-  };
-}
-function useDragReorder(initialItems, onReorder) {
-  const [items, setItems] = react.useState(initialItems);
-  const [dragIndex, setDragIndex] = react.useState(-1);
-  const [dragOverIndex, setDragOverIndex] = react.useState(-1);
-  const itemsRef = react.useRef(initialItems);
-  if (initialItems !== itemsRef.current) {
-    itemsRef.current = initialItems;
-    setItems(initialItems);
-  }
-  const isDragging = dragIndex >= 0;
-  const handleDragStart = react.useCallback((index) => (e) => {
-    e.preventDefault();
-    setDragIndex(index);
-    setDragOverIndex(index);
-    e.target.setPointerCapture?.(e.pointerId);
-  }, []);
-  const handleDragMove = react.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 = react.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 = react.useCallback((index) => ({
-    onPointerDown: handleDragStart(index),
-    style: { cursor: "grab", touchAction: "none" },
-    "aria-grabbed": dragIndex === index,
-    role: "button"
-  }), [handleDragStart, dragIndex]);
-  const getItemProps = react.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 = react.useRef(null);
-  const callbackRef = react.useRef(onLoadMore);
-  callbackRef.current = onLoadMore;
-  const hasMoreRef = react.useRef(hasMore);
-  hasMoreRef.current = hasMore;
-  const isLoadingRef = react.useRef(isLoading);
-  isLoadingRef.current = isLoading;
-  react.useEffect(() => {
-    return () => {
-      observerRef.current?.disconnect();
-    };
-  }, []);
-  const sentinelRef = react.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] = react.useState(0);
-  const [isPulling, setIsPulling] = react.useState(false);
-  const [isRefreshing, setIsRefreshing] = react.useState(false);
-  const startY = react.useRef(0);
-  const scrollTopRef = react.useRef(0);
-  const onTouchStart = react.useCallback((e) => {
-    const container = e.currentTarget;
-    scrollTopRef.current = container.scrollTop;
-    if (scrollTopRef.current <= 0) {
-      startY.current = e.touches[0].clientY;
-      setIsPulling(true);
-    }
-  }, []);
-  const onTouchMove = react.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 = react.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 = react.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 = react.useRef(/* @__PURE__ */ new Map());
-  const pinch = react.useRef(null);
-  const computePinch = react.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 = react.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 = react.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 = react.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 = react.useCallback(
-    (e) => {
-      if (!enabled) return;
-      endPointer(e, true);
-    },
-    [enabled, endPointer]
-  );
-  const handlePointerCancel = react.useCallback(
-    (e) => {
-      if (!enabled) return;
-      endPointer(e, false);
-    },
-    [enabled, endPointer]
-  );
-  const handleWheel = react.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] = react.useState(false);
-  const onRevealRef = react.useRef(onReveal);
-  const onDismissRef = react.useRef(onDismiss);
-  onRevealRef.current = onReveal;
-  onDismissRef.current = onDismiss;
-  const reveal = react.useCallback(() => {
-    setRevealed((wasRevealed) => {
-      if (!wasRevealed) onRevealRef.current?.();
-      return true;
-    });
-  }, []);
-  const dismiss = react.useCallback(() => {
-    setRevealed((wasRevealed) => {
-      if (wasRevealed) onDismissRef.current?.();
-      return false;
-    });
-  }, []);
-  const onPointerDown = react.useCallback(
-    (e) => {
-      if (!enabled || e.pointerType === "mouse") return;
-      if (revealed) dismiss();
-      else reveal();
-    },
-    [enabled, revealed, reveal, dismiss]
-  );
-  react.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] = react.useState(false);
-  const eventBus = useEventBus();
-  const handleDragStart = react.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 = react.useCallback(
-    (e) => {
-      setIsDragging(false);
-      eventBus.emit("UI:DRAG_END", { kind: payload.kind, data: payload.data });
-    },
-    [payload, eventBus]
-  );
-  const dragProps = react.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] = react.useState(false);
-  const eventBus = useEventBus();
-  const handleDragOver = react.useCallback(
-    (e) => {
-      if (disabled) return;
-      if (!hasAlmadarPayload(e)) return;
-      e.preventDefault();
-      e.dataTransfer.dropEffect = "copy";
-      setIsOver(true);
-    },
-    [disabled]
-  );
-  const handleDragLeave = react.useCallback(
-    (e) => {
-      setIsOver(false);
-    },
-    []
-  );
-  const handleDrop = react.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 = react.useMemo(
-    () => ({
-      onDragOver: handleDragOver,
-      onDragLeave: handleDragLeave,
-      onDrop: handleDrop
-    }),
-    [handleDragOver, handleDragLeave, handleDrop]
-  );
-  return { dropProps, isOver };
-}
-function useRenderInterpolation(options = {}) {
-  const tickIntervalMs = options.tickIntervalMs ?? 1e3 / 30;
-  const prevRef = react.useRef(null);
-  const currRef = react.useRef(null);
-  const rafRef = react.useRef(null);
-  const onSnapshot = react.useCallback((entities) => {
-    prevRef.current = currRef.current;
-    currRef.current = { entities, arrivedAt: performance.now() };
-  }, []);
-  const getInterpolated = react.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 = react.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]
-  );
-  react.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 reactQuery.useQuery({
-    queryKey: ["github", "status"],
-    queryFn: () => fetchWithAuth("/api/github/status"),
-    staleTime: 6e4,
-    // 1 minute
-    retry: false
-  });
-}
-function useConnectGitHub() {
-  const connectGitHub = react.useCallback(() => {
-    const userId = getUserId();
-    const state = btoa(JSON.stringify({ userId, returnUrl: window.location.href }));
-    window.location.href = `${API_BASE}/api/github/oauth/authorize?state=${state}`;
-  }, []);
-  return { connectGitHub };
-}
-function useDisconnectGitHub() {
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.useQuery({
-    queryKey: ["github", "branches", owner, repo],
-    queryFn: () => fetchWithAuth(`/api/github/repos/${owner}/${repo}/branches`),
-    enabled: enabled && !!owner && !!repo,
-    staleTime: 6e4
-    // 1 minute
-  });
-}
-
-exports.ALMADAR_DND_MIME = ALMADAR_DND_MIME;
-exports.DEFAULT_SLOTS = DEFAULT_SLOTS;
-exports.I18nProvider = I18nProvider;
-exports.createTranslate = createTranslate;
-exports.parseQueryBinding = parseQueryBinding;
-exports.useAgentChat = useAgentChat;
-exports.useAuthContext = useAuthContext;
-exports.useCanvasGestures = useCanvasGestures;
-exports.useCompile = useCompile;
-exports.useConnectGitHub = useConnectGitHub;
-exports.useDeepAgentGeneration = useDeepAgentGeneration;
-exports.useDisconnectGitHub = useDisconnectGitHub;
-exports.useDragReorder = useDragReorder;
-exports.useDraggable = useDraggable;
-exports.useDropZone = useDropZone;
-exports.useEmitEvent = useEmitEvent;
-exports.useEventBus = useEventBus;
-exports.useEventListener = useEventListener;
-exports.useExtensions = useExtensions;
-exports.useFileEditor = useFileEditor;
-exports.useFileSystem = useFileSystem;
-exports.useGitHubBranches = useGitHubBranches;
-exports.useGitHubRepo = useGitHubRepo;
-exports.useGitHubRepos = useGitHubRepos;
-exports.useGitHubStatus = useGitHubStatus;
-exports.useInfiniteScroll = useInfiniteScroll;
-exports.useLongPress = useLongPress;
-exports.useOrbitalHistory = useOrbitalHistory;
-exports.usePreview = usePreview;
-exports.usePullToRefresh = usePullToRefresh;
-exports.useQuerySingleton = useQuerySingleton;
-exports.useRenderInterpolation = useRenderInterpolation;
-exports.useSwipeGesture = useSwipeGesture;
-exports.useTapReveal = useTapReveal;
-exports.useTraitListens = useTraitListens;
-exports.useTranslate = useTranslate;
-exports.useUIEvents = useUIEvents;
-exports.useUISlotManager = useUISlotManager;
-exports.useValidation = useValidation;