@schlessera/brain-ui-react 0.14.0 → 0.16.0

package/src/config.ts

@@ -1,8 +1,21 @@
 /**
- * Deployment-tunable branding/copy. A module-level singleton, matching the
- * renderer/ASR registries: the shell calls `configureBrainUi()` once at boot
- * (before mounting), components read `uiConfig` at render time. Runtime
- * plugin-style reconfiguration is deliberately unsupported.
+ * The package's single configuration chokepoint.
+ *
+ * `ui-server` resolves its configuration once, at the edge, in `createApp()`,
+ * and nothing deeper in that package touches the ambient environment. This is
+ * the browser-side mirror of that rule: the deployment shell calls
+ * `configureBrainUi()` once at boot, before the first render, and every module
+ * below reads the resolved values instead of reaching for build-tool globals.
+ *
+ * The rule exists because a library that reads `import.meta.env` pins its
+ * consumers to one bundler. `VITE_BACKEND_URL` used to be read here at module
+ * load, so a webpack or Next.js consumer had no way to point the client at a
+ * split-topology backend at all, and no way to discover that from the types.
+ * `scripts/check-env-access.ts` now refuses `import.meta.env` anywhere in a
+ * package's `src`, so the loophole cannot reopen.
+ *
+ * Values are a module-level singleton, matching the renderer/ASR registries.
+ * Runtime plugin-style reconfiguration is deliberately unsupported.
  */
 export interface BrainUiConfig {
   /** Product name shown on the login screen and connection status. */
@@ -13,6 +26,24 @@ export interface BrainUiConfig {
   shareTitle: string;
   /** Composer placeholder. */
   composerPlaceholder: string;
+  /**
+   * Origin of the API/WebSocket backend, for a SPLIT topology (client and
+   * backend on different origins, e.g. a public frontend reaching its backend
+   * over a VPN). Empty — the default — means SAME-ORIGIN: API calls go to
+   * `/api` and the WebSocket derives its host from `window.location`.
+   *
+   * The shell resolves this however it likes (a Vite `VITE_*` define, a
+   * `<meta>` tag, a runtime fetch) and passes the result in. A trailing slash
+   * is stripped.
+   */
+  backendUrl: string;
+  /**
+   * Install the `window.__chatStore` / `window.__graphStore` debug handles,
+   * which let browser automation inject fixture messages without a live agent
+   * session. The shell decides what "development" means — this package must
+   * not infer it from a bundler's DEV flag.
+   */
+  devTools: boolean;
 }
 
 export const uiConfig: BrainUiConfig = {
@@ -20,8 +51,36 @@ export const uiConfig: BrainUiConfig = {
   assistantName: "Brain",
   shareTitle: "Shared from Brain",
   composerPlaceholder: "Ask your brain anything...",
+  backendUrl: "",
+  devTools: false,
 };
 
+/**
+ * Dev-handle installers, registered at module scope by the stores that own a
+ * handle. They cannot read `uiConfig.devTools` themselves: ES imports are
+ * hoisted, so a store's module body runs BEFORE the shell's
+ * `configureBrainUi()` call. Registering instead of reading lets the flag
+ * arrive late and still take effect.
+ */
+const devHandleInstallers: Array<() => void> = [];
+let devHandlesInstalled = false;
+
+function installDevHandles(): void {
+  if (devHandlesInstalled) return;
+  devHandlesInstalled = true;
+  for (const install of devHandleInstallers) install();
+}
+
+/** Register a debug handle to install if (and when) `devTools` is turned on. */
+export function registerDevHandle(install: () => void): void {
+  devHandleInstallers.push(install);
+  if (uiConfig.devTools) install();
+}
+
 export function configureBrainUi(overrides: Partial<BrainUiConfig>): void {
   Object.assign(uiConfig, overrides);
+  if (typeof overrides.backendUrl === "string") {
+    uiConfig.backendUrl = overrides.backendUrl.replace(/\/$/, "");
+  }
+  if (uiConfig.devTools) installDevHandles();
 }

package/src/hooks/use-websocket.ts

@@ -1,5 +1,5 @@
 import { useEffect, useRef, useCallback } from "react";
-import { WSClient } from "../lib/ws-client.js";
+import { BrainUiClient } from "@schlessera/brain-ui-sdk/client";
 import { useConnectionStore } from "../stores/connection-store.js";
 import { useChatStore, activeChat, type ChatKey } from "../stores/chat-store.js";
 import { useProviderStore } from "../stores/provider-store.js";
@@ -96,6 +96,31 @@ export function runStateForFrame(msg: ServerMessage): "streaming" | "queued" | "
   return "streaming";
 }
 
+/**
+ * Does this frame announce the identity of the conversation THIS client just
+ * started?
+ *
+ * The old test was `session_info || result` for any unknown session, which
+ * adopted whichever arrived first — an older background turn finishing, or
+ * another client's new session, would capture the user's draft and bind it to
+ * a transcript they never wrote. `draftId` is minted per draft turn and echoed
+ * on `session_info`, so a match is proof.
+ *
+ * A server too old to echo it sends no `draftId`, and the pre-existing
+ * behaviour applies rather than the draft never binding at all: correctness
+ * where the information exists, compatibility where it does not.
+ */
+function isOurDraftAnnouncement(
+  state: ReturnType<typeof useChatStore.getState>,
+  msg: ServerMessage
+): boolean {
+  if (msg.type !== "session_info" && msg.type !== "result") return false;
+  const pending = state.pendingDraftId;
+  if (msg.type === "session_info" && msg.draftId) return msg.draftId === pending;
+  // No echo to compare against.
+  return true;
+}
+
 export function handleServerMessage(msg: ServerMessage) {
   const state = useChatStore.getState();
 
@@ -119,7 +144,7 @@ export function handleServerMessage(msg: ServerMessage) {
     key = state.activeSessionId; // null = the draft view
   } else if (state.buffers[frameSessionId]) {
     key = frameSessionId;
-  } else if (state.draft && (msg.type === "session_info" || msg.type === "result")) {
+  } else if (state.draft && isOurDraftAnnouncement(state, msg)) {
     // A draft run just got its server identity: adopt the draft buffer.
     state.bindDraftSession(frameSessionId);
     key = frameSessionId;
@@ -268,6 +293,11 @@ export function handleServerMessage(msg: ServerMessage) {
     }
 
     case "error":
+      // ALWAYS recorded. Appending to the transcript only works while a
+      // message is streaming, and this used to be the whole handler — so an
+      // error arriving between turns (a rejected frame, a failed resume) was
+      // dropped as silently on the client as it was on the server.
+      useConnectionStore.getState().reportError(msg.code, msg.message);
       if (buffer()?.isStreaming) {
         state.appendText(key, `\n\n**Error:** ${msg.message}`);
         state.finishAssistantMessage(key);
@@ -382,7 +412,7 @@ function handleStatusChange(status: "connecting" | "connected" | "disconnected")
 }
 
 // Singleton client - survives React re-renders
-let wsClient: WSClient | null = null;
+let wsClient: BrainUiClient | null = null;
 
 /**
  * Send on the live socket from outside a component.
@@ -393,8 +423,8 @@ let wsClient: WSClient | null = null;
  * socket for both. Anything that needs to send but not to own (the share
  * intake) goes through here instead of calling the hook again.
  *
- * Returns false when there is no open socket, since `WSClient.send` drops
- * silently in that case and a caller that just staged an upload needs to know.
+ * Returns false when there is no open socket: `send` drops silently in that
+ * case and a caller that just staged an upload needs to know.
  */
 export function sendClientMessage(msg: ClientMessage): boolean {
   if (!wsClient) return false;
@@ -410,7 +440,26 @@ export function useWebSocket() {
     if (initialized.current) return;
     initialized.current = true;
 
-    wsClient = new WSClient(getWsUrl(), handleServerMessage, handleStatusChange);
+    wsClient = new BrainUiClient({
+      url: getWsUrl(),
+      // One handler with a shared preamble, rather than sixteen copies of the
+      // session-buffer demux — see handleServerMessage.
+      handlers: { onAny: handleServerMessage },
+      onStatusChange: handleStatusChange,
+      // A frame the SDK refused. Surfaced rather than logged into a console
+      // nobody is attached to; the server-side counterpart is the
+      // ws.frames.dropped counter.
+      onProtocolError: (err) => {
+        useConnectionStore
+          .getState()
+          .reportError(
+            "PROTOCOL_ERROR",
+            err.frameType
+              ? `Dropped a ${err.frameType} frame: ${err.detail}`
+              : `Dropped an unreadable frame: ${err.detail}`
+          );
+      },
+    });
     wsClient.connect();
 
     // Skip the exponential backoff when the network demonstrably returns.

package/src/index.ts

@@ -72,4 +72,4 @@ export { ShareIntake } from "./components/chat/share-card.js";
 
 // API surface (typed REST client + backend URL helpers).
 export { api } from "./lib/api-client.js";
-export { API_BASE, getWsUrl, getBackendUrl } from "./lib/backend.js";
+export { apiBase, getWsUrl, getBackendUrl } from "./lib/backend.js";

package/src/lib/api-client.ts

@@ -1,4 +1,4 @@
-import { API_BASE } from "./backend.js";
+import { apiBase } from "./backend.js";
 import type {
   VoiceKeytermsResponse,
   VoiceTokenResponse,
@@ -46,7 +46,7 @@ export interface BackendInfo {
 }
 
 async function fetchJson<T>(path: string, init?: RequestInit): Promise<T> {
-  const res = await fetch(`${API_BASE}${path}`, {
+  const res = await fetch(`${apiBase()}${path}`, {
     ...init,
     headers: {
       "Content-Type": "application/json",

package/src/lib/backend.ts

@@ -1,26 +1,27 @@
 /**
- * Backend URL configuration.
+ * Where the API and WebSocket live.
  *
  * Default topology is SAME-ORIGIN: the server serves the built client and the
  * API/WS from one origin, so API calls go to "/api" and the WebSocket derives
- * its host from window.location. No build-time configuration is needed.
+ * its host from window.location. Nothing needs configuring.
  *
- * VITE_BACKEND_URL is optional advanced config for a SPLIT topology (client and
- * backend on different origins, e.g. a public frontend with the backend reached
- * over a VPN). When set at build time, API and WS calls target that origin.
- * The read is defensive — outside a Vite build (bun test, Node import of the
- * dist) `import.meta.env` does not exist.
+ * A SPLIT topology (client and backend on different origins) sets
+ * `backendUrl` through `configureBrainUi()`. These are functions rather than
+ * module constants on purpose: a constant would freeze the value at import
+ * time, and ES imports are hoisted, so it would always capture the default
+ * instead of what the shell configured.
  */
-const viteEnv = (import.meta as { env?: Record<string, string | undefined> }).env;
-const BACKEND_URL = viteEnv?.VITE_BACKEND_URL?.replace(/\/$/, "") ?? "";
+import { uiConfig } from "../config.js";
 
-/** Base URL for API calls. Empty BACKEND_URL = same-origin "/api". */
-export const API_BASE = `${BACKEND_URL}/api`;
+/** Base URL for API calls. Empty backendUrl = same-origin "/api". */
+export function apiBase(): string {
+  return `${uiConfig.backendUrl}/api`;
+}
 
-/** WebSocket URL. Derives wss/ws + host from BACKEND_URL, else same-origin. */
+/** WebSocket URL. Derives wss/ws + host from backendUrl, else same-origin. */
 export function getWsUrl(): string {
-  if (BACKEND_URL) {
-    const url = new URL("/ws", BACKEND_URL);
+  if (uiConfig.backendUrl) {
+    const url = new URL("/ws", uiConfig.backendUrl);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     return url.toString();
   }
@@ -31,5 +32,5 @@ export function getWsUrl(): string {
 
 /** Base URL for direct fetch calls (streaming endpoints). */
 export function getBackendUrl(path: string): string {
-  return `${BACKEND_URL}${path}`;
+  return `${uiConfig.backendUrl}${path}`;
 }

package/src/lib/share-intake.ts

@@ -4,7 +4,7 @@ import {
   type ShareIntakeResult,
 } from "@schlessera/brain-ui-sdk/protocol";
 import type { StoredShare } from "@schlessera/brain-ui-sdk/share-target";
-import { API_BASE } from "./backend.js";
+import { apiBase } from "./backend.js";
 import {
   fileToAttachment,
   validateAttachments,
@@ -85,7 +85,7 @@ export async function uploadShare(
 
   let response: Response;
   try {
-    response = await fetchImpl(`${API_BASE}/share`, {
+    response = await fetchImpl(`${apiBase()}/share`, {
       method: "POST",
       body: form,
     });

package/src/lib/share.ts

@@ -1,4 +1,4 @@
-import { API_BASE } from "./backend.js";
+import { apiBase } from "./backend.js";
 import type { RenderRequest } from "@schlessera/brain-ui-sdk/protocol";
 
 export type ShareKind = "file" | "text" | "richtext";
@@ -125,7 +125,7 @@ export async function renderToFile(
   req: RenderRequest,
   filename: string
 ): Promise<File> {
-  const res = await fetch(`${API_BASE}/render`, {
+  const res = await fetch(`${apiBase()}/render`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(req),

package/src/stores/chat-store.ts

@@ -6,6 +6,7 @@ import type {
   AskUserAnnotation,
 } from "@schlessera/brain-ui-sdk/protocol";
 import { useProviderStore } from "./provider-store.js";
+import { registerDevHandle } from "../config.js";
 
 export type { MessagePart };
 
@@ -102,6 +103,17 @@ interface ChatState {
   buffers: Record<string, SessionChat>;
   /** The unbound new-conversation buffer, if one is in progress. */
   draft: SessionChat | null;
+  /**
+   * Correlation id for the conversation the draft is currently starting.
+   *
+   * A client starting a conversation has no session id, so it used to adopt
+   * the FIRST `session_info` for an unknown session — which could be an older
+   * background turn's, or another client's, silently binding the user's draft
+   * to someone else's transcript. The id is sent on `chat_message` and echoed
+   * on `session_info`; adoption now requires a match. Null when no draft turn
+   * is in flight.
+   */
+  pendingDraftId: string | null;
   /** The session in view; null = the draft / new-chat view. */
   activeSessionId: string | null;
 
@@ -167,6 +179,8 @@ interface ChatState {
    * If the draft view is active, the view follows. No-op draft = empty buffer.
    */
   bindDraftSession: (sessionId: string) => void;
+  /** Mint and remember the correlation id for a draft turn about to be sent. */
+  startDraftTurn: () => string;
   /** Switch the view to a session (creating an empty buffer if none), or to the draft (null). */
   setActiveSession: (sessionId: string | null) => void;
   /** New chat: drop the draft, unbind the view, unpin the provider. */
@@ -301,10 +315,25 @@ export const useChatStore = create<ChatState>((set, get) => {
   ): void {
     mutateBuffer(key, (chat) => {
       const msgs = [...chat.messages];
-      const last = msgs[msgs.length - 1];
+      // The last ASSISTANT message, not the last message.
+      //
+      // A follow-up sent mid-stream appends a user message to the end of the
+      // buffer while the assistant is still streaming into the message before
+      // it. Indexing the end therefore aimed every subsequent delta at the
+      // user's own message, where `role === "assistant"` failed and the write
+      // was silently discarded — the turn kept running and its output stopped
+      // appearing. Scanning backwards costs nothing at these lengths and
+      // leaves single-message behaviour identical.
+      let index = -1;
+      for (let i = msgs.length - 1; i >= 0; i--) {
+        if (msgs[i].role === "assistant") {
+          index = i;
+          break;
+        }
+      }
       let out: Partial<SessionChat> = {};
-      if (last?.role === "assistant") {
-        msgs[msgs.length - 1] = fn(last);
+      if (index !== -1) {
+        msgs[index] = fn(msgs[index]);
         out = { messages: msgs };
       }
       return extra ? { ...out, ...extra(chat) } : out;
@@ -314,6 +343,7 @@ export const useChatStore = create<ChatState>((set, get) => {
   return {
     buffers: {},
     draft: null,
+    pendingDraftId: null,
     // localStorage (not sessionStorage) so the active session id survives the
     // PWA process being killed on mobile — that durability is what lets a cold
     // relaunch re-request the full transcript instead of showing nothing.
@@ -573,6 +603,15 @@ export const useChatStore = create<ChatState>((set, get) => {
         };
       }),
 
+    startDraftTurn: () => {
+      const id =
+        typeof crypto !== "undefined" && "randomUUID" in crypto
+          ? crypto.randomUUID()
+          : `draft-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      set({ pendingDraftId: id });
+      return id;
+    },
+
     bindDraftSession: (sessionId) =>
       set((state) => {
         const adopted = state.buffers[sessionId] ?? state.draft ?? emptyChat();
@@ -585,6 +624,7 @@ export const useChatStore = create<ChatState>((set, get) => {
         return {
           buffers,
           draft: null,
+          pendingDraftId: null,
           ...(followView ? { activeSessionId: sessionId } : {}),
         };
       }),
@@ -631,10 +671,12 @@ export const useChatStore = create<ChatState>((set, get) => {
 });
 
 // Dev-only handle so browser automation / manual debugging can inject
-// fixture messages without a live Claude session. The env read is defensive:
-// outside a Vite build `import.meta.env` does not exist.
-const devEnv = (import.meta as { env?: Record<string, unknown> }).env;
-if (typeof window !== "undefined" && devEnv?.DEV) {
+// fixture messages without a live Claude session. Registered rather than
+// installed: whether this is a development build is the shell's call
+// (`configureBrainUi({ devTools: true })`), not something a component library
+// infers from its bundler.
+registerDevHandle(() => {
+  if (typeof window === "undefined") return;
   (window as unknown as { __chatStore?: typeof useChatStore }).__chatStore =
     useChatStore;
-}
+});

package/src/stores/connection-store.ts

@@ -8,16 +8,38 @@ type VpnStatus =
   | "unreachable"
   | "checking";
 
+/**
+ * The last thing that went wrong, whether or not a turn was running.
+ *
+ * Before this existed, a `error` frame was only surfaced when a message was
+ * mid-stream: it was appended to the streaming transcript, and outside a turn
+ * it went nowhere at all — no console, no store, no UI. A PARSE_ERROR between
+ * turns was dropped on the client as silently as it was on the server.
+ * Protocol-level drops from the SDK client land here too.
+ */
+export interface ConnectionError {
+  code: string;
+  message: string;
+  /** Epoch millis, so a view can decide whether this is still interesting. */
+  at: number;
+}
+
 interface ConnectionState {
   wsStatus: WsStatus;
   vpnStatus: VpnStatus;
+  lastError: ConnectionError | null;
   setWsStatus: (status: WsStatus) => void;
   setVpnStatus: (status: VpnStatus) => void;
+  reportError: (code: string, message: string) => void;
+  clearError: () => void;
 }
 
 export const useConnectionStore = create<ConnectionState>((set) => ({
   wsStatus: "disconnected",
   vpnStatus: "checking",
+  lastError: null,
   setWsStatus: (wsStatus) => set({ wsStatus }),
   setVpnStatus: (vpnStatus) => set({ vpnStatus }),
+  reportError: (code, message) => set({ lastError: { code, message, at: Date.now() } }),
+  clearError: () => set({ lastError: null }),
 }));

package/src/stores/file-store.ts

@@ -6,7 +6,7 @@ import type {
   WikilinkMapResponse,
 } from "@schlessera/brain-ui-sdk/protocol";
 import { FILE_SIZE_CAP_BYTES } from "@schlessera/brain-ui-sdk/protocol";
-import { API_BASE } from "../lib/backend.js";
+import { apiBase } from "../lib/backend.js";
 import { isMermaidPath } from "../lib/mermaid.js";
 
 export type ViewMode = "preview" | "raw";
@@ -76,7 +76,7 @@ interface FileState {
 }
 
 async function fetchTree(path: string): Promise<FileEntry[]> {
-  const url = `${API_BASE}/files/tree${path ? `?path=${encodeURIComponent(path)}` : ""}`;
+  const url = `${apiBase()}/files/tree${path ? `?path=${encodeURIComponent(path)}` : ""}`;
   const res = await fetch(url);
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
@@ -87,7 +87,7 @@ async function fetchTree(path: string): Promise<FileEntry[]> {
 }
 
 async function fetchContent(path: string): Promise<FileContentResponse> {
-  const res = await fetch(`${API_BASE}/files/content?path=${encodeURIComponent(path)}`);
+  const res = await fetch(`${apiBase()}/files/content?path=${encodeURIComponent(path)}`);
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
     const err = new Error(body.error || `HTTP ${res.status}`);
@@ -99,7 +99,7 @@ async function fetchContent(path: string): Promise<FileContentResponse> {
 }
 
 async function fetchResolve(path: string): Promise<FileResolveResponse> {
-  const res = await fetch(`${API_BASE}/files/resolve?path=${encodeURIComponent(path)}`);
+  const res = await fetch(`${apiBase()}/files/resolve?path=${encodeURIComponent(path)}`);
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
     throw new Error(body.error || `HTTP ${res.status}`);
@@ -108,7 +108,7 @@ async function fetchResolve(path: string): Promise<FileResolveResponse> {
 }
 
 async function fetchWikilinks(): Promise<WikilinkMapResponse> {
-  const res = await fetch(`${API_BASE}/files/wikilinks`);
+  const res = await fetch(`${apiBase()}/files/wikilinks`);
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
     throw new Error(body.error || `HTTP ${res.status}`);
@@ -211,6 +211,11 @@ export const useFileStore = create<FileState>((set, get) => ({
 
     try {
       const content = await fetchContent(normalized);
+      // Drop a response the user has already navigated away from. Two rapid
+      // clicks race, and without this the SLOWER fetch wins: the viewer showed
+      // the newer file's path with the older file's content, which reads as
+      // corruption rather than as a stale load.
+      if (get().currentPath !== normalized) return;
       set({ currentContent: content, contentLoading: false });
       // Default mode: prefer preview when available; persist otherwise
       const { viewMode } = get();
@@ -226,6 +231,9 @@ export const useFileStore = create<FileState>((set, get) => ({
       if (e.status === 413 && e.size) msg = `File too large (${(e.size / 1024 / 1024).toFixed(2)} MB; cap ${(FILE_SIZE_CAP_BYTES / 1024 / 1024).toFixed(0)} MB).`;
       else if (e.status === 404) msg = "File not found.";
       else if (e.message === "invalid_path") msg = "Invalid path.";
+      // Same guard: a failure for a file the user already left must not
+      // replace the file they are now looking at with an error.
+      if (get().currentPath !== normalized) return;
       set({ contentError: msg, contentLoading: false });
     } finally {
       await ancestorsPromise;

package/src/stores/graph-store.ts

@@ -4,7 +4,8 @@ import type {
   GraphSubgraphResponse,
   GraphMaintenanceResponse,
 } from "@schlessera/brain-ui-sdk/protocol";
-import { API_BASE } from "../lib/backend.js";
+import { apiBase } from "../lib/backend.js";
+import { registerDevHandle } from "../config.js";
 import { buildQuery, mergeSubgraphs } from "../components/graph/lib/graph-helpers.js";
 
 export type GraphMode = "clusters" | "discovery" | "local" | "maintenance";
@@ -135,7 +136,7 @@ function cachePut(key: string, value: GraphSubgraphResponse | GraphMaintenanceRe
 }
 
 async function fetchGraphJson<T>(pathAndQuery: string): Promise<T> {
-  const res = await fetch(`${API_BASE}/graph${pathAndQuery}`);
+  const res = await fetch(`${apiBase()}/graph${pathAndQuery}`);
   if (!res.ok) {
     const body = await res.json().catch(() => ({}) as Record<string, unknown>);
     const err = new Error(
@@ -336,10 +337,9 @@ export const useGraphStore = create<GraphState>((set, get) => ({
 }));
 
 // Dev-only handle for exercising the view with injected fixtures (the
-// window.__chatStore precedent). The env read is defensive: outside a Vite
-// build `import.meta.env` does not exist.
-const devEnv = (import.meta as { env?: Record<string, unknown> }).env;
-if (typeof window !== "undefined" && devEnv?.DEV) {
+// window.__chatStore precedent), gated on the shell's `devTools` flag.
+registerDevHandle(() => {
+  if (typeof window === "undefined") return;
   (window as unknown as { __graphStore?: typeof useGraphStore }).__graphStore =
     useGraphStore;
-}
+});

package/dist/lib/ws-client.d.ts

@@ -1,26 +0,0 @@
-import type { ClientMessage, ServerMessage } from "@schlessera/brain-ui-sdk/protocol";
-type MessageHandler = (msg: ServerMessage) => void;
-type StatusHandler = (status: "connecting" | "connected" | "disconnected") => void;
-export declare class WSClient {
-    private ws;
-    private url;
-    private onMessage;
-    private onStatusChange;
-    private reconnectAttempt;
-    private reconnectTimer;
-    private closed;
-    constructor(url: string, onMessage: MessageHandler, onStatusChange: StatusHandler);
-    connect(): void;
-    send(msg: ClientMessage): void;
-    close(): void;
-    get isConnected(): boolean;
-    /**
-     * Skip the remaining backoff and reconnect immediately (e.g. when the
-     * browser fires an `online` event). No-op if open/connecting or closed
-     * deliberately.
-     */
-    reconnectNow(): void;
-    private scheduleReconnect;
-}
-export {};
-//# sourceMappingURL=ws-client.d.ts.map

package/dist/lib/ws-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws-client.d.ts","sourceRoot":"","sources":["../../src/lib/ws-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEtF,KAAK,cAAc,GAAG,CAAC,GAAG,EAAE,aAAa,KAAK,IAAI,CAAC;AACnD,KAAK,aAAa,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,cAAc,KAAK,IAAI,CAAC;AAEnF,qBAAa,QAAQ;IACnB,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,MAAM,CAAS;gBAGrB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,cAAc,EACzB,cAAc,EAAE,aAAa;IAO/B,OAAO;IAuCP,IAAI,CAAC,GAAG,EAAE,aAAa;IAMvB,KAAK;IAUL,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;;;OAIG;IACH,YAAY;IAYZ,OAAO,CAAC,iBAAiB;CAQ1B"}