@marimo-team/frontend 0.19.8-dev3 → 0.19.8-dev31

package/src/core/static/__tests__/files.test.ts

@@ -6,7 +6,7 @@ import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 import { createLoader } from "@/plugins/impl/vega/vega-loader";
 import { Functions } from "@/utils/functions";
 import type { DataURLString } from "@/utils/json/base64";
-import { patchFetch, patchVegaLoader } from "../files";
+import { patchFetch, patchVegaLoader, resolveVirtualFileURL } from "../files";
 
 // Start a tiny server to serve virtual files
 const server = http.createServer((request, response) => {
@@ -350,6 +350,181 @@ describe("patchVegaLoader - loader.load", () => {
   });
 });
 
+describe("resolveVirtualFileURL", () => {
+  // Mock URL.createObjectURL for jsdom environment
+  const mockBlobURLs = new Map<string, Blob>();
+  let blobCounter = 0;
+
+  beforeAll(() => {
+    URL.createObjectURL = vi.fn((blob: Blob) => {
+      const url = `blob:test-${blobCounter++}`;
+      mockBlobURLs.set(url, blob);
+      return url;
+    });
+    URL.revokeObjectURL = vi.fn((url: string) => {
+      mockBlobURLs.delete(url);
+    });
+  });
+
+  afterAll(() => {
+    mockBlobURLs.clear();
+  });
+
+  it("should return a blob URL for virtual files", () => {
+    const virtualFiles = {
+      "/@file/widget.js":
+        "data:text/javascript;base64,ZXhwb3J0IGRlZmF1bHQgeyByZW5kZXI6ICgpID0+IHt9IH0=" as DataURLString,
+    };
+
+    const result = resolveVirtualFileURL("/@file/widget.js", virtualFiles);
+
+    expect(result).toMatch(/^blob:/);
+  });
+
+  it("should return the original URL for non-virtual files", () => {
+    const virtualFiles = {};
+
+    const result = resolveVirtualFileURL(
+      "http://example.com/widget.js",
+      virtualFiles,
+    );
+
+    expect(result).toBe("http://example.com/widget.js");
+  });
+
+  it("should handle various URL formats", () => {
+    const virtualFiles = {
+      "/@file/module.js":
+        "data:text/javascript;base64,Y29uc29sZS5sb2coJ3Rlc3QnKQ==" as DataURLString,
+    };
+
+    const testUrls = [
+      "/@file/module.js",
+      "./@file/module.js",
+      "http://example.com/@file/module.js",
+    ];
+
+    for (const url of testUrls) {
+      const result = resolveVirtualFileURL(url, virtualFiles);
+      expect(result).toMatch(/^blob:/);
+    }
+  });
+
+  it("should create blob URL with correct content", async () => {
+    const jsCode = "export default { render: () => {} }";
+    const base64Code = btoa(jsCode);
+    const virtualFiles = {
+      "/@file/test-module.js":
+        `data:text/javascript;base64,${base64Code}` as DataURLString,
+    };
+
+    const blobUrl = resolveVirtualFileURL(
+      "/@file/test-module.js",
+      virtualFiles,
+    );
+
+    expect(blobUrl).toMatch(/^blob:/);
+    expect(URL.createObjectURL).toHaveBeenCalled();
+
+    // Verify blob content through the mock
+    const blob = mockBlobURLs.get(blobUrl);
+    expect(blob).toBeDefined();
+    const text = await blob!.text();
+    expect(text).toBe(jsCode);
+  });
+
+  it("should handle file:// URLs with @file/ paths", () => {
+    const virtualFiles = {
+      "/@file/local-module.js":
+        "data:text/javascript;base64,ZXhwb3J0IGRlZmF1bHQge30=" as DataURLString,
+    };
+
+    const result = resolveVirtualFileURL(
+      "file:///Users/test/@file/local-module.js",
+      virtualFiles,
+    );
+
+    expect(result).toMatch(/^blob:/);
+  });
+
+  it("should handle different MIME types", async () => {
+    const virtualFiles = {
+      "/@file/script.js":
+        "data:application/javascript;base64,Y29uc3QgeCA9IDE=" as DataURLString,
+    };
+
+    const blobUrl = resolveVirtualFileURL("/@file/script.js", virtualFiles);
+
+    // Should still be a valid blob URL
+    expect(blobUrl).toMatch(/^blob:/);
+
+    // Verify blob content through the mock
+    const blob = mockBlobURLs.get(blobUrl);
+    expect(blob).toBeDefined();
+    const text = await blob!.text();
+    expect(text).toBe("const x = 1");
+  });
+
+  it("should handle blob: base URIs correctly", () => {
+    // Mock document.baseURI to simulate blob: protocol
+    const originalBaseURI = document.baseURI;
+    Object.defineProperty(document, "baseURI", {
+      value: "blob:https://example.com/uuid",
+      configurable: true,
+    });
+
+    const virtualFiles = {
+      "/@file/blob-module.js":
+        "data:text/javascript;base64,ZXhwb3J0IGRlZmF1bHQge30=" as DataURLString,
+    };
+
+    const result = resolveVirtualFileURL("/@file/blob-module.js", virtualFiles);
+
+    expect(result).toMatch(/^blob:/);
+
+    // Restore original baseURI
+    Object.defineProperty(document, "baseURI", {
+      value: originalBaseURI,
+      configurable: true,
+    });
+  });
+
+  it("should handle data URLs with no explicit MIME type", async () => {
+    const virtualFiles = {
+      "/@file/generic.bin": "data:;base64,SGVsbG8gV29ybGQ=" as DataURLString,
+    };
+
+    const blobUrl = resolveVirtualFileURL("/@file/generic.bin", virtualFiles);
+    expect(blobUrl).toMatch(/^blob:/);
+
+    // Verify blob content through the mock
+    const blob = mockBlobURLs.get(blobUrl);
+    expect(blob).toBeDefined();
+    const text = await blob!.text();
+    expect(text).toBe("Hello World");
+  });
+
+  it("should match URLs with prefix paths before /@file/", async () => {
+    const virtualFiles = {
+      "/@file/4263-66-yUGhgQXp.js":
+        "data:application/javascript;base64,ZnVuY3Rpb24gcmVuZGVyKCkge30=" as DataURLString,
+    };
+
+    const blobUrl = resolveVirtualFileURL(
+      "https://molab.marimo.app/preview/@file/4263-66-yUGhgQXp.js",
+      virtualFiles,
+    );
+
+    expect(blobUrl).toMatch(/^blob:/);
+
+    // Verify blob content through the mock
+    const blob = mockBlobURLs.get(blobUrl);
+    expect(blob).toBeDefined();
+    const text = await blob!.text();
+    expect(text).toBe("function render() {}");
+  });
+});
+
 describe("maybeGetVirtualFile utility function", () => {
   it("should handle URLs without leading dots correctly", async () => {
     const virtualFiles = {
@@ -370,6 +545,25 @@ describe("maybeGetVirtualFile utility function", () => {
     expect(text2).toBe("test");
   });
 
+  it("should match URLs with prefix paths before /@file/", async () => {
+    const virtualFiles = {
+      "/@file/4263-66-yUGhgQXp.js":
+        "data:application/javascript;base64,ZnVuY3Rpb24gcmVuZGVyKCkge30=" as DataURLString,
+    };
+
+    const unpatch = patchFetch(virtualFiles);
+
+    // Test URL with a prefix path before /@file/
+    const response = await window.fetch(
+      "https://molab.marimo.app/preview/@file/4263-66-yUGhgQXp.js",
+    );
+    const text = await response.text();
+
+    expect(text).toBe("function render() {}");
+
+    unpatch();
+  });
+
   it("should handle complex file:// URLs with nested paths", async () => {
     const virtualFiles = {
       "/@file/nested/data.json":

package/src/core/static/files.ts

@@ -1,6 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import type { Loader } from "@/plugins/impl/vega/vega-loader";
+import { deserializeBlob } from "@/utils/blob";
+import type { DataURLString } from "@/utils/json/base64";
 import { Logger } from "@/utils/Logger";
 import { getStaticVirtualFiles } from "./static-state";
 import type { StaticVirtualFiles } from "./types";
@@ -120,6 +122,24 @@ function withoutLeadingDot(path: string): string {
   return path.startsWith(".") ? path.slice(1) : path;
 }
 
+/**
+ * Resolve a URL to a blob URL if it's a virtual file, for use with dynamic import().
+ * Unlike fetch, import() can't be patched, so we need to convert data URLs to blob URLs.
+ *
+ * @returns The original URL if not a virtual file, or a blob URL if it is
+ */
+export function resolveVirtualFileURL(
+  url: string,
+  files: StaticVirtualFiles = getStaticVirtualFiles(),
+): string {
+  const vfile = maybeGetVirtualFile(url, files);
+  if (!vfile) {
+    return url;
+  }
+  const blob = deserializeBlob(vfile as DataURLString);
+  return URL.createObjectURL(blob);
+}
+
 function maybeGetVirtualFile(
   url: string,
   files: StaticVirtualFiles,
@@ -130,14 +150,11 @@ function maybeGetVirtualFile(
   }
   const pathname = new URL(url, base).pathname;
 
-  // If if the URL starts with file://, then using the document.baseURI
-  // will not work. In this case, should just chop off from /@file/...
-  if (url.startsWith("file://")) {
-    const indexOfFile = url.indexOf("/@file/");
-    if (indexOfFile !== -1) {
-      url = url.slice(indexOfFile);
-    }
-  }
+  // Extract the /@file/... suffix from the URL or pathname
+  // This handles URLs like https://example.com/prefix/@file/foo.js
+  // or file:///path/to/@file/foo.js
+  const filePathFromUrl = extractFilePath(url);
+  const filePathFromPathname = extractFilePath(pathname);
 
   // Few variations to grab the URL.
   // This can happen if a static file was open at file:// or https://
@@ -145,6 +162,19 @@ function maybeGetVirtualFile(
     files[url] ||
     files[withoutLeadingDot(url)] ||
     files[pathname] ||
-    files[withoutLeadingDot(pathname)]
+    files[withoutLeadingDot(pathname)] ||
+    (filePathFromUrl && files[filePathFromUrl]) ||
+    (filePathFromPathname && files[filePathFromPathname])
   );
 }
+
+/**
+ * Extract the /@file/... path from a URL string
+ */
+function extractFilePath(url: string): string | null {
+  const indexOfFile = url.indexOf("/@file/");
+  if (indexOfFile !== -1) {
+    return url.slice(indexOfFile);
+  }
+  return null;
+}

package/src/plugins/core/registerReactComponent.tsx

@@ -101,10 +101,17 @@ function PluginSlotInternal<T>(
     return plugin.validator.safeParse(parseDataset(hostElement));
   });
 
+  // Incremented on each reset to invalidate memoized function references.
+  // This ensures that plugin functions (e.g., search) are re-created when
+  // the underlying UI element instance changes (new object-id), even if
+  // the element's data attributes haven't changed.
+  const [resetNonce, setResetNonce] = useState(0);
+
   useImperativeHandle(ref, () => ({
     reset: () => {
       setValue(getInitialValue());
       setParsedResult(plugin.validator.safeParse(parseDataset(hostElement)));
+      setResetNonce((n) => n + 1);
     },
     setChildren: (children) => {
       setChildNodes(children);
@@ -224,7 +231,8 @@ function PluginSlotInternal<T>(
     }
 
     return methods;
-  }, [plugin.functions, hostElement]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [plugin.functions, hostElement, resetNonce]);
 
   // If we failed to parse the initial value, render an error
   if (!parsedResult.success) {

package/src/plugins/impl/__tests__/DataTablePlugin.test.tsx

@@ -0,0 +1,164 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { TooltipProvider } from "@radix-ui/react-tooltip";
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { Provider } from "jotai";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import type { DownloadAsArgs } from "@/components/data-table/schemas";
+import type { FieldTypesWithExternalType } from "@/components/data-table/types";
+import { store } from "@/core/state/jotai";
+import {
+  type GetDataUrl,
+  type GetRowIds,
+  LoadingDataTableComponent,
+} from "../DataTablePlugin";
+
+beforeAll(() => {
+  global.ResizeObserver = class ResizeObserver {
+    observe() {
+      // do nothing
+    }
+    unobserve() {
+      // do nothing
+    }
+    disconnect() {
+      // do nothing
+    }
+  };
+});
+
+describe("LoadingDataTableComponent", () => {
+  /**
+   * Regression test for https://github.com/marimo-team/marimo/issues/8023
+   *
+   * When a table is replaced via mo.output.replace() with updated data,
+   * but the initial page data (unsorted first page) hasn't changed,
+   * the useAsyncData hook's deps may all remain the same.
+   * Previously, the `search` function reference was memoized on
+   * [plugin.functions, hostElement] and wouldn't change on reset(),
+   * so the useAsyncData effect wouldn't re-fire.
+   *
+   * The fix adds a resetNonce to the functionMethods memo deps,
+   * so when the plugin is reset (table instance changes), the search
+   * function reference changes, triggering useAsyncData to re-fetch.
+   *
+   * This test verifies that when the search function reference changes
+   * (simulating reset()), the component re-fetches data even if
+   * props.data hasn't changed.
+   */
+  it("should refetch data when search function reference changes", async () => {
+    const host = document.createElement("div");
+    const setValue = vi.fn();
+
+    // The initial page data string - identical for both renders.
+    // This simulates the case where only a row on page 2 changed,
+    // so the first page data is the same.
+    const initialPageData = JSON.stringify([
+      { id: 1, status: "pending", value: 10 },
+      { id: 2, status: "pending", value: 20 },
+      { id: 3, status: "pending", value: 30 },
+    ]);
+
+    const searchResult = {
+      data: [
+        { id: 1, status: "pending", value: 10 },
+        { id: 2, status: "pending", value: 20 },
+        { id: 3, status: "pending", value: 30 },
+      ],
+      total_rows: 4,
+      cell_styles: null,
+      cell_hover_texts: null,
+    };
+
+    const searchFn1 = vi.fn().mockResolvedValue(searchResult);
+    const searchFn2 = vi.fn().mockResolvedValue(searchResult);
+
+    const fieldTypes: FieldTypesWithExternalType = [
+      ["id", ["integer", "integer"]],
+      ["status", ["string", "string"]],
+      ["value", ["integer", "integer"]],
+    ];
+
+    const commonProps = {
+      label: null,
+      totalRows: 4,
+      pagination: true,
+      pageSize: 3,
+      selection: "single" as const,
+      showDownload: false,
+      showFilters: false,
+      showColumnSummaries: false as const,
+      showDataTypes: false,
+      showPageSizeSelector: false,
+      showColumnExplorer: false,
+      showRowExplorer: false,
+      showChartBuilder: false,
+      rowHeaders: [] as FieldTypesWithExternalType,
+      fieldTypes,
+      totalColumns: 3,
+      maxColumns: "all" as const,
+      hasStableRowId: false,
+      lazy: false,
+      host,
+      enableSearch: true,
+      value: [] as (number | string | { rowId: string; columnName?: string })[],
+      setValue,
+      download_as: vi.fn() as DownloadAsArgs,
+      get_column_summaries: vi.fn().mockResolvedValue({
+        data: null,
+        stats: {},
+        bin_values: {},
+        value_counts: {},
+        show_charts: false,
+      }),
+      get_data_url: vi.fn() as GetDataUrl,
+      get_row_ids: vi.fn() as GetRowIds,
+    };
+
+    const Wrapper = ({ children }: { children: React.ReactNode }) => (
+      <Provider store={store}>
+        <TooltipProvider>{children}</TooltipProvider>
+      </Provider>
+    );
+
+    // Render with first search function
+    const { rerender } = render(
+      <Wrapper>
+        <LoadingDataTableComponent
+          {...commonProps}
+          data={initialPageData}
+          search={searchFn1}
+        />
+      </Wrapper>,
+    );
+
+    // Wait for the table to render with data
+    await waitFor(() => {
+      expect(screen.getAllByRole("row").length).toBeGreaterThan(1);
+    });
+
+    // Search was called on initial load (fire-and-forget for canShowInitialPage)
+    expect(searchFn1).toHaveBeenCalled();
+
+    // Now rerender with the same data but a NEW search function reference.
+    // This simulates what happens after reset() when resetNonce increments
+    // and functionMethods is recreated.
+    await act(async () => {
+      rerender(
+        <Wrapper>
+          <LoadingDataTableComponent
+            {...commonProps}
+            data={initialPageData}
+            search={searchFn2}
+          />
+        </Wrapper>,
+      );
+    });
+
+    // The new search function should be called because the search
+    // dependency changed in useAsyncData.
+    await waitFor(() => {
+      expect(searchFn2).toHaveBeenCalled();
+    });
+  });
+});

package/src/plugins/impl/anywidget/AnyWidgetPlugin.tsx

@@ -8,6 +8,8 @@ import useEvent from "react-use-event-hook";
 import { z } from "zod";
 import { MarimoIncomingMessageEvent } from "@/core/dom/events";
 import { asRemoteURL } from "@/core/runtime/config";
+import { resolveVirtualFileURL } from "@/core/static/files";
+import { isStaticNotebook } from "@/core/static/static-state";
 import { useAsyncData } from "@/hooks/useAsyncData";
 import { useDeepCompareMemoize } from "@/hooks/useDeepCompareMemoize";
 import {
@@ -93,7 +95,11 @@ const AnyWidgetSlot = (
     error,
     refetch,
   } = useAsyncData(async () => {
-    const url = asRemoteURL(jsUrl).toString();
+    let url = asRemoteURL(jsUrl).toString();
+    // In static notebooks, resolve virtual files to blob URLs for import()
+    if (isStaticNotebook()) {
+      url = resolveVirtualFileURL(url);
+    }
     return await import(/* @vite-ignore */ url);
     // Re-render on jsHash change (which is a hash of the contents of the file)
     // instead of a jsUrl change because URLs may change without the contents

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

@@ -20,7 +20,7 @@ describe("Blob serialization and deserialization", () => {
 
   test("deserializeBlob should deserialize a base64 string to a Blob", async () => {
     const serialized = await serializeBlob(testBlob);
-    const deserialized = await deserializeBlob(serialized);
+    const deserialized = deserializeBlob(serialized);
     expect(deserialized).toBeDefined();
     expect(deserialized.size).toBe(testBlob.size);
     expect(deserialized.type).toBe(testBlob.type);
@@ -28,7 +28,7 @@ describe("Blob serialization and deserialization", () => {
 
   test("deserialized Blob should contain the original content", async () => {
     const serialized = await serializeBlob(testBlob);
-    const deserialized = await deserializeBlob(serialized);
+    const deserialized = deserializeBlob(serialized);
     const reader = new FileReader();
     // eslint-disable-next-line unicorn/prefer-blob-reading-methods
     reader.readAsText(deserialized);
@@ -45,7 +45,7 @@ describe("Blob serialization and deserialization", () => {
       type: "image/png",
     });
     const serialized = await serializeBlob(imageBlob);
-    const deserialized = await deserializeBlob(serialized);
+    const deserialized = deserializeBlob(serialized);
     expect(deserialized).toBeDefined();
     expect(deserialized.size).toBe(imageBlob.size);
     expect(deserialized.type).toBe(imageBlob.type);

package/src/utils/__tests__/mime-types.test.ts

@@ -132,7 +132,7 @@ describe("mime-types", () => {
 
   describe("sortByPrecedence", () => {
     it("should sort entries by precedence order", () => {
-      const entries: Array<[MimeType, string]> = [
+      const entries: [MimeType, string][] = [
         ["text/plain", "plain"],
         ["text/html", "html"],
         ["image/png", "png"],
@@ -151,7 +151,7 @@ describe("mime-types", () => {
     });
 
     it("should place unknown mime types at the end", () => {
-      const entries: Array<[MimeType, string]> = [
+      const entries: [MimeType, string][] = [
         ["text/plain", "plain"],
         ["text/html", "html"],
         ["application/json", "json"],
@@ -173,7 +173,7 @@ describe("mime-types", () => {
     });
 
     it("should handle empty precedence", () => {
-      const entries: Array<[MimeType, string]> = [
+      const entries: [MimeType, string][] = [
         ["text/plain", "plain"],
         ["text/html", "html"],
       ];
@@ -184,7 +184,7 @@ describe("mime-types", () => {
     });
 
     it("should not mutate original array", () => {
-      const entries: Array<[MimeType, string]> = [
+      const entries: [MimeType, string][] = [
         ["text/plain", "plain"],
         ["text/html", "html"],
       ];
@@ -198,7 +198,7 @@ describe("mime-types", () => {
 
   describe("processMimeBundle", () => {
     it("should filter and sort mime entries", () => {
-      const entries: Array<[MimeType, string]> = [
+      const entries: [MimeType, string][] = [
         ["text/plain", "plain"],
         ["text/html", "html"],
         ["image/png", "png"],
@@ -226,7 +226,7 @@ describe("mime-types", () => {
     });
 
     it("should use default config when not provided", () => {
-      const entries: Array<[MimeType, string]> = [
+      const entries: [MimeType, string][] = [
         ["text/html", "html"],
         ["image/png", "png"],
         ["text/markdown", "md"],
@@ -240,9 +240,7 @@ describe("mime-types", () => {
 
     it("should preserve data associated with mime types", () => {
       const htmlData = { content: "<h1>Hello</h1>" };
-      const entries: Array<[MimeType, typeof htmlData]> = [
-        ["text/html", htmlData],
-      ];
+      const entries: [MimeType, typeof htmlData][] = [["text/html", htmlData]];
 
       const result = processMimeBundle(entries);
 
@@ -250,7 +248,7 @@ describe("mime-types", () => {
     });
 
     it("should sort by precedence after filtering", () => {
-      const entries: Array<[MimeType, string]> = [
+      const entries: [MimeType, string][] = [
         ["text/plain", "plain"],
         ["text/markdown", "md"],
         ["text/html", "html"],

package/src/utils/__tests__/url-parser.test.ts

@@ -76,4 +76,26 @@ describe("parseContent", () => {
       url: "https://avatars.githubusercontent.com/u/123",
     });
   });
+
+  it("preserves newlines between URLs", () => {
+    const parts = parseContent("https://marimo.io\nhttps://github.com\n");
+    expect(parts).toEqual([
+      { type: "url", url: "https://marimo.io" },
+      { type: "text", value: "\n" },
+      { type: "url", url: "https://github.com" },
+      { type: "text", value: "\n" },
+    ]);
+  });
+
+  it("preserves whitespace in mixed content", () => {
+    const parts = parseContent(
+      "Line 1: https://marimo.io\nLine 2: https://github.com",
+    );
+    expect(parts).toEqual([
+      { type: "text", value: "Line 1: " },
+      { type: "url", url: "https://marimo.io" },
+      { type: "text", value: "\nLine 2: " },
+      { type: "url", url: "https://github.com" },
+    ]);
+  });
 });

package/src/utils/blob.ts

@@ -14,32 +14,19 @@ export function serializeBlob<T>(blob: Blob): Promise<DataURLString> {
   });
 }
 
-export function deserializeBlob(serializedBlob: DataURLString): Promise<Blob> {
-  return new Promise((resolve, reject) => {
-    try {
-      // Extract the base64 data from the data URL
-      const [prefix, base64Data] = serializedBlob.split(",", 2);
-      const mimeType = /^data:(.+);base64$/.exec(prefix)?.[1];
-      // Decode the base64 string
-      const binaryString = atob(base64Data);
-      // Convert the binary string to an array buffer
-      const len = binaryString.length;
-      const bytes = new Uint8Array(len);
-      for (let i = 0; i < len; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      // Create a new Blob from the array buffer
-      const blob = new Blob([bytes], { type: mimeType });
-      resolve(blob);
-    } catch (error) {
-      reject(ensureError(error));
-    }
-  });
-}
-
-function ensureError(error: unknown): Error {
-  if (error instanceof Error) {
-    return error;
+export function deserializeBlob(serializedBlob: DataURLString): Blob {
+  // Extract the base64 data from the data URL
+  const [prefix, base64Data] = serializedBlob.split(",", 2);
+  const mimeType = /^data:(.+);base64$/.exec(prefix)?.[1];
+  // Decode the base64 string
+  const binaryString = atob(base64Data);
+  // Convert the binary string to an array buffer
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
   }
-  return new Error(`${error}`);
+  // Create a new Blob from the array buffer
+  const blob = new Blob([bytes], { type: mimeType });
+  return blob;
 }