@marimo-team/frontend 0.25.3-dev81 → 0.25.3-dev85

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

@@ -1,308 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { describe, expect, it, vi } from "vitest";
-import { ConnectionSubscriptions } from "../transport";
-
-describe("ConnectionSubscriptions", () => {
-  describe("addSubscription", () => {
-    it("should add a subscription for an event", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback = vi.fn();
-
-      subscriptions.addSubscription("open", callback);
-
-      // Verify by notifying
-      subscriptions.notify("open", new Event("open"));
-      expect(callback).toHaveBeenCalledTimes(1);
-    });
-
-    it("should add multiple subscriptions for the same event", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback1 = vi.fn();
-      const callback2 = vi.fn();
-      const callback3 = vi.fn();
-
-      subscriptions.addSubscription("message", callback1);
-      subscriptions.addSubscription("message", callback2);
-      subscriptions.addSubscription("message", callback3);
-
-      const messageEvent = new MessageEvent("message", { data: "test" });
-      subscriptions.notify("message", messageEvent);
-
-      expect(callback1).toHaveBeenCalledWith(messageEvent);
-      expect(callback2).toHaveBeenCalledWith(messageEvent);
-      expect(callback3).toHaveBeenCalledWith(messageEvent);
-    });
-
-    it("should add subscriptions for different event types", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const openCallback = vi.fn();
-      const closeCallback = vi.fn();
-      const messageCallback = vi.fn();
-
-      subscriptions.addSubscription("open", openCallback);
-      subscriptions.addSubscription("close", closeCallback);
-      subscriptions.addSubscription("message", messageCallback);
-
-      subscriptions.notify("open", new Event("open"));
-      expect(openCallback).toHaveBeenCalledTimes(1);
-      expect(closeCallback).not.toHaveBeenCalled();
-      expect(messageCallback).not.toHaveBeenCalled();
-    });
-
-    it("should not add duplicate subscriptions for the same callback", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback = vi.fn();
-
-      subscriptions.addSubscription("close", callback);
-      subscriptions.addSubscription("close", callback);
-      subscriptions.addSubscription("close", callback);
-
-      subscriptions.notify("close", new Event("close"));
-
-      // Set only stores unique callbacks, so should be called once
-      expect(callback).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("removeSubscription", () => {
-    it("should remove a subscription", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback = vi.fn();
-
-      subscriptions.addSubscription("message", callback);
-      subscriptions.removeSubscription("message", callback);
-
-      const messageEvent = new MessageEvent("message", { data: "test" });
-      subscriptions.notify("message", messageEvent);
-
-      expect(callback).not.toHaveBeenCalled();
-    });
-
-    it("should only remove the specific callback", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback1 = vi.fn();
-      const callback2 = vi.fn();
-      const callback3 = vi.fn();
-
-      subscriptions.addSubscription("close", callback1);
-      subscriptions.addSubscription("close", callback2);
-      subscriptions.addSubscription("close", callback3);
-
-      subscriptions.removeSubscription("close", callback2);
-
-      subscriptions.notify("close", new Event("close"));
-
-      expect(callback1).toHaveBeenCalledTimes(1);
-      expect(callback2).not.toHaveBeenCalled();
-      expect(callback3).toHaveBeenCalledTimes(1);
-    });
-
-    it("should handle removing subscription from non-existent event type", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback = vi.fn();
-
-      subscriptions.addSubscription("open", callback);
-
-      expect(() =>
-        subscriptions.removeSubscription("close", callback),
-      ).not.toThrow();
-
-      subscriptions.notify("open", new Event("open"));
-      expect(callback).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("notify", () => {
-    it("should notify all subscribed callbacks for an event", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback1 = vi.fn();
-      const callback2 = vi.fn();
-
-      subscriptions.addSubscription("open", callback1);
-      subscriptions.addSubscription("open", callback2);
-
-      const openEvent = new Event("open");
-      subscriptions.notify("open", openEvent);
-
-      expect(callback1).toHaveBeenCalledWith(openEvent);
-      expect(callback2).toHaveBeenCalledWith(openEvent);
-    });
-
-    it("should pass the correct data to callbacks", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback = vi.fn();
-
-      subscriptions.addSubscription("message", callback);
-
-      const messageEvent = new MessageEvent("message", {
-        data: "test data",
-      });
-      subscriptions.notify("message", messageEvent);
-
-      expect(callback).toHaveBeenCalledWith(messageEvent);
-      expect(callback.mock.calls[0][0].data).toBe("test data");
-    });
-
-    it("should not notify callbacks for different event types", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const openCallback = vi.fn();
-      const closeCallback = vi.fn();
-
-      subscriptions.addSubscription("open", openCallback);
-      subscriptions.addSubscription("close", closeCallback);
-
-      subscriptions.notify("open", new Event("open"));
-
-      expect(openCallback).toHaveBeenCalledTimes(1);
-      expect(closeCallback).not.toHaveBeenCalled();
-    });
-
-    it("should handle exceptions in callbacks without affecting other callbacks", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const throwingCallback = vi.fn(() => {
-        throw new Error("Callback error");
-      });
-      const normalCallback = vi.fn();
-
-      subscriptions.addSubscription("message", throwingCallback);
-      subscriptions.addSubscription("message", normalCallback);
-
-      const messageEvent = new MessageEvent("message", { data: "test" });
-
-      expect(() => subscriptions.notify("message", messageEvent)).toThrow(
-        "Callback error",
-      );
-
-      expect(throwingCallback).toHaveBeenCalledWith(messageEvent);
-      expect(normalCallback).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("Integration scenarios", () => {
-    it("should handle complete subscription lifecycle", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback = vi.fn();
-
-      subscriptions.addSubscription("open", callback);
-
-      subscriptions.notify("open", new Event("open"));
-      expect(callback).toHaveBeenCalledTimes(1);
-
-      subscriptions.removeSubscription("open", callback);
-
-      subscriptions.notify("open", new Event("open"));
-      expect(callback).toHaveBeenCalledTimes(1);
-    });
-
-    it("should handle multiple events with multiple callbacks", () => {
-      const subscriptions = new ConnectionSubscriptions();
-
-      const openCallback1 = vi.fn();
-      const openCallback2 = vi.fn();
-      const closeCallback1 = vi.fn();
-      const messageCallback = vi.fn();
-
-      subscriptions.addSubscription("open", openCallback1);
-      subscriptions.addSubscription("open", openCallback2);
-      subscriptions.addSubscription("close", closeCallback1);
-      subscriptions.addSubscription("message", messageCallback);
-
-      subscriptions.notify("open", new Event("open"));
-      expect(openCallback1).toHaveBeenCalledTimes(1);
-      expect(openCallback2).toHaveBeenCalledTimes(1);
-      expect(closeCallback1).not.toHaveBeenCalled();
-      expect(messageCallback).not.toHaveBeenCalled();
-
-      const messageEvent = new MessageEvent("message", { data: "test" });
-      subscriptions.notify("message", messageEvent);
-      expect(openCallback1).toHaveBeenCalledTimes(1);
-      expect(openCallback2).toHaveBeenCalledTimes(1);
-      expect(closeCallback1).not.toHaveBeenCalled();
-      expect(messageCallback).toHaveBeenCalledTimes(1);
-      expect(messageCallback).toHaveBeenCalledWith(messageEvent);
-
-      subscriptions.notify("close", new Event("close"));
-      expect(openCallback1).toHaveBeenCalledTimes(1);
-      expect(openCallback2).toHaveBeenCalledTimes(1);
-      expect(closeCallback1).toHaveBeenCalledTimes(1);
-      expect(messageCallback).toHaveBeenCalledTimes(1);
-    });
-
-    it("should handle add and remove operations interleaved", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback1 = vi.fn();
-      const callback2 = vi.fn();
-      const callback3 = vi.fn();
-
-      subscriptions.addSubscription("message", callback1);
-      subscriptions.addSubscription("message", callback2);
-
-      const msg1 = new MessageEvent("message", { data: "msg1" });
-      subscriptions.notify("message", msg1);
-
-      expect(callback1).toHaveBeenCalledWith(msg1);
-      expect(callback2).toHaveBeenCalledWith(msg1);
-      expect(callback3).not.toHaveBeenCalled();
-
-      subscriptions.removeSubscription("message", callback1);
-      subscriptions.addSubscription("message", callback3);
-
-      const msg2 = new MessageEvent("message", { data: "msg2" });
-      subscriptions.notify("message", msg2);
-
-      expect(callback1).toHaveBeenCalledTimes(1);
-      expect(callback2).toHaveBeenCalledWith(msg2);
-      expect(callback3).toHaveBeenCalledWith(msg2);
-    });
-
-    it("should maintain separate subscription lists per event type", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback = vi.fn();
-
-      subscriptions.addSubscription("open", callback);
-      subscriptions.addSubscription("close", callback);
-      subscriptions.addSubscription("message", callback);
-
-      subscriptions.removeSubscription("close", callback);
-
-      subscriptions.notify("open", new Event("open"));
-      expect(callback).toHaveBeenCalledTimes(1);
-
-      subscriptions.notify(
-        "message",
-        new MessageEvent("message", { data: "test" }),
-      );
-      expect(callback).toHaveBeenCalledTimes(2);
-
-      subscriptions.notify("close", new Event("close"));
-      expect(callback).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe("Edge cases", () => {
-    it("should handle callback that modifies subscriptions", () => {
-      const subscriptions = new ConnectionSubscriptions();
-      const callback1 = vi.fn();
-      const callback2 = vi.fn(() => {
-        subscriptions.removeSubscription("message", callback1);
-      });
-
-      subscriptions.addSubscription("message", callback1);
-      subscriptions.addSubscription("message", callback2);
-
-      const messageEvent = new MessageEvent("message", { data: "test" });
-      subscriptions.notify("message", messageEvent);
-
-      expect(callback1).toHaveBeenCalledTimes(1);
-      expect(callback2).toHaveBeenCalledTimes(1);
-
-      callback1.mockClear();
-      callback2.mockClear();
-
-      subscriptions.notify("message", messageEvent);
-      expect(callback1).not.toHaveBeenCalled();
-      expect(callback2).toHaveBeenCalledTimes(1);
-    });
-  });
-});

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

@@ -1,125 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { MAX_RETRIES, WsTransport, TRANSPORT_EXHAUSTED_REASON } from "../ws";
-
-let innerListeners: Record<string, ((e: unknown) => void)[]>;
-
-vi.mock("partysocket/ws", () => {
-  class FakeReconnectingWebSocket {
-    public retryCount = 0;
-    public readyState = WebSocket.CONNECTING;
-    public constructor() {
-      innerListeners = { open: [], close: [], message: [], error: [] };
-    }
-    public addEventListener(event: string, cb: (e: unknown) => void) {
-      innerListeners[event].push(cb);
-    }
-    public removeEventListener(event: string, cb: (e: unknown) => void) {
-      innerListeners[event] = innerListeners[event].filter((c) => c !== cb);
-    }
-    public reconnect() {}
-    public close() {}
-    public send() {}
-  }
-  return { default: FakeReconnectingWebSocket };
-});
-
-interface FakeReconnectingWebSocket {
-  retryCount: number;
-  readyState: number;
-}
-
-function dispatchClose(reason = "") {
-  const evt = new CloseEvent("close", { reason, code: 1006 });
-  for (const cb of innerListeners.close) {
-    cb(evt);
-  }
-}
-
-describe("WsTransport", () => {
-  let transport: WsTransport;
-  let inner: FakeReconnectingWebSocket;
-
-  beforeEach(() => {
-    transport = new WsTransport(() => "ws://example.invalid/ws");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    inner = (transport as any).inner;
-  });
-
-  describe("close event reason", () => {
-    it("forwards the original reason before retry budget is exhausted", () => {
-      const seen: CloseEvent[] = [];
-      transport.addEventListener("close", (e) => seen.push(e));
-
-      inner.retryCount = MAX_RETRIES - 1;
-      dispatchClose("");
-
-      expect(seen).toHaveLength(1);
-      expect(seen[0].reason).toBe("");
-    });
-
-    it("rewrites reason to MARIMO_TRANSPORT_EXHAUSTED on exhaustion", () => {
-      const seen: CloseEvent[] = [];
-      transport.addEventListener("close", (e) => seen.push(e));
-
-      inner.retryCount = MAX_RETRIES;
-      dispatchClose("");
-
-      expect(seen).toHaveLength(1);
-      expect(seen[0].reason).toBe(TRANSPORT_EXHAUSTED_REASON);
-    });
-
-    it("does not rewrite a server-sent reason on exhaustion", () => {
-      // If partysocket happens to deliver a real MARIMO_* reason at the same
-      // moment the retry budget exhausts, the exhausted-state rewrite still
-      // wins because the wrapper keys off retryCount, not the original reason.
-      // Document the behavior so a future change is deliberate.
-      const seen: CloseEvent[] = [];
-      transport.addEventListener("close", (e) => seen.push(e));
-
-      inner.retryCount = MAX_RETRIES;
-      dispatchClose("MARIMO_SHUTDOWN");
-
-      expect(seen[0].reason).toBe(TRANSPORT_EXHAUSTED_REASON);
-    });
-  });
-
-  describe("addEventListener dedupe", () => {
-    it("does not double-fire when the same close listener is added twice", () => {
-      const cb = vi.fn();
-      transport.addEventListener("close", cb);
-      transport.addEventListener("close", cb);
-
-      dispatchClose("");
-
-      expect(cb).toHaveBeenCalledTimes(1);
-    });
-
-    it("a single removeEventListener fully unregisters a duplicated add", () => {
-      const cb = vi.fn();
-      transport.addEventListener("close", cb);
-      transport.addEventListener("close", cb);
-      transport.removeEventListener("close", cb);
-
-      dispatchClose("");
-
-      expect(cb).not.toHaveBeenCalled();
-      // Inner socket has no orphaned wrappers left.
-      expect(innerListeners.close).toHaveLength(0);
-    });
-  });
-
-  describe("removeEventListener", () => {
-    it("unregisters the right wrapper for close listeners", () => {
-      const cb = vi.fn();
-      transport.addEventListener("close", cb);
-      transport.removeEventListener("close", cb);
-
-      inner.retryCount = MAX_RETRIES;
-      dispatchClose("");
-
-      expect(cb).not.toHaveBeenCalled();
-    });
-  });
-});

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

@@ -1,102 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import {
-  type ConnectionEvent,
-  ConnectionSubscriptions,
-  type ConnectionTransportCallback,
-  type IConnectionTransport,
-} from "./transport";
-
-type MessageProducer = (callback: (message: MessageEvent) => void) => void;
-
-export class BasicTransport implements IConnectionTransport {
-  private subscriptions = new ConnectionSubscriptions();
-  private producer?: MessageProducer;
-
-  public static withProducerCallback(
-    producer: MessageProducer,
-  ): IConnectionTransport {
-    return new BasicTransport(producer);
-  }
-
-  public static empty(): IConnectionTransport {
-    return new BasicTransport();
-  }
-
-  private constructor(producer?: MessageProducer) {
-    this.producer = producer;
-  }
-
-  private startProducer() {
-    if (this.producer) {
-      this.producer((message) => {
-        this.subscriptions.notify("message", message);
-      });
-    }
-  }
-
-  private connect(): Promise<void> {
-    return new Promise<void>((resolve) => setTimeout(resolve, 0)).then(() => {
-      this.subscriptions.notify("open", new Event("open"));
-    });
-  }
-
-  public get readyState(): WebSocket["readyState"] {
-    return WebSocket.OPEN;
-  }
-
-  public reconnect(
-    _code?: number | undefined,
-    _reason?: string | undefined,
-  ): void {
-    this.close();
-    this.connect();
-    return;
-  }
-
-  public close(): void {
-    this.subscriptions.notify("close", new Event("close"));
-  }
-
-  public send(
-    data: string | ArrayBuffer | Blob | ArrayBufferView,
-  ): Promise<void> {
-    this.subscriptions.notify(
-      "message",
-      new MessageEvent("message", {
-        data,
-      }),
-    );
-    return Promise.resolve();
-  }
-
-  public addEventListener<T extends ConnectionEvent>(
-    event: T,
-    callback: ConnectionTransportCallback<T>,
-  ): void {
-    this.subscriptions.addSubscription(
-      event,
-      callback as ConnectionTransportCallback<ConnectionEvent>,
-    );
-
-    // Call open right away
-    if (event === "open") {
-      (callback as ConnectionTransportCallback<"open">)(new Event("open"));
-    }
-
-    // Start the producer when we have one consumer
-    if (event === "message") {
-      this.startProducer();
-    }
-  }
-
-  public removeEventListener<T extends ConnectionEvent>(
-    event: T,
-    callback: ConnectionTransportCallback<T>,
-  ): void {
-    this.subscriptions.removeSubscription(
-      event,
-      callback as ConnectionTransportCallback<ConnectionEvent>,
-    );
-  }
-}

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

@@ -1,31 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { createPyodideConnection } from "../../wasm/bridge";
-import { isWasm } from "../../wasm/utils";
-import { BasicTransport } from "./basic";
-import { SseTransport } from "./sse";
-import { WsTransport } from "./ws";
-import type { IConnectionTransport } from "./transport";
-
-export interface ConnectionTransportOptions {
-  url: () => string;
-  static: boolean;
-  transportType: "websocket" | "sse";
-  headers: () => Record<string, string>;
-}
-
-export function createConnectionTransport(
-  options: ConnectionTransportOptions,
-): IConnectionTransport {
-  if (options.static) {
-    return BasicTransport.empty();
-  }
-  if (isWasm()) {
-    return createPyodideConnection();
-  }
-  // Read the URL lazily to follow runtime redirects.
-  if (options.transportType === "sse") {
-    return new SseTransport(options.url, options.headers);
-  }
-  return new WsTransport(options.url);
-}