@marimo-team/islands 0.23.3-dev44 → 0.23.3-dev48

package/package.json

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

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

@@ -18,6 +18,7 @@ import { memo, useState } from "react";
 import type { OutputMessage } from "@/core/kernel/messages";
 import { cn } from "@/utils/cn";
 import { copyToClipboard } from "@/utils/copy";
+import { jsonParseWithSpecialChar } from "@/utils/json/json-parser";
 import { isUrl } from "@/utils/urls";
 import { useTheme } from "../../../theme/useTheme";
 import { logNever } from "../../../utils/assertNever";
@@ -386,14 +387,41 @@ function renderLeaf(leaf: string, render: LeafRenderer): React.ReactNode {
 // See `_key_formatter` in marimo/_output/formatters/structures.py.
 const KEY_ENCODED_PREFIX = "text/plain+";
 
+// Format elements for a Python collection literal. Non-finite floats
+// (NaN / Infinity / -Infinity) parse as JS `number` via
+// `jsonParseWithSpecialChar`; `JSON.stringify` on those returns `null`,
+// so render them as the same `float(...)` literals we use for scalar
+// float keys (see `decodeKeyForCopy`).
+function formatCollectionItems(items: unknown[]): string {
+  return items
+    .map((x) => {
+      if (typeof x === "number" && !Number.isFinite(x)) {
+        if (Number.isNaN(x)) {
+          return "float('nan')";
+        }
+        return x > 0 ? "float('inf')" : "-float('inf')";
+      }
+      return JSON.stringify(x);
+    })
+    .join(", ");
+}
+
 // Format a JSON-list payload as a Python tuple literal. 1-element tuples
 // need a trailing comma — `(1)` is just `1` in Python, `(1,)` is the tuple.
+// Uses `jsonParseWithSpecialChar` so bare `NaN`/`Infinity`/`-Infinity`
+// emitted by Python's json.dumps round-trip cleanly.
 function formatTuplePayload(jsonList: string): string {
-  const items = JSON.parse(jsonList) as unknown[];
-  const inner = items.map((x) => JSON.stringify(x)).join(", ");
+  const items = jsonParseWithSpecialChar<unknown[]>(jsonList);
+  // `jsonParseWithSpecialChar` returns `{}` when both parse passes fail;
+  // fall back to the raw payload so a malformed wire form doesn't crash
+  // rendering/copy. Matches the defensive pattern in `formatSetPayload`.
+  if (!Array.isArray(items)) {
+    return jsonList;
+  }
   if (items.length === 0) {
     return "()";
   }
+  const inner = formatCollectionItems(items);
   if (items.length === 1) {
     return `(${inner},)`;
   }
@@ -403,29 +431,31 @@ function formatTuplePayload(jsonList: string): string {
 // Format a JSON-list payload as a Python frozenset literal. Empty → `frozenset()`
 // rather than `frozenset({})` (which reads like a dict).
 function formatFrozensetPayload(jsonList: string): string {
-  const items = JSON.parse(jsonList) as unknown[];
+  const items = jsonParseWithSpecialChar<unknown[]>(jsonList);
+  if (!Array.isArray(items)) {
+    return jsonList;
+  }
   if (items.length === 0) {
     return "frozenset()";
   }
-  const inner = items.map((x) => JSON.stringify(x)).join(", ");
+  const inner = formatCollectionItems(items);
   return `frozenset({${inner}})`;
 }
 
 // Format a JSON-list payload as a Python set literal. Empty → `set()`
 // (not `{}`, which is a dict literal in Python).
 function formatSetPayload(jsonList: string): string {
-  try {
-    const items = JSON.parse(jsonList) as unknown[];
-    if (items.length === 0) {
-      return "set()";
-    }
-    const inner = items.map((x) => JSON.stringify(x)).join(", ");
-    return `{${inner}}`;
-  } catch {
+  const items = jsonParseWithSpecialChar<unknown[]>(jsonList);
+  if (!Array.isArray(items)) {
     // Back-compat: older wire form was `text/plain+set:{1, 2, 3}` (Python
     // set-literal string, not JSON). Pass it through as-is rather than crash.
     return jsonList;
   }
+  if (items.length === 0) {
+    return "set()";
+  }
+  const inner = formatCollectionItems(items);
+  return `{${inner}}`;
 }
 
 // Renderers for decoded non-string keys. Visual affordances match Python:

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

@@ -417,6 +417,44 @@ describe("getCopyValue with encoded non-string keys", () => {
     `);
   });
 
+  it("parses tuple/frozenset payloads containing bare NaN/Infinity", () => {
+    // Python's json.dumps emits bare `NaN`/`Infinity` inside the embedded
+    // tuple/frozenset payload strings (JSON spec violation, but ECMA-262-
+    // friendly via the fallback in jsonParseWithSpecialChar). The outer
+    // JSON stays strict because those tokens live inside a JSON string
+    // key/value. Regression for tuple-key payloads that previously broke
+    // the frontend's `JSON.parse` and threw.
+    const value = {
+      "text/plain+tuple:[NaN]": "tn",
+      "text/plain+tuple:[Infinity, -Infinity]": "ti",
+      k: "text/plain+frozenset:[Infinity, 1]",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        (float('nan'),): "tn",
+        (float('inf'), -float('inf')): "ti",
+        "k": frozenset({float('inf'), 1})
+      }"
+    `);
+  });
+
+  it("falls back to the raw payload for malformed tuple/frozenset", () => {
+    // `jsonParseWithSpecialChar` returns `{}` on parse failure rather
+    // than throwing; without an `Array.isArray` guard, the formatters
+    // would crash on `.length`/`.map`. Pass the raw payload through so
+    // a malformed wire form doesn't break the whole render.
+    const value = {
+      "text/plain+tuple:not a json list": "t",
+      k: "text/plain+frozenset:also broken",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        not a json list: "t",
+        "k": also broken
+      }"
+    `);
+  });
+
   it("unescapes string keys that looked encoded", () => {
     const value = {
       "text/plain+str:text/plain+int:2": "hello",

package/src/components/editor/renderers/slides-layout/__tests__/compute-slide-cells.test.ts

@@ -0,0 +1,150 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, it, expect } from "vitest";
+import { computeSlideCellsInfo } from "../compute-slide-cells";
+import type { SlideConfig, SlidesLayout } from "../types";
+import type { CellId } from "@/core/cells/ids";
+
+interface TestCell {
+  id: CellId;
+  output: { data: unknown } | null;
+}
+
+const DEFAULT_OUTPUT: TestCell["output"] = { data: "ok" };
+
+const cell = (
+  id: string,
+  output: TestCell["output"] = DEFAULT_OUTPUT,
+): TestCell => ({ id: id as CellId, output });
+
+const layoutOf = (entries: Array<[string, SlideConfig]>): SlidesLayout => ({
+  cells: new Map(entries.map(([id, cfg]) => [id as CellId, cfg])),
+  deck: {},
+});
+
+describe("computeSlideCellsInfo", () => {
+  it("returns empty results for empty input", () => {
+    const result = computeSlideCellsInfo([], layoutOf([]));
+    expect(result.cellsWithOutput).toEqual([]);
+    expect(result.skippedIds.size).toBe(0);
+    expect(result.slideTypes.size).toBe(0);
+    expect(result.startCellIndex).toBe(0);
+  });
+
+  it("computes firstNonSkippedIndex as the first non-skipped cell", () => {
+    const result = computeSlideCellsInfo(
+      [cell("a"), cell("b"), cell("c")],
+      layoutOf([
+        ["a", { type: "skip" }],
+        ["b", { type: "skip" }],
+        ["c", { type: "slide" }],
+      ]),
+    );
+    expect(result.startCellIndex).toBe(2);
+  });
+
+  it("falls back to 0 when every cell is skipped", () => {
+    // If the user marked everything as skip we still have to land somewhere;
+    // the renderer treats 0 as a safe default rather than rendering nothing.
+    const result = computeSlideCellsInfo(
+      [cell("a"), cell("b")],
+      layoutOf([
+        ["a", { type: "skip" }],
+        ["b", { type: "skip" }],
+      ]),
+    );
+    expect(result.startCellIndex).toBe(0);
+  });
+
+  it("uses index 0 when no cells are skipped", () => {
+    const result = computeSlideCellsInfo([cell("a"), cell("b")], layoutOf([]));
+    expect(result.startCellIndex).toBe(0);
+  });
+
+  it("filters out cells with no output", () => {
+    const result = computeSlideCellsInfo(
+      [cell("a"), cell("b", null), cell("c")],
+      layoutOf([]),
+    );
+    expect(result.cellsWithOutput.map((c) => c.id)).toEqual(["a", "c"]);
+  });
+
+  it("filters out cells whose output data is empty string", () => {
+    // Mirrors the editor contract: an explicit empty-string payload means the
+    // cell rendered nothing, so it should not occupy a slide.
+    const result = computeSlideCellsInfo(
+      [cell("a"), cell("b", { data: "" }), cell("c")],
+      layoutOf([]),
+    );
+    expect(result.cellsWithOutput.map((c) => c.id)).toEqual(["a", "c"]);
+  });
+
+  it("keeps cells whose output data is a non-empty value (including falsy ones)", () => {
+    // Only "" is treated as empty — 0 / false / null-shaped payloads still
+    // represent rendered output and should stay in the deck.
+    const result = computeSlideCellsInfo(
+      [
+        cell("a", { data: 0 }),
+        cell("b", { data: false }),
+        cell("c", { data: null }),
+      ],
+      layoutOf([]),
+    );
+    expect(result.cellsWithOutput.map((c) => c.id)).toEqual(["a", "b", "c"]);
+  });
+
+  it("populates slideTypes only for cells with an explicit type", () => {
+    const result = computeSlideCellsInfo(
+      [cell("a"), cell("b"), cell("c")],
+      layoutOf([
+        ["a", { type: "slide" }],
+        ["b", {}],
+        ["c", { type: "fragment" }],
+      ]),
+    );
+    expect(Object.fromEntries(result.slideTypes)).toEqual({
+      a: "slide",
+      c: "fragment",
+    });
+  });
+
+  it("tracks skipped cells in skippedIds", () => {
+    const result = computeSlideCellsInfo(
+      [cell("a"), cell("b"), cell("c")],
+      layoutOf([
+        ["a", { type: "slide" }],
+        ["b", { type: "skip" }],
+        ["c", { type: "skip" }],
+      ]),
+    );
+    expect([...result.skippedIds]).toEqual(["b", "c"]);
+    // Skipped cells are still "visible" deck cells — they just aren't rendered
+    // in reveal. The minimap relies on the full list plus skippedIds.
+    expect(result.cellsWithOutput.map((c) => c.id)).toEqual(["a", "b", "c"]);
+    expect(result.slideTypes.get("b" as CellId)).toBe("skip");
+  });
+
+  it("ignores layout entries for cells that have no output", () => {
+    // If a cell was skipped in the layout but no longer produces output (e.g.
+    // the user deleted its code), it should drop out of both maps — otherwise
+    // the skip set would reference ghosts.
+    const result = computeSlideCellsInfo(
+      [cell("a"), cell("b", null)],
+      layoutOf([
+        ["a", { type: "slide" }],
+        ["b", { type: "skip" }],
+      ]),
+    );
+    expect(result.cellsWithOutput.map((c) => c.id)).toEqual(["a"]);
+    expect(result.skippedIds.size).toBe(0);
+    expect(result.slideTypes.has("b" as CellId)).toBe(false);
+  });
+
+  it("preserves the input order of cells in cellsWithOutput", () => {
+    const result = computeSlideCellsInfo(
+      [cell("c"), cell("a"), cell("b")],
+      layoutOf([]),
+    );
+    expect(result.cellsWithOutput.map((c) => c.id)).toEqual(["c", "a", "b"]);
+  });
+});

package/src/components/editor/renderers/slides-layout/__tests__/plugin.test.ts

@@ -0,0 +1,298 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, it, expect } from "vitest";
+import { SlidesLayoutPlugin } from "../plugin";
+import type { CellData } from "@/core/cells/types";
+import type { CellId } from "@/core/cells/ids";
+
+function makeCell(id: string, code = "print('hi')"): CellData {
+  return {
+    id: id as CellId,
+    name: id,
+    code,
+    edited: false,
+    lastCodeRun: null,
+    lastExecutionTime: null,
+    config: { hide_code: false, disabled: false, column: null },
+    serializedEditorState: null,
+  };
+}
+
+describe("SlidesLayoutPlugin validator", () => {
+  it("accepts the legacy empty-object shape written by older marimo versions", () => {
+    // Backwards compat: any slides file saved before we introduced `cells` /
+    // `deck` looks like `{}` on disk. It must still validate.
+    expect(SlidesLayoutPlugin.validator.safeParse({}).success).toBe(true);
+  });
+
+  it("accepts a fully populated layout", () => {
+    expect(
+      SlidesLayoutPlugin.validator.safeParse({
+        cells: [{ type: "slide" }, {}],
+        deck: { transition: "fade" },
+      }).success,
+    ).toBe(true);
+  });
+
+  it("rejects unknown slide types", () => {
+    expect(
+      SlidesLayoutPlugin.validator.safeParse({
+        cells: [{ type: "bogus" }],
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("SlidesLayoutPlugin deserializeLayout", () => {
+  it("returns an empty map when serialized.cells is missing", () => {
+    // Regression: previously accessed `serialized.cells.length` on undefined
+    // and threw, preventing the app from initializing.
+    const layout = SlidesLayoutPlugin.deserializeLayout({}, [makeCell("a")]);
+    expect(layout.cells.size).toBe(0);
+    expect(layout.deck).toEqual({});
+  });
+
+  it("tolerates missing deck", () => {
+    const layout = SlidesLayoutPlugin.deserializeLayout(
+      { cells: [{ type: "slide" }] },
+      [makeCell("a")],
+    );
+    expect(layout.deck).toEqual({});
+    expect(layout.cells.get("a" as CellId)).toEqual({ type: "slide" });
+  });
+
+  it("passes through every serialized entry by position (thin passthrough)", () => {
+    const layout = SlidesLayoutPlugin.deserializeLayout(
+      // Third entry carries an unknown key to prove the deserializer does not
+      // strip fields it does not recognize (forward-compat).
+      // oxlint-disable-next-line typescript/no-explicit-any
+      { cells: [{}, { type: "fragment" }, { notes: "x" } as any] },
+      [makeCell("a"), makeCell("b"), makeCell("c")],
+    );
+    expect([...layout.cells.keys()]).toEqual(["a", "b", "c"]);
+    expect(layout.cells.get("a" as CellId)).toEqual({});
+    expect(layout.cells.get("b" as CellId)).toEqual({ type: "fragment" });
+    expect(layout.cells.get("c" as CellId)).toEqual({ notes: "x" });
+  });
+});
+
+describe("SlidesLayoutPlugin serializeLayout", () => {
+  it("emits one entry per notebook cell (dense, positional)", () => {
+    // Even with no per-cell config, the output array must have one slot per
+    // notebook cell so positional alignment is preserved on reload.
+    const serialized = SlidesLayoutPlugin.serializeLayout(
+      { cells: new Map(), deck: {} },
+      [makeCell("a"), makeCell("b", "print(42)")],
+    );
+    expect(serialized.cells).toEqual([{}, {}]);
+    expect(serialized.deck).toEqual({});
+  });
+
+  it("passes user-set SlideConfig fields through unchanged", () => {
+    const cells = [makeCell("a"), makeCell("b"), makeCell("c")];
+    const serialized = SlidesLayoutPlugin.serializeLayout(
+      {
+        cells: new Map([["b" as CellId, { type: "fragment" }]]),
+        deck: {},
+      },
+      cells,
+    );
+    expect(serialized.cells).toHaveLength(3);
+    expect(serialized.cells?.[1]).toMatchObject({ type: "fragment" });
+  });
+
+  it("serializes deck config verbatim", () => {
+    const serialized = SlidesLayoutPlugin.serializeLayout(
+      { cells: new Map(), deck: { transition: "fade" } },
+      [makeCell("a")],
+    );
+    expect(serialized.deck).toEqual({ transition: "fade" });
+  });
+
+  it("passes through unknown SlideConfig fields (forward compat)", () => {
+    // When a future version adds a new SlideConfig field, serialize should
+    // not need updating. Exercise that by stuffing an arbitrary property
+    // into the in-memory config and checking it survives.
+    const cells = [makeCell("a")];
+    // oxlint-disable-next-line typescript/no-explicit-any
+    const futureConfig = { type: "slide", notes: "speaker notes" } as any;
+    const serialized = SlidesLayoutPlugin.serializeLayout(
+      { cells: new Map([["a" as CellId, futureConfig]]), deck: {} },
+      cells,
+    );
+    expect(serialized.cells?.[0]).toMatchObject({
+      type: "slide",
+      notes: "speaker notes",
+    });
+  });
+
+  it("round-trips user-set config through serialize + deserialize", () => {
+    const cells = [makeCell("a"), makeCell("b")];
+    const before = {
+      cells: new Map([["b" as CellId, { type: "fragment" as const }]]),
+      deck: { transition: "fade" as const },
+    };
+    const serialized = SlidesLayoutPlugin.serializeLayout(before, cells);
+    const after = SlidesLayoutPlugin.deserializeLayout(serialized, cells);
+    expect(after.deck).toEqual({ transition: "fade" });
+    expect(after.cells.get("b" as CellId)).toMatchObject({ type: "fragment" });
+  });
+});
+
+/**
+ * Frozen snapshots of every on-disk shape this plugin has ever had to parse.
+ *
+ * RULES FOR THIS BLOCK:
+ * - Never delete or modify an existing snapshot — users have `.slides.json`
+ *   files in these exact shapes sitting on their disks.
+ * - When the on-disk shape evolves, add a new snapshot here (with the release
+ *   / commit that introduced it) so we keep proving we can load the old ones.
+ * - If you need to change the serializer's output, add a snapshot of the new
+ *   shape to `serializedSnapshot` so a diff will surface the change in review.
+ *
+ * Every snapshot is required to:
+ *   1. pass the zod validator (today it is defined but not applied on load;
+ *      this guards against regressions once it is),
+ *   2. deserialize without throwing,
+ *   3. survive a deserialize → serialize → deserialize round trip without
+ *      throwing or losing any user-set field carried in the expectations.
+ */
+interface BackwardsCompatCase {
+  label: string;
+  input: unknown;
+  /**
+   * Expected state after deserializing `input` against `cells`. Only asserted
+   * properties need to be listed — extra properties are ignored.
+   */
+  expected: {
+    deck?: unknown;
+    cellIds: string[];
+    cellEntries?: Array<[string, unknown]>;
+  };
+}
+
+const BACKWARDS_COMPAT_SNAPSHOTS: BackwardsCompatCase[] = [
+  {
+    // Shape written by every marimo version before we added per-slide config.
+    label: "legacy bare {} (pre-slide-config)",
+    input: {},
+    expected: { deck: {}, cellIds: [] },
+  },
+  {
+    // Current serializer output as of this commit. If you change the
+    // serializer, add the new shape as an additional snapshot — don't edit
+    // this one.
+    label: "current: cells + deck",
+    input: {
+      cells: [{ type: "slide" }, {}, { type: "fragment" }],
+      deck: { transition: "slide" },
+    },
+    expected: {
+      deck: { transition: "slide" },
+      cellIds: ["a", "b", "c"],
+      cellEntries: [
+        ["a", { type: "slide" }],
+        ["c", { type: "fragment" }],
+      ],
+    },
+  },
+  {
+    // Defensive: if a future version adds a new SlideConfig field and a user
+    // downgrades, we must not crash on unknown keys.
+    label: "forward-compat: unknown SlideConfig fields present",
+    input: {
+      cells: [{ type: "slide", notes: "x", background: "#000" }],
+    },
+    expected: {
+      deck: {},
+      cellIds: ["a"],
+      cellEntries: [["a", { type: "slide" }]],
+    },
+  },
+];
+
+describe("SlidesLayoutPlugin backwards compatibility", () => {
+  it.each(BACKWARDS_COMPAT_SNAPSHOTS)(
+    "loads snapshot: $label",
+    ({ input, expected }) => {
+      const cells = expected.cellIds.map((id) => makeCell(id));
+
+      // 1. Validator must accept the shape.
+      const parsed = SlidesLayoutPlugin.validator.safeParse(input);
+      expect(
+        parsed.success,
+        `validator rejected: ${JSON.stringify(input)}`,
+      ).toBe(true);
+
+      // 2. Deserialize must succeed and reflect the user-set fields.
+      const layout = SlidesLayoutPlugin.deserializeLayout(
+        // Use the raw input (not the validator output) because that is what
+        // `deserializeLayout` actually receives in production today.
+        // oxlint-disable-next-line typescript/no-explicit-any
+        input as any,
+        cells,
+      );
+      if (expected.deck !== undefined) {
+        expect(layout.deck).toEqual(expected.deck);
+      }
+      for (const [cellId, expectedConfig] of expected.cellEntries ?? []) {
+        expect(layout.cells.get(cellId as CellId)).toMatchObject(
+          expectedConfig as object,
+        );
+      }
+
+      // 3. Round trip must not throw and must preserve the same user fields.
+      const reserialized = SlidesLayoutPlugin.serializeLayout(layout, cells);
+      expect(
+        SlidesLayoutPlugin.validator.safeParse(reserialized).success,
+        `serializer produced a shape that no longer validates: ${JSON.stringify(reserialized)}`,
+      ).toBe(true);
+      const redeserialized = SlidesLayoutPlugin.deserializeLayout(
+        reserialized,
+        cells,
+      );
+      for (const [cellId, expectedConfig] of expected.cellEntries ?? []) {
+        expect(redeserialized.cells.get(cellId as CellId)).toMatchObject(
+          expectedConfig as object,
+        );
+      }
+      if (expected.deck !== undefined) {
+        expect(redeserialized.deck).toEqual(expected.deck);
+      }
+    },
+  );
+
+  it("current serializer output is captured by an inline snapshot", () => {
+    // If this snapshot changes you are changing the on-disk shape. That is
+    // allowed, but:
+    //   1. Add the previous shape to BACKWARDS_COMPAT_SNAPSHOTS above so we
+    //      keep proving we can still load it.
+    //   2. Update this inline snapshot.
+    const cells = [makeCell("a", "print('hello')"), makeCell("b", "x = 1")];
+    const serialized = SlidesLayoutPlugin.serializeLayout(
+      {
+        cells: new Map([
+          ["a" as CellId, { type: "slide" }],
+          ["b" as CellId, { type: "fragment" }],
+        ]),
+        deck: { transition: "fade" },
+      },
+      cells,
+    );
+    expect(serialized).toMatchInlineSnapshot(`
+      {
+        "cells": [
+          {
+            "type": "slide",
+          },
+          {
+            "type": "fragment",
+          },
+        ],
+        "deck": {
+          "transition": "fade",
+        },
+      }
+    `);
+  });
+});

package/src/components/editor/renderers/slides-layout/compute-slide-cells.ts

@@ -0,0 +1,50 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { CellId } from "@/core/cells/ids";
+import type { SlideType, SlidesLayout } from "./types";
+
+export interface SlideCellLike {
+  id: CellId;
+  output: { data: unknown } | null;
+}
+
+export interface SlideCellsInfo<T extends SlideCellLike> {
+  cellsWithOutput: T[];
+  skippedIds: Set<CellId>;
+  slideTypes: Map<CellId, SlideType>;
+  // Index of the first cell in `cellsWithOutput` that is not skipped
+  startCellIndex: number;
+}
+
+export function computeSlideCellsInfo<T extends SlideCellLike>(
+  cells: readonly T[],
+  layout: Pick<SlidesLayout, "cells">,
+): SlideCellsInfo<T> {
+  const cellsWithOutput = cells.filter(
+    (cell) => cell.output != null && cell.output.data !== "",
+  );
+  const skippedIds = new Set<CellId>();
+  const slideTypes = new Map<CellId, SlideType>();
+
+  let startCell: T | null = null;
+  let startCellIndex = 0;
+
+  for (const [index, cell] of cellsWithOutput.entries()) {
+    const type = layout.cells.get(cell.id)?.type;
+    if (type) {
+      slideTypes.set(cell.id, type);
+    }
+    if (type === "skip") {
+      skippedIds.add(cell.id);
+    } else if (startCell === null) {
+      startCell = cell;
+      startCellIndex = index;
+    }
+  }
+  return {
+    cellsWithOutput,
+    skippedIds,
+    slideTypes,
+    startCellIndex,
+  };
+}