@marimo-team/islands 0.25.3-dev30 → 0.25.3-dev302

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,
-    );
-  });
-});

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

@@ -1,209 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { describe, expect, it } from "vitest";
-import type { NotebookEvent } from "../events";
-import type { Resource } from "../resources/resource";
-import { createStream } from "../stream";
-import { fixtureEvents } from "./fixtures";
-
-interface CellIds {
-  readonly ids: readonly string[];
-}
-
-/** A resource whose events are complete on their own. */
-const cells: Resource<CellIds> = {
-  initial: { ids: [] },
-  on: {
-    cell: (state, event) =>
-      state.ids.includes(event.data.cell.id)
-        ? state
-        : { ids: [...state.ids, event.data.cell.id] },
-    "cell.removed": (state, event) =>
-      state.ids.includes(event.data.id)
-        ? { ids: state.ids.filter((id) => id !== event.data.id) }
-        : state,
-  },
-};
-
-interface Revisions {
-  /** Cells changed since the last revision. */
-  readonly pending: readonly string[];
-  readonly published: readonly (readonly string[])[];
-}
-
-function publish(state: Revisions): Revisions {
-  return { pending: [], published: [...state.published, state.pending] };
-}
-
-/** A resource assembled from groups of events, like a document from its cells. */
-const revisions: Resource<Revisions> = {
-  initial: { pending: [], published: [] },
-  on: {
-    cell: (state, event) => ({
-      ...state,
-      pending: [...state.pending, event.data.cell.id],
-    }),
-    "cell.removed": (state, event) => ({
-      ...state,
-      pending: [...state.pending, event.data.id],
-    }),
-    // A live revision completes a group. A snapshot's revision waits for ready.
-    document: (state, _event, { phase }) =>
-      phase === "live" ? publish(state) : state,
-    ready: publish,
-  },
-};
-
-function createTestStream() {
-  return createStream({ cells, revisions });
-}
-
-function replay(
-  stream: ReturnType<typeof createTestStream>,
-  events: readonly NotebookEvent[],
-  from = stream.initial,
-) {
-  return events.reduce((state, event) => stream.reduce(state, event), from);
-}
-
-const snapshot = fixtureEvents("notebook-events.sse");
-const ready = snapshot.findIndex((event) => event.event === "ready");
-const cellEvent = snapshot.find((event) => event.event === "cell");
-if (cellEvent?.event !== "cell") {
-  throw new Error("Fixture is missing a cell event");
-}
-
-describe("notebook stream", () => {
-  it("reads the snapshot, goes live at ready, and rebuilds after reset", () => {
-    const stream = createTestStream();
-    const partial = replay(stream, snapshot.slice(0, ready));
-    expect(partial).toMatchObject({
-      phase: "snapshot",
-      notebookId: "n1",
-      cursor: null,
-    });
-    expect(partial.resources.cells.ids).toEqual(["c1", "c3", "k7f2"]);
-    expect(partial.resources.revisions).toEqual({
-      pending: ["c1", "c3", "k7f2"],
-      published: [],
-    });
-
-    const live = replay(stream, snapshot.slice(ready), partial);
-    expect(live).toMatchObject({ phase: "live", cursor: "97" });
-    expect(live.resources.cells).toBe(partial.resources.cells);
-    expect(live.resources.revisions).toEqual({
-      pending: [],
-      published: [["c1", "c3", "k7f2"]],
-    });
-
-    const resetEvents = fixtureEvents("events-reset.sse");
-    const afterReset = stream.reduce(live, resetEvents[0]);
-    expect(afterReset).toEqual({ ...stream.initial, notebookId: "n1" });
-    expect(replay(stream, resetEvents, live).phase).toBe("live");
-  });
-
-  it("keeps resource state by reference when an event does not apply", () => {
-    const stream = createTestStream();
-    const state = replay(stream, snapshot);
-    const runtime = snapshot.find((event) => event.event === "runtime");
-    const unhandled = stream.reduce(state, { ...runtime!, id: "100" });
-    expect(unhandled.resources).toBe(state.resources);
-    expect(unhandled.cursor).toBe("100");
-    expect(
-      stream.reduce(state, { event: "unknown", name: "x", id: "101" })
-        .resources,
-    ).toBe(state.resources);
-    expect(
-      stream.reduce(state, { event: "marimo", data: { marimo: {} } }),
-    ).toBe(state);
-  });
-
-  it("clears resources when its notebook is removed and ignores other notebooks", () => {
-    const stream = createTestStream();
-    const state = replay(stream, snapshot);
-    const time = "2026-10-01T09:30:00Z";
-    expect(
-      stream.reduce(state, {
-        event: "notebook.removed",
-        id: "100",
-        data: { id: "n2", time },
-      }).resources,
-    ).toBe(state.resources);
-    const removed = stream.reduce(state, {
-      event: "notebook.removed",
-      id: "100",
-      data: { id: "n1", time },
-    });
-    expect(removed).toMatchObject({ phase: "live", notebookId: "n1" });
-    expect(removed.resources).toBe(stream.initial.resources);
-  });
-
-  it("rejects objects from another notebook", () => {
-    const stream = createTestStream();
-    const state = replay(stream, snapshot.slice(0, ready));
-    const notebook = snapshot[0];
-    if (notebook.event !== "notebook") {
-      throw new Error("Fixture does not start with its notebook");
-    }
-    expect(() =>
-      stream.reduce(state, {
-        ...notebook,
-        data: { notebook: { ...notebook.data.notebook, id: "n2" } },
-      }),
-    ).toThrow("changed identity");
-    expect(() =>
-      stream.reduce(state, {
-        ...cellEvent,
-        data: { cell: { ...cellEvent.data.cell, notebook_id: "n2" } },
-      }),
-    ).toThrow("changed identity");
-  });
-
-  it("records each live event's cursor and resumes in place", () => {
-    const stream = createTestStream();
-    const partial = replay(stream, snapshot.slice(0, ready));
-    expect(stream.resume(partial)).toEqual({
-      ...stream.initial,
-      notebookId: "n1",
-    });
-
-    const live = replay(stream, snapshot.slice(ready), partial);
-    const [cell, , removed, published, saved] = fixtureEvents("edits.sse");
-    const editing = replay(stream, [cell], live);
-    expect(editing.cursor).toBe("110");
-    expect(editing.resources.revisions.pending).toEqual(["c2"]);
-    expect(stream.resume(editing)).toBe(editing);
-
-    const edited = replay(stream, [removed, published], editing);
-    expect(edited.cursor).toBe("113");
-    expect(edited.resources.revisions).toEqual({
-      pending: [],
-      published: [
-        ["c1", "c3", "k7f2"],
-        ["c2", "k7f2"],
-      ],
-    });
-    expect(stream.reduce(edited, saved).cursor).toBe("114");
-    expect(
-      stream.reduce(edited, { event: "ready", id: "116", data: {} }).cursor,
-    ).toBe("116");
-    expect(stream.reduce(edited, { event: "reset", data: {} }).cursor).toBe(
-      null,
-    );
-  });
-
-  it("requires a cursor on live events other than reset and notifications", () => {
-    const stream = createTestStream();
-    const state = replay(stream, snapshot);
-    expect(() => stream.reduce(state, cellEvent)).toThrow("cursor");
-    expect(
-      stream.reduce(state, { ...cellEvent, id: "100" }).resources.cells,
-    ).toBe(state.resources.cells);
-    expect(stream.reduce(state, { event: "reset", data: {} }).phase).toBe(
-      "snapshot",
-    );
-    expect(
-      stream.reduce(state, { event: "marimo", data: { marimo: null } }),
-    ).toBe(state);
-  });
-});

package/src/core/host/connection.ts

@@ -1,81 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-export const ConnectionState = {
-  NOT_STARTED: "NOT_STARTED",
-  CONNECTING: "CONNECTING",
-  OPEN: "OPEN",
-  CLOSING: "CLOSING",
-  CLOSED: "CLOSED",
-} as const;
-
-export type ConnectionState =
-  (typeof ConnectionState)[keyof typeof ConnectionState];
-
-export const ConnectionClosedReason = {
-  KERNEL_DISCONNECTED: "KERNEL_DISCONNECTED",
-  KERNEL_STARTUP_ERROR: "KERNEL_STARTUP_ERROR",
-} as const;
-
-export type ConnectionClosedReason =
-  (typeof ConnectionClosedReason)[keyof typeof ConnectionClosedReason];
-
-export type ConnectionStatus =
-  | {
-      state: typeof ConnectionState.CLOSED;
-      code: ConnectionClosedReason;
-      reason: string;
-    }
-  | {
-      state: typeof ConnectionState.CONNECTING;
-    }
-  | {
-      state:
-        | typeof ConnectionState.OPEN
-        | typeof ConnectionState.CLOSING
-        | typeof ConnectionState.NOT_STARTED;
-    };
-
-/** The recovery policy for a closed connection. */
-export interface CloseDecision {
-  kind: "terminal" | "gave-up" | "retry";
-  status: ConnectionStatus;
-}
-
-export type ConnectionEvent = "open" | "close" | "message" | "error";
-
-export interface IConnectionTransportMap {
-  open: WebSocketEventMap["open"];
-  message: WebSocketEventMap["message"];
-  close: WebSocketEventMap["close"];
-  error: WebSocketEventMap["error"];
-}
-
-export type ConnectionTransportCallback<T extends ConnectionEvent> = (
-  data: IConnectionTransportMap[T],
-) => void;
-
-/** Transport readiness, using the WebSocket readyState values. */
-export const TransportReadyState = {
-  CONNECTING: 0,
-  OPEN: 1,
-  CLOSING: 2,
-  CLOSED: 3,
-} as const;
-
-export type TransportReadyState =
-  (typeof TransportReadyState)[keyof typeof TransportReadyState];
-
-/** A reconnectable source of notebook messages. */
-export interface NotebookTransport {
-  reconnect(code?: number | undefined, reason?: string | undefined): void;
-  close(): void;
-  addEventListener<T extends ConnectionEvent>(
-    event: T,
-    callback: ConnectionTransportCallback<T>,
-  ): void;
-  removeEventListener<T extends ConnectionEvent>(
-    event: T,
-    callback: ConnectionTransportCallback<T>,
-  ): void;
-  readyState: TransportReadyState;
-}

package/src/core/host/events.ts

@@ -1,61 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { z } from "zod";
-import * as Protocol from "./protocol";
-
-/**
- * Notebook stream events, including native marimo notifications.
- *
- * Known events follow the generated protocol. Unknown events retain their name
- * 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(),
-  id: z.string().min(1).optional(),
-});
-
-const knownNames = new Set<string>(
-  Protocol.Event.options.flatMap((schema) => schema.shape.event.options),
-);
-
-/** A decoded event, or the name and cursor of an unrecognized event. */
-export type NotebookEvent =
-  | Protocol.EventOutput
-  | {
-      readonly event: "unknown";
-      readonly name: string;
-      readonly id?: string;
-    };
-
-const sessionEnvelope = z.object({ data: Protocol.MarimoNotification });
-
-/**
- * Decode a host event or a legacy `{ data: notification }` session message.
- *
- * Throws if the envelope or a known event is malformed. Native notification
- * payloads are passed through for the session handler to interpret.
- */
-export function parseNotebookEvent(value: unknown): NotebookEvent {
-  if (typeof value === "object" && value !== null && !("event" in value)) {
-    return {
-      event: "marimo",
-      data: { marimo: sessionEnvelope.parse(value).data },
-    };
-  }
-  const parsed = envelope.parse(value);
-  if (knownNames.has(parsed.event)) {
-    return Protocol.Event.parse(parsed);
-  }
-  return { event: "unknown", name: parsed.event, id: parsed.id };
-}