A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
Prepare WASM sessions before starting execution (#11520)
Trevor Manz54bb253cef49
diff --git a/frontend/src/core/host/__tests__/wasm.test.ts b/frontend/src/core/host/__tests__/wasm.test.tsindex 2b9554335f..3780cf1ad2 100644--- a/frontend/src/core/host/__tests__/wasm.test.ts+++ b/frontend/src/core/host/__tests__/wasm.test.ts@@ -80,6 +80,7 @@ describe("WASM notebook backend", () => {expect(bridge.subscribe).toHaveBeenCalledWith("previous-4",expect.any(Function),+ controller.signal,);controller.abort();await done;diff --git a/frontend/src/core/host/wasm.ts b/frontend/src/core/host/wasm.tsindex b06d026f8e..909c5b344a 100644--- a/frontend/src/core/host/wasm.ts+++ b/frontend/src/core/host/wasm.ts@@ -15,6 +15,7 @@ export interface WasmNotebookBridge {subscribe(cursor: string | null,emit: (event: unknown) => void,+ signal: AbortSignal,): Promise<() => void>;/** Deliver a call to the worker and resolve with its status and body. */call(call: unstable_NotebookCall): Promise<unknown>;@@ -65,11 +66,15 @@ export function createWasmNotebookBackend(await abortable(() =>bridge- .subscribe(cursor, (event) => {- if (!signal.aborted) {- message(event);- }- })+ .subscribe(+ cursor,+ (event) => {+ if (!signal.aborted) {+ message(event);+ }+ },+ signal,+ ).then((close) => {unsubscribe = close;if (signal.aborted) {diff --git a/frontend/src/core/islands/worker/__tests__/controller.test.ts b/frontend/src/core/islands/worker/__tests__/controller.test.tsindex a5d669c9ca..b0f7379432 100644--- a/frontend/src/core/islands/worker/__tests__/controller.test.ts+++ b/frontend/src/core/islands/worker/__tests__/controller.test.ts@@ -2,6 +2,7 @@import type { PyodideInterface } from "pyodide";import { describe, expect, it, vi } from "vitest";+import { Deferred } from "@/utils/Deferred";import { ReadonlyWasmController } from "../controller";class TestController extends ReadonlyWasmController {@@ -50,14 +51,71 @@ function createPyodideStub(};}-function startSession(controller: TestController, code: string) {- return controller.startSession({+function prepareSession(controller: TestController, code: string) {+ return controller.prepareSession({code,filename: `${code}.py`,});}+async function startSession(controller: TestController, code: string) {+ const session = await prepareSession(controller, code);+ void session.start();+ return session;+}+describe("WASM controller session lifecycle", () => {+ it("releases a prepared session and ignores start after stop", async () => {+ const { init, pyodide } = createPyodideStub();+ const controller = new TestController();+ controller.setPyodide(pyodide);++ const session = await prepareSession(controller, "current");+ await session.stop();+ expect(init.destroy).toHaveBeenCalledOnce();+ await session.start();+ expect(init).not.toHaveBeenCalled();+ });++ it.each(["resolve", "reject"] as const)(+ "releases a stopped session before its dependencies %s",+ async (outcome) => {+ const dependencies = new Deferred<void>();+ const { init, loadPackagesFromImports, pyodide, bridge, stop } =+ createPyodideStub();+ loadPackagesFromImports.mockReturnValue(dependencies.promise);+ const controller = new TestController();+ controller.setPyodide(pyodide);+ const session = await prepareSession(controller, "current");+ const starting = session.start();+ expect(init).not.toHaveBeenCalled();+ await session.stop();+ expect(init.destroy).toHaveBeenCalledOnce();+ expect(bridge.destroy).toHaveBeenCalledOnce();+ if (outcome === "resolve") {+ dependencies.resolve();+ } else {+ dependencies.reject(new Error("Loading failed after stop"));+ }+ await starting;+ await session.stop();+ expect(stop).toHaveBeenCalledOnce();+ expect(init).not.toHaveBeenCalled();+ },+ );++ it("reports dependency failures when starting an active session", async () => {+ const { init, loadPackagesFromImports, pyodide } = createPyodideStub();+ loadPackagesFromImports.mockRejectedValue(new Error("Dependency failed"));+ const controller = new TestController();+ controller.setPyodide(pyodide);+ const session = await prepareSession(controller, "current");+ await expect(session.start()).rejects.toThrow("Dependency failed");+ expect(init).not.toHaveBeenCalled();+ expect(init.destroy).toHaveBeenCalledOnce();+ await session.stop();+ });+it("stops and releases the active session", async () => {const { init, packages, pyodide, sessionResources, stop } =createPyodideStub();@@ -115,7 +173,6 @@ describe("WASM controller session lifecycle", () => {await startSession(controller, "first");await startSession(controller, "second");- second.bridge.destroy();expect(first.stop.destroy).not.toHaveBeenCalled();@@ -125,6 +182,8 @@ describe("WASM controller session lifecycle", () => {expect(second.stop).toHaveBeenCalledOnce();expect(first.stop.destroy).toHaveBeenCalledOnce();expect(second.stop.destroy).toHaveBeenCalledOnce();+ expect(first.bridge.destroy).toHaveBeenCalledOnce();+ expect(second.bridge.destroy).toHaveBeenCalledOnce();});it("continues stopping sessions after one stop fails", async () => {diff --git a/frontend/src/core/islands/worker/controller.ts b/frontend/src/core/islands/worker/controller.tsindex 496ab5b4ca..b48eacac46 100644--- a/frontend/src/core/islands/worker/controller.ts+++ b/frontend/src/core/islands/worker/controller.ts@@ -3,7 +3,7 @@ import type { PyodideInterface } from "pyodide";import { defaultUserConfig } from "@/core/config/config-schema";import { DefaultWasmController } from "@/core/wasm/worker/bootstrap";import { WasmFileSystem } from "@/core/wasm/worker/fs";-import type { SerializedBridge } from "@/core/wasm/worker/types";+import type { WasmSession } from "@/core/wasm/worker/types";import { Logger } from "../../../utils/Logger";export class ReadonlyWasmController extends DefaultWasmController {@@ -35,17 +35,15 @@ export class ReadonlyWasmController extends DefaultWasmController {return { code, filename };}- public override async startSession(opts: {+ public override async prepareSession(opts: {code: string;filename: string | null;- }): Promise<SerializedBridge> {- const bridge = super.startSession({+ }): Promise<WasmSession> {+ return super.prepareSession({queryParameters: {},code: opts.code,filename: opts.filename,userConfig: defaultUserConfig(),});-- return bridge;}}diff --git a/frontend/src/core/islands/worker/worker.tsx b/frontend/src/core/islands/worker/worker.tsxindex 667e2f57b3..f9d5aeebae 100644--- a/frontend/src/core/islands/worker/worker.tsx+++ b/frontend/src/core/islands/worker/worker.tsx@@ -1,7 +1,6 @@/* Copyright 2026 Marimo. All rights reserved. */import type { PyodideInterface } from "pyodide";-import type { PyProxy } from "pyodide/ffi";import {createRPC,createRPCRequestHandler,@@ -56,8 +55,6 @@ interface SessionRequest {let activeSession:| (Omit<SessionRequest, "code"> & { bridge: SerializedBridge })| undefined;-/** Every running session's bridge, kept while the worker follows its notebook. */-const sessions = new Set<SerializedBridge>();let sessionQueue = Promise.resolve();async function startSession(@@ -75,15 +72,22 @@ async function startSession(code: opts.code,filename: `app-${opts.appId}.py`,});- const nextBridge = await self.controller.startSession(notebook);- sessions.add(nextBridge);+ const session = await self.controller.prepareSession(notebook);// Follow before the session instantiates. Each subscription begins with// its own kernel-ready and the session's retained notifications.- await follow(nextBridge, opts.sessionGeneration);+ try {+ await follow(session.bridge, opts.sessionGeneration);+ } catch (error) {+ await session.stop();+ throw error;+ }+ void session.start().catch((error: unknown) => {+ rpc.send.initializedError({ error: prettyError(error) });+ });if (!activeSession) {activeSession = {appId: opts.appId,- bridge: nextBridge,+ bridge: session.bridge,sessionGeneration: opts.sessionGeneration,};}@@ -100,10 +104,6 @@ async function stopActiveSession(): Promise<void> {// Stopping closes every session and its notebook subscriptions.await self.controller.stopSession();activeSession = undefined;- for (const bridge of sessions) {- (bridge as unknown as PyProxy).destroy();- }- sessions.clear();}async function follow(diff --git a/frontend/src/core/wasm/__tests__/bridge.test.ts b/frontend/src/core/wasm/__tests__/bridge.test.tsindex 0351b31dad..8b013a4b49 100644--- a/frontend/src/core/wasm/__tests__/bridge.test.ts+++ b/frontend/src/core/wasm/__tests__/bridge.test.ts@@ -11,6 +11,9 @@ const {mockSaveNotebook,mockBootstrap,rpcListeners,+ mockNotebookInfo,+ mockNotebookSubscribe,+ mockNotebookUnsubscribe,} = vi.hoisted(() => ({mockBridge: vi.fn(),mockNotebookReadFile: vi.fn(),@@ -18,6 +21,9 @@ const {mockSaveNotebook: vi.fn(),mockBootstrap: vi.fn(),rpcListeners: {} as Record<string, () => void>,+ mockNotebookInfo: vi.fn(),+ mockNotebookSubscribe: vi.fn(),+ mockNotebookUnsubscribe: vi.fn(),}));// Mock browser globals before any imports@@ -50,6 +56,9 @@ vi.mock("@/core/wasm/rpc", () => ({readFile: vi.fn(),readNotebook: mockReadNotebook,saveNotebook: mockSaveNotebook,+ notebookInfo: mockNotebookInfo,+ notebookSubscribe: mockNotebookSubscribe,+ notebookUnsubscribe: mockNotebookUnsubscribe,},},addMessageListener: (event: string, cb: () => void) => {@@ -217,6 +226,39 @@ describe("PyodideBridge.sendSave", () => {});});+it("cancels a pending notebook subscription before its RPC response", async () => {+ vi.clearAllMocks();+ store.set(initialModeAtom, "read");+ rpcListeners.initialized();+ const pending = new Deferred<void>();+ mockNotebookInfo.mockResolvedValue({ id: "n1" });+ mockNotebookSubscribe.mockReturnValue(pending.promise);+ mockNotebookUnsubscribe.mockResolvedValue(undefined);+ const controller = new AbortController();+ try {+ const backend = await PyodideBridge.INSTANCE.createNotebookBackend();+ const following = backend.transport(+ { cursor: null, signal: controller.signal },+ { open: vi.fn(), message: vi.fn() },+ );+ await vi.waitFor(() =>+ expect(mockNotebookSubscribe).toHaveBeenCalledOnce(),+ );+ const [{ id }] = mockNotebookSubscribe.mock.calls[0];+ controller.abort();+ await following;+ expect(mockNotebookUnsubscribe.mock.calls).toEqual([[id]]);++ pending.resolve();+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(mockNotebookUnsubscribe.mock.calls).toEqual([[id]]);+ } finally {+ controller.abort();+ pending.resolve();+ store.set(initialModeAtom, undefined);+ }+});+describe("getWasmWorkerName", () => {afterEach(() => {delete (window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: boolean })diff --git a/frontend/src/core/wasm/__tests__/worker.test.ts b/frontend/src/core/wasm/__tests__/worker.test.tsnew file mode 100644index 0000000000..9126eac64c--- /dev/null+++ b/frontend/src/core/wasm/__tests__/worker.test.ts@@ -0,0 +1,182 @@+/* Copyright 2026 Marimo. All rights reserved. */++import type { PyodideInterface } from "pyodide";+import { loadPyodide } from "pyodide";+import { afterEach, expect, it, vi } from "vitest";+import { defaultUserConfig } from "@/core/config/config-schema";+import { Deferred } from "@/utils/Deferred";+import { DefaultWasmController } from "../worker/bootstrap";+import { getController } from "../worker/getController";+import type { WasmRuntimeConfig } from "../runtime-config";++interface WorkerRequests {+ startSession(opts: {+ queryParameters: Record<string, string | string[]>;+ code: string;+ filename: string;+ userConfig: ReturnType<typeof defaultUserConfig>;+ }): Promise<void>;+ notebookSubscribe(opts: { id: string; cursor: string | null }): Promise<void>;+ notebookUnsubscribe(id: string): Promise<void>;+}++const { rpc, handlers } = vi.hoisted(() => ({+ handlers: {} as {+ requests: WorkerRequests;+ bootstrap: (config: WasmRuntimeConfig) => void;+ },+ rpc: {+ send: Object.assign(vi.fn(), {+ initialized: vi.fn(),+ initializedError: vi.fn(),+ initializingMessage: vi.fn(),+ notebookEvent: vi.fn(),+ }),+ },+}));++vi.mock("rpc-anywhere", () => ({+ createRPCRequestHandler: (requests: WorkerRequests) => {+ handlers.requests = requests;+ return requests;+ },+ createWorkerParentTransport: vi.fn(),+ createRPC: () => ({+ ...rpc,+ addMessageListener: (+ _name: string,+ listener: (config: WasmRuntimeConfig) => void,+ ) => {+ handlers.bootstrap = listener;+ },+ }),+}));+vi.mock("pyodide", () => ({ loadPyodide: vi.fn(), version: "314.0.0" }));+vi.mock("../worker/getController", () => ({ getController: vi.fn() }));+vi.mock("../worker/getMarimoWheel", () => ({+ getMarimoWheel: () => "marimo-base",+}));++afterEach(() => {+ vi.restoreAllMocks();+ vi.clearAllMocks();+ vi.resetModules();+});++async function startWorker(subscribing = Promise.resolve()) {+ const subscribers = new Map<string, (event: string) => void>();+ const event = JSON.stringify({+ event: "marimo",+ data: { marimo: { op: "query-params-set", key: "startup", value: "ran" } },+ });+ const notebook = {+ subscribe: vi.fn(+ async (id: string, _cursor: unknown, emit: (event: string) => void) => {+ await subscribing;+ subscribers.set(id, emit);+ },+ ),+ unsubscribe: (id: string) => subscribers.delete(id),+ destroy: vi.fn(),+ };+ const bridge = { notebook, destroy: vi.fn() };+ const init = Object.assign(+ vi.fn(() => subscribers.forEach((emit) => emit(event))),+ { destroy: vi.fn() },+ );+ const stop = Object.assign(+ vi.fn(async () => subscribers.clear()),+ {+ destroy: vi.fn(),+ },+ );+ const packages = { toJs: () => [], destroy: vi.fn() };+ const resources = Object.assign([bridge, init, packages, stop], {+ destroy: vi.fn(),+ });+ const pyodide = {+ runPython: vi.fn(() => resources),+ loadPackagesFromImports: vi.fn(async () => undefined),+ loadedPackages: {},+ };+ vi.mocked(loadPyodide).mockResolvedValue(+ pyodide as unknown as PyodideInterface,+ );+ const controller = new DefaultWasmController();+ vi.spyOn(controller, "mountFilesystem").mockResolvedValue({+ code: "",+ filename: "notebook.py",+ });+ vi.mocked(getController).mockResolvedValue(controller);+ await import("../worker/worker");+ handlers.bootstrap({ version: "0.25.1" });+ await handlers.requests.startSession({+ code: "",+ filename: "notebook.py",+ queryParameters: {},+ userConfig: defaultUserConfig(),+ });+ return { controller, init, notebook, event, pyodide };+}++it("delivers startup notifications after a delayed first subscription, without rerunning on resubscribe", async () => {+ const { controller, init, event, pyodide } = await startWorker();+ try {+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(rpc.send.initialized).toHaveBeenCalledOnce();+ expect(pyodide.loadPackagesFromImports).toHaveResolved();+ expect(init).not.toHaveBeenCalled();++ await handlers.requests.notebookSubscribe({ id: "first", cursor: null });+ await vi.waitFor(() => expect(init).toHaveBeenCalledOnce());+ expect(rpc.send.notebookEvent.mock.calls).toEqual([+ [{ id: "first", event }],+ ]);++ await handlers.requests.notebookUnsubscribe("first");+ await handlers.requests.notebookSubscribe({ id: "second", cursor: null });+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(init).toHaveBeenCalledOnce();+ } finally {+ await controller.stopSession();+ }+});++it("does not authorize startup through a subscription canceled while opening", async () => {+ const subscribing = new Deferred<void>();+ const { controller, init, notebook } = await startWorker(subscribing.promise);+ try {+ const opened = handlers.requests.notebookSubscribe({+ id: "canceled",+ cursor: null,+ });+ await vi.waitFor(() => expect(notebook.subscribe).toHaveBeenCalledOnce());+ const closed = handlers.requests.notebookUnsubscribe("canceled");+ subscribing.resolve();+ await Promise.all([opened, closed]);+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(init).not.toHaveBeenCalled();++ await handlers.requests.notebookSubscribe({ id: "active", cursor: null });+ await vi.waitFor(() => expect(init).toHaveBeenCalledOnce());+ } finally {+ await controller.stopSession();+ }+});++it("waits for a successful subscription after an opening failure", async () => {+ const { controller, init, notebook } = await startWorker();+ try {+ notebook.subscribe.mockRejectedValueOnce(new Error("Subscription failed"));+ await expect(+ handlers.requests.notebookSubscribe({ id: "failed", cursor: null }),+ ).rejects.toThrow("Subscription failed");+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(init).not.toHaveBeenCalled();++ await handlers.requests.notebookSubscribe({ id: "active", cursor: null });+ await vi.waitFor(() => expect(init).toHaveBeenCalledOnce());+ } finally {+ await controller.stopSession();+ }+});diff --git a/frontend/src/core/wasm/bridge.ts b/frontend/src/core/wasm/bridge.tsindex 2ea908def0..c6fa196237 100644--- a/frontend/src/core/wasm/bridge.ts+++ b/frontend/src/core/wasm/bridge.ts@@ -8,6 +8,7 @@ import { Deferred } from "@/utils/Deferred";import { throwNotImplemented } from "@/utils/functions";import { Logger } from "@/utils/Logger";import { reloadSafe } from "@/utils/reload-safe";+import { once } from "@/utils/once";import { generateUUID } from "@/utils/uuid";import { createModuleWorker } from "@/utils/worker";import { notebookIsRunningAtom } from "../cells/cells";@@ -211,16 +212,19 @@ export class PyodideBridge implements RunRequests, EditRequests {const { id } = await this.rpc.proxy.request.notebookInfo();return createWasmNotebookBackend({notebookId: id,- subscribe: async (cursor, emit) => {+ subscribe: async (cursor, emit, signal) => {await this.initialized.promise;+ signal.throwIfAborted();const id = generateUUID();this.notebookConsumers.set(id, emit);- const close = () => {+ const close = once(() => {+ signal.removeEventListener("abort", close);this.notebookConsumers.delete(id);void this.rpc.proxy.request.notebookUnsubscribe(id).catch(Logger.error);- };+ });+ signal.addEventListener("abort", close, { once: true });try {await this.rpc.proxy.request.notebookSubscribe({ id, cursor });return close;diff --git a/frontend/src/core/wasm/worker/bootstrap.ts b/frontend/src/core/wasm/worker/bootstrap.tsindex e69f1dfbea..891ba281cf 100644--- a/frontend/src/core/wasm/worker/bootstrap.ts+++ b/frontend/src/core/wasm/worker/bootstrap.ts@@ -1,13 +1,13 @@/* Copyright 2026 Marimo. All rights reserved. */import { loadPyodide, type PyodideInterface } from "pyodide";import type { PyCallable, PyProxy } from "pyodide/ffi";-import type { UserConfig } from "@/core/config/config-schema";import { invariant } from "../../../utils/invariant";+import { once } from "../../../utils/once";import { Logger } from "../../../utils/Logger";import { WasmFileSystem } from "./fs";import { getMarimoWheel } from "./getMarimoWheel";import { t } from "./tracer";-import type { SerializedBridge, WasmController } from "./types";+import type { SerializedBridge, WasmController, WasmSession } from "./types";import { shouldLoadDuckDBPackages } from "../utils";const MAKE_SNAPSHOT = false;@@ -43,7 +43,7 @@ export class DefaultWasmController implements WasmController {protected pyodide: PyodideInterface | null = null;private packageLoadQueue = Promise.resolve();private sessionGeneration = 0;- private activeSessionStops = new Set<PyCallable>();+ private sessions = new Set<WasmSession>();public get requirePyodide() {invariant(this.pyodide, "Pyodide not loaded");@@ -136,18 +136,15 @@ export class DefaultWasmController implements WasmController {});}- public async startSession(opts: {- queryParameters: Record<string, string | string[]>;- code: string;- filename: string | null;- userConfig: UserConfig;- }): Promise<SerializedBridge> {+ public async prepareSession(+ opts: Parameters<WasmController["prepareSession"]>[0],+ ): Promise<WasmSession> {const sessionGeneration = this.sessionGeneration;const { code, filename, queryParameters, userConfig } = opts;self.query_params = queryParameters;self.user_config = userConfig;- const span = t.startSpan("startSession.runPython");+ const span = t.startSpan("prepareSession.runPython");const nbFilename = filename || WasmFileSystem.NOTEBOOK_FILENAME;const sessionResources = this.requirePyodide.runPython(`@@ -222,45 +219,65 @@ export class DefaultWasmController implements WasmController {} finally {packagesProxy.destroy();}- this.activeSessionStops.add(stopSession);-- // Fire and forget:- // Load notebook dependencies and instantiate the session- // We don't want to wait for this to finish,- // so we can show the initial code immediately giving- // a sense of responsiveness.+ let stopped = false;+ let stopping: Promise<void> | undefined;+ const releaseInit = once(() => initSession.destroy());+ const isStopped = () =>+ stopped || sessionGeneration !== this.sessionGeneration;+ // Load in parallel with subscription setup; only start() executes cells.const dependenciesReady = this.packageLoadQueue.then(() => {- if (sessionGeneration !== this.sessionGeneration) {+ if (isStopped()) {return;}return this.loadNotebookDeps(code, foundPackages);});this.packageLoadQueue = dependenciesReady.catch(() => undefined);- void dependenciesReady- .then(() => {- if (sessionGeneration !== this.sessionGeneration) {- return;+ const session: WasmSession = {+ bridge: bridgeProxy as unknown as SerializedBridge,+ start: once(async () => {+ try {+ if (isStopped()) {+ return;+ }+ await dependenciesReady;+ if (!isStopped()) {+ initSession(userConfig.runtime.auto_instantiate);+ }+ } catch (error) {+ if (!isStopped()) {+ throw error;+ }+ } finally {+ releaseInit();}- return initSession(userConfig.runtime.auto_instantiate);- })- .catch((error: unknown) => {- Logger.error("Failed to load notebook dependencies", error);- })- .finally(() => initSession.destroy());-- return bridgeProxy as unknown as SerializedBridge;+ }),+ stop: () => {+ stopped = true;+ releaseInit();+ stopping ??= (async () => {+ await stopSession();+ stopSession.destroy();+ bridgeProxy.destroy();+ this.sessions.delete(session);+ })().catch((error: unknown) => {+ stopping = undefined;+ throw error;+ });+ return stopping;+ },+ };+ this.sessions.add(session);+ return session;}public async stopSession(): Promise<void> {this.sessionGeneration += 1;- const stops = [...this.activeSessionStops];+ const sessions = [...this.sessions];let hasFailure = false;let firstFailure: unknown;- for (const stop of stops) {+ for (const session of sessions) {try {- await stop();- this.activeSessionStops.delete(stop);- stop.destroy();+ await session.stop();} catch (error) {if (!hasFailure) {hasFailure = true;diff --git a/frontend/src/core/wasm/worker/types.ts b/frontend/src/core/wasm/worker/types.tsindex 271e5d9586..14e1895042 100644--- a/frontend/src/core/wasm/worker/types.ts+++ b/frontend/src/core/wasm/worker/types.ts@@ -54,18 +54,21 @@ export interface WasmController {code: string;filename: string | null;}): Promise<{ code: string; filename: string }>;- /**- * Start the session- * @param opts.code - The code to start with- * @param opts.fallbackCode - The code to fallback to- * @param opts.filename - The filename to start with- */- startSession(opts: {+ /** Prepare a session and load its dependencies without executing cells. */+ prepareSession(opts: {queryParameters: Record<string, string | string[]>;code: string;filename: string | null;userConfig: UserConfig;- }): Promise<SerializedBridge>;+ }): Promise<WasmSession>;+}++export interface WasmSession {+ readonly bridge: SerializedBridge;+ /** Start once dependencies are ready. Repeated calls share the same start. */+ start(): Promise<void>;+ /** Prevent a pending start and release the session and its bridge. */+ stop(): Promise<void>;}export interface RawBridge {diff --git a/frontend/src/core/wasm/worker/worker.ts b/frontend/src/core/wasm/worker/worker.tsindex 8177a5fd49..a99b4f365a 100644--- a/frontend/src/core/wasm/worker/worker.ts+++ b/frontend/src/core/wasm/worker/worker.ts@@ -29,7 +29,7 @@ import { t } from "./tracer";import type {BridgePayload,RawBridge,- SerializedBridge,+ WasmSession,WasmController,} from "./types";import { shouldLoadDuckDBPackages } from "../utils";@@ -69,14 +69,17 @@ async function loadPyodideAndPackages() {}}-const bridgeReady = new Deferred<SerializedBridge>();+const sessionReady = new Deferred<WasmSession>();let started = false;// Handle RPC requests-const notebookSubscriptions = new Map<string, Promise<void>>();+const notebookSubscriptions = new Map<+ string,+ { promise: Promise<void>; cancel(): void }+>();async function getNotebook() {- const bridge = await bridgeReady.promise;- return bridge.notebook;+ const session = await sessionReady.promise;+ return session.bridge.notebook;}const requestHandler = createRPCRequestHandler({@@ -89,22 +92,36 @@ const requestHandler = createRPCRequestHandler({}},notebookSubscribe: (request: { id: string; cursor: string | null }) => {+ let canceled = false;const subscribing = (async () => {- const notebook = await getNotebook();+ const session = await sessionReady.promise;+ const notebook = session.bridge.notebook;try {await notebook.subscribe(request.id, request.cursor, (event) => {rpc.send.notebookEvent({ id: request.id, event });});+ if (!canceled) {+ void session.start().catch((error: unknown) => {+ rpc.send.initializedError({ error: prettyError(error) });+ });+ }} finally {notebook.destroy();}})();- notebookSubscriptions.set(request.id, subscribing);+ notebookSubscriptions.set(request.id, {+ promise: subscribing,+ cancel: () => {+ canceled = true;+ },+ });return subscribing.finally(() => notebookSubscriptions.delete(request.id));},notebookUnsubscribe: async (id: string) => {// An RPC timeout can close a reader while its subscription is still opening.- await notebookSubscriptions.get(id)?.catch(() => undefined);+ const pending = notebookSubscriptions.get(id);+ pending?.cancel();+ await pending?.promise.catch(() => undefined);const notebook = await getNotebook();try {notebook.unsubscribe(id);@@ -143,19 +160,19 @@ const requestHandler = createRPCRequestHandler({code: opts.code,filename: opts.filename,});- const startSession = t.wrapAsync(- self.controller.startSession.bind(self.controller),+ const prepareSession = t.wrapAsync(+ self.controller.prepareSession.bind(self.controller),);rpc.send.initializingMessage({message: "Loading notebook and dependencies...",});- const bridge = await startSession({+ const session = await prepareSession({code: opts.code,filename: opts.filename,queryParameters: opts.queryParameters,userConfig: opts.userConfig,});- bridgeReady.resolve(bridge);+ sessionReady.resolve(session);rpc.send.initializingMessage({message: "Initializing notebook...",});@@ -286,7 +303,7 @@ const requestHandler = createRPCRequestHandler({*/saveNotebook: async (opts: SaveNotebookRequest) => {await pyodideReadyPromise; // Make sure loading is done- const bridge = await bridgeReady.promise;+ const { bridge } = await sessionReady.promise;await bridge.save(JSON.stringify(opts));},@@ -334,7 +351,7 @@ const requestHandler = createRPCRequestHandler({}// Perform the function call to the Python bridge- const bridge = await bridgeReady.promise;+ const { bridge } = await sessionReady.promise;// Serialize the payloadconst payloadString =diff --git a/marimo/_pyodide/pyodide_session.py b/marimo/_pyodide/pyodide_session.pyindex ae64fa75cf..60ef1d608c 100644--- a/marimo/_pyodide/pyodide_session.py+++ b/marimo/_pyodide/pyodide_session.py@@ -176,6 +176,7 @@ class PyodideSession:def put_control_request(self, request: commands.CommandMessage) -> None:self._enqueue_control_request(request)+ self.session_view.add_control_request(request)def put_completion_request(self, request: commands.CodeCompletionCommanddiff --git a/tests/_pyodide/test_pyodide_notebook.py b/tests/_pyodide/test_pyodide_notebook.pyindex 84abb77c95..0feb3151f3 100644--- a/tests/_pyodide/test_pyodide_notebook.py+++ b/tests/_pyodide/test_pyodide_notebook.py@@ -14,6 +14,8 @@ from marimo._ast.app_config import _AppConfigfrom marimo._config.config import DEFAULT_CONFIGfrom marimo._core.calls import EditCall, dispatchfrom marimo._messaging.notification import (+ ModelLifecycleNotification,+ ModelOpen,VariableDeclarationNotification,VariablesNotification,)@@ -24,9 +26,12 @@ from marimo._runtime.commands import (AppMetadata,CreateNotebookCommand,EditCellsCommand,+ ModelCommand,+ ModelUpdateMessage,)from marimo._session.model import SessionModefrom marimo._session.notebook import AppFileManager+from marimo._types.ids import WidgetModelId@pytest.fixture@@ -278,6 +283,49 @@ async def test_a_later_subscription_resumes_with_retained_notifications(assert "variables" in ops(notifications)+async def test_resubscription_preserves_frontend_widget_updates(bridge):+ model_id = WidgetModelId("widget-1")+ await snapshot(bridge)+ bridge.session._on_message(+ serialize_kernel_message(+ ModelLifecycleNotification(+ model_id=model_id,+ message=ModelOpen(+ state={"value": 1}, buffer_paths=[], buffers=[]+ ),+ )+ )+ )+ bridge.session.put_control_request(+ ModelCommand(+ model_id=model_id,+ message=ModelUpdateMessage(state={"value": 7}, buffer_paths=[]),+ buffers=[],+ )+ )+ bridge.notebook.unsubscribe("reader")+ notifications = []+ await snapshot(bridge, notifications=notifications)++ assert [+ notification+ for notification in notifications+ if notification["op"] == "model-lifecycle"+ ] == [+ {+ "op": "model-lifecycle",+ "model_id": model_id,+ "message": {+ "method": "open",+ "state": {"value": 7},+ "buffer_paths": [],+ "buffers": [],+ "esm_spec": None,+ },+ }+ ]++async def test_live_notifications_reach_each_subscription_until_it_closes(bridge,):