@marimo-team/islands 0.23.16-dev9 → 0.23.17-dev0

package/src/core/network/__tests__/requests-network.test.ts

@@ -22,6 +22,7 @@ vi.mock("../api", async () => {
   return {
     ...actual,
     API: {
+      handleExportResponse: vi.fn((response) => response.data),
       handleResponse: vi.fn((response) => response.data),
       handleResponseReturnNull: vi.fn(() => null),
     },
@@ -32,6 +33,7 @@ vi.mock("../api", async () => {
 vi.mock("../connection", () => ({
   isConnectedAtom: { read: vi.fn(() => true) },
   waitForConnectionOpen: vi.fn().mockResolvedValue(undefined),
+  waitForConnectionOpenIfNotebook: vi.fn().mockResolvedValue(undefined),
 }));
 
 describe("createNetworkRequests", () => {
@@ -114,6 +116,19 @@ describe("createNetworkRequests", () => {
       );
     });
 
+    it("exportAsScript should request a text export", async () => {
+      const requests = createNetworkRequests();
+      await requests.exportAsScript({ download: false });
+
+      expect(mockClient.POST).toHaveBeenCalledWith(
+        "/api/export/script",
+        expect.objectContaining({
+          body: { download: false },
+          parseAs: "text",
+        }),
+      );
+    });
+
     it("getEnvironmentInfo should GET /api/environment", async () => {
       const requests = createNetworkRequests();
       await requests.getEnvironmentInfo();
@@ -121,6 +136,39 @@ describe("createNetworkRequests", () => {
       expect(mockClient.GET).toHaveBeenCalledWith("/api/environment");
     });
 
+    it("getExportAvailability should GET /api/export/availability", async () => {
+      const requests = createNetworkRequests();
+      await requests.getExportAvailability();
+
+      expect(mockClient.GET).toHaveBeenCalledWith("/api/export/availability");
+    });
+
+    it("discoverDataSources should POST to the discovery endpoint", async () => {
+      const requests = createNetworkRequests();
+      const request = { requestId: "discovery-request" } as any;
+      await requests.discoverDataSources(request);
+
+      expect(mockClient.POST).toHaveBeenCalledWith(
+        "/api/datasources/discover",
+        expect.objectContaining({
+          body: request,
+          params: expect.anything(),
+        }),
+      );
+    });
+
+    it("getPackageList should not require a kernel connection", async () => {
+      const { waitForConnectionOpen, waitForConnectionOpenIfNotebook } =
+        await import("../connection");
+
+      const requests = createNetworkRequests();
+      await requests.getPackageList();
+
+      expect(mockClient.GET).toHaveBeenCalledWith("/api/packages/list");
+      expect(waitForConnectionOpenIfNotebook).toHaveBeenCalled();
+      expect(waitForConnectionOpen).not.toHaveBeenCalled();
+    });
+
     it("exportAsIPYNB should call the new endpoint as text", async () => {
       const requests = createNetworkRequests();
       await requests.exportAsIPYNB({

package/src/core/network/api.ts

@@ -6,6 +6,7 @@ import { Logger } from "../../utils/Logger";
 import { Strings } from "../../utils/strings";
 import { getRuntimeManager } from "../runtime/config";
 import type { RuntimeManager } from "../runtime/runtime";
+import type { ExportedFile } from "./types";
 
 function getBaseUriWithoutQueryParams(): string {
   // Remove query params and hash
@@ -15,6 +16,15 @@ function getBaseUriWithoutQueryParams(): string {
   return url.toString();
 }
 
+function getExportFilename(response: Response): string {
+  const contentDisposition = response.headers.get("Content-Disposition");
+  const match = contentDisposition?.match(/filename\*=UTF-8''([^;]+)/i);
+  if (!match) {
+    throw new Error("Export response is missing a filename");
+  }
+  return decodeURIComponent(match[1]);
+}
+
 /**
  * Wrapper around fetch that adds XSRF token and session ID to the request and
  * strong types.
@@ -119,6 +129,23 @@ export const API = {
     }
     return Promise.resolve(response.data as T);
   },
+  handleExportResponse: async <T extends BlobPart>(response: {
+    data?: T | undefined;
+    error?: Record<string, unknown>;
+    response: Response;
+  }): Promise<ExportedFile<T>> => {
+    const contents = await API.handleResponse<T>(response);
+    const mediaType = response.response.headers.get("Content-Type");
+    if (!mediaType) {
+      throw new Error("Export response is missing a media type");
+    }
+
+    return {
+      contents,
+      filename: getExportFilename(response.response),
+      mediaType,
+    };
+  },
   handleResponseReturnNull: (response: {
     error?: Record<string, unknown>;
     response: Response;

package/src/core/network/connection.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { atom } from "jotai";
+import { isNotebookPage } from "../mode";
 import { waitFor } from "../state/jotai";
 import { type ConnectionStatus, WebSocketState } from "../websocket/types";
 
@@ -17,6 +18,20 @@ export function waitForConnectionOpen() {
   });
 }
 
+/**
+ * Waits for the kernel connection, but only on pages that open one. Non-notebook
+ * pages (home, gallery) never connect, so waiting there would hang forever.
+ *
+ * Use for requests that the marimo server can serve without a session, but that
+ * should still wait for the kernel when a notebook is open.
+ */
+export function waitForConnectionOpenIfNotebook() {
+  if (!isNotebookPage()) {
+    return Promise.resolve();
+  }
+  return waitForConnectionOpen();
+}
+
 export const isConnectingAtom = atom((get) => {
   const connection = get(connectionAtom);
   return connection.state === WebSocketState.CONNECTING;

package/src/core/network/requests-lazy.ts

@@ -51,11 +51,13 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   sendRunScratchpad: "startConnection",
   saveAppConfig: "startConnection",
   saveCellConfig: "startConnection",
+  discoverDataSources: "startConnection",
 
   // Export operations start a connection
   exportAsHTML: "startConnection",
   exportAsIPYNB: "startConnection",
   exportAsMarkdown: "startConnection",
+  exportAsScript: "startConnection",
   exportAsPDF: "startConnection",
   readCode: "startConnection",
   sendCopy: "throwError",
@@ -103,6 +105,7 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
 
   // Served by the marimo server without a kernel session
   getEnvironmentInfo: "serverOnly",
+  getExportAvailability: "serverOnly",
 
   // Home operations throw errors
   getRecentFiles: "startConnection",

package/src/core/network/requests-network.ts

@@ -3,7 +3,10 @@
 import { once } from "@/utils/once";
 import { getRuntimeManager } from "../runtime/config";
 import { API, createClientWithRuntimeManager } from "./api";
-import { waitForConnectionOpen } from "./connection";
+import {
+  waitForConnectionOpen,
+  waitForConnectionOpenIfNotebook,
+} from "./connection";
 import type { EditRequests, RunRequests } from "./types";
 
 /**
@@ -19,7 +22,7 @@ function multipartInit(formData: FormData) {
   };
 }
 
-const { handleResponse, handleResponseReturnNull } = API;
+const { handleExportResponse, handleResponse, handleResponseReturnNull } = API;
 
 export function createNetworkRequests(): EditRequests & RunRequests {
   const getClient = once(() => {
@@ -264,6 +267,14 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
+    discoverDataSources: (request) => {
+      return getClient()
+        .POST("/api/datasources/discover", {
+          body: request,
+          params: getParams(),
+        })
+        .then(handleResponseReturnNull);
+    },
     validateSQL: (request) => {
       return getClient()
         .POST("/api/sql/validate", {
@@ -399,6 +410,9 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponse);
     },
+    getExportAvailability: () => {
+      return getClient().GET("/api/export/availability").then(handleResponse);
+    },
     exportAsHTML: async (request) => {
       if (
         process.env.NODE_ENV === "development" ||
@@ -412,7 +426,7 @@ export function createNetworkRequests(): EditRequests & RunRequests {
           parseAs: "text",
           params: getParams(),
         })
-        .then(handleResponse);
+        .then(handleExportResponse);
     },
     exportAsMarkdown: async (request) => {
       return getClient()
@@ -421,7 +435,16 @@ export function createNetworkRequests(): EditRequests & RunRequests {
           parseAs: "text",
           params: getParams(),
         })
-        .then(handleResponse);
+        .then(handleExportResponse);
+    },
+    exportAsScript: async (request) => {
+      return getClient()
+        .POST("/api/export/script", {
+          body: request,
+          parseAs: "text",
+          params: getParams(),
+        })
+        .then(handleExportResponse);
     },
     exportAsIPYNB: async (request) => {
       return getClient()
@@ -430,7 +453,7 @@ export function createNetworkRequests(): EditRequests & RunRequests {
           parseAs: "text",
           params: getParams(),
         })
-        .then(handleResponse);
+        .then(handleExportResponse);
     },
     exportAsPDF: async (request) => {
       return getClient()
@@ -439,7 +462,7 @@ export function createNetworkRequests(): EditRequests & RunRequests {
           parseAs: "blob",
           params: getParams(),
         })
-        .then(handleResponse);
+        .then(handleExportResponse);
     },
     autoExportAsHTML: async (request) => {
       return getClient()
@@ -489,12 +512,12 @@ export function createNetworkRequests(): EditRequests & RunRequests {
     },
     getPackageList: async () => {
       // If the sidebar is already open, it may try to load before the session has been initialized
-      await waitForConnectionOpen();
+      await waitForConnectionOpenIfNotebook();
       return getClient().GET("/api/packages/list").then(handleResponse);
     },
     getDependencyTree: async () => {
       // If the sidebar is already open, it may try to load before the session has been initialized
-      await waitForConnectionOpen();
+      await waitForConnectionOpenIfNotebook();
       return getClient().GET("/api/packages/tree").then(handleResponse);
     },
     listSecretKeys: async (request) => {

package/src/core/network/requests-static.ts

@@ -62,6 +62,7 @@ export function createStaticRequests(): EditRequests & RunRequests {
     previewSQLTableList: throwNotInEditMode,
     previewSQLSchemaList: throwNotInEditMode,
     previewDataSourceConnection: throwNotInEditMode,
+    discoverDataSources: throwNotInEditMode,
     validateSQL: throwNotInEditMode,
     openFile: throwNotInEditMode,
     getUsageStats: throwNotInEditMode,
@@ -82,9 +83,11 @@ export function createStaticRequests(): EditRequests & RunRequests {
     getWorkspaceFiles: throwNotInEditMode,
     getRunningNotebooks: throwNotInEditMode,
     shutdownSession: throwNotInEditMode,
+    getExportAvailability: throwNotInEditMode,
     exportAsHTML: throwNotInEditMode,
     exportAsIPYNB: throwNotInEditMode,
     exportAsMarkdown: throwNotInEditMode,
+    exportAsScript: throwNotInEditMode,
     exportAsPDF: throwNotInEditMode,
     autoExportAsHTML: throwNotInEditMode,
     autoExportAsMarkdown: throwNotInEditMode,

package/src/core/network/requests-toasting.tsx

@@ -43,6 +43,7 @@ export function createErrorToastingRequests(
     previewSQLTableList: "Failed to fetch SQL table list",
     previewSQLSchemaList: "Failed to fetch SQL schema list",
     previewDataSourceConnection: "Failed to preview data source connection",
+    discoverDataSources: "Failed to discover data sources",
     validateSQL: "Failed to validate SQL",
     openFile: "Failed to open file",
     getUsageStats: "", // No toast
@@ -63,9 +64,11 @@ export function createErrorToastingRequests(
     getWorkspaceFiles: "Failed to get workspace files",
     getRunningNotebooks: "Failed to get running notebooks",
     shutdownSession: "Failed to shutdown session",
+    getExportAvailability: "", // No toast
     exportAsHTML: "Failed to export HTML",
     exportAsIPYNB: "Failed to export ipynb",
     exportAsMarkdown: "Failed to export Markdown",
+    exportAsScript: "Failed to export Script",
     exportAsPDF: "Failed to export PDF",
     autoExportAsHTML: "", // No toast
     autoExportAsMarkdown: "", // No toast

package/src/core/network/types.ts

@@ -17,12 +17,23 @@ export type CellConfig = schemas["CellConfig"];
 export type RuntimeState = schemas["CellNotification"]["status"];
 export type CodeCompletionRequest = schemas["CodeCompletionRequest"];
 export type DeleteCellRequest = schemas["DeleteCellRequest"];
+export type AutoExportAsIPYNBRequest = schemas["AutoExportAsIPYNBRequest"];
+export type AutoExportAsMarkdownRequest =
+  schemas["AutoExportAsMarkdownRequest"];
 export type ExportAsHTMLRequest = schemas["ExportAsHTMLRequest"];
 export type ExportAsMarkdownRequest = schemas["ExportAsMarkdownRequest"];
 export type ExportAsIPYNBRequest = schemas["ExportAsIPYNBRequest"];
 export type ExportAsScriptRequest = schemas["ExportAsScriptRequest"];
 export type ExportAsPDFRequest = schemas["ExportAsPDFRequest"];
+export type ExportAvailabilityResponse = schemas["ExportAvailabilityResponse"];
 export type UpdateCellOutputsRequest = schemas["UpdateCellOutputsRequest"];
+
+export interface ExportedFile<T extends BlobPart = BlobPart> {
+  contents: T;
+  filename: string;
+  mediaType: string;
+}
+
 export type FileCopyRequest = schemas["FileCopyRequest"];
 export type FileCopyResponse = schemas["FileCopyResponse"];
 export type FileCreateRequest = schemas["FileCreateRequest"];
@@ -64,6 +75,7 @@ export type ListSQLTablesRequest = schemas["ListSQLTablesRequest"];
 export type ListSQLSchemasRequest = schemas["ListSQLSchemasRequest"];
 export type ListDataSourceConnectionRequest =
   schemas["ListDataSourceConnectionRequest"];
+export type DiscoverDataSourcesRequest = schemas["DiscoverDataSourcesRequest"];
 export type ValidateSQLRequest = schemas["ValidateSQLRequest"];
 export type DebugCellRequest = schemas["DebugCellRequest"];
 export type SetBreakpointsRequest = schemas["SetBreakpointsRequest"];
@@ -170,6 +182,7 @@ export interface EditRequests {
   previewDataSourceConnection: (
     request: ListDataSourceConnectionRequest,
   ) => Promise<null>;
+  discoverDataSources: (request: DiscoverDataSourcesRequest) => Promise<null>;
   validateSQL: (request: ValidateSQLRequest) => Promise<null>;
   openFile: (request: { path: string; lineNumber?: number }) => Promise<null>;
   getUsageStats: () => Promise<UsageResponse>;
@@ -205,13 +218,21 @@ export interface EditRequests {
     request: ShutdownSessionRequest,
   ) => Promise<RunningNotebooksResponse>;
   // Export requests
-  exportAsHTML: (request: ExportAsHTMLRequest) => Promise<string>;
-  exportAsIPYNB: (request: ExportAsIPYNBRequest) => Promise<string>;
-  exportAsMarkdown: (request: ExportAsMarkdownRequest) => Promise<string>;
-  exportAsPDF: (request: ExportAsPDFRequest) => Promise<Blob>;
+  getExportAvailability: () => Promise<ExportAvailabilityResponse>;
+  exportAsHTML: (request: ExportAsHTMLRequest) => Promise<ExportedFile<string>>;
+  exportAsIPYNB: (
+    request: ExportAsIPYNBRequest,
+  ) => Promise<ExportedFile<string>>;
+  exportAsMarkdown: (
+    request: ExportAsMarkdownRequest,
+  ) => Promise<ExportedFile<string>>;
+  exportAsScript: (
+    request: ExportAsScriptRequest,
+  ) => Promise<ExportedFile<string>>;
+  exportAsPDF: (request: ExportAsPDFRequest) => Promise<ExportedFile<Blob>>;
   autoExportAsHTML: (request: ExportAsHTMLRequest) => Promise<null>;
-  autoExportAsMarkdown: (request: ExportAsMarkdownRequest) => Promise<null>;
-  autoExportAsIPYNB: (request: ExportAsIPYNBRequest) => Promise<null>;
+  autoExportAsMarkdown: (request: AutoExportAsMarkdownRequest) => Promise<null>;
+  autoExportAsIPYNB: (request: AutoExportAsIPYNBRequest) => Promise<null>;
   updateCellOutputs: (request: UpdateCellOutputsRequest) => Promise<null>;
   // Package requests
   getPackageList: () => Promise<ListPackagesResponse>;

package/src/core/rtc/state.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { atomWithStorage } from "jotai/utils";
+import { SCRATCH_CELL_ID, type CellId } from "@/core/cells/ids";
 import { once } from "@/utils/once";
 import { jotaiJsonStorage } from "@/utils/storage/jotai";
 import { getFeatureFlag } from "../config/feature-flag";
@@ -23,3 +24,11 @@ export const usernameAtom = atomWithStorage<string>(
 export const isRtcEnabled = once(() => {
   return getFeatureFlag("rtc_v2");
 });
+
+/**
+ * Whether this cell type can participate in real-time collaboration.
+ * Scratchpad cells are local-only.
+ */
+export function canUseRtc(cellId: CellId): boolean {
+  return cellId !== SCRATCH_CELL_ID;
+}

package/src/core/static/download-html.ts

@@ -1,31 +1,22 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { downloadBlob } from "@/utils/download";
-import { Filenames } from "@/utils/filenames";
-import { Paths } from "@/utils/paths";
+import { downloadExportedFile } from "@/utils/download";
 import { getRequestClient } from "../network/requests";
 import { VirtualFileTracker } from "./virtual-file-tracker";
 
 /**
  * Downloads the current notebook as an HTML file.
  */
-export async function downloadAsHTML(opts: {
-  filename: string;
-  includeCode: boolean;
-}) {
+export async function downloadAsHTML(opts: { includeCode: boolean }) {
   const client = getRequestClient();
-  const { filename, includeCode } = opts;
-  const html = await client.exportAsHTML({
+  const { includeCode } = opts;
+  const exportedFile = await client.exportAsHTML({
     download: true,
     includeCode: includeCode,
     files: VirtualFileTracker.INSTANCE.filenames(),
   });
-  const filenameWithoutPath = Paths.basename(filename) ?? "notebook.py";
 
-  downloadBlob(
-    new Blob([html], { type: "text/html" }),
-    Filenames.toHTML(filenameWithoutPath),
-  );
+  downloadExportedFile(exportedFile);
 }
 
 function updateAssetUrl(existingUrl: string, assetBaseUrl: string) {

package/src/core/wasm/__tests__/bridge.test.ts

@@ -1,9 +1,20 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const { mockNotebookReadFile, rpcListeners } = vi.hoisted(() => ({
+import { cellId } from "@/__tests__/branded";
+import { Deferred } from "@/utils/Deferred";
+
+const {
+  mockBridge,
+  mockNotebookReadFile,
+  mockReadNotebook,
+  mockSaveNotebook,
+  rpcListeners,
+} = vi.hoisted(() => ({
+  mockBridge: vi.fn(),
   mockNotebookReadFile: vi.fn(),
+  mockReadNotebook: vi.fn(),
+  mockSaveNotebook: vi.fn(),
   rpcListeners: {} as Record<string, () => void>,
 }));
 
@@ -28,11 +39,11 @@ vi.mock("@/core/wasm/rpc", () => ({
   getWorkerRPC: () => ({
     proxy: {
       request: {
-        bridge: vi.fn(),
+        bridge: mockBridge,
         startSession: vi.fn(),
         readFile: vi.fn(),
-        readNotebook: vi.fn(),
-        saveNotebook: vi.fn(),
+        readNotebook: mockReadNotebook,
+        saveNotebook: mockSaveNotebook,
       },
       send: { consumerReady: vi.fn() },
     },
@@ -112,6 +123,89 @@ describe("PyodideBridge.readCode", () => {
   });
 });
 
+describe("PyodideBridge.exportAsScript", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns the script export from the Python bridge", async () => {
+    const exportedFile = {
+      contents: '# %%\nprint("hello")',
+      filename: "notebook.script.py",
+      mediaType: "text/plain; charset=utf-8",
+    };
+    mockBridge.mockResolvedValue(exportedFile);
+
+    const result = await PyodideBridge.INSTANCE.exportAsScript({
+      download: false,
+    });
+
+    expect(mockBridge).toHaveBeenCalledWith({
+      functionName: "export_script",
+      payload: { download: false },
+    });
+    expect(result).toEqual(exportedFile);
+  });
+});
+
+describe("PyodideBridge.sendSave", () => {
+  const request = {
+    cellIds: [cellId("cell-1")],
+    codes: ['value = "NEW"'],
+    names: ["_"],
+    filename: "notebook.py",
+    configs: [{}],
+    layout: null,
+    persist: true,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    store.set(initialModeAtom, "edit");
+    rpcListeners.initialized();
+    mockSaveNotebook.mockResolvedValue(null);
+    mockReadNotebook.mockResolvedValue(
+      "import marimo\napp = marimo.App()\n# NEW",
+    );
+  });
+
+  afterEach(() => {
+    store.set(initialModeAtom, undefined);
+  });
+
+  it("waits for the session save before generating exports", async () => {
+    const mainSave = new Deferred<void>();
+    mockSaveNotebook
+      .mockResolvedValueOnce(null)
+      .mockReturnValueOnce(mainSave.promise);
+
+    await PyodideBridge.INSTANCE.sendSave(request);
+    expect(mockSaveNotebook).toHaveBeenCalledTimes(2);
+    expect(mockSaveNotebook).toHaveBeenNthCalledWith(1, request);
+    expect(mockSaveNotebook).toHaveBeenNthCalledWith(2, request);
+
+    const markdown = PyodideBridge.INSTANCE.exportAsMarkdown({
+      download: false,
+    });
+    const script = PyodideBridge.INSTANCE.exportAsScript({
+      download: false,
+    });
+    await Promise.resolve();
+    expect(mockBridge).not.toHaveBeenCalled();
+
+    mainSave.resolve();
+    await Promise.all([markdown, script]);
+    expect(mockBridge).toHaveBeenCalledWith({
+      functionName: "export_markdown",
+      payload: { download: false },
+    });
+    expect(mockBridge).toHaveBeenCalledWith({
+      functionName: "export_script",
+      payload: { download: false },
+    });
+  });
+});
+
 describe("getWasmWorkerName", () => {
   afterEach(() => {
     delete (window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: boolean })

package/src/core/wasm/bridge.ts

@@ -19,6 +19,8 @@ import type {
   EnvironmentInfo,
   ExportAsHTMLRequest,
   ExportAsMarkdownRequest,
+  ExportAsScriptRequest,
+  ExportedFile,
   FileCopyResponse,
   FileCreateResponse,
   FileDeleteResponse,
@@ -60,6 +62,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
 
   private rpc!: ReturnType<typeof getWorkerRPC<WorkerSchema>>;
   private saveRpc: SaveWorker | undefined;
+  private pendingSessionSave: Promise<unknown> = Promise.resolve();
   private interruptBuffer?: Uint8Array;
   private messageConsumer:
     | ((message: MessageEvent<string>) => void)
@@ -227,18 +230,24 @@ export class PyodideBridge implements RunRequests, EditRequests {
       return null;
     }
 
-    await this.saveRpc.saveNotebook(request);
+    const durableSave = this.saveRpc.saveNotebook(request);
+    // Generated exports read the session-owned app in the main worker.
+    this.pendingSessionSave = this.pendingSessionSave
+      .catch(() => undefined)
+      .then(async () => {
+        await durableSave;
+        await this.rpc.proxy.request.saveNotebook(request);
+      });
+    void this.pendingSessionSave.catch((error) => {
+      Logger.error(error);
+    });
+
+    await durableSave;
     const code = await this.readCode();
     if (code.contents) {
       notebookFileStore.saveFile(code.contents);
       fallbackFileStore.saveFile(code.contents);
     }
-    // Also save to the other worker, since this is needed for
-    // exporting to HTML
-    // Fire-and-forget
-    void this.rpc.proxy.request.saveNotebook(request).catch((error) => {
-      Logger.error(error);
-    });
     return null;
   };
 
@@ -510,6 +519,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
   exportAsHTML: EditRequests["exportAsHTML"] = async (
     request: ExportAsHTMLRequest,
   ) => {
+    await this.pendingSessionSave;
     if (
       process.env.NODE_ENV === "development" ||
       process.env.NODE_ENV === "test"
@@ -520,17 +530,29 @@ export class PyodideBridge implements RunRequests, EditRequests {
       functionName: "export_html",
       payload: request,
     });
-    return response as string;
+    return response as ExportedFile<string>;
   };
 
   exportAsMarkdown: EditRequests["exportAsMarkdown"] = async (
     request: ExportAsMarkdownRequest,
   ) => {
+    await this.pendingSessionSave;
     const response = await this.rpc.proxy.request.bridge({
       functionName: "export_markdown",
       payload: request,
     });
-    return response as string;
+    return response as ExportedFile<string>;
+  };
+
+  exportAsScript: EditRequests["exportAsScript"] = async (
+    request: ExportAsScriptRequest,
+  ) => {
+    await this.pendingSessionSave;
+    const response = await this.rpc.proxy.request.bridge({
+      functionName: "export_script",
+      payload: request,
+    });
+    return response as ExportedFile<string>;
   };
 
   previewDatasetColumn: EditRequests["previewDatasetColumn"] = async (
@@ -629,6 +651,16 @@ export class PyodideBridge implements RunRequests, EditRequests {
     return null;
   };
 
+  discoverDataSources: EditRequests["discoverDataSources"] = async (
+    request,
+  ) => {
+    await this.putControlRequest({
+      type: "discover-data-sources",
+      ...request,
+    });
+    return null;
+  };
+
   getUsageStats = throwNotImplemented;
   getEnvironmentInfo: EditRequests["getEnvironmentInfo"] = async () => {
     const response = await this.rpc.proxy.request.bridge({
@@ -642,6 +674,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
   getWorkspaceFiles = throwNotImplemented;
   getRunningNotebooks = throwNotImplemented;
   shutdownSession = throwNotImplemented;
+  getExportAvailability = throwNotImplemented;
   exportAsIPYNB = throwNotImplemented;
   exportAsPDF = throwNotImplemented;
   autoExportAsHTML = throwNotImplemented;