@marimo-team/islands 0.25.2-dev97 → 0.25.2

package/src/core/codemirror/language/embedded/__tests__/embedded-python.test.ts

@@ -2,13 +2,17 @@
 
 import type { CompletionContext } from "@codemirror/autocomplete";
 import { python } from "@codemirror/lang-python";
+import { StreamLanguage } from "@codemirror/language";
+import { stexMath } from "@codemirror/legacy-modes/mode/stex";
 import { EditorState } from "@codemirror/state";
-import type { InlineContext } from "@lezer/markdown";
-import { beforeEach, describe, expect, it } from "vitest";
+import { classHighlighter, highlightTree } from "@lezer/highlight";
+import { parser as markdownParser } from "@lezer/markdown";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { cellId, variableName } from "@/__tests__/branded";
 import { store } from "@/core/state/jotai";
 import { variablesAtom } from "@/core/variables/state";
 import { parsePython, variableCompletionSource } from "../embedded-python";
+import { parseLatex } from "../latex";
 
 const IS_ACTIVE = () => true;
 
@@ -23,25 +27,133 @@ describe("parsePython", () => {
     ]);
   });
 
-  it("should not parse double curly braces", () => {
+  const cases = [
+    "{math.exp(3)}",
+    '${math.exp(3) + len("$}")} $',
+    "${math.exp(3)} + {math.sin(3)}$",
+    "${math.exp(3)}$",
+    "$$ {math.exp(3)} $$",
+    String.raw`\({math.exp(3)}\)`,
+    String.raw`\[{math.exp(3)}\]`,
+    String.raw`\\({math.exp(3)}\\)`,
+    String.raw`\\[{math.exp(3)}\\]`,
+    String.raw`$\frac{{{math.exp(3)}}}{{2}}$`,
+    String.raw`$\{math.exp(3)}$`,
+    '${ {"}": math.exp(3)} }$',
+    "${math.exp(3):{width}.{precision}f}$",
+  ];
+
+  function highlightedProperties(doc: string, prefix: string) {
+    const parser = markdownParser.configure([
+      parseLatex(StreamLanguage.define(stexMath).parser),
+      parsePython(python().language.parser, () => prefix.includes("f")),
+    ]);
+    const properties: string[] = [];
+    highlightTree(parser.parse(doc), classHighlighter, (from, to, classes) => {
+      if (classes.split(" ").includes("tok-propertyName")) {
+        properties.push(doc.slice(from, to));
+      }
+    });
+    return properties;
+  }
+
+  it.each(["f", "rf", "fr"])(
+    "highlights interpolation with %s strings",
+    (prefix) => {
+      for (const doc of cases) {
+        expect(highlightedProperties(doc, prefix)).toEqual(
+          doc.includes("math.sin") ? ["exp", "sin"] : ["exp"],
+        );
+      }
+    },
+  );
+
+  it.each(["", "r"])("does not interpolate %s strings", (prefix) => {
+    for (const doc of cases) {
+      expect(highlightedProperties(doc, prefix)).toEqual([]);
+    }
+  });
+
+  it("parses replacement boundaries once for a paragraph with many interpolations", () => {
     const pythonParser = python().language.parser;
-    const config = parsePython(pythonParser, IS_ACTIVE);
+    const parse = vi.spyOn(pythonParser, "parse");
+    try {
+      const doc = "{math.exp(3)} ".repeat(1000);
+      const parser = markdownParser.configure([
+        parseLatex(StreamLanguage.define(stexMath).parser),
+        parsePython(pythonParser, IS_ACTIVE),
+      ]);
+      const properties: string[] = [];
+      highlightTree(
+        parser.parse(doc),
+        classHighlighter,
+        (from, to, classes) => {
+          if (classes.split(" ").includes("tok-propertyName")) {
+            properties.push(doc.slice(from, to));
+          }
+        },
+      );
+      expect(properties).toEqual(Array.from({ length: 1000 }, () => "exp"));
+      expect(parse).toHaveBeenCalledTimes(1);
+    } finally {
+      parse.mockRestore();
+    }
+  });
 
-    // Create a mock context
-    const mockContext = {
-      slice: (from: number, to: number) => {
-        if (from === 5 && to === 6) {
-          return "{";
-        }
-        return "";
-      },
-      addDelimiter: () => -1,
-    } as unknown as InlineContext;
+  it("preserves raw backslashes between replacements", () => {
+    expect(
+      highlightedProperties(String.raw`{math.exp(3)} \N{math.sin(3)}`, "rf"),
+    ).toEqual(["exp", "sin"]);
+  });
+
+  it("finds replacements after triple quotes in markdown text", () => {
+    expect(
+      highlightedProperties('{math.exp(3)} """ {math.sin(3)}', "f"),
+    ).toEqual(["exp", "sin"]);
+  });
 
-    // Test with double curly braces
-    const result = config.parseInline![0].parse(mockContext, 123, 6); // 123 is OPEN_BRACE
-    expect(result).toBe(-1);
+  it("keeps replacement positions local to each paragraph", () => {
+    expect(
+      highlightedProperties("${math.exp(3)}$\n\n${math.sin(3)}$", "rf"),
+    ).toEqual(["exp", "sin"]);
   });
+
+  it("preserves LaTeX highlighting around Python replacements", () => {
+    const doc = String.raw`$\frac{{{math.exp(3)}}}{{2}} + \alpha$`;
+    const parser = markdownParser.configure([
+      parseLatex(StreamLanguage.define(stexMath).parser),
+      parsePython(python().language.parser, IS_ACTIVE),
+    ]);
+    const highlighted: string[] = [];
+    highlightTree(parser.parse(doc), classHighlighter, (from, to) => {
+      highlighted.push(doc.slice(from, to));
+    });
+    expect(highlighted).toEqual(
+      expect.arrayContaining(["\\frac", "exp", "\\alpha"]),
+    );
+  });
+
+  it.each(["${math.exp(3)$", "${math.exp(3)", "${{math.exp(3)}$"])(
+    "does not treat incomplete or escaped braces as replacements: %s",
+    (doc) => {
+      expect(highlightedProperties(doc, "f")).toEqual([]);
+    },
+  );
+
+  it.each(["f", "rf", "fr"])(
+    "keeps doubled braces literal in %s strings",
+    (prefix) => {
+      for (const doc of [
+        "{{math.exp(3)}}",
+        "${{math.exp(3)}}$",
+        "$ {{{{math.exp(3)}}}} $",
+        String.raw`$\{{math.exp(3)}}$`,
+        String.raw`$\frac{{1}}{{2}}$`,
+      ]) {
+        expect(highlightedProperties(doc, prefix)).toEqual([]);
+      }
+    },
+  );
 });
 
 describe("variableCompletionSource", () => {
@@ -72,10 +184,10 @@ describe("variableCompletionSource", () => {
     const context: Partial<CompletionContext> = {
       pos: 8,
       explicit: false,
-      matchBefore: (expr: RegExp) => ({ from: 7, to: 8, text: "v" }),
+      matchBefore: (_expr: RegExp) => ({ from: 7, to: 8, text: "v" }),
       state,
       aborted: false,
-      tokenBefore: (types: readonly string[]) => null,
+      tokenBefore: (_types: readonly string[]) => null,
     };
 
     const result = variableCompletionSource(context as CompletionContext);
@@ -92,10 +204,10 @@ describe("variableCompletionSource", () => {
     const context: Partial<CompletionContext> = {
       pos: 7,
       explicit: false,
-      matchBefore: (expr: RegExp) => ({ from: 6, to: 7, text: "v" }),
+      matchBefore: (_expr: RegExp) => ({ from: 6, to: 7, text: "v" }),
       state,
       aborted: false,
-      tokenBefore: (types: readonly string[]) => null,
+      tokenBefore: (_types: readonly string[]) => null,
     };
 
     const result = variableCompletionSource(context as CompletionContext);
@@ -110,10 +222,10 @@ describe("variableCompletionSource", () => {
     const context: Partial<CompletionContext> = {
       pos: 13,
       explicit: false,
-      matchBefore: (expr: RegExp) => ({ from: 12, to: 13, text: "v" }),
+      matchBefore: (_expr: RegExp) => ({ from: 12, to: 13, text: "v" }),
       state,
       aborted: false,
-      tokenBefore: (types: readonly string[]) => null,
+      tokenBefore: (_types: readonly string[]) => null,
     };
 
     const result = variableCompletionSource(context as CompletionContext);
@@ -131,7 +243,7 @@ describe("variableCompletionSource", () => {
       matchBefore: () => null,
       state,
       aborted: false,
-      tokenBefore: (types: readonly string[]) => null,
+      tokenBefore: (_types: readonly string[]) => null,
     };
 
     const result = variableCompletionSource(context as CompletionContext);
@@ -146,10 +258,10 @@ describe("variableCompletionSource", () => {
     const context: Partial<CompletionContext> = {
       pos: 9,
       explicit: false,
-      matchBefore: (expr: RegExp) => ({ from: 8, to: 9, text: "v" }),
+      matchBefore: (_expr: RegExp) => ({ from: 8, to: 9, text: "v" }),
       state,
       aborted: false,
-      tokenBefore: (types: readonly string[]) => null,
+      tokenBefore: (_types: readonly string[]) => null,
     };
 
     const result = variableCompletionSource(context as CompletionContext);

package/src/core/codemirror/language/embedded/embedded-python.ts

@@ -16,11 +16,8 @@ import { getVariableCompletions } from "../../completion/variable-completions";
 const PYTHON = "Python";
 
 const OPEN_BRACE = 123; // {
-const CLOSE_BRACE = 125; // }
 const DELIMITER_LENGTH = 1;
 
-const MARK = { mark: `${PYTHON}Mark`, resolve: PYTHON };
-
 /**
  * Define a Python code block parser for Markdown.
  *
@@ -31,6 +28,11 @@ export function parsePython(
   pythonParser: Parser,
   isActivated: () => boolean,
 ): MarkdownConfig {
+  const replacements = new WeakMap<
+    InlineContext,
+    { ends: Map<number, number>; parsedTo: number }
+  >();
+
   const defineNodes = [
     { name: PYTHON, style: tags.emphasis },
     { name: `${PYTHON}Mark`, style: tags.processingInstruction },
@@ -41,26 +43,58 @@ export function parsePython(
     parseInline: [
       {
         name: PYTHON,
+        before: "Escape",
         parse(cx: InlineContext, next: number, pos: number): number {
           if (!isActivated()) {
             return -1;
           }
 
-          if (next !== OPEN_BRACE && next !== CLOSE_BRACE) {
+          // A backslash does not escape a brace in Python f-strings.
+          if (next === 92 && cx.char(pos + 1) === OPEN_BRACE) {
+            return pos + 1;
+          }
+          if (next !== OPEN_BRACE) {
             return -1;
           }
+          if (cx.char(pos + 1) === OPEN_BRACE) {
+            return pos + 2;
+          }
 
-          // Check for double curly braces
-          if (next === OPEN_BRACE && cx.slice(pos - 1, pos) === "{") {
+          let cached = replacements.get(cx);
+          if (!cached || pos >= cached.parsedTo) {
+            // Cache all replacements so each brace does not reparse the paragraph.
+            // Keep Markdown backslashes from consuming braces as Python escapes.
+            const prefix = 'rf"""';
+            const tree = pythonParser.parse(
+              `${prefix}${cx.slice(pos, cx.end)}\n"""`,
+            );
+            const formatString = tree.topNode
+              .getChild("ExpressionStatement")
+              ?.getChild("FormatString");
+            const offset = pos - prefix.length;
+            const ends = new Map<number, number>();
+            for (const replacement of formatString?.getChildren(
+              "FormatReplacement",
+            ) ?? []) {
+              if (replacement.lastChild?.name === "}") {
+                ends.set(offset + replacement.from, offset + replacement.to);
+              }
+            }
+            cached = {
+              ends,
+              parsedTo: formatString ? offset + formatString.to : cx.end,
+            };
+            replacements.set(cx, cached);
+          }
+          const end = cached.ends.get(pos);
+          if (end === undefined) {
             return -1;
           }
-
-          return cx.addDelimiter(
-            MARK,
-            pos,
-            pos + DELIMITER_LENGTH,
-            next === OPEN_BRACE,
-            next === CLOSE_BRACE,
+          return cx.addElement(
+            cx.elt(PYTHON, pos, end, [
+              cx.elt(`${PYTHON}Mark`, pos, pos + 1),
+              cx.elt(`${PYTHON}Mark`, end - 1, end),
+            ]),
           );
         },
       },

package/src/core/codemirror/language/embedded/latex.ts

@@ -29,7 +29,7 @@
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-import { type Parser, parseMixed } from "@lezer/common";
+import { IterMode, type Parser, parseMixed } from "@lezer/common";
 import { tags } from "@lezer/highlight";
 import type {
   DelimiterType,
@@ -231,24 +231,31 @@ export function parseLatex(latexParser: Parser): MarkdownConfig {
       // Test if the node type is one of the math expression
       const delimiterLength = DELIMITER_LENGTH[node.type.name];
       if (delimiterLength) {
-        const from = node.from + delimiterLength;
-        const to = node.to - delimiterLength;
+        const from = node.node.firstChild?.to ?? node.from + delimiterLength;
+        const to = node.node.lastChild?.from ?? node.to - delimiterLength;
 
         // Ensure valid ranges
         if (from >= to || from < 0 || to < 0) {
           return null;
         }
 
-        return {
-          parser: latexParser,
-          // Remove delimiter from LaTeX parser otherwise it won't be highlighted
-          overlay: [
-            {
-              from,
-              to,
-            },
-          ],
-        };
+        // Leave Python replacements to their own parser and highlighter.
+        const overlay: { from: number; to: number }[] = [];
+        let start = from;
+        node.node.cursor(IterMode.IgnoreMounts).iterate((child) => {
+          if (child.name !== "Python") {
+            return;
+          }
+          if (start < child.from) {
+            overlay.push({ from: start, to: child.from });
+          }
+          start = child.to;
+          return false;
+        });
+        if (start < to) {
+          overlay.push({ from: start, to });
+        }
+        return overlay.length ? { parser: latexParser, overlay } : null;
       }
 
       return null;

package/src/core/datasets/__tests__/data-source-discovery.test.ts

@@ -1,5 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { requestId } from "@/__tests__/branded";
+import type { DataSourceDiscoveryResult } from "@/core/kernel/messages";
 import { connectionAtom } from "@/core/network/connection";
 import { store } from "@/core/state/jotai";
 import { ConnectionState } from "@/core/websocket/types";
@@ -41,7 +43,7 @@ describe("fetchDataSourceDiscovery", () => {
   it("shares a single in-flight request across concurrent callers", async () => {
     const request = vi
       .spyOn(DiscoverDataSources, "request")
-      .mockResolvedValue({ request_id: "request-id", sources: [] });
+      .mockResolvedValue({ request_id: requestId("request-id"), sources: [] });
 
     await Promise.all([
       fetchDataSourceDiscovery(),
@@ -55,7 +57,7 @@ describe("fetchDataSourceDiscovery", () => {
   it("re-runs discovery after the cache is invalidated", async () => {
     const request = vi
       .spyOn(DiscoverDataSources, "request")
-      .mockResolvedValue({ request_id: "request-id", sources: [] });
+      .mockResolvedValue({ request_id: requestId("request-id"), sources: [] });
 
     await fetchDataSourceDiscovery();
     invalidateDataSourceDiscovery();
@@ -68,7 +70,10 @@ describe("fetchDataSourceDiscovery", () => {
     const request = vi
       .spyOn(DiscoverDataSources, "request")
       .mockRejectedValueOnce(new Error("boom"))
-      .mockResolvedValueOnce({ request_id: "request-id", sources: [] });
+      .mockResolvedValueOnce({
+        request_id: requestId("request-id"),
+        sources: [],
+      });
 
     await expect(fetchDataSourceDiscovery()).rejects.toThrow("boom");
     await expect(fetchDataSourceDiscovery()).resolves.toEqual([]);
@@ -77,16 +82,18 @@ describe("fetchDataSourceDiscovery", () => {
 
   it("does not clear a newer cache entry when an invalidated request fails", async () => {
     let rejectFirstRequest: ((error: Error) => void) | undefined;
-    const firstRequest = new Promise<{
-      request_id: string;
-      sources: DetectedDataSource[];
-    }>((_resolve, reject) => {
-      rejectFirstRequest = reject;
-    });
+    const firstRequest = new Promise<DataSourceDiscoveryResult>(
+      (_resolve, reject) => {
+        rejectFirstRequest = reject;
+      },
+    );
     const request = vi
       .spyOn(DiscoverDataSources, "request")
       .mockReturnValueOnce(firstRequest)
-      .mockResolvedValueOnce({ request_id: "request-id", sources: [] });
+      .mockResolvedValueOnce({
+        request_id: requestId("request-id"),
+        sources: [],
+      });
 
     const staleResult = fetchDataSourceDiscovery().catch((error) => error);
     await vi.waitFor(() => expect(request).toHaveBeenCalledTimes(1));
@@ -116,7 +123,7 @@ describe("fetchDataSourceDiscovery", () => {
       }),
     ];
     vi.spyOn(DiscoverDataSources, "request").mockResolvedValue({
-      request_id: "request-id",
+      request_id: requestId("request-id"),
       sources,
     });
 

package/src/core/islands/bridge.ts

@@ -7,7 +7,7 @@ import { throwNotImplemented } from "@/utils/functions";
 import { Logger } from "@/utils/Logger";
 import { generateUUID } from "@/utils/uuid";
 import { initialNotebookState, notebookAtom } from "../cells/cells";
-import type { CommandMessage } from "../kernel/messages";
+import type { ClientCommand } from "../kernel/messages";
 import type { EditRequests, RunRequests } from "../network/types";
 import { store as defaultStore } from "../state/jotai";
 import { getMarimoExportContext } from "../static/export-context";
@@ -392,7 +392,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   // The kernel uses msgspec to parse control requests, which requires a 'type'
   // field for discriminated union deserialization.
   private async putControlRequest(
-    operation: CommandMessage,
+    operation: ClientCommand,
     session?: AppSession,
   ): Promise<void> {
     session ??= await this.getActiveSession();

package/src/core/kernel/messages.ts

@@ -2,7 +2,7 @@
 import type { components } from "@marimo-team/marimo-api";
 
 export type schemas = components["schemas"];
-export type DataType = schemas["KnownUnions"]["data_type"];
+export type DataType = schemas["DataType"];
 export const DATA_TYPES = [
   "string",
   "boolean",
@@ -24,10 +24,7 @@ export type DatabaseSchema = schemas["Schema"];
 export type DataSourceConnection = schemas["DataSourceConnection"];
 export type OutputChannel = schemas["CellChannel"];
 export type CellOutput = schemas["CellOutput"];
-export type MarimoError = Extract<
-  CellOutput["data"],
-  { type: string }[]
->[number];
+export type MarimoError = schemas["MarimoError"];
 export type OutputMessage = schemas["CellOutput"];
 export type CompletionOption =
   schemas["CompletionResultNotification"]["options"][0];
@@ -54,8 +51,8 @@ export type Capabilities =
   NotificationMessageData<"kernel-ready">["capabilities"];
 export type CacheInfoFetched = NotificationMessageData<"cache-info">;
 
-export type NotificationMessage = schemas["KnownUnions"]["notification"];
-export type CommandMessage = schemas["KnownUnions"]["command"];
+export type NotificationMessage = schemas["NotificationMessage"];
+export type ClientCommand = schemas["ClientCommand"];
 
 export type NotificationMessageType = NotificationMessage["op"];
 export interface NotificationPayload {

package/src/core/network/__tests__/api.test.ts

@@ -1,7 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { HTTPError } from "@/utils/errors";
+import { Logger } from "@/utils/Logger";
 import { API } from "../api";
 
 // Mock fetch globally
@@ -25,6 +26,118 @@ describe("API", () => {
     baseUrl = "http://localhost:8000";
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it.each(["before fetch", "during fetch"])(
+    "API.post propagates cancellation %s without logging it",
+    async (timing) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const controller = new AbortController();
+      mockFetch.mockImplementation(
+        (_url: string, { signal }: RequestInit) =>
+          new Promise<Response>((_resolve, reject) => {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            } else {
+              signal?.addEventListener("abort", () => reject(signal.reason), {
+                once: true,
+              });
+            }
+          }),
+      );
+      if (timing === "before fetch") {
+        controller.abort();
+      }
+
+      const response = API.post("/foo", {}, { signal: controller.signal });
+      controller.abort();
+
+      await expect(response).rejects.toBe(controller.signal.reason);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "http://localhost:8000/api/foo",
+        expect.objectContaining({ signal: controller.signal }),
+      );
+      expect(log).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(["application/json", "text/plain"])(
+    "API.post propagates an abort while reading %s without logging it",
+    async (contentType) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const error = new DOMException("Body read aborted", "AbortError");
+      const readBody = vi.fn().mockRejectedValue(error);
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ "Content-Type": contentType }),
+        json: readBody,
+        text: readBody,
+      });
+
+      await expect(API.post("/foo", {})).rejects.toBe(error);
+      expect(readBody).toHaveBeenCalledExactlyOnceWith();
+      expect(log).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each([new TypeError("Failed to fetch"), null, "Request failed"])(
+    "API.post logs and preserves non-abort fetch failures: %s",
+    async (error) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const controller = new AbortController();
+      controller.abort();
+      mockFetch.mockRejectedValue(error);
+
+      await expect(
+        API.post("/foo", {}, { signal: controller.signal }),
+      ).rejects.toBe(error);
+      expect(log).toHaveBeenCalledExactlyOnceWith(
+        "Error requesting http://localhost:8000/api/foo",
+        error,
+      );
+    },
+  );
+
+  it("API.post logs HTTP failures and preserves their status and body", async () => {
+    const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+    const body = { detail: "Service unavailable" };
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(body), {
+        status: 503,
+        statusText: "Service Unavailable",
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+
+    await expect(API.post("/foo", {})).rejects.toMatchObject({
+      name: "HTTPError",
+      status: 503,
+      message: "Service Unavailable",
+      cause: body,
+    });
+    expect(log).toHaveBeenCalledExactlyOnceWith(
+      "Error requesting http://localhost:8000/api/foo",
+      expect.any(HTTPError),
+    );
+  });
+
+  it("API.post logs malformed JSON responses", async () => {
+    const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+    mockFetch.mockResolvedValue(
+      new Response("invalid json", {
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+
+    await expect(API.post("/foo", {})).rejects.toBeInstanceOf(SyntaxError);
+    expect(log).toHaveBeenCalledExactlyOnceWith(
+      "Error requesting http://localhost:8000/api/foo",
+      expect.any(SyntaxError),
+    );
+  });
+
   it("API.post calls fetch with POST and correct URL", async () => {
     mockFetch.mockResolvedValue({
       ok: true,

package/src/core/network/api.ts

@@ -101,8 +101,9 @@ export const API = {
         return response.text() as unknown as RESP;
       })
       .catch((error) => {
-        // Catch and rethrow
-        Logger.error(`Error requesting ${fullUrl}`, error);
+        if (error?.name !== "AbortError") {
+          Logger.error(`Error requesting ${fullUrl}`, error);
+        }
         throw error;
       });
   },

package/src/core/wasm/bridge.ts

@@ -11,7 +11,7 @@ import { reloadSafe } from "@/utils/reload-safe";
 import { generateUUID } from "@/utils/uuid";
 import { createModuleWorker } from "@/utils/worker";
 import { notebookIsRunningAtom } from "../cells/cells";
-import type { CommandMessage } from "../kernel/messages";
+import type { ClientCommand } from "../kernel/messages";
 import { getInitialAppMode } from "../mode";
 import { API } from "../network/api";
 import { withDevAssetUrl } from "../network/export-asset-url";
@@ -711,7 +711,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
   public listStorageEntries = throwNotImplemented;
   public downloadStorage = throwNotImplemented;
 
-  private async putControlRequest(operation: CommandMessage) {
+  private async putControlRequest(operation: ClientCommand) {
     await this.rpc.proxy.request.bridge({
       functionName: "put_control_request",
       payload: operation,

package/src/core/wasm/worker/types.ts

@@ -3,7 +3,7 @@ import type { PyodideInterface } from "pyodide";
 import type { WasmRuntimeConfig } from "../runtime-config";
 import type { UserConfig } from "@/core/config/config-schema";
 import type {
-  CommandMessage,
+  ClientCommand,
   NotificationPayload,
 } from "@/core/kernel/messages";
 import type { JsonString } from "@/utils/json/base64";
@@ -74,7 +74,7 @@ export interface WasmController {
 }
 
 export interface RawBridge {
-  put_control_request(operation: CommandMessage): Promise<string>;
+  put_control_request(operation: ClientCommand): Promise<string>;
   put_input(input: string): Promise<string>;
   code_complete(request: CodeCompletionRequest): Promise<string>;
   read_code(): Promise<{ contents: string }>;