@marimo-team/islands 0.25.3-dev40 → 0.25.3-dev42

package/src/core/host/__tests__/document.test.ts

@@ -1,17 +1,20 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { describe, expect, it } from "vitest";
-import type { NotebookEvent } from "../events";
+import type * as Protocol from "@marimo-team/client/protocol";
 import { document } from "../resources/document";
-import { createStream } from "../stream";
+import { createReducer } from "@marimo-team/client/reducer";
 import { fixtureEvents } from "./fixtures";
 
-const stream = createStream({ document });
+const reducer = createReducer({ document });
 const snapshot = fixtureEvents("notebook-events.sse");
 const edits = fixtureEvents("edits.sse");
 
-function replay(events: readonly NotebookEvent[], from = stream.initial) {
-  return events.reduce((state, event) => stream.reduce(state, event), from);
+function replay(
+  events: readonly Protocol.EventOutput[],
+  from = reducer.initial,
+) {
+  return events.reduce((state, event) => reducer.reduce(state, event), from);
 }
 
 const confirmed = () => replay(snapshot);
@@ -33,12 +36,12 @@ describe("document resource", () => {
       confirmed(),
     );
     expect(current(pending)).toEqual(first);
-    const changed = stream.reduce(pending, edit);
+    const changed = reducer.reduce(pending, edit);
     expect(current(changed)?.revision).toEqual(edit.data.document);
     expect([...current(changed)!.cells.keys()].toSorted()).toEqual(
       edit.data.document.order.toSorted(),
     );
-    const saved = current(stream.reduce(changed, save));
+    const saved = current(reducer.reduce(changed, save));
     expect(saved?.revision).toEqual(save.data.document);
     expect(saved?.cells.get("c3")?.code).toBe("x = 22");
     expect(saved?.cells.has("k7f2")).toBe(false);
@@ -55,7 +58,7 @@ describe("document resource", () => {
       order: revision.order.toReversed(),
       version: revision.version + 1,
     };
-    const changed = stream.reduce(state, {
+    const changed = reducer.reduce(state, {
       event: "document",
       data: { document: reordered },
       id: "200",
@@ -66,17 +69,17 @@ describe("document resource", () => {
     });
 
     const empty = { ...revision, order: [] };
-    const opening = stream.reduce(stream.initial, {
+    const opening = reducer.reduce(reducer.initial, {
       event: "document",
       data: { document: empty },
     });
     expect(current(opening)).toBeNull();
     expect(
-      current(stream.reduce(opening, { event: "ready", data: {}, id: "0" })),
+      current(reducer.reduce(opening, { event: "ready", data: {}, id: "0" })),
     ).toEqual({ revision: empty, cells: new Map() });
     expect(
       current(
-        stream.reduce(stream.initial, { event: "ready", data: {}, id: "0" }),
+        reducer.reduce(reducer.initial, { event: "ready", data: {}, id: "0" }),
       ),
     ).toBeNull();
   });
@@ -89,7 +92,6 @@ describe("document resource", () => {
     }
     const partial = replay([cell, removed], state);
     expect(current(partial)).toBe(current(state));
-    expect(stream.resume(partial)).toBe(partial);
     const completed = replay(
       [published, { event: "ready", data: {}, id: "113" }],
       partial,
@@ -98,7 +100,7 @@ describe("document resource", () => {
   });
 
   it("removes a notebook without waiting for individual cell removals", () => {
-    const removed = stream.reduce(confirmed(), {
+    const removed = reducer.reduce(confirmed(), {
       event: "notebook.removed",
       data: { id: "n1", time: "2026-10-01T09:30:00Z" },
       id: "200",
@@ -110,15 +112,15 @@ describe("document resource", () => {
     const state = confirmed();
     const revision = current(state)!.revision;
     expect(() =>
-      stream.reduce(state, {
+      reducer.reduce(state, {
         event: "document",
         data: { document: { ...revision, order: ["missing"] } },
         id: "200",
       }),
     ).toThrow("Document records do not match");
-    const partial = stream.reduce(state, edits[0]);
+    const partial = reducer.reduce(state, edits[0]);
     expect(() =>
-      stream.reduce(partial, { event: "ready", data: {}, id: "200" }),
+      reducer.reduce(partial, { event: "ready", data: {}, id: "200" }),
     ).toThrow("incomplete document update");
   });
 });

package/src/core/host/__tests__/events.test.ts

@@ -1,8 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { describe, expect, it } from "vitest";
+import { describe, expect, expectTypeOf, it } from "vitest";
 import { z } from "zod";
-import { parseNotebookEvent } from "../events";
+import { type NotebookEvent, parseNotebookEvent } from "../events";
 
 describe("notebook messages", () => {
   it("normalizes session and host envelopes for native marimo messages", () => {
@@ -10,6 +10,9 @@ describe("notebook messages", () => {
       op: "variables",
       variables: [{ name: "x", value: Number.NaN }],
     };
+    expectTypeOf<
+      Extract<NotebookEvent, { event: "marimo" }>["data"]["marimo"]
+    >().toBeUnknown();
     const host = { event: "marimo", data: { marimo: notification } };
     expect(parseNotebookEvent({ data: notification })).toEqual(host);
     expect(parseNotebookEvent({ ...host, id: "42" })).toEqual({

package/src/core/host/__tests__/fixtures.ts

@@ -2,7 +2,7 @@
 
 import NodeFs from "node:fs";
 import NodeUrl from "node:url";
-import { parseNotebookEvent, type NotebookEvent } from "../events";
+import * as Protocol from "@marimo-team/client/protocol";
 
 /** Read the protocol's portable examples as transport messages. */
 export function fixtureMessages(name: string) {
@@ -33,7 +33,9 @@ export function fixtureMessages(name: string) {
     });
 }
 
-/** Read the protocol's portable examples as decoded notebook events. */
-export function fixtureEvents(name: string): NotebookEvent[] {
-  return fixtureMessages(name).map(parseNotebookEvent);
+/** Read the protocol's portable examples as decoded protocol events. */
+export function fixtureEvents(name: string): Protocol.EventOutput[] {
+  return fixtureMessages(name).map(({ id, ...message }) =>
+    Protocol.Event.parse(id === undefined ? message : { ...message, id }),
+  );
 }

package/src/core/host/events.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { z } from "zod";
-import * as Protocol from "./protocol";
+import * as Protocol from "@marimo-team/client/protocol";
 
 /**
  * Notebook stream events, including native marimo notifications.
@@ -29,16 +29,29 @@ const knownNames = new Set<string>(
   Protocol.Event.options.flatMap((schema) => schema.shape.event.options),
 );
 
+/**
+ * A native marimo message carried by a host stream.
+ *
+ * The protocol leaves extension events to their producer. The payload is
+ * passed through for the session handler to interpret.
+ */
+const MarimoEvent = z.object({
+  event: z.literal("marimo"),
+  id: z.string().min(1).optional(),
+  data: z.object({ marimo: z.unknown() }),
+});
+
 /** A decoded event, or the name and cursor of an unrecognized event. */
 export type NotebookEvent =
   | Protocol.EventOutput
+  | z.output<typeof MarimoEvent>
   | {
       readonly event: "unknown";
       readonly name: string;
       readonly id?: string;
     };
 
-const sessionEnvelope = z.object({ data: Protocol.MarimoNotification });
+const sessionEnvelope = z.object({ data: z.unknown() });
 
 /**
  * Decode a host event or a legacy `{ data: notification }` session message.
@@ -54,6 +67,9 @@ export function parseNotebookEvent(value: unknown): NotebookEvent {
     };
   }
   const parsed = envelope.parse(value);
+  if (parsed.event === "marimo") {
+    return MarimoEvent.parse(parsed);
+  }
   if (knownNames.has(parsed.event)) {
     return Protocol.Event.parse(parsed);
   }

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

@@ -1,6 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { Logger } from "@/utils/Logger";
+import type { Attachment } from "@marimo-team/client/protocol";
+import { createReducer } from "@marimo-team/client/reducer";
 import { type Atom, atom, type createStore } from "jotai/vanilla";
 import {
   type ConnectionStatus,
@@ -10,11 +12,16 @@ import {
   type NotebookTransport,
   TransportReadyState,
 } from "./connection";
-import { parseNotebookEvent } from "./events";
-import type { Attachment } from "./protocol";
+import { type NotebookEvent, parseNotebookEvent } from "./events";
 import { attachments } from "./resources/attachments";
 import { type Document, document } from "./resources/document";
-import { createStream } from "./stream";
+
+/** Events that may arrive without a cursor after `ready`. */
+const UNCURSORED = new Set<NotebookEvent["event"]>([
+  "reset",
+  "marimo",
+  "unknown",
+]);
 
 /** A connection to a notebook on a marimo host. */
 export interface NotebookClient {
@@ -64,8 +71,8 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
     state: ConnectionState.NOT_STARTED,
   });
   // One atom holds the whole stream, which resource atoms derive from.
-  const stream = createStream({ document, attachments });
-  const streamAtom = atom(stream.initial);
+  const reducer = createReducer({ document, attachments });
+  const streamAtom = atom(reducer.initial);
   // A resumed stream is live, but presence waits for this connection's ready.
   const readyAtom = atom(false);
   const documentAtom = atom(
@@ -103,6 +110,8 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
     let terminal = false;
     let checkingHealth = false;
     let streamKey: string | undefined;
+    // 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();
@@ -118,15 +127,23 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
       identity.searchParams.delete("access_token");
       identity.searchParams.sort();
       const key = identity.toString();
+      const current = store.get(streamAtom);
+      // A live stream keeps its state and resumes from the cursor. An
+      // incomplete snapshot starts over.
       const state =
-        key === streamKey
-          ? stream.resume(store.get(streamAtom))
-          : stream.initial;
+        key !== streamKey
+          ? reducer.initial
+          : current.phase === "snapshot"
+            ? { ...reducer.initial, notebookId: current.notebookId }
+            : current;
+      if (state.phase === "snapshot") {
+        cursor = null;
+      }
       streamKey = key;
       store.set(readyAtom, false);
       store.set(streamAtom, state);
-      if (state.cursor !== null) {
-        next.searchParams.set("cursor", state.cursor);
+      if (cursor !== null) {
+        next.searchParams.set("cursor", cursor);
       }
       return next.toString();
     });
@@ -188,7 +205,22 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
       let event;
       try {
         event = parseNotebookEvent(decodeJson(message.data));
-        store.set(streamAtom, stream.reduce(store.get(streamAtom), event));
+        const state = store.get(streamAtom);
+        if (
+          state.phase === "live" &&
+          event.id === undefined &&
+          !UNCURSORED.has(event.event)
+        ) {
+          throw new Error("Live notebook event is missing its cursor");
+        }
+        if (event.event !== "marimo" && event.event !== "unknown") {
+          store.set(streamAtom, reducer.reduce(state, event));
+        }
+        if (event.event === "reset") {
+          cursor = null;
+        } else if (event.event === "ready" || state.phase === "live") {
+          cursor = event.id ?? cursor;
+        }
         if (event.event === "ready" || event.event === "reset") {
           store.set(readyAtom, event.event === "ready");
         }
@@ -198,7 +230,8 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
           onMessageError(error);
           return;
         }
-        store.set(streamAtom, stream.initial);
+        store.set(streamAtom, reducer.initial);
+        cursor = null;
         terminal = true;
         setStatus({
           ...disconnected,
@@ -256,7 +289,7 @@ export function createNotebookClient(store: ReturnType<typeof createStore>) {
         transport.removeEventListener("message", onMessage);
         transport.close();
         reconnect = undefined;
-        store.set(streamAtom, stream.initial);
+        store.set(streamAtom, reducer.initial);
         setStatus({ state: ConnectionState.NOT_STARTED });
       },
       { once: true },

package/src/core/host/resources/attachments.ts

@@ -1,10 +1,10 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import type { Attachment } from "../protocol";
-import type { Resource } from "./resource";
+import type { Attachment } from "@marimo-team/client/protocol";
+import type { Resource } from "@marimo-team/client/reducer";
 
 /** Attachment records retained with the stream's resume cursor. */
-export const attachments: Resource<readonly Attachment[]> = {
+export const attachments: Resource<readonly Attachment[], "attachment"> = {
   initial: [],
   on: {
     attachment: (state, { data: { attachment } }) =>

package/src/core/host/resources/document.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import type * as Protocol from "../protocol";
-import type { Resource } from "./resource";
+import type * as Protocol from "@marimo-team/client/protocol";
+import type { Resource } from "@marimo-team/client/reducer";
 
 /**
  * The notebook's content at one revision.
@@ -58,7 +58,7 @@ function publish(
   return { current: { revision, cells }, pending: null };
 }
 
-export const document: Resource<DocumentState> = {
+export const document: Resource<DocumentState, "cell" | "document"> = {
   initial: { current: null, pending: null },
   on: {
     cell: (state, { data }) => {

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

@@ -45,7 +45,7 @@ import { notebookAtom } from "@/core/cells/cells";
 import { AppConfigSchema } from "@/core/config/config-schema";
 import { ConnectionNotice } from "@/components/editor/alerts/connection-notice";
 import { kernelStartupErrorAtom } from "@/core/errors/state";
-import type { RunEvent } from "@/core/host/protocol";
+import type { RunEvent } from "@marimo-team/client/protocol";
 import type { NotificationPayload } from "@/core/kernel/messages";
 import { useRuntimeManager } from "@/core/runtime/config";
 import { initialRunCompletedAtom } from "../../kernel/state";

package/src/core/host/__tests__/protocol.test.ts

@@ -1,229 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import NodeFs from "node:fs";
-import NodeUrl from "node:url";
-import { describe, expect, expectTypeOf, it } from "vitest";
-import * as Protocol from "../protocol";
-
-const fixtures = new NodeUrl.URL(
-  "../../../../../protocols/host/fixtures/",
-  import.meta.url,
-);
-
-function readFixture(name: string): unknown {
-  return JSON.parse(
-    NodeFs.readFileSync(new NodeUrl.URL(name, fixtures), "utf8"),
-  );
-}
-
-const records = {
-  "record.json": Protocol.HostRecord,
-  "cell.json": Protocol.Cell,
-  "cell-withheld.json": Protocol.Cell,
-  "analysis.json": Protocol.Analysis,
-  "diagnostic.json": Protocol.Error,
-  "edit.json": Protocol.EditRequest,
-  "edit-conflict-request.json": Protocol.EditRequest,
-  "edit-response.json": Protocol.EditResponse,
-  "execution-restored.json": Protocol.Execution,
-  "run-cells-request.json": Protocol.RunRequest,
-};
-
-describe("host protocol fixtures", () => {
-  it.each(Object.entries(records))("parses %s unchanged", (name, schema) => {
-    const input = readFixture(name);
-    const original = structuredClone(input);
-    expect(schema.parse(input)).toEqual(original);
-    expect(input).toEqual(original);
-  });
-
-  it.each(NodeFs.readdirSync(new NodeUrl.URL("problems/", fixtures)))(
-    "parses problem %s",
-    (name) => {
-      const input = readFixture(`problems/${name}`);
-      expect(Protocol.Problem.parse(input)).toEqual(input);
-    },
-  );
-
-  it.each(NodeFs.readdirSync(fixtures).filter((name) => name.endsWith(".sse")))(
-    "parses events in %s unchanged",
-    (name) => {
-      const stream = NodeFs.readFileSync(
-        new NodeUrl.URL(name, fixtures),
-        "utf8",
-      );
-      let count = 0;
-      for (const frame of stream.split(/\r?\n\r?\n/)) {
-        const event = /^event: (.+)$/m.exec(frame)?.[1];
-        if (!event && !/^data:/m.test(frame)) {
-          continue;
-        }
-        const data = frame
-          .split(/\r?\n/)
-          .filter((line) => line.startsWith("data:"))
-          .map((line) => line.slice(5).trimStart())
-          .join("\n");
-        const id = /^id: (.+)$/m.exec(frame)?.[1];
-        const payload: unknown = JSON.parse(data);
-        const input = { event, data: payload, ...(id ? { id } : {}) };
-        const original = structuredClone(input);
-        expect(Protocol.Event.parse(input)).toEqual(original);
-        expect(input).toEqual(original);
-        count += 1;
-      }
-      expect(count).toBeGreaterThan(0);
-    },
-  );
-});
-
-describe("host protocol bindings", () => {
-  it("preserves native marimo payloads without interpreting them", () => {
-    expectTypeOf<Protocol.MarimoEvent["data"]["marimo"]>().toBeUnknown();
-    const input = {
-      event: "marimo",
-      id: "42",
-      data: {
-        marimo: {
-          future_payload: { value: Number.NaN },
-        },
-      },
-    };
-    expect(Protocol.Event.parse(input)).toEqual(input);
-  });
-
-  it("accepts additive fields and preserves arbitrary notebook settings", () => {
-    const cell = Protocol.Cell.parse(readFixture("cell.json"));
-    const input = {
-      ...cell,
-      future: { enabled: true },
-      config: { ...cell.config, future: 42 },
-    };
-    const original = structuredClone(input);
-    expect(Protocol.Cell.parse(input)).toEqual(cell);
-    expect(input).toEqual(original);
-
-    const { document } = Protocol.EditResponse.parse(
-      readFixture("edit-response.json"),
-    );
-    const configured = {
-      ...document,
-      app_config: { extension: { values: [1, null, false] } },
-    };
-    expect(Protocol.Document.parse(configured)).toEqual(configured);
-  });
-
-  it("requires source in edits while allowing withheld source in records", () => {
-    expectTypeOf<Protocol.Cell["code"]>().toEqualTypeOf<string | null>();
-    expectTypeOf<Protocol.CellInput["code"]>().toEqualTypeOf<string>();
-    const cell = Protocol.Cell.parse(readFixture("cell.json"));
-    const { code, ...missing } = cell;
-    expect(Protocol.Cell.safeParse(missing).success).toBe(false);
-    expect(Protocol.Cell.parse({ ...cell, code: "" }).code).toBe("");
-    for (const input of [{ id: cell.id }, { id: cell.id, code: null }]) {
-      expect(Protocol.CellInput.safeParse(input).success).toBe(false);
-    }
-    expect(Protocol.CellInput.parse({ id: cell.id, code }).code).toBe(code);
-    expect(Protocol.CellInput.parse({ id: cell.id, code: "" }).code).toBe("");
-  });
-
-  it("applies the defaults declared for cell inputs", () => {
-    expect(
-      Protocol.CellInput.parse({ id: "c3", code: "x = 1", config: {} }),
-    ).toEqual({
-      id: "c3",
-      code: "x = 1",
-      name: "_",
-      config: {
-        column: null,
-        disabled: false,
-        hide_code: false,
-        expand_output: false,
-      },
-    });
-  });
-
-  it.each(["run_id", "runtime_id", "caused_by"] as const)(
-    "requires the nullable execution field %s",
-    (field) => {
-      const execution = Protocol.Execution.parse(
-        readFixture("execution-restored.json"),
-      );
-      const missing = Object.fromEntries(
-        Object.entries(execution).filter(([key]) => key !== field),
-      );
-      expect(Protocol.Execution.safeParse(missing).success).toBe(false);
-      expect(
-        Protocol.Execution.safeParse({ ...execution, [field]: null }).success,
-      ).toBe(true);
-    },
-  );
-
-  it("preserves snapshot metadata omissions and validates live timestamps", () => {
-    const cell = Protocol.Cell.parse(readFixture("cell.json"));
-    expect(Protocol.CellMessage.parse({ cell })).toEqual({ cell });
-    const message = { cell, time: "2026-01-01T12:00:00+05:30" };
-    expect(Protocol.CellMessage.parse(message)).toEqual(message);
-    for (const time of [
-      null,
-      "yesterday",
-      "2026-02-30T12:00:00Z",
-      "2026-01-01T12:00:00",
-    ]) {
-      expect(Protocol.CellMessage.safeParse({ cell, time }).success).toBe(
-        false,
-      );
-    }
-  });
-
-  it("rejects invalid cell fields without coercing their values", () => {
-    const cell = Protocol.Cell.parse(readFixture("cell.json"));
-    for (const patch of [
-      { id: "" },
-      { code: 42 },
-      { etag: 42 },
-      { version: "2" },
-      { version: 0 },
-      { version: 1.5 },
-      { config: { ...cell.config, disabled: "false" } },
-    ]) {
-      expect(Protocol.Cell.safeParse({ ...cell, ...patch }).success).toBe(
-        false,
-      );
-    }
-    const result = Protocol.Cell.safeParse({ ...cell, code: 42 });
-    expect(result.success).toBe(false);
-    if (result.success) {
-      throw new Error("Expected an invalid cell");
-    }
-    expect(result.error.issues).toEqual([
-      expect.objectContaining({ path: ["code"], code: "invalid_type" }),
-    ]);
-  });
-
-  it("requires the fields of the selected change kind", () => {
-    const change = { kind: "delete_cell", id: "c3", base_etag: "*" };
-    expect(Protocol.Change.parse(change)).toEqual(change);
-    expect(
-      Protocol.Change.safeParse({ kind: "delete_cell", id: "c3" }).success,
-    ).toBe(false);
-    expect(
-      Protocol.Change.safeParse({ ...change, kind: "unknown" }).success,
-    ).toBe(false);
-  });
-
-  it("requires custom payloads while allowing any JSON value", () => {
-    for (const data of [
-      null,
-      false,
-      42,
-      "text",
-      { nested: [1, null, false] },
-    ]) {
-      const custom = { type: "example.event", data };
-      expect(Protocol.Custom.parse(custom)).toEqual(custom);
-    }
-    expect(Protocol.Custom.safeParse({ type: "example.event" }).success).toBe(
-      false,
-    );
-  });
-});