@marimo-team/islands 0.23.14-dev43 → 0.23.14-dev45

package/dist/{process-output-B9ysqk1y.js → process-output-kGk2Jc2x.js}

@@ -1,6 +1,6 @@
 import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { at as parseHtmlContent, it as ansiToPlainText } from "./html-to-image-DLSOS-bE.js";
+import { at as parseHtmlContent, it as ansiToPlainText } from "./html-to-image-DOqQBSQc.js";
 import { u as createLucideIcon } from "./dist--2Bqjvs0.js";
 import { t as Strings } from "./strings-Dq_j3Rxw.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";

package/dist/{reveal-component-CD1M60a6.js → reveal-component-BrJ-d3iB.js}

@@ -6,10 +6,10 @@ import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { _ as Logger, g as cn, h as Events, l as useEventListener, t as Button } from "./button-BacYv-bE.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { lt as kioskModeAtom, pt as outputIsStale } from "./html-to-image-DLSOS-bE.js";
+import { lt as kioskModeAtom, pt as outputIsStale } from "./html-to-image-DOqQBSQc.js";
 import "./chunk-5FQGJX7Z-BbqSm5gU.js";
 import { u as createLucideIcon } from "./dist--2Bqjvs0.js";
-import { a as DEFAULT_SLIDE_TYPE, c as Slide, ct as PanelGroup, i as DEFAULT_DECK_TRANSITION, lt as PanelResizeHandle, on as EyeOff, s as SlideSidebar, sn as Expand, st as Panel, t as useNotebookCodeAvailable, un as Code } from "./code-visibility-BCkKHNom.js";
+import { a as DEFAULT_SLIDE_TYPE, c as Slide, ct as PanelGroup, i as DEFAULT_DECK_TRANSITION, lt as PanelResizeHandle, on as EyeOff, s as SlideSidebar, sn as Expand, st as Panel, t as useNotebookCodeAvailable, un as Code } from "./code-visibility-D-7iipEs.js";
 import { X as useDebouncedCallback } from "./input-BSdZp5Ng.js";
 import "./toDate-D1Z7ZXWh.js";
 import "./react-dom-BTJzcVJ9.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.23.14-dev43",
+  "version": "0.23.14-dev45",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/__mocks__/requests.ts

@@ -45,6 +45,7 @@ export const MockRequestClient = {
       openFile: vi.fn().mockResolvedValue({}),
       getUsageStats: vi.fn().mockResolvedValue({}),
       sendPdb: vi.fn().mockResolvedValue({}),
+      sendSetBreakpoints: vi.fn().mockResolvedValue({}),
       sendListFiles: vi.fn().mockResolvedValue({ files: [] }),
       sendSearchFiles: vi
         .fn()

package/src/components/app-config/user-config-form.tsx

@@ -1288,6 +1288,32 @@ export const UserConfigForm: React.FC = () => {
                 </div>
               )}
             />
+            <OverriddenFormField
+              control={form.control}
+              name="experimental.debugger"
+              render={({ field, override }) => (
+                <div className="flex flex-col gap-y-1">
+                  <FormItem className={formItemClasses}>
+                    <FormLabel className="font-normal">Debugger</FormLabel>
+                    <FormControl>
+                      <Checkbox
+                        data-testid="debugger-checkbox"
+                        checked={override.value === true}
+                        disabled={override.isOverridden}
+                        onCheckedChange={field.onChange}
+                      />
+                    </FormControl>
+                  </FormItem>
+                  <IsOverridden override={override} />
+                  <FormDescription>
+                    Enable the live debugger: a clickable breakpoint gutter,
+                    current-line highlighting while a cell runs, and dropping
+                    into <Kbd className="inline">pdb</Kbd> at breakpoints. This
+                    change requires a page refresh to take effect.
+                  </FormDescription>
+                </div>
+              )}
+            />
           </SettingGroup>
         );
     }

package/src/components/debugger/debugger-code.tsx

@@ -208,7 +208,7 @@ export const DebuggerControls: React.FC<{
         </Button>
       </Tooltip>
       {onClear && (
-        <Tooltip content="Clear">
+        <Tooltip content="Quit and clear">
           <Button
             variant="text"
             size="icon"
@@ -217,7 +217,12 @@ export const DebuggerControls: React.FC<{
               buttonClasses,
               "text-(--red-11) hover:text-(--red-11) hover:bg-(--red-2) hover:border-(--red-8)",
             )}
-            onClick={onClear}
+            onClick={() => {
+              // Quit the debugger (`q`) before tearing down the console, so
+              // the stdin response targets the still-present pdb prompt.
+              onSubmit("q");
+              onClear();
+            }}
           >
             <TrashIcon fontSize={36} className={iconClasses} />
           </Button>

package/src/components/editor/notebook-cell.tsx

@@ -29,6 +29,7 @@ import { outputIsLoading, outputIsStale } from "@/core/cells/cell";
 import { isOutputEmpty } from "@/core/cells/outputs";
 import { useIsPendingCut } from "@/core/cells/pending-cut-service";
 import { autocompletionKeymap } from "@/core/codemirror/cm";
+import { clearCellBreakpoints } from "@/core/codemirror/cells/debugger-state";
 import type { LanguageAdapterType } from "@/core/codemirror/language/types";
 import { CSSClasses } from "@/core/constants";
 import { canCollapseOutline } from "@/core/dom/outline";
@@ -746,6 +747,9 @@ const EditableCellComponent = ({
               onRefactorWithAI={handleRefactorWithAI}
               onClear={() => {
                 actions.clearCellConsoleOutput({ cellId });
+                // The debugger "Clear" (trashcan) also drops this cell's
+                // breakpoints; no-op when none are set.
+                clearCellBreakpoints(cellId);
               }}
               onSubmitDebugger={(text, index) => {
                 actions.setStdinResponse({
@@ -1211,6 +1215,9 @@ const SetupCellComponent = ({
               onRefactorWithAI={handleRefactorWithAI}
               onClear={() => {
                 actions.clearCellConsoleOutput({ cellId });
+                // The debugger "Clear" (trashcan) also drops this cell's
+                // breakpoints; no-op when none are set.
+                clearCellBreakpoints(cellId);
               }}
               onSubmitDebugger={(text, index) => {
                 actions.setStdinResponse({

package/src/components/editor/output/MarimoTracebackOutput.tsx

@@ -24,8 +24,10 @@ import { Tooltip } from "@/components/ui/tooltip";
 import { getCellEditorView } from "@/core/cells/cells";
 import type { CellId } from "@/core/cells/ids";
 import { SCRATCH_CELL_ID } from "@/core/cells/ids";
+import { toggleBreakpoint } from "@/core/codemirror/cells/debugger-state";
 import { insertDebuggerAtLine } from "@/core/codemirror/editing/debugging";
 import { aiFeaturesEnabledAtom } from "@/core/config/config";
+import { getFeatureFlag } from "@/core/config/feature-flag";
 import { getRequestClient } from "@/core/network/requests";
 import { isStaticNotebook } from "@/core/static/static-state";
 import { isWasm } from "@/core/wasm/utils";
@@ -212,7 +214,14 @@ function lastLine(text: string): string {
 export const replaceTracebackFilenames = (domNode: DOMNode) => {
   const info = getTracebackInfo(domNode);
   if (info?.kind === "cell") {
-    const tooltipContent = <InsertBreakpointContent />;
+    // With the live debugger enabled, toggle a real gutter breakpoint
+    // instead of mutating the user's code with a `breakpoint()` statement.
+    const debuggerEnabled = getFeatureFlag("debugger");
+    const tooltipContent = debuggerEnabled ? (
+      <ToggleBreakpointContent />
+    ) : (
+      <InsertBreakpointContent />
+    );
     return (
       <span className="nb">
         <span className="inline-flex items-center">
@@ -228,6 +237,10 @@ export const replaceTracebackFilenames = (domNode: DOMNode) => {
               >
                 <BugPlayIcon
                   onClick={() => {
+                    if (debuggerEnabled && !isStaticNotebook()) {
+                      toggleBreakpoint(info.cellId, info.lineNumber);
+                      return;
+                    }
                     const view = getCellEditorView(info.cellId);
                     if (view) {
                       insertDebuggerAtLine(view, info.lineNumber);
@@ -294,3 +307,7 @@ const InsertBreakpointContent = () => {
     </>
   );
 };
+
+const ToggleBreakpointContent = () => {
+  return <>Toggle a breakpoint at this line</>;
+};

package/src/core/cells/__tests__/cell.test.ts

@@ -218,3 +218,42 @@ describe("transitionCell serialization", () => {
     );
   });
 });
+
+describe("transitionCell stdin resolution", () => {
+  function stdinOutput(): OutputMessage {
+    return {
+      channel: "stdin",
+      mimetype: "text/plain",
+      data: "(Pdb) ",
+      timestamp: Date.now() as Seconds,
+    } as OutputMessage;
+  }
+
+  it("resolves a dangling pdb prompt when the cell goes idle", () => {
+    // A paused-pdb cell shows an unanswered stdin prompt (the debugger box);
+    // once it finishes (e.g. after quitting with `q`), the box is removed.
+    const cell = createCellRuntimeState({
+      status: "running",
+      debuggerActive: true,
+      consoleOutputs: [stdinOutput()],
+    });
+    const next = transitionCell(cell, {
+      cell_id: "cell-1",
+      status: "idle",
+    } as CellMessage);
+    expect(next.debuggerActive).toBe(false);
+    expect(next.consoleOutputs[0].response).toBe("");
+  });
+
+  it("leaves an unanswered prompt interactive while still running", () => {
+    const cell = createCellRuntimeState({
+      status: "running",
+      consoleOutputs: [stdinOutput()],
+    });
+    const next = transitionCell(cell, {
+      cell_id: "cell-1",
+      status: null,
+    } as CellMessage);
+    expect(next.consoleOutputs[0].response).toBeUndefined();
+  });
+});

package/src/core/cells/cell.ts

@@ -118,9 +118,11 @@ export function transitionCell(
   // Coalesce console outputs, which are streamed during execution.
   let consoleOutputs = cell.consoleOutputs;
 
-  // If interrupted on the incoming message,
-  // remove the debugger and resolve all stdin for previous console outputs
-  if (didInterruptFromThisMessage) {
+  // When the cell is interrupted or finishes (idle), there is no live
+  // stdin/pdb session, so resolve any dangling stdin prompt. This removes the
+  // debugger box — e.g. after quitting pdb with `q`, which stops the cell
+  // (idle) rather than interrupting it.
+  if (didInterruptFromThisMessage || message.status === "idle") {
     nextCell.debuggerActive = false;
     consoleOutputs = consoleOutputs.map((output) => {
       if (output.channel === "stdin") {

package/src/core/codemirror/cells/debugger-decorations.ts

@@ -0,0 +1,188 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import {
+  type EditorState,
+  type Extension,
+  RangeSet,
+  RangeSetBuilder,
+  StateEffect,
+  StateField,
+} from "@codemirror/state";
+import {
+  Decoration,
+  type DecorationSet,
+  EditorView,
+  gutter,
+  GutterMarker,
+  type PluginValue,
+  ViewPlugin,
+  type ViewUpdate,
+} from "@codemirror/view";
+import type { CellId } from "@/core/cells/ids";
+import type { Observable } from "@/core/state/observable";
+import { Logger } from "@/utils/Logger";
+import { toggleBreakpoint } from "./debugger-state";
+
+// --- Current-line highlight -------------------------------------------------
+
+function createLineDecoration(
+  state: EditorState,
+  line: number | null,
+): DecorationSet {
+  if (line == null || line < 1 || line > state.doc.lines) {
+    return Decoration.none;
+  }
+  const builder = new RangeSetBuilder<Decoration>();
+  try {
+    const doc = state.doc.line(line);
+    builder.add(
+      doc.from,
+      doc.from,
+      Decoration.line({ class: "cm-debugger-current-line" }),
+    );
+  } catch (error) {
+    Logger.debug("Invalid debugger line", { error });
+  }
+  return builder.finish();
+}
+
+class CurrentLineHighlighter implements PluginValue {
+  private unsubscribe: () => void;
+  decorations: DecorationSet;
+
+  constructor(view: EditorView, lineObservable: Observable<number | null>) {
+    this.decorations = createLineDecoration(view.state, lineObservable.get());
+    this.unsubscribe = lineObservable.sub((line) => {
+      this.decorations = createLineDecoration(view.state, line);
+      // Force a re-render; the decoration set changed out of band.
+      view.dispatch({ userEvent: "marimo.debugger-line-update" });
+    });
+  }
+
+  update(update: ViewUpdate) {
+    this.decorations = this.decorations.map(update.changes);
+  }
+
+  destroy() {
+    this.unsubscribe();
+  }
+}
+
+/** Highlight the line a cell's frame watcher is currently executing. */
+export function debuggerLineHighlighter(
+  lineObservable: Observable<number | null>,
+): Extension {
+  return [
+    ViewPlugin.define(
+      (view) => new CurrentLineHighlighter(view, lineObservable),
+      { decorations: (plugin) => plugin.decorations },
+    ),
+    EditorView.theme({
+      ".cm-debugger-current-line": {
+        backgroundColor: "color-mix(in srgb, var(--amber-4) 50%, transparent)",
+      },
+    }),
+  ];
+}
+
+// --- Breakpoint gutter ------------------------------------------------------
+
+class BreakpointMarker extends GutterMarker {
+  override toDOM() {
+    const dot = document.createElement("div");
+    dot.className = "cm-breakpoint-marker";
+    return dot;
+  }
+}
+
+const breakpointMarker = new BreakpointMarker();
+
+const setBreakpointLines = StateEffect.define<ReadonlySet<number>>();
+
+const breakpointLinesField = StateField.define<ReadonlySet<number>>({
+  create: () => new Set<number>(),
+  update(value, tr) {
+    for (const effect of tr.effects) {
+      if (effect.is(setBreakpointLines)) {
+        return effect.value;
+      }
+    }
+    return value;
+  },
+});
+
+function buildBreakpointMarkers(state: EditorState): RangeSet<GutterMarker> {
+  const lines = state.field(breakpointLinesField);
+  if (lines.size === 0) {
+    return RangeSet.empty;
+  }
+  const builder = new RangeSetBuilder<GutterMarker>();
+  for (const lineNo of [...lines].toSorted((a, b) => a - b)) {
+    if (lineNo >= 1 && lineNo <= state.doc.lines) {
+      const line = state.doc.line(lineNo);
+      builder.add(line.from, line.from, breakpointMarker);
+    }
+  }
+  return builder.finish();
+}
+
+/** Keep `breakpointLinesField` in sync with the per-cell breakpoints atom. */
+class BreakpointSync implements PluginValue {
+  private unsubscribe: () => void;
+
+  constructor(view: EditorView, observable: Observable<ReadonlySet<number>>) {
+    const apply = (lines: ReadonlySet<number>) => {
+      view.dispatch({ effects: setBreakpointLines.of(lines) });
+    };
+    // Dispatching during view construction is disallowed; defer the initial
+    // sync (e.g. for editors that mount after breakpoints already exist).
+    // Read the value fresh inside the microtask so a `sub` update that lands
+    // first isn't clobbered by a stale snapshot.
+    if (observable.get().size > 0) {
+      queueMicrotask(() => apply(observable.get()));
+    }
+    this.unsubscribe = observable.sub(apply);
+  }
+
+  destroy() {
+    this.unsubscribe();
+  }
+}
+
+/** A clickable gutter for toggling breakpoints on a cell's lines. */
+export function breakpointGutter(
+  cellId: CellId,
+  breakpointsObservable: Observable<ReadonlySet<number>>,
+): Extension {
+  return [
+    breakpointLinesField,
+    ViewPlugin.define(
+      (view) => new BreakpointSync(view, breakpointsObservable),
+    ),
+    gutter({
+      class: "cm-breakpoint-gutter",
+      markers: (view) => buildBreakpointMarkers(view.state),
+      initialSpacer: () => breakpointMarker,
+      domEventHandlers: {
+        mousedown: (view, line) => {
+          const lineNo = view.state.doc.lineAt(line.from).number;
+          toggleBreakpoint(cellId, lineNo);
+          return true;
+        },
+      },
+    }),
+    EditorView.theme({
+      ".cm-breakpoint-gutter": {
+        width: "14px",
+        cursor: "pointer",
+      },
+      ".cm-breakpoint-marker": {
+        width: "8px",
+        height: "8px",
+        borderRadius: "50%",
+        backgroundColor: "var(--red-9)",
+        margin: "4px auto",
+      },
+    }),
+  ];
+}

package/src/core/codemirror/cells/debugger-state.ts

@@ -0,0 +1,92 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { atom } from "jotai";
+import type { CellId } from "@/core/cells/ids";
+import { getRequestClient } from "@/core/network/requests";
+import { store } from "@/core/state/jotai";
+import { Logger } from "@/utils/Logger";
+
+/**
+ * State for the experimental live debugger.
+ *
+ * - `debuggerCurrentLineAtom` holds the cell + line the kernel's frame watcher
+ *   is currently executing (driven by `active-line` notifications). Only one
+ *   cell runs at a time, so a single global value suffices.
+ * - `breakpointsAtom` holds the user's gutter breakpoints, session-only. It is
+ *   the source of truth; mutations are mirrored to the kernel via
+ *   `sendSetBreakpoints`.
+ */
+
+export interface DebuggerLine {
+  cellId: CellId;
+  line: number;
+}
+
+export const debuggerCurrentLineAtom = atom<DebuggerLine | null>(null);
+
+export const breakpointsAtom = atom<ReadonlyMap<CellId, ReadonlySet<number>>>(
+  new Map<CellId, ReadonlySet<number>>(),
+);
+
+const EMPTY_LINES: ReadonlySet<number> = new Set();
+
+/** Per-cell derived atom: the current debug line for `cellId`, or `null`. */
+export function createDebuggerLineAtom(cellId: CellId) {
+  return atom((get) => {
+    const current = get(debuggerCurrentLineAtom);
+    return current?.cellId === cellId ? current.line : null;
+  });
+}
+
+/** Per-cell derived atom: the breakpoint lines for `cellId`. */
+export function createCellBreakpointsAtom(cellId: CellId) {
+  return atom((get) => get(breakpointsAtom).get(cellId) ?? EMPTY_LINES);
+}
+
+function sendBreakpoints(map: ReadonlyMap<CellId, ReadonlySet<number>>): void {
+  const breakpoints: Record<string, number[]> = {};
+  for (const [cellId, lines] of map) {
+    if (lines.size > 0) {
+      breakpoints[cellId] = [...lines].toSorted((a, b) => a - b);
+    }
+  }
+  // Fire-and-forget: the request layer rethrows on failure (e.g. static or
+  // wasm mode with no live kernel). Swallow it so toggling a breakpoint never
+  // surfaces as an unhandled promise rejection.
+  getRequestClient()
+    .sendSetBreakpoints({ breakpoints })
+    .catch((error) => {
+      Logger.debug("Failed to sync breakpoints to kernel", { error });
+    });
+}
+
+/** Remove all breakpoints for a cell and sync the full set to the kernel. */
+export function clearCellBreakpoints(cellId: CellId): void {
+  const prev = store.get(breakpointsAtom);
+  if (!prev.has(cellId)) {
+    return;
+  }
+  const next = new Map(prev);
+  next.delete(cellId);
+  store.set(breakpointsAtom, next);
+  sendBreakpoints(next);
+}
+
+/** Toggle a breakpoint at `(cellId, line)` and sync the full set to the kernel. */
+export function toggleBreakpoint(cellId: CellId, line: number): void {
+  const prev = store.get(breakpointsAtom);
+  const next = new Map(prev);
+  const lines = new Set(next.get(cellId) ?? []);
+  if (lines.has(line)) {
+    lines.delete(line);
+  } else {
+    lines.add(line);
+  }
+  if (lines.size > 0) {
+    next.set(cellId, lines);
+  } else {
+    next.delete(cellId);
+  }
+  store.set(breakpointsAtom, next);
+  sendBreakpoints(next);
+}

package/src/core/codemirror/cells/extensions.ts

@@ -17,6 +17,7 @@ import {
 import { loroSyncAnnotation } from "@/core/codemirror/rtc/loro/sync";
 import type { KeymapConfig } from "@/core/config/config-schema";
 import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
+import { getFeatureFlag } from "@/core/config/feature-flag";
 import { duplicateWithCtrlModifier } from "@/core/hotkeys/shortcuts";
 import { store } from "@/core/state/jotai";
 import { createObservable } from "@/core/state/observable";
@@ -25,6 +26,14 @@ import { formattingChangeEffect } from "../format";
 import { goToDefinitionAtCursorPosition } from "../go-to-definition/utils";
 import { getEditorCodeAsPython } from "../language/utils";
 import { isAtEndOfEditor, isAtStartOfEditor } from "../utils";
+import {
+  breakpointGutter,
+  debuggerLineHighlighter,
+} from "./debugger-decorations";
+import {
+  createCellBreakpointsAtom,
+  createDebuggerLineAtom,
+} from "./debugger-state";
 import {
   type CodemirrorCellActions,
   cellActionsState,
@@ -428,6 +437,19 @@ export function cellBundle({
     errorLineHighlighter(
       createObservable(createTracebackInfoAtom(cellId), store),
     ),
+    // Experimental live debugger: clickable breakpoint gutter + current-line
+    // highlight. Gated so there is no gutter/overhead when disabled.
+    getFeatureFlag("debugger")
+      ? [
+          breakpointGutter(
+            cellId,
+            createObservable(createCellBreakpointsAtom(cellId), store),
+          ),
+          debuggerLineHighlighter(
+            createObservable(createDebuggerLineAtom(cellId), store),
+          ),
+        ]
+      : [],
   ];
 }
 

package/src/core/config/feature-flag.tsx

@@ -11,6 +11,7 @@ export interface ExperimentalFeatures {
   rtc_v2: boolean;
   cache_panel: boolean;
   external_agents: boolean;
+  debugger: boolean; // Live frame-watching debugger (gutter breakpoints + pdb)
   // Add new feature flags here
 }
 
@@ -20,6 +21,7 @@ const defaultValues: ExperimentalFeatures = {
   rtc_v2: false,
   cache_panel: false,
   external_agents: import.meta.env.DEV,
+  debugger: false,
 };
 
 export function getFeatureFlag<T extends keyof ExperimentalFeatures>(

package/src/core/islands/bootstrap.ts

@@ -174,6 +174,7 @@ function handleMessage(
       case "completion-result":
       case "reload":
       case "focus-cell":
+      case "active-line":
       case "variables":
       case "variable-values":
       case "data-column-preview":

package/src/core/islands/bridge.ts

@@ -244,6 +244,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   sendListFiles = throwNotImplemented;
   sendSearchFiles = throwNotImplemented;
   sendPdb = throwNotImplemented;
+  sendSetBreakpoints = throwNotImplemented;
   sendCreateFileOrFolder = throwNotImplemented;
   sendDeleteFileOrFolder = throwNotImplemented;
   sendCopyFileOrFolder = throwNotImplemented;

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

@@ -108,6 +108,7 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   sendStdin: "waitForConnectionOpen",
   sendInterrupt: "waitForConnectionOpen",
   sendPdb: "waitForConnectionOpen",
+  sendSetBreakpoints: "waitForConnectionOpen",
   sendInstallMissingPackages: "waitForConnectionOpen",
   readSnippets: "waitForConnectionOpen",
   previewDatasetColumn: "waitForConnectionOpen",

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

@@ -293,6 +293,14 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
+    sendSetBreakpoints: (request) => {
+      return getClient()
+        .POST("/api/kernel/pdb/breakpoints", {
+          body: request,
+          params: getParams(),
+        })
+        .then(handleResponseReturnNull);
+    },
     sendListFiles: async (request) => {
       await waitForConnectionOpen();
       return getClient()

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

@@ -68,6 +68,7 @@ export function createStaticRequests(): EditRequests & RunRequests {
     sendListFiles: throwNotInEditMode,
     sendSearchFiles: throwNotInEditMode,
     sendPdb: throwNotInEditMode,
+    sendSetBreakpoints: throwNotInEditMode,
     sendCreateFileOrFolder: throwNotInEditMode,
     sendDeleteFileOrFolder: throwNotInEditMode,
     sendCopyFileOrFolder: throwNotInEditMode,

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

@@ -49,6 +49,7 @@ export function createErrorToastingRequests(
     sendListFiles: "Failed to list files",
     sendSearchFiles: "Failed to search files",
     sendPdb: "Failed to start debug session",
+    sendSetBreakpoints: "", // No toast
     sendCreateFileOrFolder: "Failed to create file or folder",
     sendDeleteFileOrFolder: "Failed to delete file or folder",
     sendCopyFileOrFolder: "Failed to duplicate file or folder",

package/src/core/network/types.ts

@@ -66,6 +66,7 @@ export type ListDataSourceConnectionRequest =
   schemas["ListDataSourceConnectionRequest"];
 export type ValidateSQLRequest = schemas["ValidateSQLRequest"];
 export type DebugCellRequest = schemas["DebugCellRequest"];
+export type SetBreakpointsRequest = schemas["SetBreakpointsRequest"];
 export type ReadCodeResponse = schemas["ReadCodeResponse"];
 export type RecentFilesResponse = schemas["RecentFilesResponse"];
 export type RenameNotebookRequest = schemas["RenameNotebookRequest"];
@@ -172,6 +173,7 @@ export interface EditRequests {
   getUsageStats: () => Promise<UsageResponse>;
   // Debugger
   sendPdb: (request: DebugCellRequest) => Promise<null>;
+  sendSetBreakpoints: (request: SetBreakpointsRequest) => Promise<null>;
   // File explorer requests
   sendListFiles: (request: FileListRequest) => Promise<FileListResponse>;
   sendSearchFiles: (request: FileSearchRequest) => Promise<FileSearchResponse>;

package/src/core/wasm/bridge.ts

@@ -257,6 +257,10 @@ export class PyodideBridge implements RunRequests, EditRequests {
     throwNotImplemented();
   };
 
+  sendSetBreakpoints: EditRequests["sendSetBreakpoints"] = async () => {
+    throwNotImplemented();
+  };
+
   sendRun: EditRequests["sendRun"] = async (request) => {
     await this.rpc.proxy.request.loadPackages(request.codes.join("\n"));