@marimo-team/islands 0.23.7-dev9 → 0.23.7-dev90

package/src/core/cells/document-changes.ts

@@ -218,13 +218,14 @@ export function toDocumentChanges(
       ];
     }
 
-    // dropCellOverCell/dropCellOverColumn/moveCellToIndex → set-config + reorder-cells
+    // dropCellOverCell/dropCellOverColumn/moveCellToIndex/moveCellsRelativeTo → set-config + reorder-cells
     // Drag-and-drop reorders can move cells within or across columns.
     // We emit config changes for cells whose column changed, then
     // the full ordering.
     case "dropCellOverCell":
     case "dropCellOverColumn":
     case "moveCellToIndex":
+    case "moveCellsRelativeTo":
       return columnChanges(prevState, newState);
 
     // updateCellCode → set-code
@@ -302,6 +303,10 @@ export function toDocumentChanges(
     case "undoDeleteCell": {
       const changes = newCellChanges(prevState, newState);
       const colChanges = columnChanges(prevState, newState);
+      // Undo-cut has no new cells — always emit reorder to sync the move.
+      if (changes.length === 0) {
+        return colChanges;
+      }
       // Only include column changes if layout actually changed
       // (colChanges always has at least a reorder-cells change)
       return colChanges.length > 1 ? [...changes, ...colChanges] : changes;

package/src/core/cells/pending-cut-service.ts

@@ -0,0 +1,55 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { atom, useAtomValue } from "jotai";
+import type { CellId } from "@/core/cells/ids";
+import { createReducerAndAtoms } from "@/utils/createReducer";
+
+interface PendingCutState {
+  cellIds: Set<CellId>;
+}
+
+const initialState = (): PendingCutState => ({
+  cellIds: new Set(),
+});
+
+const {
+  valueAtom: pendingCutStateAtom,
+  useActions: usePendingCutActionsInternal,
+} = createReducerAndAtoms(initialState, {
+  markForCut: (_state, action: { cellIds: CellId[] }) => {
+    return {
+      cellIds: new Set(action.cellIds),
+    };
+  },
+  clear: () => {
+    return initialState();
+  },
+});
+
+export { pendingCutStateAtom };
+
+export const pendingCutCellIdsAtom = atom(
+  (get) => get(pendingCutStateAtom).cellIds,
+);
+
+export const clearPendingCutAtom = atom(null, (_get, set) => {
+  set(pendingCutStateAtom, initialState());
+});
+
+export function usePendingCutActions() {
+  return usePendingCutActionsInternal();
+}
+
+export function useIsPendingCut(cellId: CellId): boolean {
+  const cellIds = useAtomValue(pendingCutCellIdsAtom);
+  return cellIds.has(cellId);
+}
+
+export function usePendingCutState() {
+  return useAtomValue(pendingCutStateAtom);
+}
+
+export function useHasPendingCut(): boolean {
+  const state = useAtomValue(pendingCutStateAtom);
+  return state.cellIds.size > 0;
+}

package/src/core/cells/utils.ts

@@ -65,6 +65,17 @@ export function canUndoDeletes(state: NotebookState) {
   return state.history.length > 0;
 }
 
+/**
+ * Label for the undo action based on the last history entry type.
+ */
+export function getUndoLabel(state: NotebookState): string {
+  const last = state.history[state.history.length - 1];
+  if (!last) {
+    return "Undo cell deletion";
+  }
+  return last.type === "move" ? "Undo move" : "Undo cell deletion";
+}
+
 /**
  * Get the status of the descendants of the given cell.
  */

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

@@ -10,6 +10,10 @@ import {
 } from "@codemirror/view";
 import { createTracebackInfoAtom } from "@/core/cells/cells";
 import { type CellId, HTMLCellId, SCRATCH_CELL_ID } from "@/core/cells/ids";
+import {
+  clearPendingCutAtom,
+  pendingCutCellIdsAtom,
+} from "@/core/cells/pending-cut-service";
 import { loroSyncAnnotation } from "@/core/codemirror/rtc/loro/sync";
 import type { KeymapConfig } from "@/core/config/config-schema";
 import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
@@ -326,6 +330,12 @@ function cellCodeEditing(hotkeys: HotkeyProvider): Extension[] {
         code: nextCode,
         formattingChange: isFormattingChange,
       });
+
+      // Clear pending cut state if this cell was marked for cut
+      const pendingCutCellIds = store.get(pendingCutCellIdsAtom);
+      if (pendingCutCellIds.has(cellId)) {
+        store.set(clearPendingCutAtom);
+      }
     }
   });
 

package/src/core/codemirror/go-to-definition/__tests__/commands.test.ts

@@ -101,6 +101,158 @@ print(x)`);
     `);
   });
 
+  test("selects the nearest in-scope local definition", async () => {
+    const code = `\
+a = 10
+
+def my_func():
+    a = 20
+    print(a)`;
+    view = createEditor(code);
+    const result = goToVariableDefinition(view, "a", code.lastIndexOf("a"));
+
+    expect(result).toBe(true);
+    await tick();
+    expect(renderEditorView(view)).toMatchInlineSnapshot(`
+      "
+      a = 10
+
+      def my_func():
+          a = 20
+          ^
+          print(a)
+      "
+    `);
+  });
+
+  test("selects the nearest in-scope parameter definition", async () => {
+    const code = `\
+a = 10
+
+def my_func(a):
+    print(a)`;
+    view = createEditor(code);
+    const result = goToVariableDefinition(view, "a", code.lastIndexOf("a"));
+
+    expect(result).toBe(true);
+    await tick();
+    expect(renderEditorView(view)).toMatchInlineSnapshot(`
+      "
+      a = 10
+
+      def my_func(a):
+                  ^
+          print(a)
+      "
+    `);
+  });
+
+  test("selects the comprehension target inside a set comprehension", async () => {
+    const code = `\
+x = 100
+s = {x for x in range(10)}`;
+    view = createEditor(code);
+    // Go-to-definition on the `x` before `for` (the expression part of the
+    // comprehension).
+    const usagePosition = code.indexOf("{x") + 1;
+    const result = goToVariableDefinition(view, "x", usagePosition);
+
+    expect(result).toBe(true);
+    await tick();
+    // Should jump to the comprehension target `x` (after `for`), not the
+    // outer `x = 100`. The Lezer Python grammar emits
+    // `SetComprehensionExpression`, and we now correctly match it in
+    // SCOPE_CREATING_NODES, so the comprehension creates a scope and the
+    // for-target is collected correctly.
+    expect(renderEditorView(view)).toMatchInlineSnapshot(`
+      "
+      x = 100
+      s = {x for x in range(10)}
+                 ^
+      "
+    `);
+  });
+
+  test("selects the comprehension target inside a dict comprehension", async () => {
+    const code = `\
+x = 100
+d = {x: x for x in range(10)}`;
+    view = createEditor(code);
+    const usagePosition = code.indexOf("{x") + 1;
+    const result = goToVariableDefinition(view, "x", usagePosition);
+
+    expect(result).toBe(true);
+    await tick();
+    // Positive control: `DictionaryComprehensionExpression` matches the grammar
+    // and is in SCOPE_CREATING_NODES, so this should jump to the comprehension
+    // target `x` (after `for`).
+    expect(renderEditorView(view)).toMatchInlineSnapshot(`
+      "
+      x = 100
+      d = {x: x for x in range(10)}
+                    ^
+      "
+    `);
+  });
+
+  test("skips enclosing class scope when resolving from inside a method", async () => {
+    const code = `\
+x = 100
+class Foo:
+    x = 10
+    def method(self):
+        return x`;
+    view = createEditor(code);
+    // Go-to-definition on the `x` inside `return x`.
+    const usagePosition = code.lastIndexOf("x");
+    const result = goToVariableDefinition(view, "x", usagePosition);
+
+    expect(result).toBe(true);
+    await tick();
+    // Should jump to `x = 100` at module scope. In Python, methods do NOT see
+    // their enclosing class body's names — class scopes are skipped in LEGB
+    // lookup once a function boundary has been crossed. We now correctly skip
+    // ClassDefinition in getScopeChain once a function boundary is crossed.
+    expect(renderEditorView(view)).toMatchInlineSnapshot(`
+      "
+      x = 100
+      ^
+      class Foo:
+          x = 10
+          def method(self):
+              return x
+      "
+    `);
+  });
+
+  test("resolves a global forward-reference from inside a function", async () => {
+    const code = `\
+def foo():
+    return a
+
+a = 10`;
+    view = createEditor(code);
+    // Go-to-definition on the `a` inside `return a`.
+    const usagePosition = code.indexOf("return a") + "return ".length;
+    const result = goToVariableDefinition(view, "a", usagePosition);
+
+    expect(result).toBe(true);
+    await tick();
+    // Should jump to `a = 10` at the bottom. Python allows forward references
+    // from within nested functions to module-level names. We now correctly omit
+    // "global" from POSITION_SENSITIVE_SCOPES, allowing forward references to
+    // global-level definitions declared after the usage position.
+    expect(renderEditorView(view)).toMatchInlineSnapshot(`
+      "
+      def foo():
+          return a
+
+      a = 10
+      ^
+      "
+    `);
+  });
+
   test("selects outer-scope function declaration", async () => {
     view = createEditor(`\
 def x():

package/src/core/codemirror/go-to-definition/__tests__/utils.test.ts

@@ -0,0 +1,99 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { python } from "@codemirror/lang-python";
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { afterEach, describe, expect, test } from "vitest";
+import { cellId, variableName } from "@/__tests__/branded";
+import { initialNotebookState, notebookAtom } from "@/core/cells/cells";
+import { store } from "@/core/state/jotai";
+import { variablesAtom } from "@/core/variables/state";
+import { goToDefinitionAtCursorPosition } from "../utils";
+
+async function tick(): Promise<void> {
+  await new Promise((resolve) => requestAnimationFrame(resolve));
+}
+
+function createEditor(content: string, selection: number) {
+  const state = EditorState.create({
+    doc: content,
+    selection: { anchor: selection },
+    extensions: [python()],
+  });
+
+  return new EditorView({
+    state,
+    parent: document.body,
+  });
+}
+
+const views: EditorView[] = [];
+
+afterEach(() => {
+  for (const view of views.splice(0)) {
+    view.destroy();
+  }
+
+  store.set(notebookAtom, initialNotebookState());
+  store.set(variablesAtom, {});
+});
+
+describe("goToDefinitionAtCursorPosition", () => {
+  test("prefers the current-cell local definition over a reactive global", async () => {
+    const globalCell = cellId("global-cell");
+    const localCell = cellId("local-cell");
+    const globalCode = `\
+a = 10
+print(a)`;
+    const localCode = `\
+def test():
+    a = 20
+    print(a)`;
+
+    const globalView = createEditor(globalCode, globalCode.length);
+    const localView = createEditor(localCode, localCode.lastIndexOf("a"));
+    views.push(globalView, localView);
+
+    const notebook = initialNotebookState();
+    notebook.cellHandles[globalCell] = {
+      current: { editorView: globalView, editorViewOrNull: globalView },
+    };
+    notebook.cellHandles[localCell] = {
+      current: { editorView: localView, editorViewOrNull: localView },
+    };
+
+    store.set(notebookAtom, notebook);
+    store.set(variablesAtom, {
+      [variableName("a")]: {
+        dataType: "int",
+        declaredBy: [globalCell],
+        name: variableName("a"),
+        usedBy: [localCell],
+        value: "10",
+      },
+    });
+
+    const result = goToDefinitionAtCursorPosition(localView);
+
+    expect(result).toBe(true);
+    await tick();
+    expect(localView.state.selection.main.head).toBe(
+      localCode.indexOf("a = 20"),
+    );
+    expect(globalView.state.selection.main.head).toBe(globalCode.length);
+  });
+
+  test("keeps private variables within the current cell", async () => {
+    const code = `\
+_x = 10
+output = _x + 10`;
+    const view = createEditor(code, code.lastIndexOf("_x"));
+    views.push(view);
+
+    const result = goToDefinitionAtCursorPosition(view);
+
+    expect(result).toBe(true);
+    await tick();
+    expect(view.state.selection.main.head).toBe(code.indexOf("_x = 10"));
+  });
+});