@schlessera/brain-ui-react 0.15.0 → 0.17.0

package/src/components/chat/tool-views.tsx

@@ -21,6 +21,10 @@ import { linkifyPaths, FileLink } from "./brain-markdown.js";
 import { MarkdownContent } from "./markdown-content.js";
 import { isInternalRepoPath } from "../../stores/file-store.js";
 import { GET_LOCATION_TOOL_NAME, normalizeToolName } from "../../lib/tool-names.js";
+import { computeDiffRows, type WordToken } from "../../lib/diff.js";
+
+// Re-exported so existing imports of the diff engine from this module keep working.
+export { computeDiffRows };
 
 // ============================================================
 // Shared helpers
@@ -265,143 +269,6 @@ function PathHeader({ path, badge }: { path: string | null; badge?: string | nul
   );
 }
 
-// ------------------------------------------------------------
-// Diff helpers — line-level LCS with word-level refinement
-// ------------------------------------------------------------
-
-type DiffOp<T> = { kind: "same" | "del" | "ins"; value: T };
-
-/**
- * Hand-rolled LCS diff (standard DP + forward walk) so we avoid pulling in the
- * `diff` package. Returns ops in source order: `same` where the sequences
- * agree, `del` for items only in `a`, `ins` for items only in `b`.
- */
-function diffSeq<T>(
-  a: T[],
-  b: T[],
-  eq: (x: T, y: T) => boolean = (x, y) => x === y
-): DiffOp<T>[] {
-  const m = a.length;
-  const n = b.length;
-  // dp[i][j] = length of the LCS of a[i:] and b[j:]
-  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-  for (let i = m - 1; i >= 0; i--) {
-    for (let j = n - 1; j >= 0; j--) {
-      dp[i][j] = eq(a[i], b[j])
-        ? dp[i + 1][j + 1] + 1
-        : Math.max(dp[i + 1][j], dp[i][j + 1]);
-    }
-  }
-  const ops: DiffOp<T>[] = [];
-  let i = 0;
-  let j = 0;
-  while (i < m && j < n) {
-    if (eq(a[i], b[j])) {
-      ops.push({ kind: "same", value: a[i] });
-      i++;
-      j++;
-    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
-      ops.push({ kind: "del", value: a[i] });
-      i++;
-    } else {
-      ops.push({ kind: "ins", value: b[j] });
-      j++;
-    }
-  }
-  while (i < m) ops.push({ kind: "del", value: a[i++] });
-  while (j < n) ops.push({ kind: "ins", value: b[j++] });
-  return ops;
-}
-
-/** A word token, flagged when it differs from its counterpart line. */
-type WordToken = { text: string; changed: boolean };
-
-/**
- * Token-level LCS for a single deleted/inserted line pair. Splitting on
- * `/(\s+)/` keeps the whitespace as its own tokens so we can reassemble the
- * line exactly. Unchanged tokens are shared between both sides.
- */
-function wordDiff(oldLine: string, newLine: string): { del: WordToken[]; ins: WordToken[] } {
-  const a = oldLine.split(/(\s+)/);
-  const b = newLine.split(/(\s+)/);
-  // Token-level LCS is O(words²); a pathological minified line would be slow.
-  // Above the cap, skip word refinement and flag the whole line as changed.
-  if (a.length * b.length > 10_000) {
-    return {
-      del: [{ text: oldLine, changed: true }],
-      ins: [{ text: newLine, changed: true }],
-    };
-  }
-  const ops = diffSeq(a, b);
-  const del: WordToken[] = [];
-  const ins: WordToken[] = [];
-  for (const op of ops) {
-    if (op.kind === "same") {
-      del.push({ text: op.value, changed: false });
-      ins.push({ text: op.value, changed: false });
-    } else if (op.kind === "del") {
-      del.push({ text: op.value, changed: true });
-    } else {
-      ins.push({ text: op.value, changed: true });
-    }
-  }
-  return { del, ins };
-}
-
-/** A rendered diff row. `tokens` is set only for word-refined single-line edits. */
-type DiffRow = {
-  kind: "same" | "del" | "ins";
-  line: string;
-  tokens: WordToken[] | null;
-};
-
-/**
- * Merge `old_string`/`new_string` into a single diff: unchanged lines appear
- * once as neutral, deletions/insertions keep the red/green treatment. A change
- * block that is exactly one deleted line against one inserted line gets
- * word-level highlighting.
- */
-export function computeDiffRows(oldStr: string, newStr: string): DiffRow[] {
-  const oldLines = oldStr.split("\n");
-  const newLines = newStr.split("\n");
-  // Line-level LCS is O(m×n) in time and memory; a huge Edit (thousands of
-  // lines) would build a massive DP matrix and hang the UI. Above the cap, fall
-  // back to a naive "all old removed, all new added" diff.
-  if (oldLines.length * newLines.length > 250_000) {
-    return [
-      ...oldLines.map((line): DiffRow => ({ kind: "del", line, tokens: null })),
-      ...newLines.map((line): DiffRow => ({ kind: "ins", line, tokens: null })),
-    ];
-  }
-  const ops = diffSeq(oldLines, newLines);
-  const rows: DiffRow[] = [];
-  let idx = 0;
-  while (idx < ops.length) {
-    if (ops[idx].kind === "same") {
-      rows.push({ kind: "same", line: ops[idx].value, tokens: null });
-      idx++;
-      continue;
-    }
-    // Collect a maximal run of changes, grouping deletes before inserts.
-    const dels: string[] = [];
-    const inss: string[] = [];
-    while (idx < ops.length && ops[idx].kind !== "same") {
-      if (ops[idx].kind === "del") dels.push(ops[idx].value);
-      else inss.push(ops[idx].value);
-      idx++;
-    }
-    if (dels.length === 1 && inss.length === 1) {
-      const { del, ins } = wordDiff(dels[0], inss[0]);
-      rows.push({ kind: "del", line: dels[0], tokens: del });
-      rows.push({ kind: "ins", line: inss[0], tokens: ins });
-    } else {
-      for (const d of dels) rows.push({ kind: "del", line: d, tokens: null });
-      for (const s of inss) rows.push({ kind: "ins", line: s, tokens: null });
-    }
-  }
-  return rows;
-}
-
 /** Render a diff line, emphasizing changed word tokens when refined. */
 function DiffLine({ tokens, line, changedClass }: {
   tokens: WordToken[] | null;

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/lib/diff.ts

@@ -0,0 +1,140 @@
+// Standalone text-diff engine behind the Edit tool's diff view: line-level
+// LCS with word-level refinement for single-line change pairs. Pure data —
+// no React; rendering stays in components/chat/tool-views.tsx.
+
+// ------------------------------------------------------------
+// Diff helpers — line-level LCS with word-level refinement
+// ------------------------------------------------------------
+
+type DiffOp<T> = { kind: "same" | "del" | "ins"; value: T };
+
+/**
+ * Hand-rolled LCS diff (standard DP + forward walk) so we avoid pulling in the
+ * `diff` package. Returns ops in source order: `same` where the sequences
+ * agree, `del` for items only in `a`, `ins` for items only in `b`.
+ */
+function diffSeq<T>(
+  a: T[],
+  b: T[],
+  eq: (x: T, y: T) => boolean = (x, y) => x === y
+): DiffOp<T>[] {
+  const m = a.length;
+  const n = b.length;
+  // dp[i][j] = length of the LCS of a[i:] and b[j:]
+  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = m - 1; i >= 0; i--) {
+    for (let j = n - 1; j >= 0; j--) {
+      dp[i][j] = eq(a[i], b[j])
+        ? dp[i + 1][j + 1] + 1
+        : Math.max(dp[i + 1][j], dp[i][j + 1]);
+    }
+  }
+  const ops: DiffOp<T>[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (eq(a[i], b[j])) {
+      ops.push({ kind: "same", value: a[i] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ kind: "del", value: a[i] });
+      i++;
+    } else {
+      ops.push({ kind: "ins", value: b[j] });
+      j++;
+    }
+  }
+  while (i < m) ops.push({ kind: "del", value: a[i++] });
+  while (j < n) ops.push({ kind: "ins", value: b[j++] });
+  return ops;
+}
+
+/** A word token, flagged when it differs from its counterpart line. */
+export type WordToken = { text: string; changed: boolean };
+
+/**
+ * Token-level LCS for a single deleted/inserted line pair. Splitting on
+ * `/(\s+)/` keeps the whitespace as its own tokens so we can reassemble the
+ * line exactly. Unchanged tokens are shared between both sides.
+ */
+function wordDiff(oldLine: string, newLine: string): { del: WordToken[]; ins: WordToken[] } {
+  const a = oldLine.split(/(\s+)/);
+  const b = newLine.split(/(\s+)/);
+  // Token-level LCS is O(words²); a pathological minified line would be slow.
+  // Above the cap, skip word refinement and flag the whole line as changed.
+  if (a.length * b.length > 10_000) {
+    return {
+      del: [{ text: oldLine, changed: true }],
+      ins: [{ text: newLine, changed: true }],
+    };
+  }
+  const ops = diffSeq(a, b);
+  const del: WordToken[] = [];
+  const ins: WordToken[] = [];
+  for (const op of ops) {
+    if (op.kind === "same") {
+      del.push({ text: op.value, changed: false });
+      ins.push({ text: op.value, changed: false });
+    } else if (op.kind === "del") {
+      del.push({ text: op.value, changed: true });
+    } else {
+      ins.push({ text: op.value, changed: true });
+    }
+  }
+  return { del, ins };
+}
+
+/** A rendered diff row. `tokens` is set only for word-refined single-line edits. */
+export type DiffRow = {
+  kind: "same" | "del" | "ins";
+  line: string;
+  tokens: WordToken[] | null;
+};
+
+/**
+ * Merge `old_string`/`new_string` into a single diff: unchanged lines appear
+ * once as neutral, deletions/insertions keep the red/green treatment. A change
+ * block that is exactly one deleted line against one inserted line gets
+ * word-level highlighting.
+ */
+export function computeDiffRows(oldStr: string, newStr: string): DiffRow[] {
+  const oldLines = oldStr.split("\n");
+  const newLines = newStr.split("\n");
+  // Line-level LCS is O(m×n) in time and memory; a huge Edit (thousands of
+  // lines) would build a massive DP matrix and hang the UI. Above the cap, fall
+  // back to a naive "all old removed, all new added" diff.
+  if (oldLines.length * newLines.length > 250_000) {
+    return [
+      ...oldLines.map((line): DiffRow => ({ kind: "del", line, tokens: null })),
+      ...newLines.map((line): DiffRow => ({ kind: "ins", line, tokens: null })),
+    ];
+  }
+  const ops = diffSeq(oldLines, newLines);
+  const rows: DiffRow[] = [];
+  let idx = 0;
+  while (idx < ops.length) {
+    if (ops[idx].kind === "same") {
+      rows.push({ kind: "same", line: ops[idx].value, tokens: null });
+      idx++;
+      continue;
+    }
+    // Collect a maximal run of changes, grouping deletes before inserts.
+    const dels: string[] = [];
+    const inss: string[] = [];
+    while (idx < ops.length && ops[idx].kind !== "same") {
+      if (ops[idx].kind === "del") dels.push(ops[idx].value);
+      else inss.push(ops[idx].value);
+      idx++;
+    }
+    if (dels.length === 1 && inss.length === 1) {
+      const { del, ins } = wordDiff(dels[0], inss[0]);
+      rows.push({ kind: "del", line: dels[0], tokens: del });
+      rows.push({ kind: "ins", line: inss[0], tokens: ins });
+    } else {
+      for (const d of dels) rows.push({ kind: "del", line: d, tokens: null });
+      for (const s of inss) rows.push({ kind: "ins", line: s, tokens: null });
+    }
+  }
+  return rows;
+}

package/src/stores/chat-store.ts

@@ -103,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;
 
@@ -168,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. */
@@ -302,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;
@@ -315,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.
@@ -427,7 +456,7 @@ export const useChatStore = create<ChatState>((set, get) => {
         ),
       })),
 
-    requestToolApproval: (key, toolUseId, toolName, input, description) =>
+    requestToolApproval: (key, toolUseId, toolName, input, _description) =>
       mutateLastAssistant(key, (last) => {
         // Check if tool call already exists (from streaming)
         const existingIdx = last.toolCalls.findIndex(
@@ -574,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();
@@ -586,6 +624,7 @@ export const useChatStore = create<ChatState>((set, get) => {
         return {
           buffers,
           draft: null,
+          pendingDraftId: null,
           ...(followView ? { activeSessionId: sessionId } : {}),
         };
       }),

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

@@ -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

@@ -204,7 +204,20 @@ function sceneRequest(state: GraphState): { endpoint: string; query: string } |
 }
 
 export const useGraphStore = create<GraphState>((set, get) => ({
-  mode: "local",
+  /**
+   * Clusters, not Local.
+   *
+   * Local is centred on ONE node and has no center until the user picks one,
+   * so opening the graph landed on an empty canvas with a picker — which reads
+   * as "the graph is broken", not as "choose a starting point". Clusters is
+   * the only mode that answers the question someone opening a graph view is
+   * actually asking: what is in here, and what clumps together.
+   *
+   * Local stays one click away, and clicking any node still switches to it
+   * (node-popover.tsx) — that is the natural way in, rather than the landing
+   * state.
+   */
+  mode: "clusters",
   meta: null,
   metaState: "idle",
 

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"}