ltcai 7.9.0 → 8.1.0

package/latticeai/core/local_embeddings.py

@@ -23,6 +23,10 @@ DEFAULT_EMBEDDING_DIM = 384
 EMBEDDING_MODEL_ID = f"lattice-local-hash-v1:{DEFAULT_EMBEDDING_DIM}"
 
 
+def embedding_model_id(dim: int) -> str:
+    return f"lattice-local-hash-v1:{int(dim)}"
+
+
 def _tokenize(text: str) -> List[str]:
     raw = str(text or "").lower()
     tokens = re.findall(r"[a-z0-9][a-z0-9_.:/+-]{1,}|[가-힣]{2,}", raw)
@@ -57,6 +61,10 @@ class LocalEmbeddingModel:
     dim: int = DEFAULT_EMBEDDING_DIM
     model_id: str = EMBEDDING_MODEL_ID
 
+    def __post_init__(self) -> None:
+        if self.model_id == EMBEDDING_MODEL_ID and self.dim != DEFAULT_EMBEDDING_DIM:
+            object.__setattr__(self, "model_id", embedding_model_id(self.dim))
+
     def embed(self, text: str) -> List[float]:
         vector = [0.0] * self.dim
         features = _tokenize(text)

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "7.9.0"
+MARKETPLACE_VERSION = "8.1.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/mcp_registry.py

@@ -6,9 +6,12 @@ Extracted from server.py to reduce module size.
 
 import json
 import logging
+import os
+import subprocess
+import sys
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Callable, Dict, List, Optional
 
 import httpx
 from fastapi import HTTPException
@@ -789,3 +792,139 @@ async def install_skill(plugin: str, skill: str) -> Dict:
         "license": entry["license"],
         "author":  entry["author"],
     }
+
+
+def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
+    """Return bound MCP state helpers for given data_dir. No global side effects."""
+    MCP_FILE = Path(data_dir) / "mcp_installs.json"
+
+    def load_mcp_installs() -> Dict:
+        if not os.path.exists(MCP_FILE):
+            return {"installed": {}, "updated_at": None}
+        try:
+            with open(MCP_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if "installed" not in data:
+                data["installed"] = {}
+            return data
+        except Exception as e:
+            logging.warning("load_mcp_installs failed: %s", e)
+            return {"installed": {}, "updated_at": None}
+
+    def save_mcp_installs(data: Dict) -> None:
+        data["updated_at"] = datetime.now().isoformat()
+        with open(MCP_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def mcp_public_item(item: Dict, installed_state: Dict) -> Dict:
+        state = installed_state.get(item.get("id"), {}) or {}
+        installed = item.get("install_mode") in {"builtin", "bundled"} or bool(state.get("installed"))
+        connector_pending = item.get("install_mode") == "connector" and not state.get("authenticated")
+        authenticated = item.get("install_mode") != "connector" or bool(state.get("authenticated"))
+        return {
+            "id": item.get("id"),
+            "name": item.get("name"),
+            "category": item.get("category", ""),
+            "install_mode": item.get("install_mode"),
+            "description": item.get("description", ""),
+            "capabilities": item.get("capabilities", []),
+            "connector_url": item.get("connector_url"),
+            "external_url": item.get("external_url"),
+            "package": item.get("package"),
+            "homepage": item.get("homepage"),
+            "source": item.get("source", "local"),
+            "installed": installed,
+            "status": state.get("status") or ("active" if installed and not connector_pending else "needs_auth" if connector_pending else "available"),
+            "authenticated": authenticated,
+            "updated_at": state.get("updated_at"),
+        }
+
+    async def recommend_mcps(query: str, limit: int = 5) -> List[Dict]:
+        text = (query or "").lower()
+        installed = load_mcp_installs().get("installed", {})
+        registry = await _get_combined_registry()
+        scored: List[Dict] = []
+        for item in registry:
+            score = 0
+            hits: List[str] = []
+            for keyword in item.get("keywords", []):
+                if keyword.lower() in text:
+                    score += 3 if len(keyword) > 2 else 1
+                    hits.append(keyword)
+            if not hits and text:
+                desc_words = item.get("description", "").lower().split()
+                for word in text.split():
+                    if len(word) > 2 and word in desc_words:
+                        score += 1
+                        hits.append(word)
+            if item.get("id") == "filesystem" and any(w in text for w in ["만들", "구현", "build", "deploy", "코드", "앱"]):
+                score += 2
+            if score:
+                public = mcp_public_item(item, installed)
+                public["score"] = score
+                public["matched_keywords"] = hits[:6]
+                scored.append(public)
+        if not scored:
+            fallback_ids = ["filesystem", "browser", "documents"]
+            scored = [
+                {**mcp_public_item(item, installed), "score": 1, "matched_keywords": []}
+                for item in registry if item.get("id") in fallback_ids
+            ]
+        return sorted(scored, key=lambda x: x["score"], reverse=True)[:max(1, min(limit, 24))]
+
+    async def install_mcp(mcp_id: str) -> Dict:
+        registry = await _get_combined_registry()
+        item = next((entry for entry in registry if entry.get("id") == mcp_id), None)
+        if not item:
+            raise HTTPException(status_code=404, detail="MCP를 찾을 수 없습니다.")
+        data = load_mcp_installs()
+        state = data.setdefault("installed", {})
+        status = "active"
+        message = "MCP가 활성화되었습니다."
+        if item.get("install_mode") == "connector":
+            status = "needs_auth"
+            message = "커넥터 인증이 필요합니다. Codex 앱의 connector 설정에서 계정을 연결하면 바로 사용할 수 있습니다."
+        elif item.get("install_mode") == "pip":
+            packages = item.get("pip_packages") or []
+            for pkg in packages:
+                completed = subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "--upgrade", pkg],
+                    capture_output=True, text=True, timeout=900, check=False,
+                )
+                if completed.returncode != 0:
+                    raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
+            message = f"필수 패키지 설치 완료: {', '.join(packages)}"
+        elif item.get("install_mode") == "pypi":
+            pkg = item.get("package", "")
+            version = item.get("package_version")
+            pkg_str = f"{pkg}=={version}" if version else pkg
+            completed = subprocess.run([sys.executable, "-m", "pip", "install", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            if completed.returncode != 0:
+                raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
+            message = f"pip 패키지 설치 완료: {pkg_str}"
+        elif item.get("install_mode") == "npm":
+            pkg = item.get("package", "")
+            version = item.get("package_version")
+            pkg_str = f"{pkg}@{version}" if version else pkg
+            completed = subprocess.run(["npm", "install", "-g", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            if completed.returncode != 0:
+                raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
+            message = f"npm 패키지 설치 완료: {pkg_str}"
+        state[mcp_id] = {
+            "installed": True,
+            "status": status,
+            "authenticated": item.get("install_mode") != "connector",
+            "updated_at": datetime.now().isoformat(),
+        }
+        save_mcp_installs(data)
+        public = mcp_public_item(item, state)
+        public["message"] = message
+        return public
+
+    return {
+        "load_mcp_installs": load_mcp_installs,
+        "save_mcp_installs": save_mcp_installs,
+        "mcp_public_item": mcp_public_item,
+        "recommend_mcps": recommend_mcps,
+        "install_mcp": install_mcp,
+    }

package/latticeai/core/tool_registry.py

@@ -292,7 +292,14 @@ class ToolRegistry:
             })
         diagnostics = self.diagnostics()
         return {
+            "schema_version": "tool-registry-contract/v1",
             "status": "ok" if diagnostics["ready"] else "degraded",
+            "boundary": {
+                "owner": "latticeai.core.tool_registry.ToolRegistry",
+                "dispatch_owner": "tools.DEFAULT_TOOL_REGISTRY",
+                "policy_owner": "latticeai.core.tool_registry.ToolRegistry",
+                "permission_owner": "latticeai.services.tool_dispatch.ToolDispatchService",
+            },
             "catalog_brief": self.catalog_brief.strip(),
             "diagnostics": diagnostics,
             "tools": tools,

package/latticeai/core/workspace_os.py

@@ -21,7 +21,7 @@ from typing import Any, Callable, Dict, Iterable, List, Optional
 from lattice_brain.runtime.contracts import realtime_event_contract, run_record_contract, workflow_run_contract
 
 
-WORKSPACE_OS_VERSION = "7.9.0"
+WORKSPACE_OS_VERSION = "8.1.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/services/architecture_readiness.py

@@ -1,10 +1,10 @@
 """Machine-checkable architecture readiness gates for release work.
 
-The 7.7 complete-product line preserves the 7.6 closure of the two local review
-notes by keeping their architectural claims in a small contract: AgentRuntime,
-ToolRegistry, central Config,
-decomposed API routers, and Knowledge Graph portability must all be discoverable
-and testable before the release can be called complete.
+8.1.0 keeps the major architecture priorities under an explicit release
+contract while the product surface is refreshed. AgentRuntime, ToolRegistry,
+central Config, decomposed server runtime, and Knowledge Graph stabilization
+must remain discoverable, ordered, and backed by tests before the release can be
+called complete.
 """
 
 from __future__ import annotations
@@ -15,6 +15,19 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 
+ARCHITECTURE_VERSION_TARGET = "8.1.0"
+
+PREFERRED_REFACTORING_ORDER = [
+    "agent-runtime",
+    "tool-registry",
+    "config-centralization",
+    "server-decomposition",
+    "kg-hardening",
+    "documentation-sync",
+    "ui-enhancements",
+]
+
+
 @dataclass(frozen=True)
 class ArchitectureGate:
     id: str
@@ -108,12 +121,43 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
 
     api_router_count = len(list((root / "latticeai" / "api").glob("*.py")))
     runtime_module_count = len(list((root / "latticeai" / "runtime").glob("*.py")))
+    ordered_gate_ids = [gate.id for gate in gates]
+    contract = {
+        "schema_version": "lattice-architecture-contract/v1",
+        "version_target": ARCHITECTURE_VERSION_TARGET,
+        "refactoring_order": list(PREFERRED_REFACTORING_ORDER),
+        "boundaries": {
+            "agent-runtime": {
+                "owner": "lattice_brain.runtime.agent_runtime.AgentRuntime",
+                "surface": "/agents",
+                "status": "facade",
+            },
+            "tool-registry": {
+                "owner": "latticeai.core.tool_registry.ToolRegistry",
+                "surface": "/tools",
+                "status": "registry",
+            },
+            "config-centralization": {
+                "owner": "latticeai.core.config.Config",
+                "surface": "composition root",
+                "status": "typed-config",
+            },
+            "kg-hardening": {
+                "owner": "lattice_brain.graph.store.KnowledgeGraphStore",
+                "strategy": "additive reprojection with legacy read compatibility",
+                "rollback": "portable export/import and non-destructive migration paths",
+            },
+        },
+        "ordered_gate_ids": ordered_gate_ids,
+    }
     return {
         "status": "complete" if all(gate.status == "complete" for gate in gates) else "incomplete",
-        "version_target": "7.9.0",
+        "version_target": ARCHITECTURE_VERSION_TARGET,
+        "contract": contract,
         "gates": [gate.__dict__ for gate in gates],
         "metrics": {
             "api_router_modules": api_router_count,
             "runtime_modules": runtime_module_count,
+            "architecture_gates": len(gates),
         },
     }

package/latticeai/services/model_runtime.py

@@ -127,8 +127,42 @@ get_user_api_key = _missing_user_api_key
 
 
 def configure_model_runtime(**deps) -> None:
-    """Wire app-owned runtime dependencies without importing server_app."""
-    globals().update({key: value for key, value in deps.items() if key in globals()})
+    """Wire app-owned runtime dependencies without importing server_app.
+
+    Explicit per-key assignment (no blanket globals().update) so wiring is
+    auditable and side effects are visible. Preserves exact public module
+    globals and prior behavior for all callers and shims.
+    """
+    global router, APP_MODE, DEFAULT_HOST, DEFAULT_PORT, DATA_DIR, BASE_DIR
+    global ENABLE_TELEGRAM, ENABLE_GRAPH, AUTOLOAD_MODELS, MODEL_IDLE_UNLOAD_SECONDS
+    global ALLOW_LOCAL_MODELS, REQUIRE_AUTH, INVITE_GATE_ENABLED, ALLOW_PLAINTEXT_API_KEYS
+    global CORS_ALLOW_NETWORK, PUBLIC_MODEL, LOCAL_MODEL, IS_PUBLIC_MODE
+    global keyring, get_current_user, get_user_api_key
+
+    router = deps.get("router", router)
+    APP_MODE = deps.get("APP_MODE", APP_MODE)
+    DEFAULT_HOST = deps.get("DEFAULT_HOST", DEFAULT_HOST)
+    DEFAULT_PORT = deps.get("DEFAULT_PORT", DEFAULT_PORT)
+    DATA_DIR = deps.get("DATA_DIR", DATA_DIR)
+    BASE_DIR = deps.get("BASE_DIR", BASE_DIR)
+    ENABLE_TELEGRAM = deps.get("ENABLE_TELEGRAM", ENABLE_TELEGRAM)
+    ENABLE_GRAPH = deps.get("ENABLE_GRAPH", ENABLE_GRAPH)
+    AUTOLOAD_MODELS = deps.get("AUTOLOAD_MODELS", AUTOLOAD_MODELS)
+    MODEL_IDLE_UNLOAD_SECONDS = deps.get("MODEL_IDLE_UNLOAD_SECONDS", MODEL_IDLE_UNLOAD_SECONDS)
+    ALLOW_LOCAL_MODELS = deps.get("ALLOW_LOCAL_MODELS", ALLOW_LOCAL_MODELS)
+    REQUIRE_AUTH = deps.get("REQUIRE_AUTH", REQUIRE_AUTH)
+    INVITE_GATE_ENABLED = deps.get("INVITE_GATE_ENABLED", INVITE_GATE_ENABLED)
+    ALLOW_PLAINTEXT_API_KEYS = deps.get("ALLOW_PLAINTEXT_API_KEYS", ALLOW_PLAINTEXT_API_KEYS)
+    CORS_ALLOW_NETWORK = deps.get("CORS_ALLOW_NETWORK", CORS_ALLOW_NETWORK)
+    PUBLIC_MODEL = deps.get("PUBLIC_MODEL", PUBLIC_MODEL)
+    LOCAL_MODEL = deps.get("LOCAL_MODEL", LOCAL_MODEL)
+    IS_PUBLIC_MODE = deps.get("IS_PUBLIC_MODE", IS_PUBLIC_MODE)
+    if "keyring" in deps:
+        keyring = deps["keyring"]
+    if "get_current_user" in deps:
+        get_current_user = deps["get_current_user"]
+    if "get_user_api_key" in deps:
+        get_user_api_key = deps["get_user_api_key"]
 
 
 # Catalog data + version-dedup helpers live in ``model_catalog``; re-exported

package/latticeai/services/product_readiness.py

@@ -1,12 +1,13 @@
-"""Machine-checkable *product* readiness gates for the 7.9 line.
+"""Machine-checkable *product* readiness gates for the 8.1 line.
 
 Where ``architecture_readiness`` proves the internal structure is sound, this
-module answers the product question the 7.9 release exists to settle: *are the
-runtime boundaries still clear and release-ready after hardening?* It does so honestly — every
-gate is backed by evidence that is probed on disk, so a gate only reports
-``complete`` when its evidence actually resolves. The same report can be printed
-by ``scripts/product_readiness.py`` and re-run after every change, which is the
-point: completeness is something we keep measuring, not a one-time claim.
+module answers the product question the 8.1 release exists to settle: *is the
+Brain experience still release-ready after the default surface becomes more
+intuitive?* It does so honestly — every gate is backed by evidence that is
+probed on disk, so a gate only reports ``complete`` when its evidence actually
+resolves. The same report can be printed by ``scripts/product_readiness.py`` and
+re-run after every change, which is the point: completeness is something we keep
+measuring, not a one-time claim.
 """
 
 from __future__ import annotations
@@ -17,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "7.9.0"
+PRODUCT_VERSION_TARGET = "8.1.0"
 
 
 @dataclass(frozen=True)
@@ -64,10 +65,10 @@ PRODUCT_GATES: List[ProductGate] = [
         evidence=[
             "package.json::release:artifacts",
             "package.json::release:validate",
-            "README.md::dist/ltcai-7.9.0-py3-none-any.whl",
-            "README.md::dist/ltcai-7.9.0.tar.gz",
-            "README.md::dist/ltcai-7.9.0.vsix",
-            "README.md::ltcai-7.9.0.tgz",
+            "README.md::dist/ltcai-8.1.0-py3-none-any.whl",
+            "README.md::dist/ltcai-8.1.0.tar.gz",
+            "README.md::dist/ltcai-8.1.0.vsix",
+            "README.md::ltcai-8.1.0.tgz",
             "scripts/validate_release_artifacts.py",
             "scripts/release_smoke.py",
             "Dockerfile",
@@ -83,18 +84,19 @@ PRODUCT_GATES: List[ProductGate] = [
         title="Release story is documented and honest",
         evidence=[
             "README.md",
-            "README.md::The current release is **7.9.0",
-            "SECURITY.md::7.9.x (latest)",
-            "vscode-extension/README.md::**7.9.0",
-            "docs/CHANGELOG.md::## [7.9.0]",
+            "README.md::The current release is **8.1.0",
+            "SECURITY.md::8.1.x (latest)",
+            "vscode-extension/README.md::**8.1.0",
+            "docs/CHANGELOG.md::## [8.1.0]",
             "FEATURE_STATUS.md",
-            "RELEASE_NOTES_v7.9.0.md",
+            "RELEASE_NOTES_v8.1.0.md",
             "latticeai/core/agent.py::SingleAgentRuntime",
             "latticeai/core/agent.py::AgentRuntime = SingleAgentRuntime",
             "lattice_brain/runtime/contracts.py::runtime-boundary/v1",
             "lattice_brain/runtime/contracts.py::RuntimeBoundaryProtocol",
             "lattice_brain/runtime/agent_runtime.py::def boundary",
             "latticeai/core/agent.py::def boundary",
+            "latticeai/services/architecture_readiness.py::lattice-architecture-contract/v1",
             "latticeai/services/tool_dispatch.py::rollback_file",
         ],
     ),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "7.9.0",
+  "version": "8.1.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -85,7 +85,6 @@
     "static/manifest.json",
     "static/sw.js",
     "static/css/",
-    "frontend/",
     "static/app/",
     "static/icons/",
     "plugins/",
@@ -94,6 +93,7 @@
     "!docs/images/tmp_frames/",
     "!**/__pycache__/",
     "!**/*.pyc",
+    "!**/*.map",
     "README.md",
     "setup_wizard.py",
     "knowledge_graph_api.py",

package/scripts/build_frontend_assets.mjs

@@ -6,6 +6,7 @@ const repo = join(import.meta.dirname, "..");
 const appDir = join(repo, "static", "app");
 const nestedViteManifest = join(appDir, ".vite", "asset-manifest.json");
 const publicManifest = join(appDir, "asset-manifest.json");
+const serviceWorker = join(repo, "static", "sw.js");
 const pkg = JSON.parse(readFileSync(join(repo, "package.json"), "utf8"));
 
 const assetsDir = join(appDir, "assets");
@@ -39,11 +40,19 @@ const manifest = {
   version: pkg.version,
   generated_at: "vite",
   entrypoints: {
-    app: assets["frontend/index.html"] || "/static/app/index.html",
+    app: assets["index.html"] || "/static/app/index.html",
   },
   assets,
-  vite: raw,
 };
 
 writeFileSync(publicManifest, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+if (existsSync(serviceWorker)) {
+  const cacheVersion = pkg.version.replace(/\D/g, "");
+  const source = readFileSync(serviceWorker, "utf8");
+  const normalized = source.replace(
+    /const CACHE = "lattice-v[^"]+";/,
+    `const CACHE = "lattice-v${cacheVersion}";`,
+  );
+  if (normalized !== source) writeFileSync(serviceWorker, normalized, "utf8");
+}
 console.log(`wrote static/app/asset-manifest.json with ${Object.keys(assets).length} assets`);

package/src-tauri/Cargo.lock

@@ -1584,7 +1584,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "7.9.0"
+version = "8.1.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "7.9.0"
+version = "8.1.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "7.9.0",
+  "version": "8.1.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,110 +1,19 @@
 {
-  "version": "7.9.0",
+  "version": "8.1.0",
   "generated_at": "vite",
   "entrypoints": {
-    "app": "/static/app/index.html"
+    "app": "/static/app/assets/index-Bvv79nre.js"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "_primitives-CD38lt4n.js": "/static/app/assets/primitives-CD38lt4n.js",
-    "_textarea-BZk6ybp5.js": "/static/app/assets/textarea-BZk6ybp5.js",
-    "index.html": "/static/app/assets/index-DbcEYJQ2.js",
-    "assets/index-C7g26IF6.css": "/static/app/assets/index-C7g26IF6.css",
-    "src/pages/Act.tsx": "/static/app/assets/Act-DOvf59ru.js",
-    "src/pages/Brain.tsx": "/static/app/assets/Brain-C7_0mEiI.js",
-    "src/pages/Capture.tsx": "/static/app/assets/Capture-B9Tlhzqr.js",
-    "src/pages/Library.tsx": "/static/app/assets/Library-BJPEEm5O.js",
-    "src/pages/System.tsx": "/static/app/assets/System-D6t9jo9V.js"
-  },
-  "vite": {
-    "../node_modules/@tauri-apps/api/core.js": {
-      "file": "assets/core-CwxXejkd.js",
-      "name": "core",
-      "src": "../node_modules/@tauri-apps/api/core.js",
-      "isDynamicEntry": true
-    },
-    "_primitives-CD38lt4n.js": {
-      "file": "assets/primitives-CD38lt4n.js",
-      "name": "primitives",
-      "imports": [
-        "index.html"
-      ]
-    },
-    "_textarea-BZk6ybp5.js": {
-      "file": "assets/textarea-BZk6ybp5.js",
-      "name": "textarea",
-      "imports": [
-        "index.html"
-      ]
-    },
-    "index.html": {
-      "file": "assets/index-DbcEYJQ2.js",
-      "name": "index",
-      "src": "index.html",
-      "isEntry": true,
-      "dynamicImports": [
-        "../node_modules/@tauri-apps/api/core.js",
-        "src/pages/Act.tsx",
-        "src/pages/Brain.tsx",
-        "src/pages/Capture.tsx",
-        "src/pages/Library.tsx",
-        "src/pages/System.tsx"
-      ],
-      "css": [
-        "assets/index-C7g26IF6.css"
-      ]
-    },
-    "src/pages/Act.tsx": {
-      "file": "assets/Act-DOvf59ru.js",
-      "name": "Act",
-      "src": "src/pages/Act.tsx",
-      "isDynamicEntry": true,
-      "imports": [
-        "index.html",
-        "_primitives-CD38lt4n.js",
-        "_textarea-BZk6ybp5.js"
-      ]
-    },
-    "src/pages/Brain.tsx": {
-      "file": "assets/Brain-C7_0mEiI.js",
-      "name": "Brain",
-      "src": "src/pages/Brain.tsx",
-      "isDynamicEntry": true,
-      "imports": [
-        "index.html",
-        "_primitives-CD38lt4n.js",
-        "_textarea-BZk6ybp5.js"
-      ]
-    },
-    "src/pages/Capture.tsx": {
-      "file": "assets/Capture-B9Tlhzqr.js",
-      "name": "Capture",
-      "src": "src/pages/Capture.tsx",
-      "isDynamicEntry": true,
-      "imports": [
-        "index.html",
-        "_primitives-CD38lt4n.js"
-      ]
-    },
-    "src/pages/Library.tsx": {
-      "file": "assets/Library-BJPEEm5O.js",
-      "name": "Library",
-      "src": "src/pages/Library.tsx",
-      "isDynamicEntry": true,
-      "imports": [
-        "index.html",
-        "_primitives-CD38lt4n.js"
-      ]
-    },
-    "src/pages/System.tsx": {
-      "file": "assets/System-D6t9jo9V.js",
-      "name": "System",
-      "src": "src/pages/System.tsx",
-      "isDynamicEntry": true,
-      "imports": [
-        "index.html",
-        "_primitives-CD38lt4n.js"
-      ]
-    }
+    "_primitives-B70WOra0.js": "/static/app/assets/primitives-B70WOra0.js",
+    "_textarea-Czrd9gwM.js": "/static/app/assets/textarea-Czrd9gwM.js",
+    "index.html": "/static/app/assets/index-Bvv79nre.js",
+    "assets/index-Dslqglia.css": "/static/app/assets/index-Dslqglia.css",
+    "src/pages/Act.tsx": "/static/app/assets/Act-BOO66G-c.js",
+    "src/pages/Brain.tsx": "/static/app/assets/Brain-C6lEYiD7.js",
+    "src/pages/Capture.tsx": "/static/app/assets/Capture-TATXBRDw.js",
+    "src/pages/Library.tsx": "/static/app/assets/Library-DK4FIp8a.js",
+    "src/pages/System.tsx": "/static/app/assets/System-Bgs6Ql7x.js"
   }
 }