@marimo-team/frontend 0.23.3-dev3 → 0.23.3-dev32

package/src/components/editor/output/__tests__/JsonOutput-mimetype.test.tsx

@@ -39,4 +39,84 @@ describe("JsonOutput with enhanced mimetype handling", () => {
     expect(container).toBeInTheDocument();
     expect(container.querySelector(".marimo-json-output")).toBeInTheDocument();
   });
+
+  it("renders encoded non-string keys with Python-style affordances", () => {
+    // Server-side `_key_formatter` encodes non-string dict keys with
+    // mimetype prefixes; the frontend `keyRenderer` must decode them
+    // so users see the original Python types (unquoted ints, parens for
+    // tuples, etc.) instead of the raw encoded strings.
+    const data = {
+      "text/plain+int:2": "int_val",
+      "text/plain+float:2.5": "float_val",
+      "text/plain+bool:True": "bool_val",
+      "text/plain+none:": "none_val",
+      "text/plain+tuple:[1, 2]": "tuple_val",
+      "text/plain+frozenset:[3, 4]": "fs_val",
+      "text/plain+str:text/plain+int:2": "escaped_str_val",
+      plain: "unchanged",
+    };
+
+    const { container } = render(<JsonOutput data={data} format="tree" />);
+    const text = container.textContent ?? "";
+
+    // `text/plain+str:` is the escape prefix — must never survive in output.
+    expect(text).not.toContain("text/plain+str:");
+    // Other encoded prefixes must not leak as-is. (They can still appear
+    // inside the unescaped original string key `"text/plain+int:2"`,
+    // which is intentional — but not for types *other* than int.)
+    expect(text).not.toContain("text/plain+bool:True");
+    expect(text).not.toContain("text/plain+tuple:[");
+    expect(text).not.toContain("text/plain+frozenset:[");
+    expect(text).not.toContain("text/plain+none:");
+
+    // Decoded visual forms are present with Python-style affordances.
+    expect(text).toContain('None:"none_val"');
+    expect(text).toContain('True:"bool_val"');
+    expect(text).toContain('2:"int_val"');
+    expect(text).toContain('2.5:"float_val"');
+    expect(text).toContain('(1, 2):"tuple_val"');
+    expect(text).toContain('frozenset({3, 4}):"fs_val"');
+    // Escaped str key renders as the original literal string (quoted).
+    expect(text).toContain('"text/plain+int:2":"escaped_str_val"');
+    // Plain string key unchanged.
+    expect(text).toContain('"plain":"unchanged"');
+  });
+
+  it("renders 1-tuple and empty-frozenset keys with correct Python syntax", () => {
+    // Regressions caught in review: `(1)` is not a tuple (needs `(1,)`),
+    // and `frozenset({})` reads like constructing from an empty dict
+    // (should be `frozenset()`). Locks in the tree-view rendering so these
+    // don't slip back.
+    const data = {
+      "text/plain+tuple:[42]": "one_tuple",
+      "text/plain+tuple:[]": "empty_tuple",
+      "text/plain+frozenset:[]": "empty_fs",
+      "text/plain+frozenset:[1]": "one_fs",
+    };
+
+    const { container } = render(<JsonOutput data={data} format="tree" />);
+    const text = container.textContent ?? "";
+
+    expect(text).toContain('(42,):"one_tuple"'); // trailing comma
+    expect(text).toContain('():"empty_tuple"');
+    expect(text).toContain('frozenset():"empty_fs"'); // not `frozenset({})`
+    expect(text).toContain('frozenset({1}):"one_fs"');
+  });
+
+  it("quotes integer-like string keys to distinguish them from int keys", () => {
+    // Without this, `"2"` and the decoded int `2` look identical — the
+    // textea viewer drops quotes from integer-like string keys by default.
+    const data = {
+      "2": "string_two",
+      "text/plain+int:2": "int_two",
+    };
+
+    const { container } = render(<JsonOutput data={data} format="tree" />);
+    const text = container.textContent ?? "";
+
+    expect(text).toContain('"2":"string_two"'); // quoted
+    expect(text).toContain('2:"int_two"'); // unquoted
+    // Non-integer string keys still render without our intervention.
+    expect(text).not.toContain("text/plain+"); // prefix stripped from int key
+  });
 });

package/src/components/editor/output/__tests__/json-output.test.ts

@@ -174,7 +174,21 @@ describe("getCopyValue", () => {
   it("should handle sets", () => {
     const value = "text/plain+set:[1,2,3]";
     const result = getCopyValue(value);
-    expect(result).toMatchInlineSnapshot(`"{1,2,3}"`);
+    expect(result).toMatchInlineSnapshot(`"{1, 2, 3}"`);
+  });
+
+  it("should handle empty set", () => {
+    // Empty set literal in Python is `set()`, not `{}` (which is a dict).
+    expect(getCopyValue("text/plain+set:[]")).toMatchInlineSnapshot(`"set()"`);
+  });
+
+  it("should handle frozenset values", () => {
+    expect(getCopyValue("text/plain+frozenset:[1,2]")).toMatchInlineSnapshot(
+      `"frozenset({1, 2})"`,
+    );
+    expect(getCopyValue("text/plain+frozenset:[]")).toMatchInlineSnapshot(
+      `"frozenset()"`,
+    );
   });
 
   it("should handle sets in mixed types", () => {
@@ -188,7 +202,7 @@ describe("getCopyValue", () => {
       `
       "{
         "key1": 42,
-        "key2": {1,2,3},
+        "key2": {1, 2, 3},
         "key3": True
       }"
     `,
@@ -311,6 +325,137 @@ describe("determineMaxDisplayLength", () => {
   });
 });
 
+describe("getCopyValue with encoded non-string keys", () => {
+  // Keys are encoded by _key_formatter in
+  // marimo/_output/formatters/structures.py. Frontend must round-trip them
+  // to Python literals in the copy output.
+
+  it("decodes int keys unquoted", () => {
+    // JS reorders integer-like string keys to the front of object iteration
+    // (spec-mandated), so `"2"` appears before `"text/plain+int:2"` here.
+    // This is pre-existing and unrelated to the encoding — both entries
+    // survive, which is the regression this guards.
+    const value = { "text/plain+int:2": "no", "2": "oh" };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        "2": "oh",
+        2: "no"
+      }"
+    `);
+  });
+
+  it("decodes large int keys unquoted (no BigInt precision concern)", () => {
+    const value = { "text/plain+int:18446744073709551616": "v" };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        18446744073709551616: "v"
+      }"
+    `);
+  });
+
+  it("decodes float, bool, None, tuple, frozenset keys", () => {
+    const value = {
+      "text/plain+float:2.5": "f",
+      "text/plain+bool:True": "t",
+      "text/plain+bool:False": "b",
+      "text/plain+none:": "n",
+      "text/plain+tuple:[1, 2]": "tup",
+      "text/plain+frozenset:[3, 4]": "fs",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        2.5: "f",
+        True: "t",
+        False: "b",
+        None: "n",
+        (1, 2): "tup",
+        frozenset({3, 4}): "fs"
+      }"
+    `);
+  });
+
+  it("emits 1-element tuple keys with a trailing comma (Python syntax)", () => {
+    // `(1)` is just `1` in Python — a 1-tuple needs `(1,)`.
+    const value = {
+      "text/plain+tuple:[1]": "one",
+      "text/plain+tuple:[]": "empty",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        (1,): "one",
+        (): "empty"
+      }"
+    `);
+  });
+
+  it("emits empty frozenset keys as `frozenset()` not `frozenset({})`", () => {
+    // `frozenset({})` reads like it's constructing from an empty dict.
+    const value = {
+      "text/plain+frozenset:[]": "empty",
+      "text/plain+frozenset:[1]": "single",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        frozenset(): "empty",
+        frozenset({1}): "single"
+      }"
+    `);
+  });
+
+  it("decodes NaN/Inf float keys to valid Python literals", () => {
+    const value = {
+      "text/plain+float:nan": "n",
+      "text/plain+float:inf": "p",
+      "text/plain+float:-inf": "m",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        float('nan'): "n",
+        float('inf'): "p",
+        -float('inf'): "m"
+      }"
+    `);
+  });
+
+  it("unescapes string keys that looked encoded", () => {
+    const value = {
+      "text/plain+str:text/plain+int:2": "hello",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        "text/plain+int:2": "hello"
+      }"
+    `);
+  });
+
+  it("decodes keys at every nesting level", () => {
+    const value = {
+      outer: {
+        "text/plain+int:1": "inner",
+        "text/plain+tuple:[2, 3]": "tup",
+      },
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        "outer": {
+          1: "inner",
+          (2, 3): "tup"
+        }
+      }"
+    `);
+  });
+
+  it("leaves plain string keys untouched", () => {
+    const value = { foo: 1, bar: 2 };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        "foo": 1,
+        "bar": 2
+      }"
+    `);
+  });
+});
+
 describe("getCopyValue with application/ mimetypes", () => {
   it("should strip application/ mimetype prefix from leaf data", () => {
     expect(getCopyValue("application/json:{data}")).toBe('"{data}"');

package/src/components/home/state.ts

@@ -15,7 +15,19 @@ export const RunningNotebooksContext = React.createContext<{
   runningNotebooks: new Map(),
   setRunningNotebooks: Functions.NOOP,
 });
-export const WorkspaceRootContext = React.createContext<string>("");
+
+/**
+ * Context providing the workspace root plus a `refreshWorkspace` hook used by
+ * file actions (rename/duplicate/delete) so they can invalidate both the
+ * workspace tree and any sibling views (e.g. recent notebooks) in one call.
+ */
+export const WorkspaceContext = React.createContext<{
+  root: string;
+  refreshWorkspace: () => void;
+}>({
+  root: "",
+  refreshWorkspace: Functions.NOOP,
+});
 
 export const includeMarkdownAtom = atomWithStorage<boolean>(
   "marimo:home:include-markdown",

package/src/components/pages/home-page.tsx

@@ -14,7 +14,7 @@ import {
   SearchIcon,
 } from "lucide-react";
 import type React from "react";
-import { Suspense, use, useEffect, useRef, useState } from "react";
+import { Suspense, use, useEffect, useMemo, useRef, useState } from "react";
 import {
   type NodeApi,
   type NodeRendererProps,
@@ -22,16 +22,27 @@ import {
   type TreeApi,
 } from "react-arborist";
 import { useLocale } from "react-aria";
+import useEvent from "react-use-event-hook";
 import { MarkdownIcon } from "@/components/editor/cell/code/icons";
 import {
   FILE_ICON as FILE_TYPE_ICONS,
   type FileIconType as FileType,
   guessFileIconType as guessFileType,
 } from "@/components/editor/file-tree/file-icons";
+import { FileNameInput } from "@/components/editor/file-tree/file-name-input";
+import {
+  DeleteMenuItem,
+  DuplicateMenuItem,
+  FileActionsDropdown,
+  RenameMenuItem,
+  useFileOperations,
+  useNotebookFileActions,
+} from "@/components/editor/file-tree/file-operations";
 import { useImperativeModal } from "@/components/modal/ImperativeModal";
 import { AlertDialogDestructiveAction } from "@/components/ui/alert-dialog";
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
+import { DropdownMenuSeparator } from "@/components/ui/dropdown-menu";
 import { Label } from "@/components/ui/label";
 import { Tooltip } from "@/components/ui/tooltip";
 import { toast } from "@/components/ui/use-toast";
@@ -61,7 +72,7 @@ import {
   expandedFoldersAtom,
   includeMarkdownAtom,
   RunningNotebooksContext,
-  WorkspaceRootContext,
+  WorkspaceContext,
 } from "../home/state";
 import { Spinner } from "../icons/spinner";
 import { Input } from "../ui/input";
@@ -131,7 +142,7 @@ const HomePage: React.FC = () => {
             files={recents.files}
           />
           <ErrorBoundary>
-            <WorkspaceNotebooks />
+            <WorkspaceNotebooks onRefreshRecents={recentsResponse.refetch} />
           </ErrorBoundary>
         </div>
       </RunningNotebooksContext>
@@ -139,7 +150,9 @@ const HomePage: React.FC = () => {
   );
 };
 
-const WorkspaceNotebooks: React.FC = () => {
+const WorkspaceNotebooks: React.FC<{ onRefreshRecents: () => void }> = ({
+  onRefreshRecents,
+}) => {
   const { getWorkspaceFiles } = useRequestClient();
   const [includeMarkdown, setIncludeMarkdown] = useAtom(includeMarkdownAtom);
   const [searchText, setSearchText] = useState("");
@@ -154,6 +167,19 @@ const WorkspaceNotebooks: React.FC = () => {
     [includeMarkdown],
   );
 
+  // Fire-and-forget refresh of both the workspace tree and the "Recent
+  // notebooks" list — file mutations on the workspace tree can affect both,
+  // so we invalidate them together rather than having two refresh triggers.
+  const refreshWorkspace = useEvent(() => {
+    refetch();
+    onRefreshRecents();
+  });
+
+  const workspaceContextValue = useMemo(
+    () => ({ root: workspace?.root ?? "", refreshWorkspace }),
+    [workspace?.root, refreshWorkspace],
+  );
+
   if (isPending) {
     return <Spinner centered={true} size="xlarge" className="mt-6" />;
   }
@@ -167,7 +193,7 @@ const WorkspaceNotebooks: React.FC = () => {
   }
 
   return (
-    <WorkspaceRootContext value={workspace.root}>
+    <WorkspaceContext value={workspaceContextValue}>
       <div className="flex flex-col gap-2">
         {workspace.hasMore && (
           <Banner kind="warn" className="rounded p-4">
@@ -216,7 +242,7 @@ const WorkspaceNotebooks: React.FC = () => {
           <NotebookFileTree searchText={searchText} files={workspace.files} />
         </div>
       </div>
-    </WorkspaceRootContext>
+    </WorkspaceContext>
   );
 };
 
@@ -244,6 +270,8 @@ const NotebookFileTree: React.FC<{
   const [openState, setOpenState] = useAtom(expandedFoldersAtom);
   const openStateIsEmpty = Object.keys(openState).length === 0;
   const ref = useRef<TreeApi<FileInfo>>(undefined);
+  const { root, refreshWorkspace } = use(WorkspaceContext);
+  const { renameFile } = useFileOperations({ root });
 
   useEffect(() => {
     // If empty, collapse all
@@ -252,6 +280,21 @@ const NotebookFileTree: React.FC<{
     }
   }, [openStateIsEmpty]);
 
+  const handleRename = useEvent(async (id: string, name: string) => {
+    const node = ref.current?.get(id);
+    if (!node) {
+      toast({
+        title: "Failed",
+        description: `Node with id ${id} not found in the tree`,
+      });
+      return;
+    }
+    const result = await renameFile(node.data, name);
+    if (result) {
+      refreshWorkspace();
+    }
+  });
+
   if (files.length === 0) {
     return (
       <div className="flex flex-col px-5 py-10 items-center justify-center">
@@ -277,6 +320,9 @@ const NotebookFileTree: React.FC<{
         const prevOpen = openState[id] ?? false;
         setOpenState({ ...openState, [id]: !prevOpen });
       }}
+      onRename={async ({ id, name }) => {
+        await handleRename(id, name);
+      }}
       padding={5}
       rowHeight={35}
       indent={15}
@@ -286,7 +332,6 @@ const NotebookFileTree: React.FC<{
       // Disable interactions
       disableDrop={true}
       disableDrag={true}
-      disableEdit={true}
       disableMultiSelection={true}
     >
       {Node}
@@ -301,11 +346,24 @@ const Node = ({ node, style }: NodeRendererProps<FileInfo>) => {
 
   const Icon = FILE_TYPE_ICONS[fileType];
   const iconEl = <Icon className="w-5 h-5 shrink-0" strokeWidth={1.5} />;
-  const root = use(WorkspaceRootContext);
+  const { root } = use(WorkspaceContext);
+  const { runningNotebooks } = use(RunningNotebooksContext);
 
   const renderItem = () => {
     const itemClassName =
       "flex items-center pl-1 cursor-pointer hover:bg-accent/50 hover:text-accent-foreground rounded-l flex-1 overflow-hidden h-full pr-3 gap-2";
+
+    // Inline rename input; react-arborist flips `node.isEditing` when
+    // `node.edit()` is called from the FileActions menu.
+    if (node.isEditing) {
+      return (
+        <div className={itemClassName}>
+          {iconEl}
+          <FileNameInput node={node} />
+        </div>
+      );
+    }
+
     if (node.data.isDirectory) {
       return (
         <span className={itemClassName}>
@@ -322,6 +380,7 @@ const Node = ({ node, style }: NodeRendererProps<FileInfo>) => {
 
     const isMarkdown =
       relativePath.endsWith(".md") || relativePath.endsWith(".qmd");
+    const isRunning = runningNotebooks.has(relativePath);
 
     return (
       <a
@@ -334,10 +393,19 @@ const Node = ({ node, style }: NodeRendererProps<FileInfo>) => {
           {node.data.name}
           {isMarkdown && <MarkdownIcon className="ml-2 inline opacity-80" />}
         </span>
-        <SessionShutdownButton filePath={relativePath} />
+
+        <FileActions node={node} isRunning={isRunning} />
+        {/*
+          Trailing action slots. Using a fixed-width row here (rather than
+          conditionally rendered inline elements) keeps every row's right
+          edge aligned even though any individual slot may be empty.
+        */}
+        <div className="w-8 h-8 flex items-center justify-center shrink-0">
+          <SessionShutdownButton filePath={relativePath} />
+        </div>
         <ExternalLinkIcon
           size={20}
-          className="group-hover:opacity-100 opacity-0 text-primary"
+          className="group-hover:opacity-100 opacity-0 text-primary shrink-0"
         />
       </a>
     );
@@ -362,6 +430,44 @@ const Node = ({ node, style }: NodeRendererProps<FileInfo>) => {
   );
 };
 
+const FileActions = ({
+  node,
+  isRunning,
+}: {
+  node: NodeApi<FileInfo>;
+  isRunning: boolean;
+}) => {
+  const { root, refreshWorkspace } = use(WorkspaceContext);
+  const { handleRename, handleDuplicate, handleDelete } =
+    useNotebookFileActions({ node, root, onAfterChange: refreshWorkspace });
+
+  const lockedReason = isRunning
+    ? "Stop the notebook's kernel before renaming or deleting."
+    : undefined;
+
+  return (
+    <FileActionsDropdown
+      testId="workspace-more-button"
+      buttonClassName="w-8 h-8 p-0 shrink-0"
+      contentClassName="print:hidden w-fit min-w-[140px]"
+      preventDefaultOnTrigger={true}
+    >
+      <RenameMenuItem
+        onSelect={handleRename}
+        disabled={isRunning}
+        title={lockedReason}
+      />
+      <DuplicateMenuItem onSelect={handleDuplicate} />
+      <DropdownMenuSeparator />
+      <DeleteMenuItem
+        onSelect={handleDelete}
+        disabled={isRunning}
+        title={lockedReason}
+      />
+    </FileActionsDropdown>
+  );
+};
+
 const FolderArrow = ({ node }: { node: NodeApi<FileInfo> }) => {
   if (!node.data.isDirectory) {
     return <span className="w-5 h-5 shrink-0" />;

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

@@ -10,6 +10,14 @@ import {
 } from "@/__tests__/branded";
 
 type Base64String = components["schemas"]["Base64String"];
+interface TestIslandApp {
+  id: string;
+  cells: { code: string; idx: number; output: string }[];
+}
+interface TestExportContext {
+  trusted: true;
+  notebookCode?: string;
+}
 
 // Mock browser APIs before any imports
 vi.stubGlobal(
@@ -33,8 +41,23 @@ class MockURL {
 vi.stubGlobal("URL", MockURL);
 
 // Mock the worker RPC before importing the bridge
-const mockBridge = vi.fn();
-const mockLoadPackages = vi.fn();
+const {
+  mockBridge,
+  mockLoadPackages,
+  mockStartSessionRequest,
+  mockParseMarimoIslandApps,
+  mockCreateMarimoFile,
+  mockGetMarimoExportContext,
+} = vi.hoisted(() => ({
+  mockBridge: vi.fn(),
+  mockLoadPackages: vi.fn(),
+  mockStartSessionRequest: vi.fn(),
+  mockParseMarimoIslandApps: vi.fn<() => TestIslandApp[]>(() => []),
+  mockCreateMarimoFile: vi.fn(),
+  mockGetMarimoExportContext: vi.fn<() => TestExportContext | undefined>(
+    () => undefined,
+  ),
+}));
 
 vi.mock("@/core/wasm/rpc", () => ({
   getWorkerRPC: () => ({
@@ -42,7 +65,7 @@ vi.mock("@/core/wasm/rpc", () => ({
       request: {
         bridge: mockBridge,
         loadPackages: mockLoadPackages,
-        startSession: vi.fn(),
+        startSession: mockStartSessionRequest,
       },
       send: {
         consumerReady: vi.fn(),
@@ -54,8 +77,8 @@ vi.mock("@/core/wasm/rpc", () => ({
 
 // Mock the parse module to avoid DOM dependencies
 vi.mock("../parse", () => ({
-  parseMarimoIslandApps: () => [],
-  createMarimoFile: vi.fn(),
+  parseMarimoIslandApps: mockParseMarimoIslandApps,
+  createMarimoFile: mockCreateMarimoFile,
 }));
 
 // Mock uuid to have predictable tokens
@@ -63,6 +86,10 @@ vi.mock("@/utils/uuid", () => ({
   generateUUID: () => "test-uuid-12345",
 }));
 
+vi.mock("@/core/static/export-context", () => ({
+  getMarimoExportContext: mockGetMarimoExportContext,
+}));
+
 // Mock getMarimoVersion
 vi.mock("@/core/meta/globals", () => ({
   getMarimoVersion: () => "0.0.0-test",
@@ -71,6 +98,7 @@ vi.mock("@/core/meta/globals", () => ({
 // Mock the jotai store
 vi.mock("@/core/state/jotai", () => ({
   store: {
+    get: vi.fn(),
     set: vi.fn(),
   },
 }));
@@ -83,9 +111,92 @@ describe("IslandsPyodideBridge", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
+    mockParseMarimoIslandApps.mockReturnValue([]);
+    mockCreateMarimoFile.mockReset();
+    mockGetMarimoExportContext.mockReturnValue(undefined);
     bridge = new IslandsPyodideBridge({ autoStartSessions: false });
   });
 
+  describe("startSessionsForAllApps", () => {
+    it("should prefer trusted export notebook code when there is exactly one reactive app", async () => {
+      mockParseMarimoIslandApps.mockReturnValue([
+        {
+          id: "app-1",
+          cells: [{ code: "x = 1", idx: 0, output: "<div>1</div>" }],
+        },
+      ]);
+      mockGetMarimoExportContext.mockReturnValue({
+        trusted: true,
+        notebookCode:
+          "import marimo\napp = marimo.App()\n@app.cell\ndef __():\n    x = 1\n    return",
+      });
+
+      await (
+        bridge as unknown as { startSessionsForAllApps(): Promise<void> }
+      ).startSessionsForAllApps();
+
+      expect(mockCreateMarimoFile).not.toHaveBeenCalled();
+      expect(mockStartSessionRequest).toHaveBeenCalledWith({
+        appId: "app-1",
+        code: "import marimo\napp = marimo.App()\n@app.cell\ndef __():\n    x = 1\n    return",
+      });
+    });
+
+    it("should keep synthesized per-app files for multiple reactive apps even when export context exists", async () => {
+      mockParseMarimoIslandApps.mockReturnValue([
+        {
+          id: "app-1",
+          cells: [{ code: "x = 1", idx: 0, output: "<div>1</div>" }],
+        },
+        {
+          id: "app-2",
+          cells: [{ code: "y = 2", idx: 0, output: "<div>2</div>" }],
+        },
+      ]);
+      mockGetMarimoExportContext.mockReturnValue({
+        trusted: true,
+        notebookCode: "full notebook should be ignored",
+      });
+      mockCreateMarimoFile
+        .mockReturnValueOnce("generated app 1")
+        .mockReturnValueOnce("generated app 2");
+
+      await (
+        bridge as unknown as { startSessionsForAllApps(): Promise<void> }
+      ).startSessionsForAllApps();
+
+      expect(mockCreateMarimoFile).toHaveBeenCalledTimes(2);
+      expect(mockStartSessionRequest).toHaveBeenNthCalledWith(1, {
+        appId: "app-1",
+        code: "generated app 1",
+      });
+      expect(mockStartSessionRequest).toHaveBeenNthCalledWith(2, {
+        appId: "app-2",
+        code: "generated app 2",
+      });
+    });
+
+    it("should synthesize a file for a single app when no trusted export context is present", async () => {
+      mockParseMarimoIslandApps.mockReturnValue([
+        {
+          id: "app-1",
+          cells: [{ code: "x = 1", idx: 0, output: "<div>1</div>" }],
+        },
+      ]);
+      mockCreateMarimoFile.mockReturnValue("generated app 1");
+
+      await (
+        bridge as unknown as { startSessionsForAllApps(): Promise<void> }
+      ).startSessionsForAllApps();
+
+      expect(mockCreateMarimoFile).toHaveBeenCalledTimes(1);
+      expect(mockStartSessionRequest).toHaveBeenCalledWith({
+        appId: "app-1",
+        code: "generated app 1",
+      });
+    });
+  });
+
   describe("sendComponentValues", () => {
     it("should include type field and token in control request", async () => {
       const request = {