ltcai 2.2.2 → 3.0.1

package/static/v3/js/core/dom.js

@@ -0,0 +1,148 @@
+/* ============================================================================
+ * Lattice AI v3 — DOM helpers
+ * A tiny, dependency-free hyperscript. Builds real DOM nodes (no innerHTML for
+ * dynamic content → no injection surface). Ergonomic enough to author views.
+ * ========================================================================== */
+
+/**
+ * h("div.card#id", { props }, ...children)
+ *   - tag selector supports .class (many) and #id
+ *   - props: class | className, id, on:{event:fn}, dataset:{k:v},
+ *            style:{k:v} or string, html (trusted innerHTML), attrs (any other)
+ *   - children: Node | string | number | falsy (skipped) | array (flattened)
+ */
+export function h(selector, props, ...children) {
+  const { tag, id, classes } = parseSelector(selector);
+  const el = document.createElement(tag);
+  if (id) el.id = id;
+  if (classes.length) el.classList.add(...classes);
+
+  if (props && (props.nodeType || typeof props === "string" || Array.isArray(props))) {
+    children.unshift(props);
+    props = null;
+  }
+
+  if (props) {
+    for (const [key, val] of Object.entries(props)) {
+      if (val == null || val === false) continue;
+      if (key === "class" || key === "className") {
+        for (const c of String(val).split(/\s+/).filter(Boolean)) el.classList.add(c);
+      } else if (key === "on" && typeof val === "object") {
+        for (const [ev, fn] of Object.entries(val)) el.addEventListener(ev, fn);
+      } else if (key === "dataset" && typeof val === "object") {
+        for (const [k, v] of Object.entries(val)) { if (v != null) el.dataset[k] = v; }
+      } else if (key === "style" && typeof val === "object") {
+        for (const [k, v] of Object.entries(val)) el.style.setProperty(k, v);
+      } else if (key === "style") {
+        el.setAttribute("style", val);
+      } else if (key === "html") {
+        el.innerHTML = val;
+      } else if (key === "ref" && typeof val === "function") {
+        val(el);
+      } else if (key in el && key !== "list" && typeof val !== "object") {
+        try { el[key] = val; } catch { el.setAttribute(key, val); }
+      } else {
+        el.setAttribute(key, val === true ? "" : val);
+      }
+    }
+  }
+
+  appendChildren(el, children);
+  return el;
+}
+
+function parseSelector(sel) {
+  if (typeof sel !== "string") return { tag: "div", id: "", classes: [] };
+  const idMatch = sel.match(/#([\w-]+)/);
+  const id = idMatch ? idMatch[1] : "";
+  const classes = (sel.match(/\.([\w-]+)/g) || []).map((c) => c.slice(1));
+  const tag = (sel.match(/^([\w-]+)/) || [, "div"])[1];
+  return { tag, id, classes };
+}
+
+function appendChildren(el, children) {
+  for (const child of children.flat(Infinity)) {
+    if (child == null || child === false || child === true) continue;
+    el.append(child.nodeType ? child : document.createTextNode(String(child)));
+  }
+}
+
+/** Fragment of many children. */
+export function frag(...children) {
+  const f = document.createDocumentFragment();
+  appendChildren(f, children);
+  return f;
+}
+
+/** Replace the contents of a node. */
+export function render(host, ...children) {
+  host.replaceChildren();
+  appendChildren(host, children);
+  return host;
+}
+
+export function clear(host) { host.replaceChildren(); return host; }
+
+export function escapeHtml(s) {
+  return String(s == null ? "" : s).replace(/[&<>"']/g, (c) =>
+    ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+}
+
+export const $ = (sel, root = document) => root.querySelector(sel);
+export const $$ = (sel, root = document) => Array.from(root.querySelectorAll(sel));
+
+/** Tabler icon element: icon("home") → <i class="ti ti-home"> */
+export function icon(name, extra = "") {
+  const i = document.createElement("i");
+  i.className = `ti ti-${name}${extra ? " " + extra : ""}`;
+  i.setAttribute("aria-hidden", "true");
+  i.setAttribute("data-fallback", iconFallback(name));
+  return i;
+}
+
+function iconFallback(name) {
+  const map = {
+    home: "H", search: "?", menu: "=", x: "x", refresh: "R",
+    "arrow-up": "^", "arrow-up-right": ">", "arrows-join": "H",
+    "chart-dots-3": "G", "grid-dots": "V", message: "C", "message-2": "C",
+    "message-plus": "+", "message-off": "C", user: "U", users: "U",
+    settings: "S", files: "F", cpu: "M", "cpu-off": "M", "player-play": ">",
+    "player-stop": "s", "layout-sidebar": "<", "layout-sidebar-right": ">",
+    "external-link": "o", trash: "x", sparkles: "*", "alert-triangle": "!",
+    "alert-circle": "!", "info-circle": "i", "circle-check": "v",
+    "circle-filled": "*", "stack-2": "S", "ruler-2": "R", binary: "B",
+    category: "T", abc: "K", "search-off": "?"
+  };
+  if (map[name]) return map[name];
+  return String(name || "?").split("-").map((part) => part[0] || "").join("").slice(0, 2).toUpperCase() || "?";
+}
+
+/** Compact relative-time formatter. */
+export function timeAgo(value) {
+  if (!value) return "";
+  const then = new Date(value).getTime();
+  if (Number.isNaN(then)) return String(value);
+  const diff = Math.max(0, Date.now() - then);
+  const mins = Math.floor(diff / 60000);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.floor(hrs / 24);
+  if (days < 30) return `${days}d ago`;
+  return new Date(then).toLocaleDateString();
+}
+
+/** Format a number with thousands separators / compact suffix. */
+export function fmtNum(n) {
+  if (n == null || Number.isNaN(Number(n))) return "—";
+  const v = Number(n);
+  if (Math.abs(v) >= 1_000_000) return (v / 1_000_000).toFixed(1).replace(/\.0$/, "") + "M";
+  if (Math.abs(v) >= 1_000) return (v / 1_000).toFixed(1).replace(/\.0$/, "") + "k";
+  return v.toLocaleString();
+}
+
+export function debounce(fn, ms = 220) {
+  let t;
+  return (...args) => { clearTimeout(t); t = setTimeout(() => fn(...args), ms); };
+}

package/static/v3/js/core/fixtures.js

@@ -0,0 +1,171 @@
+/* ============================================================================
+ * Lattice AI v3 — Sample fixtures
+ * Clearly-labeled SAMPLE data used ONLY as a graceful fallback when a backend
+ * endpoint is not yet available. The UI always renders a "Sample data" badge
+ * when these are used, so nothing here is presented as real backend output.
+ * No backend logic is implemented — these are static shapes that mirror the
+ * live API contracts so views remain usable during local setup.
+ * ========================================================================== */
+
+export const INDEX_STATUS = {
+  generated_at: null,
+  pipelines: {
+    knowledge_graph: { state: "ready", entities: 1284, relations: 3960, last_built: null, coverage: 0.91 },
+    vector_index: { state: "ready", vectors: 48230, dimensions: 384, model: "lattice-local-hash-v1", coverage: 0.87 },
+    hybrid: { state: "ready", strategy: "weighted-rank-fusion", weights: { keyword: 0.35, vector: 0.40, graph: 0.25 }, last_eval: null },
+  },
+  sources: [
+    { id: "src-notes", label: "Workspace Notes", files: 312, state: "indexed", progress: 1 },
+    { id: "src-repo", label: "Connected Repo", files: 1840, state: "indexed", progress: 1 },
+    { id: "src-uploads", label: "Uploads", files: 96, state: "indexing", progress: 0.62 },
+  ],
+};
+
+export const GRAPH = {
+  nodes: [
+    { id: "n:lattice", label: "Lattice AI", type: "Topic", weight: 0.98, x: 0.5, y: 0.46 },
+    { id: "n:hybrid", label: "Hybrid Search", type: "Concept", weight: 0.86, x: 0.72, y: 0.30 },
+    { id: "n:vector", label: "Vector Index", type: "Concept", weight: 0.84, x: 0.30, y: 0.28 },
+    { id: "n:graph", label: "Knowledge Graph", type: "Concept", weight: 0.9, x: 0.5, y: 0.74 },
+    { id: "n:embed", label: "lattice-local-hash-v1", type: "Model", weight: 0.6, x: 0.16, y: 0.5 },
+    { id: "n:rrf", label: "Rank Fusion", type: "Method", weight: 0.58, x: 0.86, y: 0.54 },
+    { id: "n:notes", label: "Workspace Notes", type: "File", weight: 0.52, x: 0.36, y: 0.9 },
+    { id: "n:repo", label: "Connected Repo", type: "File", weight: 0.55, x: 0.66, y: 0.9 },
+  ],
+  edges: [
+    { from: "n:lattice", to: "n:hybrid", type: "provides", weight: 1.0 },
+    { from: "n:lattice", to: "n:graph", type: "builds", weight: 1.2 },
+    { from: "n:lattice", to: "n:vector", type: "builds", weight: 1.1 },
+    { from: "n:hybrid", to: "n:vector", type: "fuses", weight: 0.9 },
+    { from: "n:hybrid", to: "n:graph", type: "fuses", weight: 0.9 },
+    { from: "n:hybrid", to: "n:rrf", type: "uses", weight: 0.7 },
+    { from: "n:vector", to: "n:embed", type: "uses", weight: 0.8 },
+    { from: "n:graph", to: "n:notes", type: "from", weight: 0.6 },
+    { from: "n:graph", to: "n:repo", type: "from", weight: 0.6 },
+  ],
+};
+
+export const GRAPH_STATS = {
+  nodes: { Topic: 1, Concept: 3, Model: 1, Method: 1, File: 2 },
+  edges: { provides: 1, builds: 2, fuses: 2, uses: 2, from: 2 },
+  total_nodes: 8,
+  total_edges: 9,
+};
+
+export function hybridResults(query) {
+  const q = (query || "retrieval").trim() || "retrieval";
+  const base = [
+    { id: "doc-1", title: "Hybrid retrieval design notes", path: "notes/retrieval.md", snippet: `…blends the knowledge graph and the vector field for "${q}", reconciling structure with semantic proximity…`, vector: 0.91, lexical: 0.64, graph: 0.78 },
+    { id: "doc-2", title: "Vector index configuration", path: "config/index.yaml", snippet: `…embedding model and dimensions used to build the dense field that answers "${q}"…`, vector: 0.88, lexical: 0.41, graph: 0.35 },
+    { id: "doc-3", title: "Graph entity: Rank Fusion", path: "graph://method/rrf", snippet: `…reciprocal-rank fusion merges ranked lists so a strong "${q}" signal in either modality surfaces…`, vector: 0.54, lexical: 0.33, graph: 0.95 },
+    { id: "doc-4", title: "Workspace memory — decisions", path: "memory/decisions.md", snippet: `…prior decision relevant to "${q}", retrieved via graph adjacency from the active answer…`, vector: 0.49, lexical: 0.58, graph: 0.71 },
+    { id: "doc-5", title: "Connected repo: README", path: "repo/README.md", snippet: `…lexical hit on "${q}" reinforced by neighboring entities in the knowledge graph…`, vector: 0.4, lexical: 0.82, graph: 0.4 },
+  ];
+  return base.map((r) => ({ ...r, score: Number((0.4 * r.vector + 0.35 * r.lexical + 0.25 * r.graph).toFixed(3)) }))
+    .sort((a, b) => b.score - a.score);
+}
+
+export const WORKSPACE_OS = {
+  version: "3.0.0",
+  counts: { snapshots: 4, traces: 18, memories: 36, agent_runs: 12, workflows: 5, skills: 7, timeline: 24 },
+  models: { current_model: "mlx-community/local-model-4bit", loaded_models: ["mlx-community/local-model-4bit"] },
+};
+
+export const MODELS = {
+  current: "mlx-community/local-model-4bit",
+  catalog: [
+    { id: "mlx-community/local-model-4bit", name: "Local Model 4bit", family: "local", params: "12B", quant: "4bit", state: "loaded", context: 32768, recommended: true },
+    { id: "mlx-community/reasoner-8bit", name: "Reasoner 8bit", family: "local", params: "8B", quant: "8bit", state: "available", context: 16384 },
+    { id: "lattice-local-hash-v1", name: "lattice-local-hash-v1 (fallback vectors)", family: "embedding", params: "hash", quant: "local", state: "loaded", context: 384 },
+  ],
+};
+
+export const AGENTS = [
+  { id: "agent:planner", name: "Planner", role: "Decomposes goals into steps", state: "available", runs: 42, handoffs: ["agent:builder"] },
+  { id: "agent:builder", name: "Builder", role: "Implements and edits files", state: "available", runs: 38, handoffs: ["agent:reviewer"] },
+  { id: "agent:reviewer", name: "Reviewer", role: "Reviews diffs for risk", state: "idle", runs: 31, handoffs: [] },
+  { id: "agent:retriever", name: "Retriever", role: "Runs hybrid search over the workspace", state: "available", runs: 57, handoffs: ["agent:planner"] },
+];
+
+export const PIPELINES = [
+  { id: "pl-ingest", name: "Ingest → Embed → Graph", state: "active", stages: ["Watch source", "Chunk", "Embed", "Extract entities", "Link graph"], last_run: null, throughput: "1.8k files/run" },
+  { id: "pl-eval", name: "Retrieval Eval", state: "idle", stages: ["Sample queries", "Hybrid search", "Score fusion", "Report"], last_run: null, throughput: "120 q/run" },
+];
+
+export const FILES = [
+  { name: "retrieval.md", kind: "markdown", size: 4821, path: "notes/retrieval.md", indexed: true, updated: null },
+  { name: "index.yaml", kind: "config", size: 932, path: "config/index.yaml", indexed: true, updated: null },
+  { name: "decisions.md", kind: "markdown", size: 6210, path: "memory/decisions.md", indexed: true, updated: null },
+  { name: "diagram.png", kind: "image", size: 184320, path: "assets/diagram.png", indexed: false, updated: null },
+  { name: "dataset.csv", kind: "data", size: 51200, path: "data/dataset.csv", indexed: true, updated: null },
+];
+
+export const SYSINFO = { cpu_pct: 28.4, ram_pct: 61.2, gpu_mem_pct: 44.0, gpu_mem_gb: 12.6 };
+
+export const CHAT = {
+  conversations: [
+    { id: "conv-hybrid", title: "How hybrid search ranks", updated_at: "2026-06-06T13:20:00", messages: [
+      { role: "user", content: "How does hybrid search rank results?", timestamp: "2026-06-06T13:19:00" },
+      { role: "assistant", content: "It fuses two signals: the vector index scores semantic similarity, while the knowledge graph scores structural proximity. Reciprocal-rank fusion merges the two ranked lists so a strong hit in either modality surfaces.", timestamp: "2026-06-06T13:20:00" },
+    ] },
+    { id: "conv-reindex", title: "Reindex the workspace", updated_at: "2026-06-06T11:05:00", messages: [
+      { role: "user", content: "How do I rebuild the vector index?", timestamp: "2026-06-06T11:04:00" },
+      { role: "assistant", content: "Trigger a rebuild from the Pipeline view, or call the index rebuild endpoint. The embedding model re-encodes every chunk and the graph is relinked.", timestamp: "2026-06-06T11:05:00" },
+    ] },
+    { id: "conv-entities", title: "Entities in retrieval.md", updated_at: "2026-06-05T18:40:00", messages: [
+      { role: "user", content: "What entities were extracted from retrieval.md?", timestamp: "2026-06-05T18:39:00" },
+      { role: "assistant", content: "Hybrid Search, Vector Index, and Rank Fusion, each linked back to Lattice AI in the knowledge graph.", timestamp: "2026-06-05T18:40:00" },
+    ] },
+  ],
+};
+
+/** Build a sample graph-RAG trace (mirrors the backend /chat trace shape). */
+export function sampleTrace(query) {
+  return {
+    question: query || "",
+    confidence: 0.86,
+    graph_nodes: GRAPH.nodes.slice(0, 4).map((n) => ({ id: n.id, title: n.label, type: n.type })),
+    source_files: FILES.slice(0, 3).map((f) => ({ source: f.path })),
+    vector_matches: [
+      { path: "notes/retrieval.md", score: 0.91 },
+      { path: "config/index.yaml", score: 0.78 },
+      { path: "memory/decisions.md", score: 0.66 },
+    ],
+  };
+}
+
+export const ADMIN = {
+  summary: { total_users: 6, active_users: 5, admin_users: 2, total_messages: 1284 },
+  users: [
+    { email: "owner@acme.dev", nickname: "Owner", role: "owner", disabled: false, last_seen: null },
+    { email: "admin@acme.dev", nickname: "Admin", role: "admin", disabled: false, last_seen: null },
+    { email: "ml@acme.dev", nickname: "ML Eng", role: "member", disabled: false, last_seen: null },
+    { email: "guest@acme.dev", nickname: "Guest", role: "viewer", disabled: true, last_seen: null },
+  ],
+  roles: [
+    { role: "owner", members: 1, caps: ["all"] },
+    { role: "admin", members: 1, caps: ["users", "policies", "audit", "security"] },
+    { role: "member", members: 3, caps: ["chat", "search", "files", "pipeline"] },
+    { role: "viewer", members: 1, caps: ["chat", "search"] },
+  ],
+  audit: [
+    { ts: null, actor: "admin@acme.dev", action: "policy.update", target: "local_file_access", severity: "informational" },
+    { ts: null, actor: "ml@acme.dev", action: "search.hybrid", target: "q: retrieval design", severity: "informational" },
+    { ts: null, actor: "owner@acme.dev", action: "user.invite", target: "guest@acme.dev", severity: "notice" },
+    { ts: null, actor: "system", action: "index.rebuild", target: "vector_index", severity: "informational" },
+  ],
+  security: {
+    risk_rate: 1.2,
+    risky_messages: 3,
+    compliant_messages: 1281,
+    severity_counts: { high: 0, medium: 1, low: 2 },
+    dlp_fields: [{ field: "email", hits: 4 }, { field: "api_key", hits: 1 }],
+  },
+  policies: [
+    { id: "local_file_access", label: "Local file access", value: "Approval-token gated (per path/user/action)", enforced: true },
+    { id: "package_install", label: "Package install", value: "Admin-only with audit trail", enforced: true },
+    { id: "data_residency", label: "Data residency", value: "Single-tenant local storage (~/.ltcai)", enforced: true },
+    { id: "model_egress", label: "Model egress", value: "Local-only (no external inference)", enforced: true },
+  ],
+  vpc: { provider: "local", region: "on-prem", vpn_status: "standby", peering_status: "not_configured", private_subnets: [], enabled: false },
+};

package/static/v3/js/core/router.js

@@ -0,0 +1,37 @@
+/* ============================================================================
+ * Lattice AI v3 — Hash router
+ * Maps location.hash → { key, params }. Hash routing keeps the SPA shell
+ * served by a single static route (/app) with no server-side rewrites.
+ *   #/home                  → { key: "home" }
+ *   #/admin/users           → { key: "admin/users" }
+ *   #/chat?new=1            → { key: "chat", params: { new: "1" } }
+ * ========================================================================== */
+
+export function createRouter({ onRoute, fallback = "home" }) {
+  function parse() {
+    let hash = location.hash.replace(/^#\/?/, "");
+    let query = "";
+    const qi = hash.indexOf("?");
+    if (qi >= 0) { query = hash.slice(qi + 1); hash = hash.slice(0, qi); }
+    const key = hash.replace(/\/+$/, "") || fallback;
+    const params = {};
+    if (query) new URLSearchParams(query).forEach((v, k) => { params[k] = v; });
+    return { key, params };
+  }
+
+  function handle() { onRoute(parse()); }
+
+  return {
+    start() {
+      window.addEventListener("hashchange", handle);
+      if (!location.hash) { location.replace("#/" + fallback); }
+      else { handle(); }
+    },
+    current: parse,
+    navigate(key, params) {
+      const qs = params && Object.keys(params).length ? "?" + new URLSearchParams(params).toString() : "";
+      const next = "#/" + String(key).replace(/^#?\/?/, "") + qs;
+      if (location.hash === next) handle(); else location.hash = next;
+    },
+  };
+}

package/static/v3/js/core/routes.js

@@ -0,0 +1,73 @@
+/* ============================================================================
+ * Lattice AI v3 — Information architecture (single source of truth)
+ *
+ * One declarative table drives the nav rail, the command palette, the router,
+ * breadcrumbs, and lazy view loading. Mode gating (Basic < Advanced < Admin)
+ * and the Admin section live here so the whole shell stays consistent.
+ * ========================================================================== */
+
+export const MODE_RANK = { basic: 0, advanced: 1, admin: 2 };
+
+/** Nav groups in display order. */
+export const GROUPS = [
+  { id: "workspace", label: "Workspace" },
+  { id: "retrieval", label: "Retrieval" },
+  { id: "data", label: "Data" },
+  { id: "compute", label: "Compute" },
+  { id: "system", label: "System" },
+  { id: "admin", label: "Administration", adminOnly: true },
+];
+
+/**
+ * Route table. `minMode` = lowest mode in which the item appears in the rail
+ * (deep-links still resolve). `view` = module basename under js/views/.
+ */
+export const ROUTES = [
+  // Workspace
+  { key: "home", label: "Home", icon: "layout-dashboard", group: "workspace", minMode: "basic", view: "home", title: "Home", desc: "Your local-first AI workspace at a glance." },
+  { key: "chat", label: "Chat", icon: "message-2", group: "workspace", minMode: "basic", view: "chat", title: "Chat", desc: "Grounded conversation over your indexed workspace." },
+
+  // Retrieval (the product identity)
+  { key: "knowledge-graph", label: "Knowledge Graph", icon: "chart-dots-3", group: "retrieval", minMode: "basic", view: "knowledge-graph", title: "Knowledge Graph", desc: "Entities and relations extracted from your workspace." },
+  { key: "hybrid-search", label: "Hybrid Search", icon: "arrows-join", group: "retrieval", minMode: "basic", view: "hybrid-search", title: "Hybrid Search", desc: "Graph structure fused with vector similarity." },
+
+  // Data
+  { key: "files", label: "Files", icon: "folders", group: "data", minMode: "basic", view: "files", title: "Files", desc: "Connected sources and indexed documents." },
+  { key: "pipeline", label: "Pipeline", icon: "git-branch", group: "data", minMode: "advanced", view: "pipeline", title: "Pipeline", desc: "Ingest, embed, and graph-build flows." },
+
+  // Compute
+  { key: "agents", label: "Agents", icon: "robot", group: "compute", minMode: "advanced", view: "agents", title: "Agents", desc: "Multi-agent roles, runs, and handoffs." },
+  { key: "models", label: "Models", icon: "cpu", group: "compute", minMode: "basic", view: "models", title: "Models", desc: "Local MLX models and embeddings." },
+  { key: "my-computer", label: "My Computer", icon: "device-desktop-analytics", group: "compute", minMode: "advanced", view: "my-computer", title: "My Computer", desc: "Local hardware, memory, and runtime." },
+
+  // System
+  { key: "settings", label: "Settings", icon: "settings", group: "system", minMode: "basic", view: "settings", title: "Settings", desc: "Appearance, workspace, and integrations." },
+
+  // Admin
+  { key: "admin/users", label: "Users", icon: "users", group: "admin", minMode: "admin", view: "admin-users", title: "Users", desc: "Workspace members and access.", admin: true },
+  { key: "admin/permissions", label: "Permissions", icon: "key", group: "admin", minMode: "admin", view: "admin-permissions", title: "Permissions", desc: "Roles and capability mapping.", admin: true },
+  { key: "admin/audit", label: "Audit Logs", icon: "report-search", group: "admin", minMode: "admin", view: "admin-audit", title: "Audit Logs", desc: "Activity and access trail.", admin: true },
+  { key: "admin/security", label: "Security", icon: "shield-check", group: "admin", minMode: "admin", view: "admin-security", title: "Security", desc: "Sensitive-data signals and DLP.", admin: true },
+  { key: "admin/policies", label: "Policies", icon: "file-certificate", group: "admin", minMode: "admin", view: "admin-policies", title: "Policies", desc: "Governance and enforcement.", admin: true },
+  { key: "admin/private-vpc", label: "Private VPC", icon: "cloud-lock", group: "admin", minMode: "admin", view: "admin-private-vpc", title: "Private VPC", desc: "Network isolation and peering.", admin: true },
+];
+
+export const ROUTE_BY_KEY = Object.fromEntries(ROUTES.map((r) => [r.key, r]));
+
+/** Routes visible in the rail for a given mode. */
+export function visibleRoutes(mode) {
+  const rank = MODE_RANK[mode] ?? 0;
+  return ROUTES.filter((r) => {
+    if (r.admin) return mode === "admin";
+    return (MODE_RANK[r.minMode] ?? 0) <= rank;
+  });
+}
+
+/** Lazy-load a view module by basename. Cached. */
+const cache = new Map();
+export async function loadView(view) {
+  if (cache.has(view)) return cache.get(view);
+  const mod = await import(`../views/${view}.js`);
+  cache.set(view, mod);
+  return mod;
+}