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

package/src/core/network/types.ts

@@ -80,6 +80,17 @@ export type SaveUserConfigurationRequest =
 export interface SetCellConfigRequest {
   configs: Record<CellId, Partial<CellConfig>>;
 }
+/**
+ * Client-side shape for creating a file/directory/notebook. The HTTP
+ * transport sends this as multipart/form-data; the WASM bridge base64-encodes
+ * `file` internally and crosses the JS<->Py boundary as JSON.
+ */
+export interface FileCreateInput {
+  path: string;
+  type: "file" | "directory" | "notebook";
+  name: string;
+  file?: Blob;
+}
 export type UpdateUIElementRequest = schemas["UpdateUIElementRequest"];
 export type ModelRequest = schemas["ModelRequest"];
 export type NotebookDocumentTransactionRequest =
@@ -165,7 +176,7 @@ export interface EditRequests {
   sendListFiles: (request: FileListRequest) => Promise<FileListResponse>;
   sendSearchFiles: (request: FileSearchRequest) => Promise<FileSearchResponse>;
   sendCreateFileOrFolder: (
-    request: FileCreateRequest,
+    request: FileCreateInput,
   ) => Promise<FileCreateResponse>;
   sendDeleteFileOrFolder: (
     request: FileDeleteRequest,

package/src/core/wasm/bridge.ts

@@ -3,6 +3,7 @@
 
 import { toast } from "@/components/ui/use-toast";
 import { userConfigAtom } from "@/core/config/config";
+import { serializeBlob } from "@/utils/blob";
 import { Deferred } from "@/utils/Deferred";
 import { throwNotImplemented } from "@/utils/functions";
 import { Logger } from "@/utils/Logger";
@@ -431,9 +432,21 @@ export class PyodideBridge implements RunRequests, EditRequests {
   sendCreateFileOrFolder: EditRequests["sendCreateFileOrFolder"] = async (
     request,
   ) => {
+    // The WASM RPC boundary can only carry JSON, so we base64-encode the
+    // file bytes here. The HTTP transport uses multipart/form-data instead.
+    let contents: string | null = null;
+    if (request.file) {
+      const dataUrl = await serializeBlob(request.file);
+      contents = dataUrl.split(",")[1] ?? "";
+    }
     const response = await this.rpc.proxy.request.bridge({
       functionName: "create_file_or_directory",
-      payload: request,
+      payload: {
+        path: request.path,
+        type: request.type,
+        name: request.name,
+        contents,
+      },
     });
     return response as FileCreateResponse;
   };

package/src/plugins/impl/vega/resolve-data.ts

@@ -1,6 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { asRemoteURL } from "@/core/runtime/config";
+import { Semaphore } from "@/utils/semaphore";
 import { vegaLoadData } from "./loader";
 import type {
   FacetedUnitSpec,
@@ -17,6 +18,8 @@ type AnySpec =
   | UnitSpec<Field>
   | GenericFacetSpec<FacetedUnitSpec<Field>, LayerSpec<Field>, Field>;
 
+const VEGA_DATA_FETCH_CONCURRENCY = 5;
+
 /**
  * Given a VegaLite spec with URL data, resolve the data and return a new spec with the resolved data.
  *
@@ -30,6 +33,9 @@ export async function resolveVegaSpecData(
   }
 
   const datasets = "datasets" in spec ? { ...spec.datasets } : {};
+  // Single semaphore shared across the whole spec so total in-flight fetches
+  // (across all nested layers/hconcat/vconcat) stay bounded.
+  const fetchSem = new Semaphore(VEGA_DATA_FETCH_CONCURRENCY);
 
   const traverse = async <T extends AnySpec>(spec: T): Promise<T> => {
     if (!spec) {
@@ -80,7 +86,8 @@ export async function resolveVegaSpecData(
     } catch {
       return spec;
     }
-    const data = await vegaLoadData(url.href, spec.data.format);
+    const format = spec.data.format;
+    const data = await fetchSem.run(() => vegaLoadData(url.href, format));
 
     datasets[url.pathname] = data;
 

package/src/utils/__tests__/semaphore.test.ts

@@ -0,0 +1,218 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import { Deferred } from "../Deferred";
+import { mapWithConcurrency, Semaphore } from "../semaphore";
+
+describe("Semaphore", () => {
+  it("rejects invalid permit counts", () => {
+    expect(() => new Semaphore(0)).toThrow();
+    expect(() => new Semaphore(-1)).toThrow();
+    expect(() => new Semaphore(1.5)).toThrow();
+  });
+
+  it("resolves run() with the function's value", async () => {
+    const sem = new Semaphore(1);
+    await expect(sem.run(async () => 42)).resolves.toBe(42);
+    expect(sem.available).toBe(1);
+    expect(sem.pending).toBe(0);
+  });
+
+  it("releases the permit when run() rejects", async () => {
+    const sem = new Semaphore(1);
+    await expect(
+      sem.run(async () => {
+        throw new Error("boom");
+      }),
+    ).rejects.toThrow("boom");
+    expect(sem.available).toBe(1);
+  });
+
+  it("caps concurrent in-flight tasks at `permits`", async () => {
+    const sem = new Semaphore(3);
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const gates = Array.from({ length: 10 }, () => new Deferred<void>());
+
+    const tasks = gates.map((gate) =>
+      sem.run(async () => {
+        inFlight++;
+        maxInFlight = Math.max(maxInFlight, inFlight);
+        await gate.promise;
+        inFlight--;
+      }),
+    );
+
+    // Let microtasks run so the first batch is scheduled.
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(maxInFlight).toBe(3);
+    expect(sem.available).toBe(0);
+    expect(sem.pending).toBe(7);
+
+    // Release them all and confirm everyone finishes.
+    for (const gate of gates) {
+      gate.resolve();
+    }
+    await Promise.all(tasks);
+    expect(maxInFlight).toBe(3);
+    expect(sem.available).toBe(3);
+    expect(sem.pending).toBe(0);
+  });
+
+  it("releases waiters in FIFO order", async () => {
+    const sem = new Semaphore(1);
+    const order: number[] = [];
+    const hold = new Deferred<void>();
+
+    // First holder takes the only permit and parks on `hold`.
+    const first = sem.run(async () => {
+      order.push(0);
+      await hold.promise;
+    });
+
+    // Queue three more in known order.
+    const rest = [1, 2, 3].map((i) =>
+      sem.run(async () => {
+        order.push(i);
+      }),
+    );
+
+    await Promise.resolve();
+    expect(order).toEqual([0]);
+    expect(sem.pending).toBe(3);
+
+    hold.resolve();
+    await Promise.all([first, ...rest]);
+    expect(order).toEqual([0, 1, 2, 3]);
+  });
+
+  it("throws on release() beyond initial permit count", () => {
+    const sem = new Semaphore(2);
+    expect(() => sem.release()).toThrow(/more times than acquire/);
+  });
+
+  it("supports manual acquire/release", async () => {
+    const sem = new Semaphore(2);
+    await sem.acquire();
+    await sem.acquire();
+    expect(sem.available).toBe(0);
+
+    let resolved = false;
+    const waiter = sem.acquire().then(() => {
+      resolved = true;
+    });
+    await Promise.resolve();
+    expect(resolved).toBe(false);
+
+    sem.release();
+    await waiter;
+    expect(resolved).toBe(true);
+
+    sem.release();
+    sem.release();
+    expect(sem.available).toBe(2);
+  });
+});
+
+describe("mapWithConcurrency", () => {
+  it("returns [] for empty input without invoking fn", async () => {
+    let called = 0;
+    const result = await mapWithConcurrency([], 5, async () => {
+      called++;
+      return 1;
+    });
+    expect(result).toEqual([]);
+    expect(called).toBe(0);
+  });
+
+  it("preserves input order in the result", async () => {
+    const input = [10, 20, 30, 40, 50];
+    const result = await mapWithConcurrency(input, 2, async (n) => {
+      // Reverse the natural completion order so we'd notice if order broke.
+      await new Promise((r) => setTimeout(r, input.length - input.indexOf(n)));
+      return n * 2;
+    });
+    expect(result).toEqual([20, 40, 60, 80, 100]);
+  });
+
+  it("respects the concurrency cap", async () => {
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const items = Array.from({ length: 20 }, (_, i) => i);
+    const gates = items.map(() => new Deferred<void>());
+
+    const result = mapWithConcurrency(items, 4, async (i) => {
+      inFlight++;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      await gates[i].promise;
+      inFlight--;
+      return i;
+    });
+
+    // Flush microtasks so the first batch enters fn().
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(maxInFlight).toBe(4);
+
+    // Releasing one gate should let exactly one queued task enter fn().
+    for (const gate of gates) {
+      gate.resolve();
+    }
+    await result;
+    expect(maxInFlight).toBe(4);
+  });
+
+  it("lets in-flight tasks complete after the first rejection", async () => {
+    const completed: number[] = [];
+    const gates = [0, 1, 2, 3, 4].map(() => new Deferred<void>());
+
+    const result = mapWithConcurrency([0, 1, 2, 3, 4], 5, async (i) => {
+      await gates[i].promise;
+      if (i === 0) {
+        throw new Error("first failed");
+      }
+      completed.push(i);
+      return i;
+    });
+
+    // Reject the first one; the other 4 are still gated.
+    gates[0].resolve();
+    // Drain the rejection (catch so it doesn't escape the test).
+    await expect(result).rejects.toThrow("first failed");
+
+    // The other tasks were already in-flight when the rejection happened;
+    // they should still resolve when their gates open.
+    for (let i = 1; i < gates.length; i++) {
+      gates[i].resolve();
+    }
+    // Yield so the remaining sem.run() finallys run.
+    await new Promise((r) => setTimeout(r, 0));
+    expect(completed.toSorted()).toEqual([1, 2, 3, 4]);
+  });
+
+  it("rejects on the first error", async () => {
+    await expect(
+      mapWithConcurrency([1, 2, 3], 2, async (n) => {
+        if (n === 2) {
+          throw new Error("nope");
+        }
+        return n;
+      }),
+    ).rejects.toThrow("nope");
+  });
+
+  it("throws on invalid concurrency, even for empty input", () => {
+    expect(() => mapWithConcurrency([1, 2, 3], 0, async (n) => n)).toThrow();
+    expect(() => mapWithConcurrency([], 0, async (n: number) => n)).toThrow();
+  });
+
+  it("passes the index to fn", async () => {
+    const result = await mapWithConcurrency(
+      ["a", "b", "c"],
+      2,
+      async (item, index) => `${index}:${item}`,
+    );
+    expect(result).toEqual(["0:a", "1:b", "2:c"]);
+  });
+});

package/src/utils/fileToBase64.ts

@@ -1,5 +1,9 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import { mapWithConcurrency } from "./semaphore";
+
+const FILE_READ_CONCURRENCY = 5;
+
 /**
  * Converts a Blob or File to either a base64-encoded string or a data URL.
  *
@@ -35,11 +39,8 @@ export function blobToString(
  * Returns a promised array of tuples [file name, file contents].
  */
 export function filesToBase64(files: File[]): Promise<[string, string][]> {
-  return Promise.all(
-    files.map((file) =>
-      blobToString(file, "base64").then(
-        (contents) => [file.name, contents] as [string, string],
-      ),
-    ),
-  );
+  return mapWithConcurrency(files, FILE_READ_CONCURRENCY, async (file) => {
+    const contents = await blobToString(file, "base64");
+    return [file.name, contents] as [string, string];
+  });
 }

package/src/utils/semaphore.ts

@@ -0,0 +1,88 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+/**
+ * Counting semaphore that gates async work to at most `permits` in-flight
+ * tasks. Waiters are released in FIFO order.
+ */
+export class Semaphore {
+  private readonly maxPermits: number;
+  private permits: number;
+  private waiters: Array<() => void> = [];
+
+  constructor(permits: number) {
+    if (!Number.isInteger(permits) || permits < 1) {
+      throw new Error(
+        `Semaphore permits must be a positive integer, got ${permits}`,
+      );
+    }
+    this.maxPermits = permits;
+    this.permits = permits;
+  }
+
+  /** Permits currently available. */
+  get available(): number {
+    return this.permits;
+  }
+
+  /** Number of waiters queued for a permit. */
+  get pending(): number {
+    return this.waiters.length;
+  }
+
+  acquire(): Promise<void> {
+    if (this.permits > 0) {
+      this.permits--;
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+
+  release(): void {
+    const next = this.waiters.shift();
+    if (next) {
+      next();
+      return;
+    }
+    if (this.permits >= this.maxPermits) {
+      throw new Error(
+        "Semaphore.release() called more times than acquire() — refusing to exceed initial permit count",
+      );
+    }
+    this.permits++;
+  }
+
+  /** Acquire a permit, run `fn`, then release the permit. */
+  async run<T>(fn: () => Promise<T>): Promise<T> {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+}
+
+/**
+ * Map over `items` with bounded parallelism. Preserves input order in the
+ * result. Rejects as soon as the first task rejects (like `Promise.all`);
+ * already-started tasks keep running to completion in the background but
+ * their results are dropped.
+ */
+// oxlint-disable-next-line marimo/prefer-object-params -- map-style helper, mirrors Array.prototype.map
+export function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  // Validate concurrency before the empty-input fast path so misconfiguration
+  // is never silently accepted.
+  const sem = new Semaphore(concurrency);
+  if (items.length === 0) {
+    return Promise.resolve([]);
+  }
+  return Promise.all(
+    items.map((item, index) => sem.run(() => fn(item, index))),
+  );
+}

package/dist/apl-BKoVld9y.js

@@ -1,4 +0,0 @@
-import { t as apl } from "./apl-Dt8GMXYg.js";
-export {
-  apl
-};

package/dist/asciiarmor-DQrKIjoo.js

@@ -1,4 +0,0 @@
-import { t as asciiArmor } from "./asciiarmor-CitDQ85h.js";
-export {
-  asciiArmor
-};

package/dist/asn1-BZvnj0dq.js

@@ -1,4 +0,0 @@
-import { t as asn1 } from "./asn1-abrf9SMK.js";
-export {
-  asn1
-};

package/dist/brainfuck-D558nlUv.js

@@ -1,4 +0,0 @@
-import { t as brainfuck } from "./brainfuck-BL-Boof0.js";
-export {
-  brainfuck
-};

package/dist/classDiagram-2ON5EDUG-CBHMR6ZU.js

@@ -1,30 +0,0 @@
-import "./purify.es-DT70lfR0.js";
-import "./chunk-S3R3BYOJ-DphMP0FA.js";
-import { r as __name } from "./src-BY0BGg6V.js";
-import "./chunk-ABZYJK2D-BrBb_0yY.js";
-import "./chunk-HN2XXSSU-2Vfbq-kU.js";
-import "./chunk-CVBHYZKI-B6xhgaBd.js";
-import "./chunk-ATLVNIR6-D-0XqNah.js";
-import "./dist-C89sHDXk.js";
-import "./chunk-JA3XYJ7Z-6wbaigKe.js";
-import "./chunk-JZLCHNYA-_rfptlUP.js";
-import "./chunk-QXUST7PY-BDG0-0Or.js";
-import "./chunk-N4CR4FBY-DIZG9dVD.js";
-import "./chunk-FMBD7UC4-CHdus51S.js";
-import "./chunk-55IACEB6-D8THf2mi.js";
-import "./chunk-QN33PNHL-Cc64y40m.js";
-import { i as styles_default, n as classDiagram_default, r as classRenderer_v3_unified_default, t as ClassDB } from "./chunk-B4BG7PRW-8iRKvugR.js";
-var diagram = {
-  parser: classDiagram_default,
-  get db() {
-    return new ClassDB();
-  },
-  renderer: classRenderer_v3_unified_default,
-  styles: styles_default,
-  init: /* @__PURE__ */ __name((e) => {
-    e.class || (e.class = {}), e.class.arrowMarkerAbsolute = e.arrowMarkerAbsolute;
-  }, "init")
-};
-export {
-  diagram
-};

package/dist/classDiagram-v2-WZHVMYZB-BsUtUGM_.js

@@ -1,30 +0,0 @@
-import "./purify.es-DT70lfR0.js";
-import "./chunk-S3R3BYOJ-DphMP0FA.js";
-import { r as __name } from "./src-BY0BGg6V.js";
-import "./chunk-ABZYJK2D-BrBb_0yY.js";
-import "./chunk-HN2XXSSU-2Vfbq-kU.js";
-import "./chunk-CVBHYZKI-B6xhgaBd.js";
-import "./chunk-ATLVNIR6-D-0XqNah.js";
-import "./dist-C89sHDXk.js";
-import "./chunk-JA3XYJ7Z-6wbaigKe.js";
-import "./chunk-JZLCHNYA-_rfptlUP.js";
-import "./chunk-QXUST7PY-BDG0-0Or.js";
-import "./chunk-N4CR4FBY-DIZG9dVD.js";
-import "./chunk-FMBD7UC4-CHdus51S.js";
-import "./chunk-55IACEB6-D8THf2mi.js";
-import "./chunk-QN33PNHL-Cc64y40m.js";
-import { i as styles_default, n as classDiagram_default, r as classRenderer_v3_unified_default, t as ClassDB } from "./chunk-B4BG7PRW-8iRKvugR.js";
-var diagram = {
-  parser: classDiagram_default,
-  get db() {
-    return new ClassDB();
-  },
-  renderer: classRenderer_v3_unified_default,
-  styles: styles_default,
-  init: /* @__PURE__ */ __name((e) => {
-    e.class || (e.class = {}), e.class.arrowMarkerAbsolute = e.arrowMarkerAbsolute;
-  }, "init")
-};
-export {
-  diagram
-};

package/dist/clojure-Cq8mTSrE.js

@@ -1,4 +0,0 @@
-import { t as clojure } from "./clojure-DaojKHow.js";
-export {
-  clojure
-};

package/dist/cmake-D8HCovWK.js

@@ -1,4 +0,0 @@
-import { t as cmake } from "./cmake-DN-_v0XE.js";
-export {
-  cmake
-};

package/dist/cobol-UolN-9iU.js

@@ -1,4 +0,0 @@
-import { t as cobol } from "./cobol-C3VpMyux.js";
-export {
-  cobol
-};

package/dist/coffeescript-VdNuWrt5.js

@@ -1,4 +0,0 @@
-import { t as coffeeScript } from "./coffeescript-DIkz3Tbt.js";
-export {
-  coffeeScript
-};

package/dist/commonlisp-ALX7fpDc.js

@@ -1,4 +0,0 @@
-import { t as commonLisp } from "./commonlisp-CB1boOiP.js";
-export {
-  commonLisp
-};

package/dist/crystal-PbyO9Q_s.js

@@ -1,4 +0,0 @@
-import { t as crystal } from "./crystal-DI2oCml6.js";
-export {
-  crystal
-};

package/dist/css-DFklJkr_.js

@@ -1,4 +0,0 @@
-import { n as mkCSS, t as gss } from "./css-BdEVwQDV.js";
-export {
-  gss
-};

package/dist/cypher-BifNeYlv.js

@@ -1,4 +0,0 @@
-import { t as cypher } from "./cypher-BNHToqxU.js";
-export {
-  cypher
-};

package/dist/d-BA-JP4PJ.js

@@ -1,4 +0,0 @@
-import { t as d } from "./d-D7we7I1b.js";
-export {
-  d
-};

package/dist/diff-CtkDpav4.js

@@ -1,4 +0,0 @@
-import { t as diff } from "./diff-Cia6fzjN.js";
-export {
-  diff
-};

package/dist/dist-BuBwsFva.js

@@ -1,5 +0,0 @@
-import "./dist-CCADb07R.js";
-import { n as wastLanguage, t as wast } from "./dist-C9fmTOin.js";
-export {
-  wast
-};

package/dist/dist-BzmEQ9u7.js

@@ -1,5 +0,0 @@
-import "./dist-CCADb07R.js";
-import { n as yamlLanguage, t as yaml } from "./dist-Zn0KNbo9.js";
-export {
-  yaml
-};

package/dist/dist-Cih01ssx.js

@@ -1,5 +0,0 @@
-import "./dist-CCADb07R.js";
-import { n as jsonLanguage, t as json } from "./dist-BK-3fF4P.js";
-export {
-  json
-};

package/dist/dist-CqfONiY9.js

@@ -1,5 +0,0 @@
-import "./dist-CCADb07R.js";
-import { n as cppLanguage, t as cpp } from "./dist-HVuryI1a.js";
-export {
-  cpp
-};

package/dist/dist-D0iD0Fi9.js

@@ -1,5 +0,0 @@
-import "./dist-CCADb07R.js";
-import { n as javaLanguage, t as java } from "./dist-C-J0pt5p.js";
-export {
-  java
-};

package/dist/dist-DtNLXm8d.js

@@ -1,5 +0,0 @@
-import "./dist-CCADb07R.js";
-import { n as rustLanguage, t as rust } from "./dist-CinA9Enb.js";
-export {
-  rust
-};

package/dist/dtd-DW3_UFEG.js

@@ -1,4 +0,0 @@
-import { t as dtd } from "./dtd-H4Hubdwp.js";
-export {
-  dtd
-};

package/dist/dylan-pDhodO2N.js

@@ -1,4 +0,0 @@
-import { t as dylan } from "./dylan-fVO6rnq3.js";
-export {
-  dylan
-};

package/dist/ecl-BJT8-YD7.js

@@ -1,4 +0,0 @@
-import { t as ecl } from "./ecl-B94VPjNR.js";
-export {
-  ecl
-};

package/dist/eiffel-Dmns-9vS.js

@@ -1,4 +0,0 @@
-import { t as eiffel } from "./eiffel-C_R6TusS.js";
-export {
-  eiffel
-};

package/dist/elm-Da4sO4Bz.js

@@ -1,4 +0,0 @@
-import { t as elm } from "./elm-DzCHbO2g.js";
-export {
-  elm
-};

package/dist/erlang-C-zBsDi7.js

@@ -1,4 +0,0 @@
-import { t as erlang } from "./erlang-BGNkx6JU.js";
-export {
-  erlang
-};

package/dist/factor-4xPWlWB5.js

@@ -1,4 +0,0 @@
-import { t as factor } from "./factor-C2GT7jfQ.js";
-export {
-  factor
-};

package/dist/forth-l-c75zSd.js

@@ -1,4 +0,0 @@
-import { t as forth } from "./forth-Bybw0cJ7.js";
-export {
-  forth
-};

package/dist/fortran-DIujSODW.js

@@ -1,4 +0,0 @@
-import { t as fortran } from "./fortran-C6PoCLkI.js";
-export {
-  fortran
-};