@cryptiklemur/lattice 1.14.1 → 1.14.2

package/client/src/components/chat/ChatView.tsx

@@ -92,7 +92,7 @@ export function ChatView() {
       if (msg.type === "user") return 100;
       return 200;
     },
-    overscan: 30,
+    overscan: isMobile ? 10 : 20,
   });
 
   var scrollToBottom = useCallback(function () {
@@ -122,18 +122,12 @@ export function ChatView() {
           requestAnimationFrame(function () {
             var el = scrollParentRef.current;
             if (el) el.scrollTop = el.scrollHeight;
-            requestAnimationFrame(function () {
-              if (el) el.scrollTop = el.scrollHeight;
-            });
           });
         } else {
           var count = messages.length;
           var virt = virtualizer;
           requestAnimationFrame(function () {
             virt.scrollToIndex(count - 1, { align: "end" });
-            requestAnimationFrame(function () {
-              virt.scrollToIndex(count - 1, { align: "end" });
-            });
           });
         }
         return;
@@ -252,7 +246,7 @@ export function ChatView() {
       filled = contextUsage.inputTokens + contextUsage.cacheReadTokens + contextUsage.cacheCreationTokens;
       percent = Math.min(100, Math.round((filled / contextUsage.contextWindow) * 100));
     }
-    var autocompact = contextBreakdown ? Math.round((contextBreakdown.autocompactAt / contextBreakdown.contextWindow) * 100) : 90;
+    var autocompact = contextBreakdown && contextBreakdown.contextWindow > 0 ? Math.round((contextBreakdown.autocompactAt / contextBreakdown.contextWindow) * 100) : 90;
     return {
       contextPercent: percent,
       contextFilled: filled,

package/client/src/components/sidebar/SessionList.tsx

@@ -248,6 +248,10 @@ export function SessionList(props: SessionListProps) {
         var previewMsg = msg as SessionPreviewMessage;
         setPreviews(function (prev3) {
           var next = new Map(prev3);
+          if (next.size >= 100 && !next.has(previewMsg.sessionId)) {
+            var oldest = next.keys().next().value;
+            if (oldest !== undefined) next.delete(oldest);
+          }
           next.set(previewMsg.sessionId, previewMsg.preview);
           return next;
         });

package/client/src/hooks/useWebSocket.ts

@@ -8,6 +8,7 @@ export interface WebSocketContextValue {
   send: (msg: ClientMessage) => void;
   subscribe: (type: string, callback: (msg: ServerMessage) => void) => void;
   unsubscribe: (type: string, callback: (msg: ServerMessage) => void) => void;
+  reconnectNow: () => void;
 }
 
 export var WebSocketContext = createContext<WebSocketContextValue | null>(null);

package/client/src/providers/WebSocketProvider.tsx

@@ -80,7 +80,8 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
             cb(msg);
           });
         }
-      } catch {
+      } catch (err) {
+        console.warn("[lattice] Failed to parse WebSocket message:", err);
       }
     };
 
@@ -91,7 +92,7 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
       setStatus("disconnected");
       wsRef.current = null;
       if (hasConnectedRef.current) {
-        showToast("Disconnected from daemon. Reconnecting...", "warning");
+        showToast("Disconnected from daemon. Reconnecting automatically...", "warning");
         sendNotification("Lattice", "Lost connection to daemon", "connection");
       }
       scheduleReconnect();
@@ -113,6 +114,19 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
     }, delay);
   }
 
+  function reconnectNow() {
+    if (retryTimerRef.current !== null) {
+      clearTimeout(retryTimerRef.current);
+      retryTimerRef.current = null;
+    }
+    backoffRef.current = 1000;
+    if (wsRef.current) {
+      wsRef.current.close();
+      wsRef.current = null;
+    }
+    connect();
+  }
+
   function send(msg: ClientMessage) {
     var ws = wsRef.current;
     if (ws && ws.readyState === WebSocket.OPEN) {
@@ -157,7 +171,7 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
   }, []);
 
   return (
-    <WebSocketContext.Provider value={{ status, send, subscribe, unsubscribe }}>
+    <WebSocketContext.Provider value={{ status, send, subscribe, unsubscribe, reconnectNow }}>
       {props.children}
     </WebSocketContext.Provider>
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",

package/server/src/auth/passphrase.ts

@@ -1,6 +1,9 @@
 import { scryptSync, randomBytes, timingSafeEqual } from "node:crypto";
 
-var activeSessions = new Set<string>();
+var TOKEN_TTL = 86400000;
+var CLEANUP_INTERVAL = 600000;
+
+var activeSessions = new Map<string, number>();
 
 export function hashPassphrase(passphrase: string): string {
   var salt = randomBytes(16).toString("hex");
@@ -32,7 +35,7 @@ export function generateSessionToken(): string {
 }
 
 export function addSession(token: string): void {
-  activeSessions.add(token);
+  activeSessions.set(token, Date.now());
 }
 
 export function removeSession(token: string): void {
@@ -40,9 +43,26 @@ export function removeSession(token: string): void {
 }
 
 export function isValidSession(token: string): boolean {
-  return activeSessions.has(token);
+  var createdAt = activeSessions.get(token);
+  if (createdAt === undefined) {
+    return false;
+  }
+  if (Date.now() - createdAt > TOKEN_TTL) {
+    activeSessions.delete(token);
+    return false;
+  }
+  return true;
 }
 
 export function clearSessions(): void {
   activeSessions.clear();
 }
+
+setInterval(function () {
+  var now = Date.now();
+  activeSessions.forEach(function (createdAt, token) {
+    if (now - createdAt > TOKEN_TTL) {
+      activeSessions.delete(token);
+    }
+  });
+}, CLEANUP_INTERVAL);

package/server/src/daemon.ts

@@ -17,6 +17,8 @@ import "./handlers/chat";
 import "./handlers/attachment";
 import { loadInterruptedSessions, unwatchSessionLock, cleanupClientPermissions } from "./project/sdk-bridge";
 import { clearActiveSession, getActiveSession } from "./handlers/chat";
+import { clearActiveProject } from "./handlers/fs";
+import { clearClientRemoteNode } from "./ws/router";
 import "./handlers/fs";
 import "./handlers/terminal";
 import "./handlers/settings";
@@ -38,6 +40,10 @@ interface WsData {
   id: string;
 }
 
+var RATE_LIMIT_WINDOW = 10000;
+var RATE_LIMIT_MAX = 100;
+var clientRateLimits = new Map<string, { count: number; windowStart: number }>();
+
 function parseCookies(cookieHeader: string): Map<string, string> {
   var map = new Map<string, string>();
   var parts = cookieHeader.split(";");
@@ -295,6 +301,18 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
         sendTo(ws.data.id, { type: "mesh:nodes", nodes: buildNodesMessage() });
       },
       message(ws: ServerWebSocket<WsData>, message: string | Buffer) {
+        var now = Date.now();
+        var limit = clientRateLimits.get(ws.data.id);
+        if (!limit || now - limit.windowStart > RATE_LIMIT_WINDOW) {
+          limit = { count: 0, windowStart: now };
+          clientRateLimits.set(ws.data.id, limit);
+        }
+        limit.count++;
+        if (limit.count > RATE_LIMIT_MAX) {
+          sendTo(ws.data.id, { type: "chat:error", message: "Rate limit exceeded, please slow down" });
+          return;
+        }
+
         var text = typeof message === "string" ? message : message.toString();
         try {
           var msg = JSON.parse(text) as ClientMessage;
@@ -309,10 +327,13 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
           unwatchSessionLock(activeSession.sessionId);
         }
         clearActiveSession(ws.data.id);
+        clearActiveProject(ws.data.id);
+        clearClientRemoteNode(ws.data.id);
         removeClient(ws.data.id);
         cleanupClientTerminals(ws.data.id);
         cleanupClientAttachments(ws.data.id);
         cleanupClientPermissions(ws.data.id);
+        clientRateLimits.delete(ws.data.id);
         console.log(`[lattice] Client disconnected: ${ws.data.id}`);
       },
     },

package/server/src/handlers/attachment.ts

@@ -3,10 +3,13 @@ import type { AttachmentChunkMessage, AttachmentCompleteMessage, ClientMessage }
 import { registerHandler } from "../ws/router";
 import { sendTo } from "../ws/broadcast";
 
+var MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024;
+
 interface PendingUpload {
   chunks: Map<number, Buffer>;
   totalChunks: number;
   receivedCount: number;
+  totalBytes: number;
   createdAt: number;
 }
 
@@ -45,6 +48,7 @@ registerHandler("attachment", function (clientId: string, message: ClientMessage
         chunks: new Map(),
         totalChunks: msg.totalChunks,
         receivedCount: 0,
+        totalBytes: 0,
         createdAt: Date.now(),
       };
       store.set(msg.attachmentId, pending);
@@ -59,8 +63,20 @@ registerHandler("attachment", function (clientId: string, message: ClientMessage
       return;
     }
 
-    pending.chunks.set(msg.chunkIndex, Buffer.from(msg.data, "base64"));
+    var chunkBuffer = Buffer.from(msg.data, "base64");
+    if (pending.totalBytes + chunkBuffer.length > MAX_ATTACHMENT_SIZE) {
+      store.delete(msg.attachmentId);
+      sendTo(clientId, {
+        type: "attachment:error",
+        attachmentId: msg.attachmentId,
+        error: "Attachment exceeds maximum size of " + (MAX_ATTACHMENT_SIZE / 1024 / 1024) + "MB",
+      });
+      return;
+    }
+
+    pending.chunks.set(msg.chunkIndex, chunkBuffer);
     pending.receivedCount++;
+    pending.totalBytes += chunkBuffer.length;
 
     sendTo(clientId, {
       type: "attachment:progress",

package/server/src/handlers/session.ts

@@ -89,45 +89,73 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     setActiveProject(clientId, activateMsg.projectSlug);
     watchSessionLock(activateMsg.sessionId);
     void Promise.all([
-      loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId),
-      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId),
-      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId),
-      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId),
+      loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
+        console.error("[lattice] Failed to load session history:", err);
+        return null;
+      }),
+      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
+        console.error("[lattice] Failed to load session title:", err);
+        return null;
+      }),
+      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
+        console.error("[lattice] Failed to load session usage:", err);
+        return null;
+      }),
+      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
+        console.error("[lattice] Failed to load context breakdown:", err);
+        return null;
+      }),
     ]).then(function (results) {
-      var interrupted = wasSessionInterrupted(activateMsg.sessionId);
-      if (interrupted) {
-        clearInterruptedFlag(activateMsg.sessionId);
-      }
-      var busy = isSessionBusy(activateMsg.sessionId);
-      sendTo(clientId, {
-        type: "session:history",
-        projectSlug: activateMsg.projectSlug,
-        sessionId: activateMsg.sessionId,
-        messages: results[0],
-        title: results[1],
-        interrupted: interrupted || undefined,
-        busy: busy || undefined,
-      });
-      var usage = results[2];
-      if (usage) {
+      try {
+        var interrupted = wasSessionInterrupted(activateMsg.sessionId);
+        if (interrupted) {
+          clearInterruptedFlag(activateMsg.sessionId);
+        }
+        var busy = isSessionBusy(activateMsg.sessionId);
         sendTo(clientId, {
-          type: "chat:context_usage",
-          inputTokens: usage.inputTokens,
-          outputTokens: usage.outputTokens,
-          cacheReadTokens: usage.cacheReadTokens,
-          cacheCreationTokens: usage.cacheCreationTokens,
-          contextWindow: usage.contextWindow,
+          type: "session:history",
+          projectSlug: activateMsg.projectSlug,
+          sessionId: activateMsg.sessionId,
+          messages: results[0] || [],
+          title: results[1],
+          interrupted: interrupted || undefined,
+          busy: busy || undefined,
         });
+      } catch (err) {
+        console.error("[lattice] Error sending session history:", err);
+        sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
       }
-      var breakdown = results[3];
-      if (breakdown) {
-        sendTo(clientId, {
-          type: "chat:context_breakdown",
-          segments: breakdown.segments,
-          contextWindow: breakdown.contextWindow,
-          autocompactAt: breakdown.autocompactAt,
-        });
+      try {
+        var usage = results[2];
+        if (usage) {
+          sendTo(clientId, {
+            type: "chat:context_usage",
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+            contextWindow: usage.contextWindow,
+          });
+        }
+      } catch (err) {
+        console.error("[lattice] Error sending context usage:", err);
+      }
+      try {
+        var breakdown = results[3];
+        if (breakdown) {
+          sendTo(clientId, {
+            type: "chat:context_breakdown",
+            segments: breakdown.segments,
+            contextWindow: breakdown.contextWindow,
+            autocompactAt: breakdown.autocompactAt,
+          });
+        }
+      } catch (err) {
+        console.error("[lattice] Error sending context breakdown:", err);
       }
+    }).catch(function (err) {
+      console.error("[lattice] Failed to activate session:", err);
+      sendTo(clientId, { type: "chat:error", message: "Failed to activate session" });
     });
     return;
   }

package/server/src/index.ts

@@ -82,14 +82,33 @@ switch (command) {
 async function runDaemon(): Promise<void> {
   var { startDaemon } = await import("./daemon");
   writePid(process.pid);
-  process.on("SIGTERM", function () {
-    removePid();
-    process.exit(0);
-  });
-  process.on("SIGINT", function () {
-    removePid();
-    process.exit(0);
-  });
+  var shutdownInProgress = false;
+  function gracefulShutdown(): void {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    console.log("[lattice] Shutting down gracefully...");
+
+    var { broadcast, closeAllClients } = require("./ws/broadcast") as typeof import("./ws/broadcast");
+    var { getActiveStreamCount } = require("./project/sdk-bridge") as typeof import("./project/sdk-bridge");
+    var { stopMeshConnections } = require("./mesh/connector") as typeof import("./mesh/connector");
+
+    broadcast({ type: "chat:error", message: "Server is shutting down" });
+    stopMeshConnections();
+
+    var waited = 0;
+    var checkInterval = setInterval(function () {
+      var activeCount = getActiveStreamCount();
+      waited += 500;
+      if (activeCount === 0 || waited >= 5000) {
+        clearInterval(checkInterval);
+        closeAllClients();
+        removePid();
+        process.exit(0);
+      }
+    }, 500);
+  }
+  process.on("SIGTERM", gracefulShutdown);
+  process.on("SIGINT", gracefulShutdown);
   await startDaemon(portOverride);
 }
 

package/server/src/mesh/connector.ts

@@ -22,6 +22,17 @@ var messageCallbacks: Array<(nodeId: string, msg: MeshMessage) => void> = [];
 
 var MIN_BACKOFF_MS = 1000;
 var MAX_BACKOFF_MS = 30000;
+var CONNECTION_TIMEOUT_MS = 10000;
+var CIRCUIT_BREAKER_THRESHOLD = 5;
+var CIRCUIT_BREAKER_COOLDOWN = 60000;
+
+interface CircuitState {
+  failures: number;
+  openUntil: number;
+  halfOpen: boolean;
+}
+
+var circuitBreakers = new Map<string, CircuitState>();
 
 export function startMeshConnections(): void {
   var peers = loadPeers();
@@ -72,15 +83,38 @@ export function connectToPeer(nodeId: string, address: string): void {
 }
 
 function openConnection(conn: PeerConnection, url: string): void {
+  var circuit = circuitBreakers.get(conn.nodeId);
+  if (circuit && circuit.failures >= CIRCUIT_BREAKER_THRESHOLD && !circuit.halfOpen) {
+    if (Date.now() < circuit.openUntil) {
+      conn.retryTimer = setTimeout(function () {
+        if (conn.dead) return;
+        conn.retryTimer = null;
+        circuit!.halfOpen = true;
+        openConnection(conn, url);
+      }, circuit.openUntil - Date.now());
+      return;
+    }
+    circuit.halfOpen = true;
+  }
+
   var ws = new WebSocket(url);
   conn.ws = ws;
 
+  var connectionTimer = setTimeout(function () {
+    if (ws.readyState !== WebSocket.OPEN) {
+      console.error("[mesh] Connection timeout for peer: " + conn.nodeId);
+      ws.close();
+    }
+  }, CONNECTION_TIMEOUT_MS);
+
   ws.addEventListener("open", function () {
+    clearTimeout(connectionTimer);
     if (conn.dead) {
       ws.close();
       return;
     }
 
+    circuitBreakers.delete(conn.nodeId);
     conn.backoffMs = MIN_BACKOFF_MS;
 
     var identity = loadOrCreateIdentity();
@@ -134,11 +168,26 @@ function openConnection(conn: PeerConnection, url: string): void {
   });
 
   ws.addEventListener("close", function () {
+    clearTimeout(connectionTimer);
     if (conn.dead) {
       return;
     }
 
-    console.log("[mesh] Disconnected from peer: " + conn.nodeId + ", reconnecting in " + conn.backoffMs + "ms");
+    var circuit = circuitBreakers.get(conn.nodeId);
+    if (!circuit) {
+      circuit = { failures: 0, openUntil: 0, halfOpen: false };
+      circuitBreakers.set(conn.nodeId, circuit);
+    }
+    circuit.failures++;
+
+    if (circuit.halfOpen) {
+      circuit.halfOpen = false;
+      circuit.openUntil = Date.now() + CIRCUIT_BREAKER_COOLDOWN;
+      console.log("[mesh] Circuit breaker open for peer: " + conn.nodeId + " (half-open attempt failed)");
+    } else if (circuit.failures >= CIRCUIT_BREAKER_THRESHOLD) {
+      circuit.openUntil = Date.now() + CIRCUIT_BREAKER_COOLDOWN;
+      console.log("[mesh] Circuit breaker open for peer: " + conn.nodeId + " after " + circuit.failures + " consecutive failures");
+    }
 
     for (var i = 0; i < disconnectedCallbacks.length; i++) {
       disconnectedCallbacks[i](conn.nodeId);

package/server/src/mesh/pairing.ts

@@ -3,7 +3,10 @@ import QRCode from "qrcode";
 
 var BASE62_CHARS = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
 
-var pendingTokens = new Set<string>();
+var PAIRING_TOKEN_TTL = 300000;
+var CLEANUP_INTERVAL = 60000;
+
+var pendingTokens = new Map<string, number>();
 
 function base62Encode(buf: Buffer): string {
   var n = BigInt("0x" + buf.toString("hex"));
@@ -55,7 +58,7 @@ export async function generateInviteCode(
   var encoded = base62Encode(payload);
   var code = formatCode(encoded);
 
-  pendingTokens.add(token);
+  pendingTokens.set(token, Date.now());
 
   var qrDataUrl = await QRCode.toString(code, { type: "svg" });
 
@@ -86,9 +89,26 @@ export function parseInviteCode(
 }
 
 export function validatePairingToken(token: string): boolean {
-  return pendingTokens.has(token);
+  var createdAt = pendingTokens.get(token);
+  if (createdAt === undefined) {
+    return false;
+  }
+  if (Date.now() - createdAt > PAIRING_TOKEN_TTL) {
+    pendingTokens.delete(token);
+    return false;
+  }
+  return true;
 }
 
 export function consumePairingToken(token: string): void {
   pendingTokens.delete(token);
 }
+
+setInterval(function () {
+  var now = Date.now();
+  pendingTokens.forEach(function (createdAt, token) {
+    if (now - createdAt > PAIRING_TOKEN_TTL) {
+      pendingTokens.delete(token);
+    }
+  });
+}, CLEANUP_INTERVAL);

package/server/src/project/sdk-bridge.ts

@@ -5,7 +5,7 @@ import type { CanUseTool, PermissionMode, PermissionResult, PermissionUpdate } f
 import type { MessageParam } from "@anthropic-ai/sdk/resources";
 import type { Attachment } from "@lattice/shared";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { sendTo, broadcast } from "../ws/broadcast";
 import { syncSessionToPeers } from "../mesh/session-sync";
@@ -58,6 +58,7 @@ export function getAvailableModels(): ModelEntry[] {
 }
 
 var activeStreams = new Map<string, Query>();
+var pendingStreams = new Set<string>();
 var streamMetadata = new Map<string, { projectSlug: string; clientId: string; startedAt: number }>();
 var interruptedSessions = new Set<string>();
 
@@ -174,6 +175,10 @@ export function getActiveStream(sessionId: string): Query | undefined {
   return activeStreams.get(sessionId);
 }
 
+export function getActiveStreamCount(): number {
+  return activeStreams.size;
+}
+
 /**
  * Check if a session is controlled by an external process (not Lattice).
  * Lattice's own active streams are handled by isProcessing on the client,
@@ -339,11 +344,13 @@ export function startChatStream(options: ChatStreamOptions): void {
   var { projectSlug, sessionId, text, attachments, clientId, cwd, env, model, effort, isNewSession } = options;
   var startTime = Date.now();
 
-  if (activeStreams.has(sessionId)) {
+  if (activeStreams.has(sessionId) || pendingStreams.has(sessionId)) {
     sendTo(clientId, { type: "chat:error", message: "Session already has an active stream." });
     return;
   }
 
+  pendingStreams.add(sessionId);
+
   var projectSettingsPath = join(cwd, ".claude", "settings.json");
   var savedAdditionalDirs: string[] = [];
   var latticeDefaults: Record<string, unknown> = {};
@@ -442,7 +449,15 @@ export function startChatStream(options: ChatStreamOptions): void {
     if (toolName === "Bash") {
       var cmd = ((input.command || "") as string).trim();
       if (cmd.startsWith("cd ")) {
-        return Promise.resolve({ behavior: "allow", updatedInput: input, toolUseID: options.toolUseID } as PermissionResult);
+        var cdTarget = cmd.slice(3).trim().replace(/^["']|["']$/g, "");
+        if (cdTarget.startsWith("~")) {
+          cdTarget = join(homedir(), cdTarget.slice(1));
+        }
+        var cdResolved = resolve(cwd, cdTarget);
+        var home = homedir();
+        if (cdResolved.startsWith(cwd) || cdResolved === cwd || cdResolved.startsWith(home) || cdResolved === home) {
+          return Promise.resolve({ behavior: "allow", updatedInput: input, toolUseID: options.toolUseID } as PermissionResult);
+        }
       }
     }
 
@@ -606,6 +621,7 @@ export function startChatStream(options: ChatStreamOptions): void {
   }
 
   var stream = query({ prompt: queryPrompt, options: queryOptions });
+  pendingStreams.delete(sessionId);
   activeStreams.set(sessionId, stream);
   streamMetadata.set(sessionId, { projectSlug, clientId, startedAt: Date.now() });
   persistStreamState();
@@ -621,6 +637,7 @@ export function startChatStream(options: ChatStreamOptions): void {
       console.error("[lattice] SDK stream error: " + errMsg);
       sendTo(clientId, { type: "chat:error", message: errMsg });
     } finally {
+      pendingStreams.delete(sessionId);
       activeStreams.delete(sessionId);
       streamMetadata.delete(sessionId);
       persistStreamState();

package/server/src/ws/broadcast.ts

@@ -29,3 +29,10 @@ export function sendTo(id: string, message: object): void {
 export function getClientCount(): number {
   return clients.size;
 }
+
+export function closeAllClients(): void {
+  for (var [, ws] of clients) {
+    ws.close();
+  }
+  clients.clear();
+}

package/server/src/ws/router.ts

@@ -1,6 +1,31 @@
 import type { ClientMessage } from "@lattice/shared";
 import { sendTo } from "./broadcast";
 
+var _registry: typeof import("../project/registry") | null = null;
+var _connector: typeof import("../mesh/connector") | null = null;
+var _proxy: typeof import("../mesh/proxy") | null = null;
+
+function getRegistry(): typeof import("../project/registry") {
+  if (!_registry) {
+    _registry = require("../project/registry") as typeof import("../project/registry");
+  }
+  return _registry;
+}
+
+function getConnector(): typeof import("../mesh/connector") {
+  if (!_connector) {
+    _connector = require("../mesh/connector") as typeof import("../mesh/connector");
+  }
+  return _connector;
+}
+
+function getProxy(): typeof import("../mesh/proxy") {
+  if (!_proxy) {
+    _proxy = require("../mesh/proxy") as typeof import("../mesh/proxy");
+  }
+  return _proxy;
+}
+
 type Handler = (clientId: string, message: ClientMessage) => void | Promise<void>;
 
 var handlers = new Map<string, Handler>();
@@ -72,31 +97,20 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
 }
 
 function getLocalProject(slug: string): boolean {
-  try {
-    var { getProjectBySlug } = require("../project/registry") as typeof import("../project/registry");
-    return getProjectBySlug(slug) !== undefined;
-  } catch {
-    return false;
-  }
+  return getRegistry().getProjectBySlug(slug) !== undefined;
 }
 
 function getRemoteNodeForProject(slug: string): { nodeId: string } | undefined {
-  try {
-    var { findNodeForProject } = require("../mesh/connector") as typeof import("../mesh/connector");
-    var nodeId = findNodeForProject(slug);
-    if (nodeId) {
-      return { nodeId: nodeId };
-    }
-    return undefined;
-  } catch {
-    return undefined;
+  var nodeId = getConnector().findNodeForProject(slug);
+  if (nodeId) {
+    return { nodeId: nodeId };
   }
+  return undefined;
 }
 
 function proxyMessage(clientId: string, nodeId: string, projectSlug: string, message: ClientMessage): void {
   try {
-    var { proxyToRemoteNode } = require("../mesh/proxy") as typeof import("../mesh/proxy");
-    proxyToRemoteNode(nodeId, projectSlug, clientId, message);
+    getProxy().proxyToRemoteNode(nodeId, projectSlug, clientId, message);
   } catch (err) {
     console.error("[router] Failed to proxy message:", err);
     sendTo(clientId, { type: "chat:error", message: "Failed to proxy message to remote node" });