@marimo-team/frontend 0.22.1-dev8 → 0.22.2-dev50

package/src/core/codemirror/copilot/__tests__/transport.test.ts

@@ -1,5 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/* oxlint-disable typescript/no-explicit-any */
 
 import { WebSocketTransport } from "@open-rpc/client-js";
 import { beforeEach, describe, expect, it, vi } from "vitest";
@@ -365,7 +365,7 @@ describe("LazyWebsocketTransport", () => {
       expect(delegate.connect).toHaveBeenCalled();
     });
 
-    it("should clamp timeout to maxTimeoutMs", async () => {
+    it("should use maxTimeoutMs as default when no timeout is provided", async () => {
       const transport = new LazyWebsocketTransport({
         getWsUrl: mockGetWsUrl,
         waitForReady: mockWaitForReady,
@@ -376,12 +376,29 @@ describe("LazyWebsocketTransport", () => {
       await transport.connect();
 
       const data: any = { method: "test", params: [] };
-      await transport.sendData(data, 10_000);
+      await transport.sendData(data, undefined);
 
       const delegate = (transport as any).delegate;
       expect(delegate.sendData).toHaveBeenCalledWith(data, 5000);
     });
 
+    it("should respect caller-provided timeout without clamping", async () => {
+      const transport = new LazyWebsocketTransport({
+        getWsUrl: mockGetWsUrl,
+        waitForReady: mockWaitForReady,
+        showError: mockShowError,
+        maxTimeoutMs: 5000,
+      });
+
+      await transport.connect();
+
+      const data: any = { method: "test", params: [] };
+      await transport.sendData(data, 30_000);
+
+      const delegate = (transport as any).delegate;
+      expect(delegate.sendData).toHaveBeenCalledWith(data, 30_000);
+    });
+
     it("should throw error if reconnection fails", async () => {
       const connectionError = new Error("Connection failed");
       (WebSocketTransport as any).mockImplementation(function (this: any) {
@@ -407,6 +424,115 @@ describe("LazyWebsocketTransport", () => {
     });
   });
 
+  describe("onReconnect", () => {
+    it("should call onReconnect after close + sendData reconnection", async () => {
+      const transport = new LazyWebsocketTransport({
+        getWsUrl: mockGetWsUrl,
+        waitForReady: mockWaitForReady,
+        showError: mockShowError,
+      });
+
+      const onReconnect = vi.fn().mockResolvedValue(undefined);
+      transport.onReconnect = onReconnect;
+
+      // Initial connect
+      await transport.connect();
+      expect(onReconnect).not.toHaveBeenCalled();
+
+      // Close the transport (simulates failure handling)
+      transport.close();
+
+      // sendData should reconnect and call onReconnect
+      const data: any = { method: "test", params: [] };
+      await transport.sendData(data, 5000);
+
+      expect(onReconnect).toHaveBeenCalledTimes(1);
+    });
+
+    it("should NOT call onReconnect on initial sendData connection", async () => {
+      const transport = new LazyWebsocketTransport({
+        getWsUrl: mockGetWsUrl,
+        waitForReady: mockWaitForReady,
+        showError: mockShowError,
+      });
+
+      const onReconnect = vi.fn().mockResolvedValue(undefined);
+      transport.onReconnect = onReconnect;
+
+      // sendData without prior connect — this is the initial connection
+      const data: any = { method: "test", params: [] };
+      await transport.sendData(data, 5000);
+
+      expect(onReconnect).not.toHaveBeenCalled();
+    });
+
+    it("should call onReconnect after tryConnect failure + retry via sendData", async () => {
+      let connectAttempt = 0;
+      (WebSocketTransport as any).mockImplementation(function (this: any) {
+        this.connect = vi.fn().mockImplementation(() => {
+          connectAttempt++;
+          // First 2 attempts fail (retries=2 exhausted), then succeed on next sendData
+          if (connectAttempt <= 2) {
+            return Promise.reject(new Error("Connection failed"));
+          }
+          return Promise.resolve(undefined);
+        });
+        this.close = vi.fn();
+        this.sendData = vi.fn().mockResolvedValue({ result: "success" });
+        this.subscribe = vi.fn();
+        this.unsubscribe = vi.fn();
+      });
+
+      const transport = new LazyWebsocketTransport({
+        getWsUrl: mockGetWsUrl,
+        waitForReady: mockWaitForReady,
+        showError: mockShowError,
+        retries: 2,
+        retryDelayMs: 10,
+      });
+
+      const onReconnect = vi.fn().mockResolvedValue(undefined);
+      transport.onReconnect = onReconnect;
+
+      // Initial connect fails (all retries exhausted)
+      await expect(transport.connect()).rejects.toThrow("Connection failed");
+      expect(onReconnect).not.toHaveBeenCalled();
+
+      // Now sendData reconnects successfully
+      const data: any = { method: "test", params: [] };
+      await transport.sendData(data, 5000);
+
+      expect(onReconnect).toHaveBeenCalledTimes(1);
+    });
+
+    it("should propagate onReconnect rejection and allow retry", async () => {
+      const transport = new LazyWebsocketTransport({
+        getWsUrl: mockGetWsUrl,
+        waitForReady: mockWaitForReady,
+        showError: mockShowError,
+      });
+
+      const reconnectError = new Error("Re-initialization failed");
+      const onReconnect = vi.fn().mockRejectedValueOnce(reconnectError);
+      transport.onReconnect = onReconnect;
+
+      await transport.connect();
+      transport.close();
+
+      const data: any = { method: "test", params: [] };
+      await expect(transport.sendData(data, 5000)).rejects.toThrow(
+        "Re-initialization failed",
+      );
+      expect(onReconnect).toHaveBeenCalledTimes(1);
+
+      // needsReInitialization should still be true, so a subsequent retry
+      // will attempt onReconnect again
+      onReconnect.mockResolvedValueOnce(undefined);
+      await transport.sendData(data, 5000);
+      expect(onReconnect).toHaveBeenCalledTimes(2);
+    });
+  });
+
   describe("close", () => {
     it("should close delegate and clear it", async () => {
       const transport = new LazyWebsocketTransport({

package/src/core/codemirror/copilot/client.ts

@@ -37,13 +37,20 @@ export const createWSTransport = once(() => {
 export const getCopilotClient = once(() => {
   const userConfig = store.get(resolvedMarimoConfigAtom);
   const copilotSettings = userConfig.ai?.github?.copilot_settings ?? {};
+  const transport = createWSTransport();
 
-  return new CopilotLanguageServerClient({
+  const client = new CopilotLanguageServerClient({
     rootUri: FILE_URI,
     workspaceFolders: null,
-    transport: createWSTransport(),
+    transport,
     copilotSettings,
   });
+
+  // Re-run the LSP initialize handshake when the transport reconnects
+  // after a close or connection failure.
+  transport.onReconnect = () => client.reInitialize();
+
+  return client;
 });
 
 export function copilotServer() {

package/src/core/codemirror/copilot/getCodes.ts

@@ -27,7 +27,7 @@ export function getOtherCellsCode(otherCode: string) {
       return code;
     })
     .filter(Boolean)
-    .sort((a, b) => {
+    .toSorted((a, b) => {
       if (a.startsWith("import") && !b.startsWith("import")) {
         return -1;
       }

package/src/core/codemirror/copilot/language-server.ts

@@ -86,6 +86,17 @@ export class CopilotLanguageServerClient extends LanguageServerClient {
     });
   }
 
+  /**
+   * Re-run the LSP initialize handshake and send configuration.
+   * Called by the transport's onReconnect callback after reconnecting.
+   */
+  async reInitialize(): Promise<void> {
+    logger.log("#reInitialize: Re-initializing LSP connection");
+    this.initializePromise = this.initialize();
+    await this.initializePromise;
+    await this.sendConfiguration();
+  }
+
   private async sendConfiguration() {
     const settings = this.copilotSettings;
     // Skip if no settings are provided
@@ -110,7 +121,7 @@ export class CopilotLanguageServerClient extends LanguageServerClient {
     ).request(method, params);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  // oxlint-disable-next-line typescript/no-explicit-any
   override async notify(method: any, params: any): Promise<any> {
     logger.debug("#notify", method, params);
     return super.notify(method, params);

package/src/core/codemirror/copilot/transport.ts

@@ -36,7 +36,8 @@ export interface LazyWebsocketTransportOptions {
   retryDelayMs?: number;
 
   /**
-   * Maximum timeout for sendData operations in milliseconds.
+   * Default timeout for sendData operations in milliseconds.
+   * Used when the caller does not provide an explicit timeout.
    * @default 5000
    */
   maxTimeoutMs?: number;
@@ -60,6 +61,13 @@ export class LazyWebsocketTransport extends Transport {
   private delegate: WebSocketTransport | undefined;
   private pendingSubscriptions: Subscription[] = [];
   private readonly options: Required<LazyWebsocketTransportOptions>;
+  private needsReInitialization = false;
+
+  /**
+   * Callback invoked after the transport reconnects following a close or connection failure.
+   * Used by the LSP client to re-run the initialize handshake on the new connection.
+   */
+  onReconnect?: () => Promise<void>;
 
   constructor(options: LazyWebsocketTransportOptions) {
     super();
@@ -157,11 +165,11 @@ export class LazyWebsocketTransport extends Transport {
         );
         if (attempt === this.options.retries) {
           this.delegate = undefined;
+          this.needsReInitialization = true;
           // Show error toast on final retry
           this.options.showError(
             "GitHub Copilot Connection Error",
-            "Failed to connect to GitHub Copilot. Please check your settings and try again.\n\n" +
-              prettyError(error),
+            `Failed to connect to GitHub Copilot. Please check your settings and try again.\n\n${prettyError(error)}`,
           );
           throw error;
         }
@@ -183,6 +191,7 @@ export class LazyWebsocketTransport extends Transport {
   override close(): void {
     this.delegate?.close();
     this.delegate = undefined;
+    this.needsReInitialization = true;
   }
 
   override async sendData(
@@ -200,8 +209,28 @@ export class LazyWebsocketTransport extends Transport {
         Logger.error("Copilot#sendData: Failed to reconnect transport", error);
         throw new Error(
           "Unable to connect to GitHub Copilot. Please check your settings and try again.",
+          { cause: error },
         );
       }
+
+      // Re-run LSP initialization handshake after reconnecting
+      if (this.needsReInitialization && this.onReconnect) {
+        Logger.log(
+          "Copilot#sendData: Re-initializing LSP after reconnection...",
+        );
+        try {
+          await this.onReconnect();
+          this.needsReInitialization = false;
+        } catch (error) {
+          // Close the uninitialized connection so the next attempt starts fresh
+          this.close();
+          Logger.error(
+            "Copilot#sendData: LSP re-initialization after reconnection failed",
+            error,
+          );
+          throw error;
+        }
+      }
     }
 
     // After reconnection, delegate should be initialized
@@ -211,11 +240,8 @@ export class LazyWebsocketTransport extends Transport {
       );
     }
 
-    // Clamp timeout to maxTimeoutMs
-    timeout = Math.min(
-      timeout ?? this.options.maxTimeoutMs,
-      this.options.maxTimeoutMs,
-    );
+    // Use maxTimeoutMs as default when no timeout is provided
+    timeout = timeout ?? this.options.maxTimeoutMs;
     return this.delegate.sendData(data, timeout);
   }
 }

package/src/core/codemirror/copilot/types.ts

@@ -1,5 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-/* eslint-disable @typescript-eslint/no-empty-interface */
+/* oxlint-disable typescript/no-empty-object-type */
 
 export interface GitHubCopilotSignInInitiateResult {
   verificationUri: string; // https://github.com/login/device

package/src/core/codemirror/facet.ts

@@ -15,7 +15,7 @@ import { Facet } from "@codemirror/state";
 export function singleFacet<T>() {
   return Facet.define<T, T>({
     combine: (values) => {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      // oxlint-disable-next-line typescript/no-non-null-assertion
       return values.find((v) => v !== undefined)!;
     },
   });

package/src/core/codemirror/language/__tests__/sql.test.ts

@@ -1722,9 +1722,9 @@ describe("tablesCompletionSource", () => {
       };
 
       const getCompletion = (extensions: Extension[]) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // oxlint-disable-next-line typescript/no-explicit-any
         const ext = extensions.find((ext) => (ext as any).facet === undefined);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // oxlint-disable-next-line typescript/no-explicit-any
         return (ext as any)?.value?.override?.[0];
       };
 
@@ -2140,7 +2140,7 @@ describe("tablesCompletionSource", () => {
       ...mockStore.get(dataSourceConnectionsAtom),
       connectionsMap: new Map([
         [TEST_ENGINE, newConnection],
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // oxlint-disable-next-line typescript/no-explicit-any
       ]) as any,
       latestEngineSelected: TEST_ENGINE,
     });
@@ -2153,7 +2153,7 @@ describe("tablesCompletionSource", () => {
     mockStore.set(dataSourceConnectionsAtom, {
       connectionsMap: new Map([
         [TEST_ENGINE, mockConnection],
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // oxlint-disable-next-line typescript/no-explicit-any
       ]) as any,
       latestEngineSelected: TEST_ENGINE,
     });

package/src/core/codemirror/language/languages/markdown.ts

@@ -38,9 +38,7 @@ export const MARKDOWN_INITIAL_HIDE_CODE = true;
 /**
  * Language adapter for Markdown.
  */
-export class MarkdownLanguageAdapter
-  implements LanguageAdapter<MarkdownLanguageAdapterMetadata>
-{
+export class MarkdownLanguageAdapter implements LanguageAdapter<MarkdownLanguageAdapterMetadata> {
   private parser = new MarkdownParser();
 
   readonly type = "markdown";

package/src/core/codemirror/language/languages/python.ts

@@ -45,6 +45,7 @@ import type { LanguageAdapter } from "../types";
 
 const pylspClient = once((lspConfig: LSPConfig) => {
   // Create a mutable reference for the resync callback
+  // oxlint-disable-next-line prefer-const -- reassigned after closure capture
   let resyncCallback: (() => Promise<void>) | undefined;
 
   const transport = createTransport("pylsp", async () => {
@@ -151,6 +152,7 @@ const pylspClient = once((lspConfig: LSPConfig) => {
 });
 
 const tyLspClient = once((_: LSPConfig) => {
+  // oxlint-disable-next-line prefer-const -- reassigned after closure capture
   let resyncCallback: (() => Promise<void>) | undefined;
 
   const transport = createTransport("ty", async () => {
@@ -181,6 +183,7 @@ const tyLspClient = once((_: LSPConfig) => {
 
 const pyreflyClient = once(
   (lspConfig: LSPConfig & { diagnostics: DiagnosticsConfig }) => {
+    // oxlint-disable-next-line prefer-const -- reassigned after closure capture
     let resyncCallback: (() => Promise<void>) | undefined;
 
     const transport = createTransport("pyrefly", async () => {
@@ -218,6 +221,7 @@ const pyreflyClient = once(
 );
 
 const pyrightClient = once((_: LSPConfig) => {
+  // oxlint-disable-next-line prefer-const -- reassigned after closure capture
   let resyncCallback: (() => Promise<void>) | undefined;
 
   const transport = createTransport("basedpyright", async () => {

package/src/core/codemirror/language/languages/sql/completion-builder.ts

@@ -76,7 +76,7 @@ export class CompletionBuilder {
    * Set a value at a nested path, creating intermediate objects as needed
    */
   private setAt(path: string[], value: SQLNamespace): void {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // oxlint-disable-next-line typescript/no-explicit-any
     let current: any = this.schema;
     for (const key of path.slice(0, -1)) {
       if (!current[key]) {

package/src/core/codemirror/language/languages/sql/completion-sources.tsx

@@ -91,13 +91,11 @@ export function customKeywordCompletionSource(): CompletionSource {
 
 // e.g. lazily load keyword docs
 const getKeywordDocs = once(async (): Promise<Record<string, unknown>> => {
-  const keywords = await import(
-    "@marimo-team/codemirror-sql/data/common-keywords.json"
-  );
+  const keywords =
+    await import("@marimo-team/codemirror-sql/data/common-keywords.json");
   // Include DuckDB for now, but we can remove this once we have a better way to handle dialect-specific keywords
-  const duckdbKeywords = await import(
-    "@marimo-team/codemirror-sql/data/duckdb-keywords.json"
-  );
+  const duckdbKeywords =
+    await import("@marimo-team/codemirror-sql/data/duckdb-keywords.json");
   return {
     ...keywords.default.keywords,
     ...duckdbKeywords.default.keywords,

package/src/core/codemirror/language/languages/sql/sql.ts

@@ -77,9 +77,7 @@ function getLatestEngine(): ConnectionName {
 /**
  * Language adapter for SQL.
  */
-export class SQLLanguageAdapter
-  implements LanguageAdapter<SQLLanguageAdapterMetadata>
-{
+export class SQLLanguageAdapter implements LanguageAdapter<SQLLanguageAdapterMetadata> {
   private parser = new SQLParser();
   readonly type = "sql";
   sqlModeEnabled: boolean;

package/src/core/codemirror/language/metadata.ts

@@ -5,7 +5,7 @@ import type { EditorView } from "@codemirror/view";
 /**
  * Metadata for language adapters
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// oxlint-disable-next-line typescript/no-explicit-any
 export type LanguageMetadata = Record<string, any>;
 
 /**

package/src/core/codemirror/language/panel/sql.tsx

@@ -1,6 +1,9 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import type { SelectTriggerProps } from "@radix-ui/react-select";
+import type { Select as SelectPrimitive } from "radix-ui";
+
+type SelectTriggerProps = SelectPrimitive.SelectTriggerProps;
+
 import { useAtomValue } from "jotai";
 import {
   AlertCircle,

package/src/core/codemirror/language/types.ts

@@ -1,5 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/* oxlint-disable typescript/no-explicit-any */
 
 import type { Extension } from "@codemirror/state";
 import type { CellId } from "@/core/cells/ids";

package/src/core/codemirror/lsp/__tests__/notebook-lsp.test.ts

@@ -1,5 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/* oxlint-disable typescript/no-explicit-any */
 
 import { EditorView } from "@codemirror/view";
 import {

package/src/core/codemirror/lsp/notebook-lsp.ts

@@ -815,7 +815,7 @@ export class NotebookLanguageServerClient implements ILanguageServerClient {
                 ...diag,
                 range: lens.reverseRange(diag.range, cellId),
               };
-              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              // oxlint-disable-next-line typescript/no-non-null-assertion
               diagnosticsByCellId.get(cellId)!.push(cellDiag);
               break; // Exit inner loop once we find the matching cell
             }

package/src/core/codemirror/misc/__tests__/dnd.test.ts

@@ -1,5 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/* oxlint-disable typescript/no-explicit-any */
 import { EditorView } from "@codemirror/view";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { dndBundle } from "../dnd";

package/src/core/codemirror/reactive-references/__tests__/analyzer.test.ts

@@ -45,9 +45,8 @@ def foo(x):
   });
 
   test("should handle lambda parameters", () => {
-    expect(
-      runHighlight(["a", "b"], "result = lambda a: a + b"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["a", "b"], "result = lambda a: a + b"))
+      .toMatchInlineSnapshot(`
       "
       result = lambda a: a + b
                              ^
@@ -56,9 +55,8 @@ def foo(x):
   });
 
   test("should handle comprehension variables", () => {
-    expect(
-      runHighlight(["a", "data"], "result = [a for a in data]"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["a", "data"], "result = [a for a in data]"))
+      .toMatchInlineSnapshot(`
       "
       result = [a for a in data]
                            ^^^^
@@ -146,9 +144,8 @@ def factorial(n):
   });
 
   test("function param vs global", () => {
-    expect(
-      runHighlight(["a", "b"], "def foo(a): return a + b"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["a", "b"], "def foo(a): return a + b"))
+      .toMatchInlineSnapshot(`
       "
       def foo(a): return a + b
                              ^
@@ -157,9 +154,8 @@ def factorial(n):
   });
 
   test("lambda param vs global", () => {
-    expect(
-      runHighlight(["x", "b"], "func = lambda x: x + b"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["x", "b"], "func = lambda x: x + b"))
+      .toMatchInlineSnapshot(`
       "
       func = lambda x: x + b
                            ^
@@ -168,9 +164,8 @@ def factorial(n):
   });
 
   test("lambda with multiple params", () => {
-    expect(
-      runHighlight(["x", "y", "z"], "f = lambda x, y: x + y + z"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["x", "y", "z"], "f = lambda x, y: x + y + z"))
+      .toMatchInlineSnapshot(`
       "
       f = lambda x, y: x + y + z
                                ^
@@ -187,9 +182,8 @@ def factorial(n):
   });
 
   test("nested comprehension", () => {
-    expect(
-      runHighlight(["a", "b"], "[(a + b) for a, b in [(1,2), (3,4)]]"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["a", "b"], "[(a + b) for a, b in [(1,2), (3,4)]]"))
+      .toMatchInlineSnapshot(`
       "
       [(a + b) for a, b in [(1,2), (3,4)]]
       "
@@ -225,9 +219,8 @@ def factorial(n):
   });
 
   test("class body using globals", () => {
-    expect(
-      runHighlight(["a", "b"], "class MyClass:\n  value = a + b"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["a", "b"], "class MyClass:\n  value = a + b"))
+      .toMatchInlineSnapshot(`
       "
       class MyClass:
         value = a + b
@@ -237,9 +230,8 @@ def factorial(n):
   });
 
   test("decorator using global", () => {
-    expect(
-      runHighlight(["logger"], "@logger\ndef decorated(): pass"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["logger"], "@logger\ndef decorated(): pass"))
+      .toMatchInlineSnapshot(`
       "
       @logger
        ^^^^^^
@@ -317,9 +309,8 @@ ${" ".repeat(8)}
   });
 
   test("multiple assignment", () => {
-    expect(
-      runHighlight(["x", "y", "z", "a"], "x = y = z + a"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["x", "y", "z", "a"], "x = y = z + a"))
+      .toMatchInlineSnapshot(`
       "
       x = y = z + a
               ^   ^
@@ -353,9 +344,8 @@ ${" ".repeat(8)}
   });
 
   test("global in return", () => {
-    expect(
-      runHighlight(["config"], "def get_config(): return config"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["config"], "def get_config(): return config"))
+      .toMatchInlineSnapshot(`
       "
       def get_config(): return config
                                ^^^^^^
@@ -410,9 +400,8 @@ class Configurable:
   });
 
   test("comprehension shadows global 2", () => {
-    expect(
-      runHighlight(["i"], "squares = [i**2 for i in range(10)]"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["i"], "squares = [i**2 for i in range(10)]"))
+      .toMatchInlineSnapshot(`
       "
       squares = [i**2 for i in range(10)]
       "
@@ -420,9 +409,8 @@ class Configurable:
   });
 
   test("comprehension with global in condition", () => {
-    expect(
-      runHighlight(["x", "z"], "filtered = [x for x in [] if x > z]"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["x", "z"], "filtered = [x for x in [] if x > z]"))
+      .toMatchInlineSnapshot(`
       "
       filtered = [x for x in [] if x > z]
                                        ^
@@ -459,9 +447,8 @@ def make_adder(x):
   });
 
   test("rebinding in list comprehension", () => {
-    expect(
-      runHighlight(["x"], "rebinding = [x for x in range(5)]"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["x"], "rebinding = [x for x in range(5)]"))
+      .toMatchInlineSnapshot(`
       "
       rebinding = [x for x in range(5)]
       "
@@ -644,9 +631,8 @@ def run(polars):
   });
 
   test("mixed comprehension and outer globals", () => {
-    expect(
-      runHighlight(["y", "z"], "values = [y + z for y in range(5)]"),
-    ).toMatchInlineSnapshot(`
+    expect(runHighlight(["y", "z"], "values = [y + z for y in range(5)]"))
+      .toMatchInlineSnapshot(`
       "
       values = [y + z for y in range(5)]
                     ^