@marimo-team/islands 0.25.3-dev48 → 0.25.3-dev51

package/src/__tests__/mount.test.ts

@@ -6,7 +6,6 @@ import { initialLayoutState, layoutStateAtom } from "@/core/layout/state";
 import { kioskModeAtom } from "@/core/mode";
 import { connectionAtom } from "@/core/network/connection";
 import { store } from "@/core/state/jotai";
-import { runtimeConfigAtom } from "@/core/runtime/config";
 import { isStaticNotebook } from "@/core/static/static-state";
 import { ConnectionState } from "@/core/websocket/types";
 import { pairConfigAtom } from "@/core/config/pair";
@@ -102,25 +101,6 @@ describe("mount", () => {
   });
 
   describe("connection state initialization", () => {
-    it("passes the host notebook identity to the local runtime", () => {
-      mount({ ...baseOptions, notebookId: "nb_local" }, mockElement);
-      expect(store.get(runtimeConfigAtom).notebookId).toBe("nb_local");
-    });
-
-    it("uses a remote runtime's own notebook identity", () => {
-      mount(
-        {
-          ...baseOptions,
-          notebookId: "nb_local",
-          runtimeConfig: [
-            { url: "https://remote.example", notebookId: "nb_remote" },
-          ],
-        },
-        mockElement,
-      );
-      expect(store.get(runtimeConfigAtom).notebookId).toBe("nb_remote");
-    });
-
     it("should set connection to CONNECTING when runtimeConfig has lazy=false", () => {
       mount(
         {

package/src/components/editor/chrome/wrapper/__tests__/attachment-status.test.tsx

@@ -16,6 +16,7 @@ import { TooltipProvider } from "@/components/ui/tooltip";
 import { toast } from "@/components/ui/use-toast";
 import type { Attachment } from "@/core/attachments/state";
 import { pairConfigAtom } from "@/core/config/pair";
+import { createNotebookClient } from "@/core/host/notebook-client";
 import {
   type StableSessionId,
   stableSessionIdAtom,
@@ -45,10 +46,9 @@ function renderStatus(attachments: Attachment[] = [AGENT], preview = true) {
   store.set(connectionAtom, { state: ConnectionState.OPEN });
   store.set(pairConfigAtom, { ...PAIR_CONFIG, hostEnabled: preview });
   store.set(notebookClientAtom, {
+    ...createNotebookClient(store).client,
     connectionAtom: atom({ state: ConnectionState.OPEN }),
-    documentAtom: atom(null),
     attachmentsAtom,
-    reconnect: async () => undefined,
   });
   store.set(attachmentsAtom, attachments);
   store.set(stableSessionIdAtom, "stable/test" as StableSessionId);

package/src/components/editor/errors/__tests__/send-error-report-button.test.tsx

@@ -25,6 +25,7 @@ import {
 } from "@/core/cells/error-report";
 import { pairConfigAtom } from "@/core/config/pair";
 import { notebookStateFromSession } from "@/core/cells/session";
+import { createNotebookClient } from "@/core/host/notebook-client";
 import type { MarimoError, OutputMessage } from "@/core/kernel/messages";
 import {
   type StableSessionId,
@@ -97,10 +98,9 @@ function renderButton({
   store.set(connectionAtom, { state: ConnectionState.OPEN });
   store.set(pairConfigAtom, { ...PAIR_CONFIG, hostEnabled: preview });
   store.set(notebookClientAtom, {
+    ...createNotebookClient(store).client,
     connectionAtom: atom({ state: ConnectionState.OPEN }),
-    documentAtom: atom(null),
     attachmentsAtom,
-    reconnect: async () => undefined,
   });
   store.set(attachmentsAtom, attachments);
   store.set(stableSessionIdAtom, stableId);

package/src/core/host/__tests__/notebook-client.test.ts

@@ -49,12 +49,10 @@ function setup(url: () => string = () => "ws://localhost/ws") {
         return transport;
       },
       url,
-      messageFormat: "host",
       signal,
       waitUntilReady: () => healthy.promise,
       checkHealth,
       onNotification: (notification) => onNotification({ data: notification }),
-      onMessageError: vi.fn(),
       decodeJson: jsonParseWithSpecialChar,
       classifyClose: classifyCloseEvent,
     });
@@ -76,6 +74,71 @@ function setup(url: () => string = () => "ws://localhost/ws") {
 }
 
 describe("NotebookClient lifetime", () => {
+  it("exposes identity and capabilities only after the notebook is ready", async () => {
+    const { connect, healthy, events, receive, client, store } = setup();
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    healthy.resolve();
+    await healthy.promise;
+    events.dispatchEvent(new Event("open"));
+    const notebook = {
+      id: "nb/with space",
+      project_id: "p1",
+      path: null,
+      name: "Notebook",
+      operations: ["notebook.edit"],
+      updated_at: null,
+    };
+    receive({ event: "notebook", data: { notebook } });
+    expect(store.get(client.notebookAtom)).toBeNull();
+    receive({ event: "ready", id: "1", data: {} });
+    expect(store.get(client.notebookAtom)).toEqual(notebook);
+    receive({
+      event: "notebook",
+      id: "2",
+      data: { notebook: { ...notebook, operations: [] } },
+    });
+    expect(store.get(client.notebookAtom)?.operations).toEqual([]);
+    receive({ event: "notebook.removed", id: "3", data: { id: notebook.id } });
+    expect(store.get(client.notebookAtom)).toBeNull();
+    lifetime.abort();
+  });
+
+  it("rebuilds the replica after a reconnect reset selects a new notebook", async () => {
+    const notebookId = "n2";
+    const { connect, events, healthy, urls, receive, client, store } = setup(
+      () => "ws://localhost/ws?session_id=visitor",
+    );
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    healthy.resolve();
+    await healthy.promise;
+    events.dispatchEvent(new Event("open"));
+    fixtureMessages("notebook-events.sse").forEach(receive);
+    expect(store.get(client.documentAtom)?.revision.notebook_id).toBe("n1");
+
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(urls.at(-1)?.searchParams.get("cursor")).toBe("97");
+    expect(store.get(client.documentAtom)?.revision.notebook_id).toBe("n1");
+    expect(store.get(client.notebookAtom)).toBeNull();
+    events.dispatchEvent(new Event("open"));
+    receive({ event: "reset", data: {} });
+    expect(store.get(client.documentAtom)).toBeNull();
+    for (const event of fixtureMessages("notebook-events.sse")) {
+      receive(
+        JSON.parse(
+          JSON.stringify(event).replaceAll('"n1"', JSON.stringify(notebookId)),
+        ),
+      );
+    }
+    expect(store.get(client.documentAtom)?.revision.notebook_id).toBe(
+      notebookId,
+    );
+    expect(store.get(client.connectionAtom).state).toBe(ConnectionState.OPEN);
+    expect(store.get(client.notebookAtom)?.id).toBe(notebookId);
+    lifetime.abort();
+  });
+
   it.each(["{broken", JSON.stringify({ event: "ready", data: {} })])(
     "stops consuming a malformed host stream: %s",
     (data) => {
@@ -423,7 +486,7 @@ describe("NotebookClient attachments", () => {
     },
   );
 
-  it("keeps legacy sessions empty", async () => {
+  it("keeps host resources empty for notification-only WASM connections", async () => {
     const { client, store, receive, lifetime } = await open();
     receive({ data: { op: "kernel-ready" } });
     receive({ data: { op: "reconnected" } });

package/src/core/host/events.ts

@@ -10,15 +10,6 @@ import * as Protocol from "@marimo-team/client/protocol";
  * and cursor so clients can skip them without losing their place in the stream.
  */
 
-/** Event kinds requested by the client; removals and controls are implicit. */
-export const NOTEBOOK_EVENT_TYPES = [
-  "notebook",
-  "document",
-  "cell",
-  "attachment",
-  "marimo",
-] as const satisfies readonly (Protocol.ObjectType | "marimo")[];
-
 const envelope = z.object({
   event: z.string().min(1),
   data: z.unknown(),
@@ -54,7 +45,7 @@ export type NotebookEvent =
 const sessionEnvelope = z.object({ data: z.unknown() });
 
 /**
- * Decode a host event or a legacy `{ data: notification }` session message.
+ * Decode a host event or an in-process WASM `{ data: notification }` message.
  *
  * Throws if the envelope or a known event is malformed. Native notification
  * payloads are passed through for the session handler to interpret.

package/src/core/host/notebook-client.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { Logger } from "@/utils/Logger";
-import type { Attachment } from "@marimo-team/client/protocol";
+import type { Attachment, NotebookOutput } from "@marimo-team/client/protocol";
 import { createReducer } from "@marimo-team/client/reducer";
 import { type Atom, atom, type createStore } from "jotai/vanilla";
 import {
@@ -27,6 +27,8 @@ const UNCURSORED = new Set<NotebookEvent["event"]>([
 export interface NotebookClient {
   /** Client connection status, independent of application session readiness. */
   readonly connectionAtom: Atom<ConnectionStatus>;
+  /** Identity and capabilities, available while the stream is connected and ready. */
+  readonly notebookAtom: Atom<NotebookOutput | null>;
   /**
    * The most recently confirmed document.
    *
@@ -47,8 +49,6 @@ export interface NotebookConnection {
   createTransport: (url: () => string) => NotebookTransport;
   /** The current stream URL, including authentication and subscription options. */
   url: () => string;
-  /** Host events require an intact stream; legacy notifications are independent. */
-  messageFormat: "host" | "session";
   /** Abort to close the transport and clear the client's state. */
   signal: AbortSignal;
   /** Wait until the host can accept the initial connection. */
@@ -59,8 +59,6 @@ export interface NotebookConnection {
   decodeJson: (message: string) => unknown;
   /** Handle a native marimo notification. Its payload has not been validated. */
   onNotification: (notification: unknown) => void;
-  /** Report a malformed message without coupling the client to editor UI. */
-  onMessageError: (error: unknown) => void;
   /** Choose the connection status and retry policy after the transport closes. */
   classifyClose: (event: CloseEvent) => CloseDecision;
 }
@@ -75,6 +73,11 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
   const streamAtom = atom(reducer.initial);
   // A resumed stream is live, but presence waits for this connection's ready.
   const readyAtom = atom(false);
+  const notebookAtom = atom((get) =>
+    get(readyAtom) && get(connectionAtom).state === ConnectionState.OPEN
+      ? get(streamAtom).notebook
+      : null,
+  );
   const documentAtom = atom(
     (get) => get(streamAtom).resources.document.current,
   );
@@ -86,6 +89,7 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
   let reconnect: (() => Promise<void>) | undefined;
   const client: NotebookClient = {
     connectionAtom,
+    notebookAtom,
     documentAtom,
     attachmentsAtom,
     reconnect: async () => reconnect?.(),
@@ -94,12 +98,10 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
   function connect({
     createTransport,
     url,
-    messageFormat,
     signal,
     waitUntilReady,
     checkHealth,
     onNotification,
-    onMessageError,
     decodeJson,
     classifyClose,
   }: NotebookConnection) {
@@ -113,9 +115,6 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
     // The id of the last live event. Null before `ready` and after `reset`.
     let cursor: string | null = null;
     const transport = createTransport(() => {
-      if (messageFormat === "session") {
-        return url();
-      }
       const next = new URL(url());
       next.searchParams.delete("cursor");
       if (signal.aborted) {
@@ -131,11 +130,9 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
       // A live stream keeps its state and resumes from the cursor. An
       // incomplete snapshot starts over.
       const state =
-        key !== streamKey
+        key !== streamKey || current.phase === "snapshot"
           ? reducer.initial
-          : current.phase === "snapshot"
-            ? { ...reducer.initial, notebookId: current.notebookId }
-            : current;
+          : current;
       if (state.phase === "snapshot") {
         cursor = null;
       }
@@ -226,10 +223,6 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
         }
       } catch (error) {
         Logger.error("Failed to decode notebook message", error);
-        if (messageFormat === "session") {
-          onMessageError(error);
-          return;
-        }
         store.set(streamAtom, reducer.initial);
         cursor = null;
         terminal = true;

package/src/core/runtime/__tests__/runtime.test.ts

@@ -2,11 +2,7 @@
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { Mocks } from "@/__mocks__/common";
-import {
-  generateSessionId,
-  isSessionId,
-  type SessionId,
-} from "@/core/kernel/session";
+import type { SessionId } from "@/core/kernel/session";
 import { Logger } from "@/utils/Logger";
 import { RuntimeManager } from "../runtime";
 import type { RuntimeConfig } from "../types";
@@ -56,38 +52,6 @@ describe("RuntimeManager", () => {
   });
 
   describe("getWsURL", () => {
-    it("uses host notebook events with the existing session and auth parameters", () => {
-      const original = window.location.href;
-      window.history.replaceState({}, "", "/?types=run");
-      try {
-        const runtime = new RuntimeManager({
-          ...mockConfig,
-          url: "https://example.com/nested?file=notebook.py",
-          notebookId: "nb_123",
-        });
-        const sessionId = "s_123456";
-        if (!isSessionId(sessionId)) {
-          throw new Error("Invalid test session ID");
-        }
-        const url = runtime.getWsURL(sessionId);
-        expect({
-          endpoint: `${url.origin}${url.pathname}`,
-          params: Object.fromEntries(url.searchParams),
-        }).toEqual({
-          endpoint:
-            "wss://example.com/nested/api/marimo/v1/notebooks/nb_123/events/ws",
-          params: {
-            file: "notebook.py",
-            types: "notebook,document,cell,attachment,marimo",
-            session_id: sessionId,
-            access_token: "test-token",
-          },
-        });
-      } finally {
-        window.history.replaceState({}, "", original);
-      }
-    });
-
     it("should return WebSocket URL with session ID for https", () => {
       const runtime = new RuntimeManager(mockConfig);
       const sessionId = "1234" as SessionId;
@@ -257,21 +221,6 @@ describe("RuntimeManager", () => {
   });
 
   describe("getSseURL", () => {
-    it.each([undefined, "nb_123"])(
-      "uses the legacy session stream when notebookId is %s",
-      (notebookId) => {
-        const runtime = new RuntimeManager({
-          ...mockConfig,
-          url: "https://example.com/nested?file=notebook.py",
-          notebookId,
-        });
-        const sessionId = generateSessionId();
-        expect(runtime.getSseURL(sessionId).toString()).toBe(
-          `https://example.com/nested/sse?file=notebook.py&session_id=${sessionId}`,
-        );
-      },
-    );
-
     it("should never put the auth token in the URL, even cross-origin", () => {
       // SSE requests can send headers, so auth travels in the
       // Authorization header; a token in the URL would leak into
@@ -781,7 +730,7 @@ describe("RuntimeManager", () => {
       );
     });
 
-    it("should throw when creating WebSocket URLs from blob URLs", () => {
+    it("warns when creating WebSocket URLs from blob URLs", () => {
       const runtime = new RuntimeManager({
         url: "blob:https://example.com/12345678-1234-1234-1234-123456789abc",
         lazy: true,

package/src/core/runtime/runtime.ts

@@ -3,7 +3,6 @@
 import { Deferred } from "@/utils/Deferred";
 import { Logger } from "@/utils/Logger";
 import { KnownQueryParams } from "../constants";
-import { NOTEBOOK_EVENT_TYPES } from "../host/events";
 import { isIslands } from "../islands/utils";
 import { getSessionId, type SessionId } from "../kernel/session";
 import { isStaticNotebook } from "../static/static-state";
@@ -155,17 +154,7 @@ export class RuntimeManager {
    */
   public getWsURL(sessionId: SessionId): URL {
     const searchParams = this.getSessionSearchParams(sessionId);
-    // TODO(MO-8039): Rediscover hosts and resolve notebooks on reconnect.
-    const notebookId = this.config.notebookId;
-    const path = notebookId
-      ? `/api/marimo/v1/notebooks/${encodeURIComponent(notebookId)}/events/ws`
-      : "/ws";
-    const url = this.formatWsURL(path, searchParams);
-    if (notebookId) {
-      // TODO(MO-8034): Separate host options from notebook query params.
-      url.searchParams.set("types", NOTEBOOK_EVENT_TYPES.join(","));
-    }
-    return url;
+    return this.formatWsURL("/ws", searchParams);
   }
 
   /**
@@ -175,8 +164,6 @@ export class RuntimeManager {
    * (see `headers()`) instead of the URL.
    */
   public getSseURL(sessionId: SessionId): URL {
-    // TODO: Migrate editor SSE to the host event stream. Until then, host
-    // state such as attachments is unavailable on this legacy connection.
     const url = this.formatHttpURL({
       path: "/sse",
       searchParams: this.getSessionSearchParams(sessionId),

package/src/core/runtime/types.ts

@@ -1,8 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 export interface RuntimeConfig {
-  /** The host notebook for WebSocket events. SSE uses the legacy session stream. */
-  readonly notebookId?: string;
   /**
    * The URL of the runtime server.
    */

package/src/core/websocket/__tests__/useNotebookClient.hook.test.tsx

@@ -15,11 +15,12 @@ import { notebookClientAtom } from "../state";
 
 vi.mock("../transports/create", () => ({ createConnectionTransport: vi.fn() }));
 
-function makeTransport() {
+function makeTransport(url?: () => string) {
   const events = new EventTarget();
   const transport: IConnectionTransport = {
     readyState: WebSocket.CLOSED,
     reconnect: vi.fn(() => {
+      url?.();
       transport.readyState = WebSocket.OPEN;
       events.dispatchEvent(new Event("open"));
     }),
@@ -52,16 +53,13 @@ function makeTransport() {
 function setup(strict = false) {
   const store = createStore();
   const options = {
-    sessionId: "first",
     static: false,
     transportType: "websocket" as const,
-    messageFormat: "host" as const,
     url: () => "ws://localhost/ws",
     headers: () => ({}),
     waitUntilReady: async () => undefined,
     checkHealth: async () => true,
     onNotification: vi.fn(),
-    onMessageError: vi.fn(),
   };
   const wrapper = ({ children }: PropsWithChildren) => (
     <Provider store={store}>{children}</Provider>
@@ -121,25 +119,6 @@ describe("useNotebookClient", () => {
     unmount();
   });
 
-  it("replaces the transport when session identity changes and ignores old messages", async () => {
-    const first = makeTransport();
-    const second = makeTransport();
-    vi.mocked(createConnectionTransport)
-      .mockReturnValueOnce(first.transport)
-      .mockReturnValueOnce(second.transport);
-    const { rerender, options, unmount } = setup();
-    await act(async () => Promise.resolve());
-    rerender({ ...options, sessionId: "second" });
-    await act(async () => Promise.resolve());
-    expect(first.transport.close).toHaveBeenCalledOnce();
-    act(() => {
-      first.notify();
-      second.notify();
-    });
-    expect(options.onNotification).toHaveBeenCalledOnce();
-    unmount();
-  });
-
   it("cleans up every transport under Strict Mode and only connects the active lifetime", async () => {
     const transports: ReturnType<typeof makeTransport>[] = [];
     vi.mocked(createConnectionTransport).mockImplementation(() => {

package/src/core/websocket/__tests__/useNotebookSession.hook.test.tsx

@@ -36,7 +36,6 @@ vi.mock("@/core/runtime/config", async () => {
 });
 
 import { MockNotebook } from "@/__mocks__/notebook";
-import * as Toast from "@/components/ui/use-toast";
 import { Logger } from "@/utils/Logger";
 import { Deferred } from "@/utils/Deferred";
 import { cellId } from "@/__tests__/branded";
@@ -235,36 +234,29 @@ describe("useNotebookSession messages", () => {
   }
 
   it.each(["{broken", "null"])(
-    "reports a malformed legacy frame and continues applying notifications: %s",
+    "closes a malformed stream and ignores subsequent notifications: %s",
     (data) => {
-      const toast = vi.spyOn(Toast, "toast");
-      try {
-        receive({ data: { op: "reconnected" } });
-        act(() =>
-          getTransportHandlers().onMessage(
-            new MessageEvent("message", { data }),
-          ),
-        );
-        expect(toast).toHaveBeenCalledExactlyOnceWith({
-          title: "Failed to handle message",
-          description: expect.any(String),
-          variant: "danger",
-        });
-        expect(store.get(connectionAtom)).toEqual({
-          state: ConnectionState.OPEN,
-        });
-        receive({
-          data: {
+      receive({ event: "marimo", data: { marimo: { op: "reconnected" } } });
+      act(() =>
+        getTransportHandlers().onMessage(new MessageEvent("message", { data })),
+      );
+      expect(store.get(connectionAtom)).toEqual({
+        state: ConnectionState.CLOSED,
+        code: "KERNEL_DISCONNECTED",
+        reason: "Failed to decode notebook message",
+      });
+      receive({
+        event: "marimo",
+        data: {
+          marimo: {
             op: "completed-run",
             run_id: "r1",
             outcome: "succeeded",
             error: null,
           },
-        });
-        expect(store.get(initialRunCompletedAtom)).toBe(true);
-      } finally {
-        toast.mockRestore();
-      }
+        },
+      });
+      expect(store.get(initialRunCompletedAtom)).toBe(false);
     },
   );
 

package/src/core/websocket/transports/__tests__/sse.test.ts

@@ -90,6 +90,23 @@ describe("SseTransport", () => {
     expect(messages[1].data).toBe("line1\nline2");
   });
 
+  it("preserves host event names and cursors without carrying IDs into snapshots", async () => {
+    const { stream, push } = createControllableStream();
+    fetchMock.mockResolvedValueOnce(sseResponse(stream));
+    transport.reconnect();
+    await vi.waitFor(() => expect(opens).toHaveLength(1));
+
+    push("id: cursor-1\nevent: rea");
+    push("dy\ndata: {}\n\n: keep-alive\n\nevent: reset\ndata: {}\n\n");
+    push('event: marimo\ndata: {"marimo":\ndata: {"op":"reconnected"}}\n\n');
+    await vi.waitFor(() => expect(messages).toHaveLength(3));
+    expect(messages.map((message) => JSON.parse(message.data))).toEqual([
+      { event: "ready", id: "cursor-1", data: {} },
+      { event: "reset", data: {} },
+      { event: "marimo", data: { marimo: { op: "reconnected" } } },
+    ]);
+  });
+
   it("ignores keep-alive comments", async () => {
     const { stream, push } = createControllableStream();
     fetchMock.mockResolvedValueOnce(sseResponse(stream));

package/src/core/websocket/transports/sse.ts

@@ -218,16 +218,20 @@ export class SseTransport implements IConnectionTransport {
     const decoder = new TextDecoder();
     let buffer = "";
     let eventName: string | null = null;
+    let eventId: string | null = null;
     let dataLines: string[] = [];
 
     const dispatch = (): ServerClose | null => {
       if (dataLines.length === 0) {
         eventName = null;
+        eventId = null;
         return null;
       }
       const data = dataLines.join("\n");
       const name = eventName;
+      const id = eventId;
       eventName = null;
+      eventId = null;
       dataLines = [];
       if (name === "close") {
         return parseServerClose(data);
@@ -236,9 +240,15 @@ export class SseTransport implements IConnectionTransport {
       // (rather than on open, so a server that accepts and immediately
       // closes cannot retry forever).
       this.retryCount = 0;
+      // Normalize SSE fields into the same envelope as host WebSockets.
+      // Leave the payload text intact for the client's JSON decoder.
+      const envelope =
+        name === null
+          ? data
+          : `{"event":${JSON.stringify(name)},"data":${data}${id === null ? "" : `,"id":${JSON.stringify(id)}`}}`;
       this.subscriptions.notify(
         "message",
-        new MessageEvent("message", { data }),
+        new MessageEvent("message", { data: envelope }),
       );
       return null;
     };
@@ -284,8 +294,10 @@ export class SseTransport implements IConnectionTransport {
           dataLines.push(fieldValue);
         } else if (field === "event") {
           eventName = fieldValue;
+        } else if (field === "id") {
+          eventId = fieldValue;
         }
-        // `id` and `retry` fields are unused.
+        // The host client owns the cursor; `retry` does not override our policy.
       }
       if (cursor > 0) {
         buffer = buffer.slice(cursor);