@marimo-team/islands 0.25.3-dev27 → 0.25.3-dev270

package/src/core/config/__tests__/config-schema.test.ts

@@ -16,13 +16,18 @@ import {
   UserConfigSchema,
 } from "../config-schema";
 
+test("legacy Manual config resolves to Read only", () => {
+  const config = UserConfigSchema.parse({ ai: { mode: "manual" } });
+  expect(config).toEqual(UserConfigSchema.parse({ ai: { mode: "ask" } }));
+});
+
 test("default AppConfig", () => {
   const defaultConfig = AppConfigSchema.parse({});
   expect(defaultConfig).toMatchInlineSnapshot(`
     {
       "auto_download": [],
       "sql_output": "auto",
-      "width": "medium",
+      "width": "compact",
     }
   `);
 });
@@ -51,7 +56,7 @@ test("default UserConfig - empty", () => {
         "custom_providers": {},
         "enabled": true,
         "inline_tooltip": false,
-        "mode": "manual",
+        "mode": "ask",
         "models": {
           "custom_models": [],
           "displayed_models": [],
@@ -79,6 +84,7 @@ test("default UserConfig - empty", () => {
       "experimental": {},
       "file_browser": {},
       "formatting": {
+        "infer_types": "off",
         "line_length": 79,
       },
       "keymap": {
@@ -127,7 +133,7 @@ test("default UserConfig - one level", () => {
         "custom_providers": {},
         "enabled": true,
         "inline_tooltip": false,
-        "mode": "manual",
+        "mode": "ask",
         "models": {
           "custom_models": [],
           "displayed_models": [],
@@ -155,6 +161,7 @@ test("default UserConfig - one level", () => {
       "experimental": {},
       "file_browser": {},
       "formatting": {
+        "infer_types": "off",
         "line_length": 79,
       },
       "keymap": {
@@ -273,7 +280,7 @@ test("resolvedMarimoConfigAtom overrides correctly and does not mutate the origi
       autosave_delay: 1000,
       format_on_save: false,
     },
-    formatting: { line_length: 79 },
+    formatting: { line_length: 79, infer_types: "off" },
   };
 
   const overrides = {
@@ -299,7 +306,7 @@ test("resolvedMarimoConfigAtom overrides correctly and does not mutate the origi
       autosave_delay: 1000,
       format_on_save: false,
     },
-    formatting: { line_length: 79 },
+    formatting: { line_length: 79, infer_types: "off" },
     display: { theme: "dark" },
   });
 
@@ -314,7 +321,7 @@ test("resolvedMarimoConfigAtom overrides correctly and does not mutate the origi
       autosave_delay: 1000,
       format_on_save: false,
     },
-    formatting: { line_length: 79 },
+    formatting: { line_length: 79, infer_types: "off" },
   });
 });
 
@@ -361,3 +368,46 @@ test("mergeConfig replaces arrays instead of merging by index", () => {
     },
   });
 });
+
+test.each([{}, { "run-cell": "Alt-Enter" }])(
+  "mergeConfig replaces shortcut dictionaries with %j",
+  (overrides) => {
+    const original = {
+      keymap: {
+        preset: "vim",
+        overrides: { "run-all": "Ctrl-Enter" },
+      },
+    };
+    expect(mergeConfig(original, { keymap: { overrides } })).toEqual({
+      keymap: { preset: "vim", overrides },
+    });
+    expect(original.keymap.overrides).toEqual({ "run-all": "Ctrl-Enter" });
+  },
+);
+
+test.each(["ai.custom_providers", "signing.trusted_signers"])(
+  "mergeConfig replaces records at %s while preserving retained record fields",
+  (path) => {
+    const [section, name] = path.split(".");
+    const original = {
+      [section]: {
+        [name]: {
+          retained: { name: "before", api_key: "secret" },
+          removed: { name: "removed" },
+        },
+      },
+    };
+    expect(
+      mergeConfig(original, {
+        [section]: { [name]: { retained: { name: "after" } } },
+      }),
+    ).toEqual({
+      [section]: {
+        [name]: { retained: { name: "after", api_key: "secret" } },
+      },
+    });
+    expect(mergeConfig(original, { [section]: { [name]: {} } })).toEqual({
+      [section]: { [name]: {} },
+    });
+  },
+);

package/src/core/config/config-schema.ts

@@ -44,6 +44,8 @@ export const DEFAULT_AI_MODEL = "openai/gpt-4o";
  */
 const AUTO_DOWNLOAD_FORMATS = ["html", "markdown", "ipynb"] as const;
 
+export const TYPE_INFERENCE_MODES = ["off", "jedi"] as const;
+
 export type CopilotMode = NonNullable<schemas["AiConfig"]["mode"]>;
 export const COPILOT_MODES: CopilotMode[] = [
   "manual",
@@ -112,6 +114,7 @@ export const UserConfigSchema = z
           .nonnegative()
           .prefault(79)
           .transform((n) => Math.min(n, 1000)),
+        infer_types: z.enum(TYPE_INFERENCE_MODES).prefault("off"),
       })
       .prefault({}),
     keymap: z
@@ -128,6 +131,7 @@ export const UserConfigSchema = z
         auto_reload: z.enum(["off", "lazy", "autorun"]).prefault("off"),
         reactive_tests: z.boolean().prefault(true),
         watcher_on_save: z.enum(["lazy", "autorun"]).prefault("lazy"),
+        sql_default_limit: z.number().int().nullable().optional(),
         default_sql_output: z.enum(VALID_SQL_OUTPUT_FORMATS).prefault("auto"),
         default_auto_download: z
           .array(z.enum(AUTO_DOWNLOAD_FORMATS))
@@ -167,7 +171,10 @@ export const UserConfigSchema = z
         enabled: z.boolean().prefault(true),
         rules: z.string().prefault(""),
         max_tokens: z.number().int().positive().nullable().optional(),
-        mode: z.enum(COPILOT_MODES).prefault("manual"),
+        mode: z
+          .enum(COPILOT_MODES)
+          .transform((mode) => (mode === "manual" ? "ask" : mode))
+          .prefault("ask"),
         inline_tooltip: z.boolean().prefault(false),
         allow_provider_config: z.boolean().prefault(true),
         open_ai: AiConfigSchema.optional(),
@@ -198,13 +205,15 @@ export const UserConfigSchema = z
     experimental: z
       .looseObject({
         markdown: z.boolean().optional(),
-        rtc: z.boolean().optional(),
         // Add new experimental features here
       })
       // Pass through so that we don't remove any extra keys that the user has added.
       .prefault(() => ({})),
     server: z
       .looseObject({
+        skip_update_check: z.boolean().optional(),
+        session_cookie_secure: z.boolean().optional(),
+        session_secret: z.string().optional(),
         disable_file_downloads: z.boolean().optional(),
         transport: z.enum(["websocket", "sse"]).optional(),
       })
@@ -272,11 +281,15 @@ export const SqlOutputSchema = z
   .enum(VALID_SQL_OUTPUT_FORMATS)
   .prefault("auto");
 
+/**
+ * The notebook's app config. The defaults are Python's `_AppConfig` defaults,
+ * since the host document carries only what differs from them.
+ */
 export const AppConfigSchema = z
   .object({
     width: z
       .enum(VALID_APP_WIDTHS)
-      .prefault("medium")
+      .prefault("compact")
       .transform((width) => {
         if (width === "normal") {
           return "compact";
@@ -290,7 +303,7 @@ export const AppConfigSchema = z
     sql_output: SqlOutputSchema,
   })
   .prefault(() => ({
-    width: "medium" as const,
+    width: "compact" as const,
     auto_download: [],
     sql_output: "auto" as const,
   }));

package/src/core/config/config.ts

@@ -1,8 +1,11 @@
 /* Copyright 2026 Marimo. All rights reserved. */
+import { dequal } from "dequal";
 import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
-import { mergeWith } from "lodash-es";
+import { selectAtom } from "jotai/vanilla/utils";
+import { cloneDeep, get, has, isPlainObject, mergeWith, set } from "lodash-es";
 import { OverridingHotkeyProvider } from "../hotkeys/hotkeys";
 import { type Platform, resolvePlatform } from "../hotkeys/shortcuts";
+import { confirmedDocumentAtom } from "../session/active-notebook";
 import { store } from "../state/jotai";
 import {
   type AppConfig,
@@ -12,16 +15,47 @@ import {
 } from "./config-schema";
 
 /**
- * Deep-merge config objects, replacing arrays instead of merging them by
- * index. Lodash `merge` keeps leftover tail items. Python `deep_merge` replaces arrays.
+ * Combine configuration sources in priority order, with later sources winning.
+ * Arrays and shortcut maps replace earlier values so removed entries stay removed.
+ * Provider and signer maps replace their keys, while retained records inherit
+ * unspecified fields (for example, a provider's API key).
+ * These rules match backend resolution so the editor and kernel use the same settings.
  */
+// TODO(MO-8400): Resolve configuration on the backend and send resolved values
+// with provenance, instead of duplicating source merging in the frontend.
 export function mergeConfig<T extends object>(...sources: object[]): T {
-  return mergeWith({}, ...sources, (_obj: unknown, src: unknown) => {
-    if (Array.isArray(src)) {
-      return [...src];
+  const result = {};
+  for (const source of sources) {
+    const replacements = [
+      "keymap.overrides",
+      "ai.custom_providers",
+      "signing.trusted_signers",
+    ]
+      .filter((path) => has(source, path))
+      .map((path) => {
+        const previous = get(result, path);
+        const incoming = get(source, path);
+        const value =
+          path !== "keymap.overrides" && isPlainObject(incoming)
+            ? Object.fromEntries(
+                Object.entries(incoming).map(([key, value]) => [
+                  key,
+                  isPlainObject(previous?.[key]) && isPlainObject(value)
+                    ? { ...previous[key], ...(value as object) }
+                    : value,
+                ]),
+              )
+            : incoming;
+        return { path, value };
+      });
+    mergeWith(result, source, (_obj: unknown, src: unknown) => {
+      return Array.isArray(src) ? [...src] : undefined;
+    });
+    for (const { path, value } of replacements) {
+      set(result, path, cloneDeep(value));
     }
-    return undefined;
-  }) as T;
+  }
+  return result as T;
 }
 
 /**
@@ -134,19 +168,30 @@ export function isAiFeatureEnabled(config: UserConfig) {
 }
 
 /**
- * Atom for storing the app config.
+ * The app config the page was served with, as the server wrote it.
+ *
+ * The host document carries the current one; this holds its place until
+ * that document arrives. It goes once every page carries its document.
  */
-export const appConfigAtom = atom<AppConfig>(parseAppConfig({}));
-
-/**
- * Returns the app config.
- */
-export function useAppConfig() {
-  return useAtom(appConfigAtom);
-}
-
-export function useSetAppConfig() {
-  return useSetAtom(appConfigAtom);
+export const pageAppConfigAtom = atom<unknown>({});
+
+/** The app config record in force, stable while its contents are. */
+const appConfigRecordAtom = selectAtom(
+  atom(
+    (get) =>
+      get(confirmedDocumentAtom)?.revision.app_config ?? get(pageAppConfigAtom),
+  ),
+  (record) => record,
+  dequal,
+);
+
+/** The notebook's app config, as the host document carries it. */
+export const appConfigAtom = atom((get) =>
+  parseAppConfig(get(appConfigRecordAtom)),
+);
+
+export function useAppConfig(): AppConfig {
+  return useAtomValue(appConfigAtom);
 }
 
 export function getAppConfig() {

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

@@ -8,7 +8,6 @@ import { getResolvedMarimoConfig } from "./config";
 export interface ExperimentalFeatures {
   markdown: boolean; // Used in playground (community cloud)
   wasm_layouts: boolean; // Used in playground (community cloud)
-  rtc_v2: boolean;
   cache_panel: boolean;
   external_agents: boolean;
   debugger: boolean; // Live frame-watching debugger (gutter breakpoints + pdb)
@@ -19,7 +18,6 @@ export interface ExperimentalFeatures {
 const defaultValues: ExperimentalFeatures = {
   markdown: true,
   wasm_layouts: false,
-  rtc_v2: false,
   cache_panel: import.meta.env.DEV,
   external_agents: import.meta.env.DEV,
   debugger: false,

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

@@ -4,7 +4,7 @@ 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";
+import { ConnectionState } from "@/core/session/types";
 import {
   fetchDataSourceDiscovery,
   invalidateDataSourceDiscovery,
@@ -185,8 +185,8 @@ describe("isDetectedSourceConnected", () => {
   });
   const emptySnapshot = {
     dialects: [] as string[],
-    storageProtocols: [] as string[],
-    storageBackendTypes: [] as string[],
+    storageProtocols: new Set<string>(),
+    storageBackendTypes: new Set<string>(),
   };
 
   it("does not hide a source when nothing is connected", () => {
@@ -242,7 +242,7 @@ describe("isDetectedSourceConnected", () => {
     expect(
       isDetectedSourceConnected(s3, {
         ...emptySnapshot,
-        storageProtocols: ["s3"],
+        storageProtocols: new Set(["s3"]),
       }),
     ).toBe(true);
   });
@@ -262,7 +262,7 @@ describe("isDetectedSourceConnected", () => {
     expect(
       isDetectedSourceConnected(hf, {
         ...emptySnapshot,
-        storageBackendTypes: ["huggingface"],
+        storageBackendTypes: new Set(["huggingface"]),
       }),
     ).toBe(true);
   });

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

@@ -27,8 +27,8 @@ export function matchesDiscoveryGroup(
  */
 export interface LiveConnectionSnapshot {
   dialects: readonly string[];
-  storageProtocols: readonly string[];
-  storageBackendTypes: readonly string[];
+  storageProtocols: ReadonlySet<string>;
+  storageBackendTypes: ReadonlySet<string>;
 }
 
 /**
@@ -47,15 +47,13 @@ export function isDetectedSourceConnected(
   }
 
   if (
-    match.protocols.some((protocol) =>
-      snapshot.storageProtocols.includes(protocol),
-    )
+    match.protocols.some((protocol) => snapshot.storageProtocols.has(protocol))
   ) {
     return true;
   }
 
   return match.backendTypes.some((backendType) =>
-    snapshot.storageBackendTypes.includes(backendType),
+    snapshot.storageBackendTypes.has(backendType),
   );
 }
 

package/src/core/documentation/doc-lookup.ts

@@ -17,7 +17,7 @@ export async function requestOutputDocumentation(
   qualifiedName: string,
 ): Promise<void> {
   // We need any valid cell_id for the completion request.
-  const cellId = getCells().inOrderIds.at(0);
+  const cellId = getCells().at(0);
   if (!cellId) {
     return;
   }

package/src/core/edit-app.tsx

@@ -5,8 +5,8 @@ import { Tooltip } from "radix-ui";
 
 const TooltipProvider = Tooltip.Provider;
 
-import { useAtomValue, useSetAtom } from "jotai";
-import { useEffect } from "react";
+import { useAtomValue } from "jotai";
+import { lazy, useEffect } from "react";
 import { NotStartedConnectionAlert } from "@/components/editor/alerts/connecting-alert";
 import { Controls } from "@/components/editor/controls/Controls";
 import { SandboxController } from "@/components/editor/chrome/panels/sandbox-controller";
@@ -27,23 +27,23 @@ import { useSetOutputsExpanded } from "../components/editor/actions/useSetOutput
 import { CellArray } from "../components/editor/renderers/cell-array";
 import { CellsRenderer } from "../components/editor/renderers/cells-renderer";
 import { useHotkey } from "../hooks/useHotkey";
-import {
-  hasCellsAtom,
-  notebookIsRunningAtom,
-  numColumnsAtom,
-  useCellActions,
-} from "./cells/cells";
+import { hasCellsAtom } from "./cells/cells";
+import { notebookIsRunningAtom } from "./executions";
+import { numColumnsAtom } from "./cells/layout";
+import { useCellActions } from "./cells/actions";
 import type { AppConfig, UserConfig } from "./config/config-schema";
 import { RuntimeState } from "./kernel/RuntimeState";
-import { getSessionId } from "./kernel/session";
 import { useTogglePresenting } from "./layout/useTogglePresenting";
 import { viewStateAtom } from "./mode";
 import { useRequestClient } from "./network/requests";
 import { useFilename } from "./saving/filename";
-import { lastSavedNotebookAtom } from "./saving/state";
-import { useNotebookSession } from "./websocket/useNotebookSession";
+import type { ConnectionStatus } from "./session/types";
+
+const LazyCommandPalette = lazy(
+  () => import("../components/editor/controls/command-palette"),
+);
 
-interface AppProps {
+export interface EditAppProps {
   /**
    * The user config.
    */
@@ -56,19 +56,24 @@ interface AppProps {
    * If true, the floating controls will be hidden.
    */
   hideControls?: boolean;
+  /** The session's connection, which the page owns with the document model. */
+  connection: ConnectionStatus;
+  reconnect: () => Promise<void>;
 }
 
-export const EditApp: React.FC<AppProps> = ({
+/** The notebook editor. Rendered inside the page's `DocumentProvider`. */
+export const EditApp: React.FC<EditAppProps> = ({
   userConfig,
   appConfig,
   hideControls = false,
+  connection,
+  reconnect,
 }) => {
-  const { setCells, mergeAllColumns, collapseAllCells, expandAllCells } =
+  const { mergeAllColumns, collapseAllCells, expandAllCells } =
     useCellActions();
   const viewState = useAtomValue(viewStateAtom);
   const numColumns = useAtomValue(numColumnsAtom);
   const filename = useFilename();
-  const setLastSavedNotebook = useSetAtom(lastSavedNotebookAtom);
   const { sendComponentValues, sendInterrupt } = useRequestClient();
 
   const isEditing = viewState.mode === "edit";
@@ -81,19 +86,7 @@ export const EditApp: React.FC<AppProps> = ({
     return () => {
       RuntimeState.INSTANCE.stop();
     };
-  }, []);
-
-  const { connection, reconnect } = useNotebookSession({
-    autoInstantiate: userConfig.runtime.auto_instantiate,
-    setCells: (cells, layout) => {
-      setCells(cells);
-      const names = cells.map((cell) => cell.name);
-      const codes = cells.map((cell) => cell.code);
-      const configs = cells.map((cell) => cell.config);
-      setLastSavedNotebook({ names, codes, configs, layout });
-    },
-    sessionId: getSessionId(),
-  });
+  }, [sendComponentValues]);
 
   // Update document title whenever filename or app_title changes
   useEffect(() => {
@@ -228,6 +221,7 @@ export const EditApp: React.FC<AppProps> = ({
           />
         </TooltipProvider>
       )}
+      <LazyCommandPalette />
     </>
   );
 };

package/src/core/errors/error-entries.ts

@@ -80,7 +80,7 @@ export function getCellErrorEntries(store: JotaiStore): CellErrorEntry[] {
   const { cellIds, cellRuntime, cellData } = store.get(notebookAtom);
   const entries: CellErrorEntry[] = [];
 
-  for (const [cellIndex, cellId] of cellIds.inOrderIds.entries()) {
+  for (const [cellIndex, cellId] of cellIds.entries()) {
     const cell = cellRuntime[cellId];
     const output = cell.output;
     if (!output || !isErrorMime(output.mimetype)) {
@@ -122,6 +122,9 @@ export function describeError(error: MarimoError): string {
   if (error.type === "import-star") {
     return error.msg;
   }
+  if (error.type === "lazy-import") {
+    return error.msg;
+  }
   if (error.type === "ancestor-stopped") {
     return error.msg;
   }

package/src/core/executions/__tests__/atoms.test.ts

@@ -0,0 +1,99 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { createStore } from "jotai";
+import { describe, expect, it } from "vitest";
+import { MockExecutions } from "@/__mocks__/executions";
+import { cellId } from "@/__tests__/branded";
+import type { CellMessage } from "@/core/kernel/messages";
+import {
+  cellExecutionInputsAtom,
+  notebookQueuedOrRunningCountAtom,
+  observeCellMessage,
+  submitCells,
+} from "../atoms";
+import { cellExecutionView } from "../select";
+
+const C1 = cellId("c1");
+
+function cellOp(status: CellMessage["status"]): CellMessage {
+  return {
+    cell_id: C1,
+    output: null,
+    console: null,
+    status,
+    stale_inputs: null,
+    timestamp: 1,
+  };
+}
+
+describe("observeCellMessage", () => {
+  it("withdraws a submission once the kernel reports the cell blocked", () => {
+    const store = createStore();
+    MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+    expect(
+      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
+    ).toBe("queued");
+
+    observeCellMessage(store, cellOp("disabled-transitively"));
+
+    const view = cellExecutionView(store.get(cellExecutionInputsAtom), C1);
+    expect(view.status).toBe("idle");
+    expect(view.blocked).toBe(true);
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+
+  it("forgets submissions and blocked cells with the replica they were made for", () => {
+    const store = createStore();
+    MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+    observeCellMessage(store, cellOp("disabled-transitively"));
+
+    MockExecutions.seed(store, []);
+
+    const view = cellExecutionView(store.get(cellExecutionInputsAtom), C1);
+    expect(view.status).toBe("idle");
+    expect(view.blocked).toBe(false);
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+
+  it("keeps a submission while the cell is merely queued", () => {
+    const store = createStore();
+    MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+
+    observeCellMessage(store, cellOp("queued"));
+
+    expect(
+      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
+    ).toBe("queued");
+  });
+
+  it("forgets acknowledged submissions and blocked cells when the replica follows a new notebook", () => {
+    const store = createStore();
+    const replica = MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+    observeCellMessage(store, {
+      ...cellOp("disabled-transitively"),
+      cell_id: cellId("c2"),
+    });
+
+    const completed = MockExecutions.inputs([MockExecutions.completed(C1)]);
+    store.set(replica.executionsAtom, completed.executions);
+    store.set(replica.resultsAtom, completed.results);
+    expect(
+      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
+    ).toBe("idle");
+
+    const empty = MockExecutions.inputs([]);
+    store.set(replica.executionsAtom, empty.executions);
+    store.set(replica.resultsAtom, empty.results);
+    store.set(replica.notebookAtom, {
+      ...store.get(replica.notebookAtom),
+      id: "n2",
+    });
+
+    expect(store.get(cellExecutionInputsAtom)).toEqual(empty);
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+});