@marimo-team/islands 0.23.15-dev7 → 0.23.15-dev72

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

@@ -0,0 +1,176 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { beforeEach, describe, expect, expectTypeOf, it, vi } from "vitest";
+import type * as MainModule from "../main";
+
+// `main.ts` is the public islands entry point (see islands/vite.config.mts),
+// so this suite snapshots its export surface + signatures and covers each
+// entry point. The real bridge/bootstrap spin up a Web Worker and the plugin
+// runtime, so we mock them.
+const mockInitializeApps = vi.fn(() => Promise.resolve());
+const mockStopSession = vi.fn((_appId?: string) => Promise.resolve());
+const mockInitializeIslands = vi.fn(() => Promise.resolve());
+const mockParseMarimoIslandApps = vi.fn(() => [] as Array<{ id: string }>);
+
+vi.mock("@/core/islands/bridge", () => ({
+  getGlobalBridge: () => ({
+    initializeApps: mockInitializeApps,
+    stopSession: mockStopSession,
+  }),
+}));
+
+vi.mock("@/core/islands/bootstrap", () => ({
+  initializeIslands: mockInitializeIslands,
+}));
+
+vi.mock("@/core/islands/parse", () => ({
+  parseMarimoIslandApps: mockParseMarimoIslandApps,
+}));
+
+/**
+ * Re-import a fresh copy of `main.ts` so the module-level `bootstrapPromise`
+ * memoization does not leak between tests. The module auto-runs `initialize()`
+ * on load, so we clear the DOM first to keep that a no-op.
+ */
+async function importMain(): Promise<typeof MainModule> {
+  vi.resetModules();
+  return import("../main");
+}
+
+beforeEach(() => {
+  document.body.replaceChildren();
+  mockInitializeApps.mockClear();
+  mockStopSession.mockClear();
+  mockInitializeIslands.mockClear();
+  mockParseMarimoIslandApps.mockReset();
+  mockParseMarimoIslandApps.mockReturnValue([]);
+});
+
+describe("islands public API surface", () => {
+  it("exposes a stable set of exports and signatures", async () => {
+    const mod = await importMain();
+    const surface = Object.fromEntries(
+      Object.keys(mod)
+        .toSorted()
+        .map((key) => {
+          const value = (mod as Record<string, unknown>)[key];
+          return [
+            key,
+            typeof value === "function"
+              ? `function(arity ${value.length})`
+              : typeof value,
+          ];
+        }),
+    );
+
+    expect(surface).toMatchInlineSnapshot(`
+      {
+        "canReplaceApp": "function(arity 0)",
+        "initialize": "function(arity 0)",
+        "stopApp": "function(arity 1)",
+      }
+    `);
+  });
+
+  it("matches the declared TypeScript signatures", () => {
+    expectTypeOf<typeof MainModule.canReplaceApp>().toEqualTypeOf<
+      () => boolean
+    >();
+    expectTypeOf<typeof MainModule.initialize>().toEqualTypeOf<
+      () => Promise<void>
+    >();
+    expectTypeOf<typeof MainModule.stopApp>().toEqualTypeOf<
+      (appId?: string) => Promise<void>
+    >();
+  });
+});
+
+describe("canReplaceApp", () => {
+  it("returns false when the document has no island element", async () => {
+    const mod = await importMain();
+
+    expect(mod.canReplaceApp()).toBe(false);
+    // Short-circuits on the DOM guard before parsing.
+    expect(mockParseMarimoIslandApps).not.toHaveBeenCalled();
+  });
+
+  it("returns true for exactly one app without materializing the DOM", async () => {
+    const mod = await importMain();
+    document.body.innerHTML = `<marimo-island data-app-id="app-1"></marimo-island>`;
+    mockParseMarimoIslandApps.mockReturnValue([{ id: "app-1" }]);
+
+    expect(mod.canReplaceApp()).toBe(true);
+    // A probe must not mutate island attributes.
+    expect(mockParseMarimoIslandApps).toHaveBeenCalledWith(document, {
+      materialize: false,
+    });
+  });
+
+  it("returns false when more than one app is present", async () => {
+    const mod = await importMain();
+    document.body.innerHTML = `<marimo-island data-app-id="app-1"></marimo-island>`;
+    mockParseMarimoIslandApps.mockReturnValue([
+      { id: "app-1" },
+      { id: "app-2" },
+    ]);
+
+    expect(mod.canReplaceApp()).toBe(false);
+  });
+
+  it("returns false when the island parses into zero apps", async () => {
+    const mod = await importMain();
+    document.body.innerHTML = `<marimo-island></marimo-island>`;
+    mockParseMarimoIslandApps.mockReturnValue([]);
+
+    expect(mod.canReplaceApp()).toBe(false);
+  });
+});
+
+describe("stopApp", () => {
+  it("forwards the requested app id to the bridge", async () => {
+    const mod = await importMain();
+
+    await mod.stopApp("app-7");
+    expect(mockStopSession).toHaveBeenCalledWith("app-7");
+
+    await mod.stopApp();
+    expect(mockStopSession).toHaveBeenLastCalledWith(undefined);
+  });
+});
+
+describe("initialize", () => {
+  it("skips bootstrap and app start when no islands are present", async () => {
+    const mod = await importMain();
+
+    await mod.initialize();
+
+    expect(mockInitializeIslands).not.toHaveBeenCalled();
+    expect(mockInitializeApps).not.toHaveBeenCalled();
+  });
+
+  it("bootstraps once, marks islands, and starts apps on each call", async () => {
+    const mod = await importMain();
+    document.body.innerHTML = `<marimo-island></marimo-island>`;
+
+    await mod.initialize();
+    await mod.initialize();
+
+    expect(mockInitializeIslands).toHaveBeenCalledOnce();
+    expect(mockInitializeApps).toHaveBeenCalledTimes(2);
+    expect(
+      document.querySelector("marimo-island")?.classList.contains("marimo"),
+    ).toBe(true);
+  });
+
+  it("clears the memoized bootstrap when it fails so it can be retried", async () => {
+    const mod = await importMain();
+    document.body.innerHTML = `<marimo-island></marimo-island>`;
+    mockInitializeIslands.mockRejectedValueOnce(new Error("bootstrap failed"));
+
+    await expect(mod.initialize()).rejects.toThrow("bootstrap failed");
+    await mod.initialize();
+
+    expect(mockInitializeIslands).toHaveBeenCalledTimes(2);
+    expect(mockInitializeApps).toHaveBeenCalledOnce();
+  });
+});

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

@@ -15,6 +15,7 @@ import {
   parseIslandElement,
   parseIslandElementsIntoApps,
   parseMarimoIslandApps,
+  retainIslandSource,
 } from "../parse";
 import { createMockIslandElement, createMockIslands } from "./test-utils.tsx";
 
@@ -53,6 +54,7 @@ function appendPayload(
   script.type = ISLANDS_JSON_SCRIPT_TYPE;
   script.textContent = JSON.stringify(payload);
   root.appendChild(script);
+  return script;
 }
 
 describe("createMarimoFile", () => {
@@ -317,6 +319,39 @@ describe("parseIslandElement", () => {
 
     expect(result).toBeNull();
   });
+
+  it("uses retained source after the custom element renders", () => {
+    const element = document.createElement(ISLAND_TAG_NAMES.ISLAND);
+    retainIslandSource(element, {
+      code: 'print("retained")',
+      output: "<div>retained output</div>",
+    });
+
+    expect(parseIslandElement(element)).toEqual({
+      code: 'print("retained")',
+      output: "<div>retained output</div>",
+    });
+
+    retainIslandSource(element, { code: "", output: "<div>static</div>" });
+    expect(parseIslandElement(element)).toBeNull();
+  });
+
+  it("prefers new live source when an island element is reused", () => {
+    const element = createMockIslandElement({
+      code: 'print("new")',
+      innerHTML: "<div>new output</div>",
+    });
+    element.setAttribute(ISLAND_DATA_ATTRIBUTES.REACTIVE, "true");
+    retainIslandSource(element, {
+      code: 'print("retained")',
+      output: "<div>retained output</div>",
+    });
+
+    expect(parseIslandElement(element)).toEqual({
+      code: 'print("new")',
+      output: "<div>new output</div>",
+    });
+  });
 });
 
 describe("parseIslandElementsIntoApps", () => {
@@ -630,6 +665,76 @@ describe("parseMarimoIslandApps", () => {
     );
   });
 
+  it("preserves payload-backed cells after a non-materializing capability probe", () => {
+    const island = createMockIslandElement({
+      appId: "app1",
+      cellId: "cell-2",
+      code: "dom_code = True",
+      innerHTML: "<div>dom output</div>",
+    });
+    island.setAttribute(ISLAND_DATA_ATTRIBUTES.REACTIVE, "true");
+    container.appendChild(island);
+    appendPayload(container, {
+      schemaVersion: 1,
+      appId: "app1",
+      cells: [createPayloadCell({ cellId: "cell-2" })],
+    });
+    const originalIsland = island.outerHTML;
+
+    const probed = parseMarimoIslandApps(container, { materialize: false });
+
+    expect(probed).toHaveLength(1);
+    expect(island.outerHTML).toBe(originalIsland);
+
+    expect(parseMarimoIslandApps(container)).toEqual(probed);
+    expect(island.getAttribute(ISLAND_DATA_ATTRIBUTES.CELL_ID)).toBeNull();
+    expect(island.getAttribute(ISLAND_DATA_ATTRIBUTES.CELL_IDX)).toBe("0");
+  });
+
+  it("refreshes a reused payload anchor when its content changes", () => {
+    const island = createMockIslandElement({
+      appId: "app1",
+      cellId: "cell-1",
+      code: 'print("dom")',
+      innerHTML: "<div>dom output</div>",
+    });
+    island.insertAdjacentHTML(
+      "beforeend",
+      '<div data-marimo-element><marimo-code-editor data-initial-value="old"></marimo-code-editor></div>',
+    );
+    island.setAttribute(ISLAND_DATA_ATTRIBUTES.REACTIVE, "true");
+    container.appendChild(island);
+    const script = appendPayload(container, {
+      schemaVersion: 1,
+      appId: "app1",
+      cells: [createPayloadCell()],
+    });
+    parseMarimoIslandApps(container);
+
+    script.textContent = JSON.stringify({
+      schemaVersion: 1,
+      appId: "app1",
+      cells: [
+        createPayloadCell({
+          code: 'print("updated")',
+          outputHtml: "<div>updated output</div>",
+        }),
+      ],
+    });
+
+    parseMarimoIslandApps(container);
+
+    expect(extractIslandCodeFromEmbed(island)).toBe('print("updated")');
+    expect(island.querySelector(ISLAND_TAG_NAMES.CELL_OUTPUT)?.innerHTML).toBe(
+      "<div>updated output</div>",
+    );
+    expect(
+      island
+        .querySelector(ISLAND_TAG_NAMES.CODE_EDITOR)
+        ?.getAttribute("data-initial-value"),
+    ).toBe(JSON.stringify('print("updated")'));
+  });
+
   it("should parse Python-generated island payload snapshots", () => {
     const html = readFileSync(
       new URL(

package/src/core/islands/bootstrap.ts

@@ -42,6 +42,7 @@ import { store as defaultStore } from "../state/jotai";
 import type { IslandsPyodideBridge } from "./bridge";
 import { MarimoIslandElement } from "./components/web-components";
 import {
+  islandsPendingInitialRunsAtom,
   shouldShowIslandsWarningIndicatorAtom,
   userTriedToInteractWithIslandsAtom,
 } from "./state";
@@ -74,6 +75,7 @@ export async function initializeIslands(
   // Setup networking
   store.set(requestClientAtom, bridge);
   store.set(initialModeAtom, "read");
+  store.set(islandsPendingInitialRunsAtom, null);
 
   // Initialize plugins for rendering static HTML
   if (config.autoInitializePlugins !== false) {
@@ -108,14 +110,17 @@ export async function initializeIslands(
   // Loading indicator: dim islands while Pyodide initializes
   store.sub(shouldShowIslandsWarningIndicatorAtom, () => {
     const showing = store.get(shouldShowIslandsWarningIndicatorAtom);
+    const currentIslands = root.querySelectorAll<HTMLElement>(
+      ISLAND_TAG_NAMES.ISLAND,
+    );
     if (showing) {
       toastIslandsLoading();
-      for (const island of islands) {
+      for (const island of currentIslands) {
         island.style.setProperty("opacity", "0.5");
       }
     } else {
       dismissIslandsLoadingToast();
-      for (const island of islands) {
+      for (const island of currentIslands) {
         island.style.removeProperty("opacity");
       }
     }
@@ -126,10 +131,13 @@ export async function initializeIslands(
   // the envelope and the payload carry the op. The bridge types the message
   // as NotificationPayload (just {data}), but the actual wire format
   // includes the outer op too.
-  bridge.consumeMessages((message) => {
+  // Worker metadata identifies the session that emitted the message.
+  bridge.consumeMessages(({ message, sessionGeneration }) => {
     handleMessage(
       message as unknown as JsonString<IslandsNotificationMessage>,
       actions,
+      store,
+      sessionGeneration,
     );
   });
 
@@ -158,9 +166,12 @@ type IslandsNotificationMessage = {
  *
  * Wire format from Python: {"op": "<name>", "data": {"op": "<name>", ...}}
  */
+// oxlint-disable-next-line marimo/prefer-object-params
 function handleMessage(
   message: JsonString<IslandsNotificationMessage>,
   actions: NotebookActions,
+  store: Store,
+  sessionGeneration: number,
 ): void {
   try {
     const msg = jsonParseWithSpecialChar(message);
@@ -189,7 +200,6 @@ function handleMessage(
       case "storage-download-ready":
       case "secret-keys-result":
       case "startup-logs":
-      case "completed-run":
       case "interrupted":
       case "reconnected":
       case "cache-cleared":
@@ -198,6 +208,17 @@ function handleMessage(
       case "notebook-document-transaction":
         return;
 
+      case "completed-run":
+        store.set(islandsPendingInitialRunsAtom, (pending) => {
+          if (!pending?.has(sessionGeneration)) {
+            return pending;
+          }
+          const next = new Set(pending);
+          next.delete(sessionGeneration);
+          return next;
+        });
+        return;
+
       case "kernel-ready":
         handleKernelReady(msg.data, {
           autoInstantiate: true,
@@ -208,7 +229,9 @@ function handleMessage(
           setKernelState: Functions.NOOP,
           onError: Logger.error,
         });
-        defineCustomElement(ISLAND_TAG_NAMES.ISLAND, MarimoIslandElement);
+        if (!window.customElements?.get(ISLAND_TAG_NAMES.ISLAND)) {
+          defineCustomElement(ISLAND_TAG_NAMES.ISLAND, MarimoIslandElement);
+        }
         return;
 
       case "send-ui-element-message":

package/src/core/islands/bridge.ts

@@ -4,16 +4,16 @@
 import { getWorkerRPC } from "@/core/wasm/rpc";
 import { Deferred } from "@/utils/Deferred";
 import { throwNotImplemented } from "@/utils/functions";
-import type { JsonString } from "@/utils/json/base64";
 import { Logger } from "@/utils/Logger";
 import { generateUUID } from "@/utils/uuid";
-import type { CommandMessage, NotificationPayload } from "../kernel/messages";
+import { initialNotebookState, notebookAtom } from "../cells/cells";
+import type { CommandMessage } from "../kernel/messages";
 import type { EditRequests, RunRequests } from "../network/types";
 import { store as defaultStore } from "../state/jotai";
 import { getMarimoExportContext } from "../static/export-context";
 import { createMarimoFile, parseMarimoIslandApps } from "./parse";
-import { islandsInitializedAtom } from "./state";
-import type { WorkerSchema } from "./worker/worker";
+import { islandsInitializedAtom, islandsPendingInitialRunsAtom } from "./state";
+import type { IslandsKernelMessage, WorkerSchema } from "./worker/worker";
 import type { WorkerFactory } from "./worker-factory";
 import { DefaultWorkerFactory } from "./worker-factory";
 
@@ -35,11 +35,12 @@ export interface IslandsBridgeConfig {
    * Optional root element for parsing islands (for testing)
    */
   root?: Document | Element;
+}
 
-  /**
-   * Whether to auto-start sessions on worker ready (default: true)
-   */
-  autoStartSessions?: boolean;
+interface AppSession {
+  appId: string;
+  code?: string;
+  sessionGeneration: number;
 }
 
 /**
@@ -51,25 +52,28 @@ export interface IslandsBridgeConfig {
  * @example
  * ```ts
  * const bridge = new IslandsPyodideBridge();
- * await bridge.initialized;
  * bridge.consumeMessages(message => console.log(message));
+ * await bridge.initializeApps();
  * ```
  */
 export class IslandsPyodideBridge implements RunRequests, EditRequests {
   private rpc: ReturnType<typeof getWorkerRPC<WorkerSchema>>;
   private messageConsumer:
-    | ((message: JsonString<NotificationPayload>) => void)
+    | ((message: IslandsKernelMessage) => void)
     | undefined;
   private readonly store: typeof defaultStore;
   private readonly root: Document | Element;
-  private readonly autoStartSessions: boolean;
+  private session: AppSession | undefined;
+  private sessionReady = new Deferred<AppSession>();
+  private nextSessionGeneration = 0;
+  private appTransition = Promise.resolve();
+  private workerReady = new Deferred<void>();
 
   public initialized = new Deferred<void>();
 
   constructor(config: IslandsBridgeConfig = {}) {
     this.store = config.store || defaultStore;
     this.root = config.root || document;
-    this.autoStartSessions = config.autoStartSessions ?? true;
 
     try {
       const factory = config.workerFactory || new DefaultWorkerFactory();
@@ -88,9 +92,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
    */
   private setupMessageListeners(): void {
     this.rpc.addMessageListener("ready", () => {
-      if (this.autoStartSessions) {
-        this.startSessionsForAllApps();
-      }
+      this.workerReady.resolve();
     });
 
     this.rpc.addMessageListener("initialized", () => {
@@ -107,19 +109,21 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
       },
     );
 
-    this.rpc.addMessageListener(
-      "kernelMessage",
-      ({ message }: { message: JsonString<NotificationPayload> }) => {
-        this.messageConsumer?.(message);
-      },
-    );
+    this.rpc.addMessageListener("kernelMessage", (message) => {
+      this.messageConsumer?.(message);
+    });
   }
 
-  /**
-   * Starts sessions for all apps found in the DOM
-   */
-  private startSessionsForAllApps(): void {
-    const apps = parseMarimoIslandApps(this.root);
+  async initializeApps(): Promise<void> {
+    await this.enqueueAppTransition(async () => {
+      await this.workerReady.promise;
+      await this.startApps();
+    });
+  }
+
+  private async startApps(): Promise<void> {
+    const apps = parseMarimoIslandApps(this.root, { materialize: false });
+    const managesSingleApp = apps.length === 1;
     Logger.debug(
       `Starting sessions for ${apps.length} app(s):`,
       apps.map((a) => `${a.id} (${a.cells.length} cells)`),
@@ -132,31 +136,105 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
         ? getMarimoExportContext()
         : undefined;
     const notebookCode = exportContext?.notebookCode;
+    const singleApp = managesSingleApp ? apps[0] : undefined;
+    const singleAppFile = singleApp
+      ? notebookCode || createMarimoFile(singleApp)
+      : undefined;
+    if (
+      singleApp &&
+      this.session?.appId === singleApp.id &&
+      this.session.code === singleAppFile
+    ) {
+      parseMarimoIslandApps(this.root);
+      return;
+    }
+    if (apps.length > 0) {
+      this.store.set(
+        islandsPendingInitialRunsAtom,
+        new Set(apps.map((_, index) => this.nextSessionGeneration + index + 1)),
+      );
+    }
+    parseMarimoIslandApps(this.root);
     for (const app of apps) {
-      const file = notebookCode || createMarimoFile(app);
+      const file = singleAppFile || createMarimoFile(app);
       Logger.debug(`App ${app.id} marimo file:\n`, file);
-      this.startSession({
+      const request = {
         code: file,
         appId: app.id,
-      }).catch((error) => {
+        sessionGeneration: ++this.nextSessionGeneration,
+      };
+      const previousSession = this.session;
+      const replacesSession = managesSingleApp && previousSession !== undefined;
+      if (replacesSession) {
+        this.store.set(notebookAtom, initialNotebookState());
+      }
+      if (managesSingleApp || !previousSession) {
+        if (managesSingleApp && this.sessionReady.status !== "pending") {
+          this.sessionReady = new Deferred<AppSession>();
+        }
+        this.session = {
+          ...request,
+          code: managesSingleApp ? file : undefined,
+        };
+      }
+      const operation = replacesSession
+        ? this.rpc.proxy.request.replaceSession(request)
+        : this.startSession(request);
+      try {
+        await operation;
+        if (this.sessionReady.status === "pending" && this.session) {
+          this.sessionReady.resolve(this.session);
+        }
+      } catch (error) {
+        if (this.session?.sessionGeneration === request.sessionGeneration) {
+          this.session = previousSession;
+        }
         Logger.error(`Failed to start session for app ${app.id}:`, error);
-      });
+        if (managesSingleApp) {
+          throw error;
+        }
+      }
     }
   }
 
+  async stopSession(appId?: string): Promise<void> {
+    await this.enqueueAppTransition(async () => {
+      const session = this.session;
+      if (session?.code === undefined || (appId && session.appId !== appId)) {
+        return;
+      }
+      await this.rpc.proxy.request.stopSession({
+        appId: session.appId,
+        sessionGeneration: session.sessionGeneration,
+      });
+      this.store.set(islandsPendingInitialRunsAtom, null);
+      this.session = undefined;
+      this.sessionReady = new Deferred<AppSession>();
+      this.store.set(notebookAtom, initialNotebookState());
+    });
+  }
+
+  private enqueueAppTransition(operation: () => Promise<void>): Promise<void> {
+    const result = this.appTransition.then(operation);
+    this.appTransition = result.catch(() => undefined);
+    return result;
+  }
+
   /**
    * Starts a new Python session for an app
    */
-  async startSession(opts: { code: string; appId: string }): Promise<void> {
+  async startSession(opts: {
+    code: string;
+    appId: string;
+    sessionGeneration: number;
+  }): Promise<void> {
     await this.rpc.proxy.request.startSession(opts);
   }
 
   /**
    * Sets up a consumer for kernel messages
    */
-  consumeMessages(
-    consumer: (message: JsonString<NotificationPayload>) => void,
-  ): void {
+  consumeMessages(consumer: (message: IslandsKernelMessage) => void): void {
     this.messageConsumer = consumer;
     this.rpc.proxy.send.consumerReady({});
   }
@@ -203,11 +281,19 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   // ============================================================================
 
   sendRun: EditRequests["sendRun"] = async (request): Promise<null> => {
-    await this.rpc.proxy.request.loadPackages(request.codes.join("\n"));
-    await this.putControlRequest({
-      type: "execute-cells",
-      ...request,
+    const session = await this.getActiveSession();
+    await this.rpc.proxy.request.loadPackages({
+      appId: session.appId,
+      code: request.codes.join("\n"),
+      sessionGeneration: session.sessionGeneration,
     });
+    await this.putControlRequest(
+      {
+        type: "execute-cells",
+        ...request,
+      },
+      session,
+    );
     return null;
   };
 
@@ -216,6 +302,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   // ============================================================================
 
   getUsageStats = throwNotImplemented;
+  getEnvironmentInfo = throwNotImplemented;
   sendRename = throwNotImplemented;
   sendSave = throwNotImplemented;
   sendCopy = throwNotImplemented;
@@ -278,13 +365,27 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
 
   // The kernel uses msgspec to parse control requests, which requires a 'type'
   // field for discriminated union deserialization.
-  private async putControlRequest(operation: CommandMessage): Promise<void> {
+  private async putControlRequest(
+    operation: CommandMessage,
+    session?: AppSession,
+  ): Promise<void> {
+    session ??= await this.getActiveSession();
     await this.rpc.proxy.request.bridge({
+      appId: session.appId,
       functionName: "put_control_request",
       payload: operation,
+      sessionGeneration: session.sessionGeneration,
     });
   }
 
+  private async getActiveSession(): Promise<AppSession> {
+    const transition = this.appTransition;
+    const session = this.session;
+    const ready = this.sessionReady;
+    await transition;
+    return session ?? ready.promise;
+  }
+
   /**
    * Cleans up resources (for testing)
    */