A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
perf: reduce redundant frontend state updates (#11377)
Myles Scolnick53ca55164e2a
diff --git a/frontend/src/components/data-table/__tests__/export-actions.test.tsx b/frontend/src/components/data-table/__tests__/export-actions.test.tsxindex 571af9cbfa..34049ed40b 100644--- a/frontend/src/components/data-table/__tests__/export-actions.test.tsx+++ b/frontend/src/components/data-table/__tests__/export-actions.test.tsx@@ -531,6 +531,23 @@ describe("ExportActions dialog", () => {expect(downloadByURL).not.toHaveBeenCalled();});+ it("does not revive an earlier source failure when switching back", async () => {+ downloadAs.mockRejectedValueOnce(new Error("First source failed"));+ const { rerenderExportActions } = renderExportActions({+ metadataSource: "first",+ });+ await openDialog();+ fireEvent.click(screen.getByRole("button", { name: "Download CSV" }));+ expect(await screen.findByRole("alert")).toHaveTextContent(+ "First source failed",+ );++ rerenderExportActions({ metadataSource: "second" });+ expect(screen.queryByRole("alert")).not.toBeInTheDocument();+ rerenderExportActions({ metadataSource: "first" });+ expect(screen.queryByRole("alert")).not.toBeInTheDocument();+ });+async function startGeoParquetInstall(strictMode = false) {const getExportMetadata = vi.fn().mockResolvedValue(geometryMetadata);downloadAs.mockResolvedValueOnce({diff --git a/frontend/src/components/data-table/charts/charts.tsx b/frontend/src/components/data-table/charts/charts.tsxindex 2a878d73e1..a23ef9e25d 100644--- a/frontend/src/components/data-table/charts/charts.tsx+++ b/frontend/src/components/data-table/charts/charts.tsx@@ -13,8 +13,8 @@ import {XIcon,} from "lucide-react";import type { JSX } from "react";-import React, { useMemo, useRef, useState } from "react";-import { type UseFormReturn, useForm } from "react-hook-form";+import React, { useMemo, useState } from "react";+import { type UseFormReturn, useForm, useWatch } from "react-hook-form";import useResizeObserver from "use-resize-observer";import { PythonIcon } from "@/components/editor/cell/code/icons";import { Alert, AlertDescription } from "@/components/ui/alert";@@ -103,16 +103,14 @@ export const TablePanel: React.FC<TablePanelProps> = ({const [selectedTab, setSelectedTab] = useState(DEFAULT_TAB_NAME);const [tabCounter, setTabCounter] = useState(tabs.length);- const prevDisplayHeader = useRef(displayHeader);+ const [prevDisplayHeader, setPrevDisplayHeader] = useState(displayHeader);++ if (displayHeader !== prevDisplayHeader) {+ setPrevDisplayHeader(displayHeader);+ }// Auto-create a default chart tab when chart builder opens with no tabs- if (- displayHeader &&- !prevDisplayHeader.current &&- tabs.length === 0 &&- cellId- ) {- prevDisplayHeader.current = displayHeader;+ if (displayHeader && !prevDisplayHeader && tabs.length === 0 && cellId) {const tabName = getChartTabName(0, NEW_CHART_TYPE);const newTabs = new Map(tabsMap);newTabs.set(cellId, [@@ -122,7 +120,6 @@ export const TablePanel: React.FC<TablePanelProps> = ({setTabCounter(1);setSelectedTab(tabName);}- prevDisplayHeader.current = displayHeader;if (!displayHeader || (tabs.length === 0 && !displayHeader)) {return dataTable;@@ -320,9 +317,10 @@ export const ChartPanel: React.FC<{saveChartType,getDataUrl,fieldTypes,- hasSchema = Boolean(fieldTypes?.length),+ hasSchema: providedHasSchema,isLargeDataset,}) => {+ const hasSchema = providedHasSchema ?? Boolean(fieldTypes?.length);const { theme } = useTheme();const form = useForm<ChartSchemaType>({defaultValues: chartConfig ?? getChartDefaults(),@@ -370,16 +368,13 @@ export const ChartPanel: React.FC<{// Re-run when the data table changes}, [tableData, renderLargeCharts, csvFieldTypes]);- const formValues = form.watch();-- // This ensures the chart re-renders when the actual values change- const memoizedFormValues = useMemo(() => {- return structuredClone(formValues);- }, [formValues]);+ // useWatch returns a new object only when a value changes. It is typed as+ // deeply partial, but the form always starts from complete defaults.+ const formValues = useWatch({ control: form.control }) as ChartSchemaType;const specWithoutData = createSpecWithoutData(selectedChartType,- memoizedFormValues,+ formValues,theme,"container",CHART_HEIGHT,diff --git a/frontend/src/components/data-table/export-actions.tsx b/frontend/src/components/data-table/export-actions.tsxindex 2dc3d3d8ec..9363c9246d 100644--- a/frontend/src/components/data-table/export-actions.tsx+++ b/frontend/src/components/data-table/export-actions.tsx@@ -24,6 +24,7 @@ import type {GetExportMetadata,} from "./schemas";import { useAsyncData } from "@/hooks/useAsyncData";+import { useStateForKey } from "@/hooks/useStateForKey";import { logNever } from "@/utils/assertNever";import { cn } from "@/utils/cn";import { copyToClipboard } from "@/utils/copy";@@ -354,7 +355,6 @@ interface ExportContext {export const ExportActions: React.FC<ExportActionProps> = (props) => {const { getExportMetadata, metadataSource } = props;const [exportDialogOpen, setExportDialogOpen] = React.useState(false);- const [failure, setFailure] = React.useState<ExportFailure | null>(null);const [settings, setSettings] =React.useState<ExportSettings>(DEFAULT_SETTINGS);const [exportContext, setExportContext] = React.useState<ExportContext>(@@ -363,6 +363,10 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {if (exportContext.source !== metadataSource) {setExportContext({ source: metadataSource });}+ const [failure, setFailure] = useStateForKey<ExportFailure | null>(+ exportContext,+ () => null,+ );const mounted = React.useRef(false);const isCurrentContext = useEvent((context: ExportContext) => mounted.current && context === exportContext,@@ -416,7 +420,6 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {}, []);React.useEffect(() => {latestActionId.current += 1;- setFailure(null);}, [metadataSource]);const policy = useAtomValue(downloadSizeLimitAtom);const overLimit = !!(@@ -452,7 +455,6 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {setExportDialogOpen(open);if (!open) {latestActionId.current += 1;- setFailure(null);setExpandedFormat(null);setSettings(DEFAULT_SETTINGS);setGeometryColumn(null);diff --git a/frontend/src/components/editor/actions/__tests__/pair-with-agent-modal.test.tsx b/frontend/src/components/editor/actions/__tests__/pair-with-agent-modal.test.tsxindex f9d47a873a..803703677a 100644--- a/frontend/src/components/editor/actions/__tests__/pair-with-agent-modal.test.tsx+++ b/frontend/src/components/editor/actions/__tests__/pair-with-agent-modal.test.tsx@@ -314,6 +314,30 @@ describe("PairWithAgentModal", () => {expect(screen.getByRole("tabpanel")).not.toHaveTextContent("--notebook");});+ it("reverifies the target when host mode is enabled again for the same Session", async () => {+ await act(async () => {+ render(<PairWithAgentModal onClose={vi.fn()} />, { wrapper });+ });+ expect(screen.getByRole("tabpanel")).toHaveTextContent(NOTEBOOK_ID);+ act(() =>+ store.set(pairConfigAtom, { ...PAIR_CONFIG, hostEnabled: false }),+ );++ const pending = new Deferred<Response>();+ vi.mocked(fetch).mockImplementation((url) =>+ String(url).endsWith("/api/sessions")+ ? pending.promise+ : responseFor(url),+ );+ act(() => store.set(pairConfigAtom, PAIR_CONFIG));+ expect(screen.getByRole("button", { name: "Copy command" })).toBeDisabled();+ expect(screen.getByRole("tabpanel")).not.toHaveTextContent(NOTEBOOK_ID);++ await act(async () => pending.resolve(await responseFor("/api/sessions")));+ expect(screen.getByRole("button", { name: "Copy command" })).toBeEnabled();+ expect(screen.getByRole("tabpanel")).toHaveTextContent(NOTEBOOK_ID);+ });+it("keeps copying disabled when Notebook verification fails", async () => {vi.mocked(fetch).mockImplementation((url) =>String(url).endsWith("/api/sessions")diff --git a/frontend/src/components/editor/actions/pair-with-agent-modal.tsx b/frontend/src/components/editor/actions/pair-with-agent-modal.tsxindex 4ff1e29f80..704467b643 100644--- a/frontend/src/components/editor/actions/pair-with-agent-modal.tsx+++ b/frontend/src/components/editor/actions/pair-with-agent-modal.tsx@@ -1,7 +1,7 @@/* Copyright 2026 Marimo. All rights reserved. */import { CheckIcon, CopyIcon } from "lucide-react";-import React, { useEffect, useState } from "react";+import React, { useEffect, useMemo, useState } from "react";import { useAtomValue } from "jotai";import { Button } from "@/components/ui/button";import {@@ -53,21 +53,20 @@ export const PairWithAgentModal: React.FC<{const config = useAtomValue(pairConfigAtom);const hostEnabled = config?.hostEnabled ?? false;const stableSessionId = useAtomValue(stableSessionIdAtom);+ const lookupIdentity = useMemo(+ () => ({ hostEnabled, stableSessionId }),+ [hostEnabled, stableSessionId],+ );const [lookup, setLookup] = useState<{- sessionId: string;- } & (- | { status: "ready"; notebookId: string | null }- | { status: "loading" | "error" }- )+ identity: typeof lookupIdentity;+ } & ({ status: "ready"; notebookId: string | null } | { status: "error" })>();useEffect(() => {- if (!hostEnabled || !stableSessionId) {- setLookup(undefined);+ const { hostEnabled, stableSessionId: sessionId } = lookupIdentity;+ if (!hostEnabled || !sessionId) {return;}- const sessionId = stableSessionId;- setLookup({ sessionId, status: "loading" });let cancelled = false;API.get<Record<string, { session_id: string; notebook_id: string | null }>>("/sessions",@@ -79,22 +78,26 @@ export const PairWithAgentModal: React.FC<{);setLookup(session- ? { sessionId, status: "ready", notebookId: session.notebook_id }- : { sessionId, status: "error" },+ ? {+ identity: lookupIdentity,+ status: "ready",+ notebookId: session.notebook_id,+ }+ : { identity: lookupIdentity, status: "error" },);}}).catch(() => {if (!cancelled) {- setLookup({ sessionId, status: "error" });+ setLookup({ identity: lookupIdentity, status: "error" });}});return () => {cancelled = true;};- }, [hostEnabled, stableSessionId]);+ }, [lookupIdentity]);const currentLookup =- lookup?.sessionId === stableSessionId ? lookup : undefined;+ lookup?.identity === lookupIdentity ? lookup : undefined;const verified = !hostEnabled || currentLookup?.status === "ready";const notebookId =hostEnabled && currentLookup?.status === "ready"diff --git a/frontend/src/components/editor/cell/__tests__/useShouldShowInterrupt.test.ts b/frontend/src/components/editor/cell/__tests__/useShouldShowInterrupt.test.tsnew file mode 100644index 0000000000..7b442bb8be--- /dev/null+++ b/frontend/src/components/editor/cell/__tests__/useShouldShowInterrupt.test.ts@@ -0,0 +1,39 @@+/* Copyright 2026 Marimo. All rights reserved. */++import { act, renderHook } from "@testing-library/react";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { useShouldShowInterrupt } from "../useShouldShowInterrupt";++describe("useShouldShowInterrupt", () => {+ beforeEach(() => vi.useFakeTimers());+ afterEach(() => vi.useRealTimers());++ it("waits for each run and hides immediately when it stops", () => {+ const { result, rerender } = renderHook(useShouldShowInterrupt, {+ initialProps: false,+ });+ expect(result.current).toBe(false);+ rerender(true);+ expect(result.current).toBe(false);+ act(() => vi.advanceTimersByTime(200));+ expect(result.current).toBe(true);+ rerender(false);+ expect(result.current).toBe(false);+ rerender(true);+ expect(result.current).toBe(false);+ act(() => vi.advanceTimersByTime(199));+ expect(result.current).toBe(false);+ act(() => vi.advanceTimersByTime(1));+ expect(result.current).toBe(true);+ });++ it("cancels the delay for a short run", () => {+ const { result, rerender } = renderHook(useShouldShowInterrupt, {+ initialProps: true,+ });+ act(() => vi.advanceTimersByTime(100));+ rerender(false);+ act(() => vi.advanceTimersByTime(200));+ expect(result.current).toBe(false);+ });+});diff --git a/frontend/src/components/editor/cell/useShouldShowInterrupt.ts b/frontend/src/components/editor/cell/useShouldShowInterrupt.tsindex d2a5a6d1bb..ff80e45b07 100644--- a/frontend/src/components/editor/cell/useShouldShowInterrupt.ts+++ b/frontend/src/components/editor/cell/useShouldShowInterrupt.ts@@ -1,5 +1,5 @@/* Copyright 2026 Marimo. All rights reserved. */-import { useEffect, useState } from "react";+import { useDelayElapsed } from "@/hooks/useDelayElapsed";const DELAY_MS = 200;@@ -10,17 +10,7 @@ const DELAY_MS = 200;export function useShouldShowInterrupt(running: boolean) {// Start a timer when the run starts.// After 200ms, show the interrupt button to avoid flickering.- const [hasRunLongEnough, setHasRunLongEnough] = useState(false);- useEffect(() => {- if (!running) {- return;- }- setHasRunLongEnough(false);- const timeout = setTimeout(() => {- setHasRunLongEnough(true);- }, DELAY_MS);- return () => clearTimeout(timeout);- }, [running]);+ const hasRunLongEnough = useDelayElapsed(running ? DELAY_MS : 0);return running && hasRunLongEnough;}diff --git a/frontend/src/components/editor/chrome/panels/__tests__/packages-panel.test.tsx b/frontend/src/components/editor/chrome/panels/__tests__/packages-panel.test.tsxindex 1d7f44a2c7..e825643198 100644--- a/frontend/src/components/editor/chrome/panels/__tests__/packages-panel.test.tsx+++ b/frontend/src/components/editor/chrome/panels/__tests__/packages-panel.test.tsx@@ -18,7 +18,10 @@ import type {DependencyTreeNode,DependencyTreeResponse,} from "@/core/network/types";-import { withPackageInvalidation } from "@/core/packages/package-data";+import {+ invalidatePackageData,+ withPackageInvalidation,+} from "@/core/packages/package-data";import { useInstallPackages } from "@/core/packages/useInstallPackage";import { sandboxAtom, sandboxSyncAtom } from "@/core/packages/sandbox-state";import { store } from "@/core/state/jotai";@@ -143,6 +146,32 @@ describe("PackagesPanel", () => {expect(screen.queryByText("cycle")).not.toBeInTheDocument();});+ it("collapses expanded nodes when the dependency tree is refreshed", async () => {+ const { client } = renderPanel(+ { kind: "sandbox", backend: "pixi" },+ populatedTree,+ );+ fireEvent.click(await screen.findByRole("treeitem", { name: /polars/ }));+ expect(screen.getByText("already in tree")).toBeInTheDocument();++ vi.mocked(client.getDependencyTree).mockResolvedValue({+ tree: structuredClone(populatedTree),+ context: { kind: "sandbox", backend: "pixi" },+ });+ act(() => invalidatePackageData());++ await waitFor(() =>+ expect(client.getDependencyTree).toHaveBeenCalledTimes(2),+ );+ await waitFor(() =>+ expect(screen.queryByText("already in tree")).not.toBeInTheDocument(),+ );+ expect(screen.getByRole("treeitem", { name: /polars/ })).toHaveAttribute(+ "aria-expanded",+ "false",+ );+ });+it("keeps the configured package manager changeable outside a sandbox", async () => {const { getPackageList } = renderPanel({kind: "package-manager",diff --git a/frontend/src/components/editor/chrome/panels/packages-panel.tsx b/frontend/src/components/editor/chrome/panels/packages-panel.tsxindex acbfa05b8b..3d231302d1 100644--- a/frontend/src/components/editor/chrome/panels/packages-panel.tsx+++ b/frontend/src/components/editor/chrome/panels/packages-panel.tsx@@ -31,6 +31,7 @@ import { usePackageAction } from "@/core/packages/usePackageAction";import { usePackageDependencies } from "@/core/packages/usePackageDependencies";import { useInstallPackages } from "@/core/packages/useInstallPackage";import { isWasm } from "@/core/wasm/utils";+import { useStateForKey } from "@/hooks/useStateForKey";import { ErrorBanner } from "@/plugins/impl/common/error-banner";import { cn } from "@/utils/cn";import { copyToClipboard } from "@/utils/copy";@@ -440,15 +441,11 @@ const DependencyTree: React.FC<{error?: Error | null;sandboxBackend: "uv" | "pixi" | null;}> = ({ tree, error, sandboxBackend }) => {- const [expandedNodes, setExpandedNodes] = React.useState<Set<string>>(- new Set(),+ const [expandedNodes, setExpandedNodes] = useStateForKey(+ tree,+ () => new Set<string>(),);- // Reset tree to collapsed state when tree data changes (including refetches)- React.useEffect(() => {- setExpandedNodes(new Set());- }, [tree]);-if (error) {return <ErrorBanner error={error} />;}diff --git a/frontend/src/components/editor/file-tree/__tests__/file-explorer-interactions.test.tsx b/frontend/src/components/editor/file-tree/__tests__/file-explorer-interactions.test.tsxindex d838f71ca4..0575297324 100644--- a/frontend/src/components/editor/file-tree/__tests__/file-explorer-interactions.test.tsx+++ b/frontend/src/components/editor/file-tree/__tests__/file-explorer-interactions.test.tsx@@ -137,5 +137,11 @@ describe("FileExplorer upload destination", () => {}),).toBeVisible();expect(screen.queryByText(".hidden")).not.toBeInTheDocument();++ fireEvent.click(screen.getByTestId("file-explorer-hidden-files-button"));+ expect(await screen.findByText(".hidden")).toBeVisible();+ expect(+ screen.getByRole("button", { name: "Upload files to workspace" }),+ ).toBeVisible();});});diff --git a/frontend/src/components/editor/file-tree/__tests__/use-file-search.test.tsx b/frontend/src/components/editor/file-tree/__tests__/use-file-search.test.tsxnew file mode 100644index 0000000000..39afe44c8f--- /dev/null+++ b/frontend/src/components/editor/file-tree/__tests__/use-file-search.test.tsx@@ -0,0 +1,91 @@+/* Copyright 2026 Marimo. All rights reserved. */++import { act, renderHook, waitFor } from "@testing-library/react";+import { beforeEach, describe, expect, it, vi } from "vitest";+import type { EditRequests } from "@/core/network/types";+import { Deferred } from "@/utils/Deferred";+import { RequestingTree } from "../requesting-tree";+import { useFileSearch } from "../use-file-search";++const sendSearchFiles = vi.hoisted(() =>+ vi.fn<EditRequests["sendSearchFiles"]>(),+);+vi.mock("@/core/network/requests", () => ({+ useRequestClient: () => ({ sendSearchFiles }),+}));++describe("useFileSearch", () => {+ let tree: RequestingTree;++ beforeEach(async () => {+ sendSearchFiles.mockReset();+ tree = new RequestingTree({+ getRoots: vi.fn().mockResolvedValue({+ roots: [{ path: "/root", name: "workspace", isPrimary: true }],+ }),+ listFiles: vi.fn().mockResolvedValue({ files: [], root: "/root" }),+ createFileOrFolder: vi.fn(),+ deleteFileOrFolder: vi.fn(),+ copyFileOrFolder: vi.fn(),+ renameFileOrFolder: vi.fn(),+ });+ await tree.initialize(() => undefined);+ });++ it("derives loading for a refetch and a changed hidden-file filter", async () => {+ sendSearchFiles.mockResolvedValue({+ files: [],+ query: "file",+ totalFound: 0,+ });+ const { result, rerender } = renderHook(+ ({ showHiddenFiles }) =>+ useFileSearch({ query: "file", tree, showHiddenFiles }),+ { initialProps: { showHiddenFiles: false } },+ );+ await waitFor(() => expect(result.current.state.status).toBe("success"));++ const pending = new Deferred<+ Awaited<ReturnType<EditRequests["sendSearchFiles"]>>+ >();+ sendSearchFiles.mockReturnValue(pending.promise);+ act(() => result.current.refetch());+ expect(result.current.state.status).toBe("loading");+ await act(async () =>+ pending.resolve({ files: [], query: "file", totalFound: 0 }),+ );+ expect(result.current.state.status).toBe("success");++ sendSearchFiles.mockReturnValue(new Promise(() => undefined));+ rerender({ showHiddenFiles: true });+ expect(result.current.state.status).toBe("loading");+ await waitFor(() =>+ expect(sendSearchFiles).toHaveBeenLastCalledWith(+ expect.objectContaining({ includeHidden: true }),+ ),+ );+ });++ it("keeps superseded scans serial and ignores their results", async () => {+ const first = new Deferred<+ Awaited<ReturnType<EditRequests["sendSearchFiles"]>>+ >();+ sendSearchFiles+ .mockReturnValueOnce(first.promise)+ .mockResolvedValue({ files: [], query: "file", totalFound: 0 });+ const { result } = renderHook(() =>+ useFileSearch({ query: "file", tree, showHiddenFiles: false }),+ );+ await waitFor(() => expect(sendSearchFiles).toHaveBeenCalledOnce());++ act(() => result.current.refetch());+ expect(sendSearchFiles).toHaveBeenCalledOnce();+ expect(result.current.state.status).toBe("loading");+ await act(async () =>+ first.resolve({ files: [], query: "file", totalFound: 0 }),+ );++ expect(sendSearchFiles).toHaveBeenCalledTimes(2);+ expect(result.current.state.status).toBe("success");+ });+});diff --git a/frontend/src/components/editor/file-tree/file-explorer.tsx b/frontend/src/components/editor/file-tree/file-explorer.tsxindex 123132ca9b..c741dc9e29 100644--- a/frontend/src/components/editor/file-tree/file-explorer.tsx+++ b/frontend/src/components/editor/file-tree/file-explorer.tsx@@ -201,11 +201,16 @@ export const FileExplorer: React.FC<{() => filterHiddenTree(data, showHiddenFiles),[data, showHiddenFiles],);- React.useEffect(() => {- if (selectedFolder && !treeContainsId(visibleData, selectedFolder.id)) {- setSelectedFolder(null);- }- }, [selectedFolder, visibleData]);+ const selectedFolderId = selectedFolder?.id;+ const selectedFolderVisible = React.useMemo(+ () =>+ selectedFolderId === undefined ||+ treeContainsId(visibleData, selectedFolderId),+ [visibleData, selectedFolderId],+ );+ if (!selectedFolderVisible) {+ setSelectedFolder(null);+ }const contextValue = React.useMemo<FileExplorerContextValue>(() => ({tree,diff --git a/frontend/src/components/editor/file-tree/use-file-search.ts b/frontend/src/components/editor/file-tree/use-file-search.tsindex 2b8954640a..c536e4e286 100644--- a/frontend/src/components/editor/file-tree/use-file-search.ts+++ b/frontend/src/components/editor/file-tree/use-file-search.ts@@ -1,6 +1,6 @@/* Copyright 2026 Marimo. All rights reserved. */-import { useCallback, useEffect, useRef, useState } from "react";+import { useCallback, useEffect, useMemo, useRef, useState } from "react";import { useRequestClient } from "@/core/network/requests";import { useDebounce } from "@/hooks/useDebounce";import {@@ -34,20 +34,29 @@ export function useFileSearch({}): { state: FileSearchState; refetch: () => void } {const { sendSearchFiles } = useRequestClient();const debouncedQuery = useDebounce(query, 300);- const pending = useRef<Promise<void>>(Promise.resolve());+ // Nullable so the ref is not built on every render+ const pending = useRef<Promise<void> | null>(null);const [revision, setRevision] = useState(0);const refetch = useCallback(() => setRevision((value) => value + 1), []);- const [result, setResult] = useState<FileSearchState>({ status: "idle" });+ const requestIdentity = useMemo(+ () => ({ query, tree, showHiddenFiles, revision, sendSearchFiles }),+ [query, tree, showHiddenFiles, revision, sendSearchFiles],+ );+ const [result, setResult] = useState<{+ requestIdentity: typeof requestIdentity;+ state: FileSearchState;+ }>();useEffect(() => {+ // Read inputs through requestIdentity so it alone drives new requests+ const { query, tree, showHiddenFiles, sendSearchFiles } = requestIdentity;let cancelled = false;if (!query || query !== debouncedQuery) {return;}- setResult({ status: "loading", query });// Let the in-flight server scan finish before starting another. Superseded// queued queries and remaining roots are skipped, keeping scan work bounded.- const request = pending.current.then(async () => {+ const request = (pending.current ?? Promise.resolve()).then(async () => {const filesByPath = new Map<string, FileTreeNode>();let rootLimitReached = false;let failedRootCount = 0;@@ -88,9 +97,12 @@ export function useFileSearch({if (!cancelled) {if (roots.length > 0 && failedRootCount === roots.length) {setResult({- status: "error",- query,- error: new Error("Could not search any root"),+ requestIdentity,+ state: {+ status: "error",+ query,+ error: new Error("Could not search any root"),+ },});return;}@@ -110,33 +122,35 @@ export function useFileSearch({rank(left) - rank(right) || left.name.localeCompare(right.name),);setResult({- status: "success",- isPartial: failedRootCount > 0,- query,- files: sortedFiles.slice(0, RESULT_LIMIT),- hasMore: rootLimitReached || sortedFiles.length > RESULT_LIMIT,+ requestIdentity,+ state: {+ status: "success",+ isPartial: failedRootCount > 0,+ query,+ files: sortedFiles.slice(0, RESULT_LIMIT),+ hasMore: rootLimitReached || sortedFiles.length > RESULT_LIMIT,+ },});}});pending.current = request.catch((error: unknown) => {if (!cancelled) {- setResult({ status: "error", query, error });+ setResult({+ requestIdentity,+ state: { status: "error", query, error },+ });}});return () => {cancelled = true;};- }, [query, debouncedQuery, tree, showHiddenFiles, revision, sendSearchFiles]);+ }, [debouncedQuery, requestIdentity]);if (!query) {return { state: { status: "idle" }, refetch };}- if (- query !== debouncedQuery ||- result.status === "idle" ||- result.query !== query- ) {+ if (query !== debouncedQuery || result?.requestIdentity !== requestIdentity) {return { state: { status: "loading", query }, refetch };}- return { state: result, refetch };+ return { state: result.state, refetch };}diff --git a/frontend/src/components/icons/__tests__/large-spinner.test.tsx b/frontend/src/components/icons/__tests__/large-spinner.test.tsxnew file mode 100644index 0000000000..dc1907f9f3--- /dev/null+++ b/frontend/src/components/icons/__tests__/large-spinner.test.tsx@@ -0,0 +1,39 @@+/* Copyright 2026 Marimo. All rights reserved. */++import { act, render, screen } from "@testing-library/react";+import { Profiler } from "react";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { LargeSpinner } from "../large-spinner";++describe("LargeSpinner", () => {+ beforeEach(() => vi.useFakeTimers());+ afterEach(() => vi.useRealTimers());++ it("fades the old title without a second commit before the timer fires", () => {+ const onRender = vi.fn();+ const spinner = (title: string) => (+ <Profiler id="spinner" onRender={onRender}>+ <LargeSpinner title={title} />+ </Profiler>+ );+ const { rerender } = render(spinner("Starting"));+ onRender.mockClear();++ rerender(spinner("Loading"));+ expect(onRender).toHaveBeenCalledOnce();+ expect(screen.getByText("Starting")).toHaveClass("opacity-0");++ act(() => vi.advanceTimersByTime(300));+ expect(screen.getByText("Loading")).toHaveClass("opacity-100");+ });++ it("restores visibility if the title changes back during the fade", () => {+ const { rerender } = render(<LargeSpinner title="Starting" />);+ rerender(<LargeSpinner title="Loading" />);+ rerender(<LargeSpinner title="Starting" />);++ expect(screen.getByText("Starting")).toHaveClass("opacity-100");+ act(() => vi.advanceTimersByTime(300));+ expect(screen.queryByText("Loading")).not.toBeInTheDocument();+ });+});diff --git a/frontend/src/components/icons/large-spinner.tsx b/frontend/src/components/icons/large-spinner.tsxindex 928b9dcb96..6faddbe4c3 100644--- a/frontend/src/components/icons/large-spinner.tsx+++ b/frontend/src/components/icons/large-spinner.tsx@@ -1,23 +1,12 @@/* Copyright 2026 Marimo. All rights reserved. */import { Loader2Icon } from "lucide-react";-import { useEffect, useState } from "react";+import { useDebounce } from "@/hooks/useDebounce";import { cn } from "@/utils/cn";export const LargeSpinner = ({ title }: { title?: string }) => {- const [currentTitle, setCurrentTitle] = useState(title);- const [isVisible, setIsVisible] = useState(true);-- useEffect(() => {- if (title !== currentTitle) {- setIsVisible(false);- const timer = setTimeout(() => {- setCurrentTitle(title);- setIsVisible(true);- }, 300); // Wait for fade out animation to complete- return () => clearTimeout(timer);- }- }, [title, currentTitle]);+ const currentTitle = useDebounce(title, 300);+ const isVisible = title === currentTitle;return (<div className="flex flex-col h-full flex-1 items-center justify-center p-4">diff --git a/frontend/src/core/network/useConnectionNotice.ts b/frontend/src/core/network/useConnectionNotice.tsindex c41dbcd175..2de14eaa6c 100644--- a/frontend/src/core/network/useConnectionNotice.ts+++ b/frontend/src/core/network/useConnectionNotice.ts@@ -17,11 +17,17 @@ export function useConnectionNotice(const notice = useAtomValue(connectionNoticeAtom);const connected = useAtomValue(isConnectedAtom);const elapsed = useDelayElapsed(notice?.pending ? delayMs : 0);- const [previous, setPrevious] = useState<ConnectionNotice | null>(null);+ const [previous, setPrevious] = useState<ConnectionNotice | null>(+ elapsed ? notice : null,+ );++ const visibleNotice = elapsed ? notice : null;+ if ((notice || !connected) && previous !== visibleNotice) {+ setPrevious(visibleNotice);+ }useEffect(() => {if (notice || !connected) {- setPrevious(elapsed ? notice : null);return;}const timeout = setTimeout(() => setPrevious(null), 1500);diff --git a/frontend/src/hooks/__tests__/useDebounce.test.tsx b/frontend/src/hooks/__tests__/useDebounce.test.tsxindex 54990a3d23..ceb43d853b 100644--- a/frontend/src/hooks/__tests__/useDebounce.test.tsx+++ b/frontend/src/hooks/__tests__/useDebounce.test.tsx@@ -121,6 +121,57 @@ describe("useDebounceControlledState", () => {expect(onChange).not.toHaveBeenCalled();});++ it("replaces an uncommitted draft when the external value changes", () => {+ const onChange = vi.fn();+ const { result, rerender } = renderHook(+ ({ value }) =>+ useDebounceControlledState({+ initialValue: value,+ onChange,+ delay: 1000,+ }),+ { initialProps: { value: "initial" } },+ );++ act(() => result.current.onChange("draft"));+ rerender({ value: "external" });+ expect(result.current.value).toBe("external");+ act(() => vi.runAllTimers());+ expect(result.current.debouncedValue).toBe("external");+ expect(onChange).not.toHaveBeenCalled();+ });++ it("handles NaN external values without repeatedly resetting the draft", () => {+ const onChange = vi.fn();+ const { result, rerender } = renderHook(+ ({ value }) =>+ useDebounceControlledState({ initialValue: value, onChange }),+ { initialProps: { value: Number.NaN } },+ );++ expect(result.current.value).toBeNaN();+ act(() => result.current.onChange(1));+ rerender({ value: Number.NaN });+ expect(result.current.value).toBe(1);+ rerender({ value: 2 });+ expect(result.current.value).toBe(2);+ rerender({ value: Number.NaN });+ expect(result.current.value).toBeNaN();+ });++ it("resets the draft when the external value changes from zero to negative zero", () => {+ const onChange = vi.fn();+ const { result, rerender } = renderHook(+ ({ value }) =>+ useDebounceControlledState({ initialValue: value, onChange }),+ { initialProps: { value: 0 } },+ );++ act(() => result.current.onChange(1));+ rerender({ value: -0 });+ expect(result.current.value).toBe(-0);+ });});describe("useDebouncedCallback", () => {diff --git a/frontend/src/hooks/__tests__/useDeepCompareMemoize.test.tsx b/frontend/src/hooks/__tests__/useDeepCompareMemoize.test.tsxnew file mode 100644index 0000000000..6f8c81724f--- /dev/null+++ b/frontend/src/hooks/__tests__/useDeepCompareMemoize.test.tsx@@ -0,0 +1,39 @@+/* Copyright 2026 Marimo. All rights reserved. */+import { renderHook } from "@testing-library/react";+import { describe, expect, it } from "vitest";+import { useDeepCompareMemoize } from "../useDeepCompareMemoize";++describe("useDeepCompareMemoize", () => {+ it("keeps equal values stable and updates changed values immediately", () => {+ const initial = { nested: [1, 2] };+ const { result, rerender } = renderHook(+ ({ value }) => useDeepCompareMemoize(value),+ {+ initialProps: { value: initial },+ },+ );+ rerender({ value: { nested: [1, 2] } });+ expect(result.current).toBe(initial);+ const changed = { nested: [1, 3] };+ rerender({ value: changed });+ expect(result.current).toBe(changed);+ rerender({ value: { nested: [1, 3] } });+ expect(result.current).toBe(changed);+ });++ it("handles inline callbacks without causing additional renders", () => {+ let renders = 0;+ const { result, rerender } = renderHook(+ ({ value }) => {+ renders++;+ return useDeepCompareMemoize({ callback: () => value });+ },+ { initialProps: { value: "initial" } },+ );++ const initialRenders = renders;+ rerender({ value: "changed" });+ expect(result.current.callback()).toBe("changed");+ expect(renders).toBe(initialRenders + 1);+ });+});diff --git a/frontend/src/hooks/__tests__/useDelayElapsed.test.tsx b/frontend/src/hooks/__tests__/useDelayElapsed.test.tsxindex 86d8645da4..e35b45c558 100644--- a/frontend/src/hooks/__tests__/useDelayElapsed.test.tsx+++ b/frontend/src/hooks/__tests__/useDelayElapsed.test.tsx@@ -52,4 +52,32 @@ describe("useDelayElapsed", () => {// The pending timeout must be cleared, not left dangling.expect(vi.getTimerCount()).toBe(0);});++ it("handles a NaN delay without resetting on every render", () => {+ const { result, rerender } = renderHook(() => useDelayElapsed(Number.NaN));+ expect(result.current).toBe(false);++ act(() => vi.runAllTimers());+ expect(result.current).toBe(true);+ rerender();+ expect(result.current).toBe(true);+ expect(vi.getTimerCount()).toBe(0);+ });++ it("restarts a completed delay after the gate is temporarily disabled", () => {+ const { result, rerender } = renderHook(+ ({ delay }) => useDelayElapsed(delay),+ { initialProps: { delay: 1000 } },+ );+ act(() => vi.advanceTimersByTime(1000));+ expect(result.current).toBe(true);+ rerender({ delay: 0 });+ expect(result.current).toBe(true);+ rerender({ delay: 1000 });+ expect(result.current).toBe(false);+ act(() => vi.advanceTimersByTime(999));+ expect(result.current).toBe(false);+ act(() => vi.advanceTimersByTime(1));+ expect(result.current).toBe(true);+ });});diff --git a/frontend/src/hooks/__tests__/useInternalStateWithSync.test.tsx b/frontend/src/hooks/__tests__/useInternalStateWithSync.test.tsxindex 66a482e00a..9178a58e67 100644--- a/frontend/src/hooks/__tests__/useInternalStateWithSync.test.tsx+++ b/frontend/src/hooks/__tests__/useInternalStateWithSync.test.tsx@@ -32,6 +32,26 @@ describe("useInternalStateWithSync", () => {expect(result.current[0]).toBe("new value");});+ it("preserves function values without calling them and resets when they change", () => {+ const initial = vi.fn(() => "initial");+ const draft = vi.fn(() => "draft");+ const changed = vi.fn(() => "changed");+ const { result, rerender } = renderHook(+ ({ value }) => useInternalStateWithSync(value),+ { initialProps: { value: initial } },+ );++ expect(result.current[0]).toBe(initial);+ act(() => result.current[1](() => draft));+ rerender({ value: initial });+ expect(result.current[0]).toBe(draft);+ rerender({ value: changed });+ expect(result.current[0]).toBe(changed);+ expect(initial).not.toHaveBeenCalled();+ expect(draft).not.toHaveBeenCalled();+ expect(changed).not.toHaveBeenCalled();+ });+it("should not update internal state if initial value remains the same", () => {const { result, rerender } = renderHook(({ value }) => useInternalStateWithSync(value),diff --git a/frontend/src/hooks/__tests__/useScript.test.tsx b/frontend/src/hooks/__tests__/useScript.test.tsxnew file mode 100644index 0000000000..05080214dd--- /dev/null+++ b/frontend/src/hooks/__tests__/useScript.test.tsx@@ -0,0 +1,77 @@+/* Copyright 2026 Marimo. All rights reserved. */+import { act, renderHook } from "@testing-library/react";+import { afterEach, describe, expect, it } from "vitest";+import { useScript } from "../useScript";++afterEach(() => {+ document.querySelectorAll("script").forEach((script) => script.remove());+});++describe("useScript", () => {+ it("observes loading and completion of a new script", async () => {+ const { result } = renderHook(() => useScript("/first.js"));+ expect(result.current).toBe("loading");+ await act(async () => {+ document.querySelector("script")?.dispatchEvent(new Event("load"));+ });+ expect(result.current).toBe("ready");+ });++ it("uses the new source's status when the source changes", async () => {+ const { result, rerender } = renderHook(({ src }) => useScript(src), {+ initialProps: { src: "/first.js" },+ });+ await act(async () => {+ document.querySelector("script")?.dispatchEvent(new Event("load"));+ });+ expect(result.current).toBe("ready");+ rerender({ src: "/second.js" });+ expect(result.current).toBe("loading");+ await act(async () => {+ document+ .querySelector('script[src="/second.js"]')+ ?.dispatchEvent(new Event("error"));+ });+ expect(result.current).toBe("error");+ });++ it("shares an existing script and only removes scripts it owns", async () => {+ const owner = renderHook(() =>+ useScript("/first.js", { removeOnUnmount: true }),+ );+ const subscriber = renderHook(() =>+ useScript("/first.js", { removeOnUnmount: true }),+ );+ expect(document.querySelectorAll("script")).toHaveLength(1);+ await act(async () => {+ document.querySelector("script")?.dispatchEvent(new Event("load"));+ });+ expect(subscriber.result.current).toBe("ready");+ subscriber.unmount();+ expect(document.querySelectorAll("script")).toHaveLength(1);+ owner.unmount();+ expect(document.querySelectorAll("script")).toHaveLength(0);+ });++ it("settles for remaining subscribers when the first unmounts mid-load", async () => {+ const first = renderHook(() => useScript("/shared.js"));+ const second = renderHook(() => useScript("/shared.js"));+ first.unmount();+ expect(second.result.current).toBe("loading");+ await act(async () => {+ document.querySelector("script")?.dispatchEvent(new Event("load"));+ });+ expect(second.result.current).toBe("ready");+ // A later subscriber sees the settled status+ expect(renderHook(() => useScript("/shared.js")).result.current).toBe(+ "ready",+ );+ });++ it("handles sources that are not valid inside a CSS selector", () => {+ const src = '/odd"name].js';+ const { result } = renderHook(() => useScript(src));+ expect(result.current).toBe("loading");+ expect(document.querySelector("script")?.getAttribute("src")).toBe(src);+ });+});diff --git a/frontend/src/hooks/__tests__/useStateForKey.test.tsx b/frontend/src/hooks/__tests__/useStateForKey.test.tsxnew file mode 100644index 0000000000..771d7bb6a7--- /dev/null+++ b/frontend/src/hooks/__tests__/useStateForKey.test.tsx@@ -0,0 +1,257 @@+/* Copyright 2026 Marimo. All rights reserved. */+import {+ act,+ fireEvent,+ render,+ renderHook,+ screen,+} from "@testing-library/react";+import {+ Profiler,+ startTransition,+ StrictMode,+ Suspense,+ useLayoutEffect,+ useState,+} from "react";+import { describe, expect, it, vi } from "vitest";+import { Deferred } from "@/utils/Deferred";+import { useStateForKey } from "../useStateForKey";++describe("useStateForKey", () => {+ it("preserves edits for the same key and creates fresh state on key changes", () => {+ const initialize = vi.fn(() => new Set<string>());+ const { result, rerender } = renderHook(+ ({ key }) => useStateForKey(key, initialize),+ { initialProps: { key: "first" } },+ );+ const initial = result.current[0];+ act(() => result.current[1](new Set(["expanded"])));+ rerender({ key: "first" });+ expect(result.current[0]).toEqual(new Set(["expanded"]));+ expect(initialize).toHaveBeenCalledOnce();++ rerender({ key: "second" });+ expect(result.current[0]).toEqual(new Set());+ expect(result.current[0]).not.toBe(initial);+ expect(initialize).toHaveBeenCalledTimes(2);++ rerender({ key: "first" });+ expect(result.current[0]).toEqual(new Set());+ expect(initialize).toHaveBeenCalledTimes(3);+ });++ it("preserves queued functional updates and ignores setters from another key", () => {+ const { result, rerender } = renderHook(+ ({ key }) => useStateForKey(key, () => 0),+ { initialProps: { key: "first" } },+ );+ const oldSetter = result.current[1];+ act(() => {+ result.current[1]((value) => value + 1);+ result.current[1]((value) => value + 1);+ });+ expect(result.current[0]).toBe(2);++ rerender({ key: "second" });+ const staleUpdate = vi.fn(() => 99);+ act(() => oldSetter(staleUpdate));+ act(() => oldSetter(99));+ expect(result.current[0]).toBe(0);+ expect(staleUpdate).not.toHaveBeenCalled();+ });++ it("uses Object.is for NaN and signed zero keys", () => {+ const { result, rerender } = renderHook(+ ({ key }) => useStateForKey(key, () => "initial"),+ { initialProps: { key: Number.NaN } },+ );+ act(() => result.current[1]("draft"));+ rerender({ key: Number.NaN });+ expect(result.current[0]).toBe("draft");++ rerender({ key: 0 });+ expect(result.current[0]).toBe("initial");+ act(() => result.current[1]("draft"));+ rerender({ key: -0 });+ expect(result.current[0]).toBe("initial");+ });++ it("stores function values without invoking them", () => {+ const initial = vi.fn();+ const changed = vi.fn();+ const { result, rerender } = renderHook(+ ({ key, value }) => useStateForKey(key, () => value),+ { initialProps: { key: "first", value: initial } },+ );+ expect(result.current[0]).toBe(initial);+ act(() => result.current[1](() => changed));+ expect(result.current[0]).toBe(changed);+ rerender({ key: "second", value: initial });+ expect(result.current[0]).toBe(initial);+ expect(initial).not.toHaveBeenCalled();+ expect(changed).not.toHaveBeenCalled();+ });++ it("uses a changed initializer only after the key changes", () => {+ const first = vi.fn(() => "first default");+ const second = vi.fn(() => "second default");+ const { result, rerender } = renderHook(+ ({ key, initialize }) => useStateForKey(key, initialize),+ { initialProps: { key: "A", initialize: first } },+ );+ act(() => result.current[1]("draft"));+ rerender({ key: "A", initialize: second });+ expect(result.current[0]).toBe("draft");+ expect(second).not.toHaveBeenCalled();+ rerender({ key: "B", initialize: second });+ expect(result.current[0]).toBe("second default");+ expect(second).toHaveBeenCalledOnce();+ });++ it("compares object keys by reference rather than their contents", () => {+ const key = { id: "A" };+ const { result, rerender } = renderHook(+ ({ key }) => useStateForKey(key, () => 0),+ { initialProps: { key } },+ );+ act(() => result.current[1](1));+ rerender({ key });+ expect(result.current[0]).toBe(1);+ rerender({ key: { id: "A" } });+ expect(result.current[0]).toBe(0);+ });++ it("keeps setters stable for the same key and accepts old setters when that key returns", () => {+ const { result, rerender } = renderHook(+ ({ key }) => useStateForKey(key, () => 0),+ { initialProps: { key: "A" } },+ );+ const setA = result.current[1];+ act(() => setA(1));+ rerender({ key: "A" });+ expect(result.current[1]).toBe(setA);+ rerender({ key: "B" });+ expect(result.current[1]).not.toBe(setA);+ act(() => setA(2));+ expect(result.current[0]).toBe(0);+ rerender({ key: "A" });+ act(() => setA(3));+ expect(result.current[0]).toBe(3);+ });++ it("retries the owner without rendering or committing stale state to children", () => {+ const onOwnerRender = vi.fn();+ const onChildRender = vi.fn();+ const onCommit = vi.fn();+ const onLayout = vi.fn();+ function Child({ owner, value }: { owner: string; value: string }) {+ onChildRender(owner, value);+ useLayoutEffect(() => onLayout(owner, value), [owner, value]);+ return <span>{value}</span>;+ }+ function Owner({ owner }: { owner: string }) {+ onOwnerRender();+ const [value, setValue] = useStateForKey(owner, () => `${owner} default`);+ return (+ <>+ <button onClick={() => setValue("draft")}>Edit</button>+ <Child owner={owner} value={value} />+ </>+ );+ }+ const content = (owner: string) => (+ <Profiler id="owner" onRender={onCommit}>+ <Owner owner={owner} />+ </Profiler>+ );+ const { rerender } = render(content("A"));+ const button = screen.getByRole("button", { name: "Edit" });+ fireEvent.click(button);+ expect(screen.getByText("draft")).toBeInTheDocument();+ onOwnerRender.mockClear();+ onChildRender.mockClear();+ onCommit.mockClear();+ onLayout.mockClear();++ rerender(content("B"));+ expect(onOwnerRender.mock.calls.length).toBeGreaterThan(1);+ expect(onChildRender.mock.calls).toEqual([["B", "B default"]]);+ expect(onLayout.mock.calls).toEqual([["B", "B default"]]);+ expect(onCommit).toHaveBeenCalledOnce();+ expect(screen.getByRole("button", { name: "Edit" })).toBe(button);+ });++ it("keeps state correct when Strict Mode repeats initialization and updates", () => {+ const initialize = vi.fn(() => new Set<string>());+ const { result, rerender } = renderHook(+ ({ key }) => useStateForKey(key, initialize),+ { initialProps: { key: "A" }, wrapper: StrictMode },+ );+ expect(initialize.mock.calls.length).toBeGreaterThan(1);+ act(() => result.current[1]((previous) => new Set([...previous, "draft"])));+ expect(result.current[0]).toEqual(new Set(["draft"]));+ rerender({ key: "B" });+ expect(result.current[0]).toEqual(new Set());+ });++ it.each(["completes", "is canceled"])(+ "preserves visible edits when a suspended transition %s",+ async (outcome) => {+ const pending = new Deferred<void>();+ let blocked = true;+ const suspended = vi.fn();+ function Pending({ owner }: { owner: string }) {+ if (owner === "B" && blocked) {+ suspended();+ throw pending.promise;+ }+ return null;+ }+ function Owner({ owner }: { owner: string }) {+ const [value, setValue] = useStateForKey(owner, () => 0);+ return (+ <>+ <button onClick={() => setValue((previous) => previous + 1)}>+ {owner}:{value}+ </button>+ <Pending owner={owner} />+ </>+ );+ }+ function Harness() {+ const [owner, setOwner] = useState("A");+ return (+ <>+ <button onClick={() => startTransition(() => setOwner("B"))}>+ Switch owner+ </button>+ <button onClick={() => setOwner("A")}>Keep owner</button>+ <Suspense fallback="Loading">+ <Owner owner={owner} />+ </Suspense>+ </>+ );+ }+ render(<Harness />);+ fireEvent.click(screen.getByRole("button", { name: "A:0" }));+ fireEvent.click(screen.getByRole("button", { name: "Switch owner" }));+ expect(suspended).toHaveBeenCalled();+ fireEvent.click(screen.getByRole("button", { name: "A:1" }));+ expect(screen.getByRole("button", { name: "A:2" })).toBeInTheDocument();+ if (outcome === "is canceled") {+ fireEvent.click(screen.getByRole("button", { name: "Keep owner" }));+ }+ await act(async () => {+ blocked = false;+ pending.resolve();+ await pending.promise;+ });+ expect(+ screen.getByRole("button", {+ name: outcome === "completes" ? "B:0" : "A:2",+ }),+ ).toBeInTheDocument();+ },+ );+});diff --git a/frontend/src/hooks/useDebounce.ts b/frontend/src/hooks/useDebounce.tsindex cd142c41ba..fbeb2d1775 100644--- a/frontend/src/hooks/useDebounce.ts+++ b/frontend/src/hooks/useDebounce.ts@@ -2,6 +2,7 @@import { debounce } from "lodash-es";import { useEffect, useMemo, useState } from "react";import useEvent from "react-use-event-hook";+import { useInternalStateWithSync } from "./useInternalStateWithSync";export function useDebounce<T>(value: T, delay: number): T {const [debouncedValue, setDebouncedValue] = useState<T>(value);@@ -41,18 +42,14 @@ export function useDebounceControlledState<T>(opts: {disabled?: boolean;}) {const { initialValue, onChange, delay, disabled } = opts;- const [internalValue, setInternalValue] = useState<T>(initialValue);+ const [internalValue, setInternalValue] = useInternalStateWithSync(+ initialValue,+ Object.is,+ );const debouncedValue = useDebounce(internalValue, delay || 200);const onUpdate = useEvent(onChange);- // Handle external changes:- useEffect(() => {- // TODO: Replace this synchronization with a controlled-state primitive.- // oxlint-disable-next-line react/no-deriving-state-in-effects -- Synchronize the debounced draft when the controlled value changes.- setInternalValue(initialValue);- }, [initialValue]);-// Handle debounced updates for user inputuseEffect(() => {if (disabled) {diff --git a/frontend/src/hooks/useDeepCompareMemoize.ts b/frontend/src/hooks/useDeepCompareMemoize.tsindex 31b8a49d13..0e9203c941 100644--- a/frontend/src/hooks/useDeepCompareMemoize.ts+++ b/frontend/src/hooks/useDeepCompareMemoize.ts@@ -12,7 +12,7 @@ import React from "react";* Useful when the re-render if more expensive than the deep compare.*/export function useDeepCompareMemoize<T>(value: T) {- const ref = React.useRef<T>(value);+ const ref = React.useRef(value);if (!dequal(value, ref.current)) {ref.current = value;diff --git a/frontend/src/hooks/useDelayElapsed.ts b/frontend/src/hooks/useDelayElapsed.tsindex 0af0a7e4cd..7afb1a838a 100644--- a/frontend/src/hooks/useDelayElapsed.ts+++ b/frontend/src/hooks/useDelayElapsed.ts@@ -1,6 +1,6 @@/* Copyright 2026 Marimo. All rights reserved. */-import { useLayoutEffect, useState } from "react";+import { useEffect, useState } from "react";/*** Returns `false` until `delayMs` has elapsed since mount (or since `delayMs`@@ -8,20 +8,24 @@ import { useLayoutEffect, useState } from "react";* `delayMs <= 0`. Useful for suppressing spinner/fallback flashes.*/export function useDelayElapsed(delayMs: number): boolean {- const [elapsed, setElapsed] = useState(delayMs <= 0);+ const [timer, setTimer] = useState({ delayMs, elapsed: delayMs <= 0 });- // Layout effect (not a plain effect) so that when `delayMs` flips from `<= 0`- // to `> 0` — e.g. a gate re-closing — we reset `elapsed` to `false` before- // the browser paints, rather than briefly flashing the fallback for a frame.- useLayoutEffect(() => {+ // Reset during render so a changed delay never commits a stale `elapsed`+ // (e.g. a gate re-closing shows no fallback flash before paint)+ if (!Object.is(timer.delayMs, delayMs)) {+ setTimer({ delayMs, elapsed: delayMs <= 0 });+ }++ useEffect(() => {if (delayMs <= 0) {- setElapsed(true);return;}- setElapsed(false);- const timeout = setTimeout(() => setElapsed(true), delayMs);+ const timeout = setTimeout(+ () => setTimer({ delayMs, elapsed: true }),+ delayMs,+ );return () => clearTimeout(timeout);}, [delayMs]);- return elapsed;+ return timer.elapsed;}diff --git a/frontend/src/hooks/useInternalStateWithSync.ts b/frontend/src/hooks/useInternalStateWithSync.tsindex 27ff3aa55d..d3f7ee1103 100644--- a/frontend/src/hooks/useInternalStateWithSync.ts+++ b/frontend/src/hooks/useInternalStateWithSync.ts@@ -1,5 +1,5 @@/* Copyright 2026 Marimo. All rights reserved. */-import { useRef, useState } from "react";+import { useState } from "react";type EqualityFn<T> = (a: T, b: T) => boolean;@@ -13,13 +13,13 @@ export function useInternalStateWithSync<T>(initial: T,equalityFn: EqualityFn<T> = defaultEqualityFn,) {- const [state, setState] = useState(initial);- const ref = useRef(initial);+ const [state, setState] = useState(() => initial);+ const [previousInitial, setPreviousInitial] = useState(() => initial);// Whenever the outside state changes, update the internal state- if (!equalityFn(ref.current, initial)) {- setState(initial); // react is ok to setState during render- ref.current = initial;+ if (!equalityFn(previousInitial, initial)) {+ setState(() => initial);+ setPreviousInitial(() => initial);}return [state, setState] as const;diff --git a/frontend/src/hooks/useScript.ts b/frontend/src/hooks/useScript.tsindex e5db999ccd..b03d7b8f1a 100644--- a/frontend/src/hooks/useScript.ts+++ b/frontend/src/hooks/useScript.ts@@ -1,90 +1,87 @@/* Copyright 2026 Marimo. All rights reserved. */-import React from "react";+import { useCallback, useSyncExternalStore } from "react";type ScriptStatus = "loading" | "ready" | "error" | "unknown";interface ScriptOptions {removeOnUnmount?: boolean;}+interface ScriptEntry {+ element: HTMLScriptElement;+ listeners: Set<() => void>;+ /** Whether useScript created the element, and so may remove it. */+ owned: boolean;+}+const defaultOptions = { removeOnUnmount: false };+// One entry per src, so reading the status on render is a map lookup+const scripts = new Map<string, ScriptEntry>();++function findScript(src: string): HTMLScriptElement | undefined {+ // Compare attributes rather than building a selector, which `src` could break+ return [...document.scripts].find(+ (script) => script.getAttribute("src") === src,+ );+}++function acquireScript(src: string): ScriptEntry {+ const cached = scripts.get(src);+ if (cached?.element.isConnected) {+ return cached;+ }+ const existing = findScript(src);+ const element = existing ?? document.createElement("script");+ const entry: ScriptEntry = {+ element,+ listeners: new Set(),+ owned: !existing,+ };+ const setStatus = (status: ScriptStatus) => {+ element.dataset.status = status;+ entry.listeners.forEach((listener) => listener());+ };+ // Listen for the script's lifetime rather than per subscriber, so the+ // status still settles if the first subscriber unmounts mid-load.+ element.addEventListener("load", () => setStatus("ready"), { once: true });+ element.addEventListener("error", () => setStatus("error"), { once: true });+ if (!existing) {+ element.src = src;+ element.async = true;+ element.dataset.status = "loading";+ document.body.append(element);+ }+ scripts.set(src, entry);+ return entry;+}+export function useScript(src: string,options: ScriptOptions = defaultOptions,) {- const [status, setStatus] = React.useState<ScriptStatus>(() => {- const existingScript = document.querySelector<HTMLScriptElement>(- `script[src="${src}"]`,- );- return (existingScript?.dataset.status as ScriptStatus) || "unknown";- });-- React.useEffect(() => {- let script = document.querySelector<HTMLScriptElement>(- `script[src="${src}"]`,- );-- const updateStatus = (newStatus: ScriptStatus) => {- if (script) {- script.dataset.status = newStatus;- setStatus(newStatus);- }- };-- const handleScriptLoad = () => updateStatus("ready");- const handleScriptError = () => updateStatus("error");-- // observes DOM changes and updates the status- const observeScript = (script: HTMLScriptElement) => {- const observer = new MutationObserver(() => {- const newStatus = script.dataset.status;- if (newStatus) {- setStatus(newStatus as ScriptStatus);- }- });- observer.observe(script, {- attributes: true,- attributeFilter: ["data-status"],- });- return observer;- };-- if (!script) {- script = document.createElement("script");- script.src = src;- script.async = true;- updateStatus("loading");- document.body.append(script);-- script.addEventListener("load", handleScriptLoad);- script.addEventListener("error", handleScriptError);-- const observer = observeScript(script);+ const { removeOnUnmount } = options;+ const getSnapshot = useCallback((): ScriptStatus => {+ const cached = scripts.get(src)?.element;+ const element = cached?.isConnected ? cached : findScript(src);+ return (element?.dataset.status as ScriptStatus) || "unknown";+ }, [src]);+ const subscribe = useCallback(+ (onChange: () => void) => {+ const entry = acquireScript(src);+ entry.listeners.add(onChange);return () => {- observer.disconnect();- if (script) {- script.removeEventListener("load", handleScriptLoad);- script.removeEventListener("error", handleScriptError);-- if (options.removeOnUnmount) {- script.remove();+ entry.listeners.delete(onChange);+ if (removeOnUnmount && entry.owned && entry.listeners.size === 0) {+ entry.element.remove();+ if (scripts.get(src) === entry) {+ scripts.delete(src);}}};- }-- const domStatus = script.dataset.status;- if (domStatus) {- if (domStatus === "ready" || domStatus === "error") {- return;- }- const observer = observeScript(script);- return () => observer.disconnect();- }-- setStatus("unknown");- }, [src, options.removeOnUnmount]);+ },+ [src, removeOnUnmount],+ );- return status;+ return useSyncExternalStore(subscribe, getSnapshot);}diff --git a/frontend/src/hooks/useStateForKey.ts b/frontend/src/hooks/useStateForKey.tsnew file mode 100644index 0000000000..3bf07b9397--- /dev/null+++ b/frontend/src/hooks/useStateForKey.ts@@ -0,0 +1,93 @@+/* Copyright 2026 Marimo. All rights reserved. */+import { type SetStateAction, useCallback, useReducer } from "react";++interface KeyedState<T> {+ key: unknown;+ value: T;+}++type KeyedAction<T> =+ | { type: "reset"; state: KeyedState<T> }+ | { type: "update"; key: unknown; update: SetStateAction<T> };++function reduceKeyedState<T>(+ previous: KeyedState<T>,+ action: KeyedAction<T>,+): KeyedState<T> {+ if (action.type === "reset") {+ return action.state;+ }+ if (!Object.is(previous.key, action.key)) {+ return previous;+ }+ const value =+ typeof action.update === "function"+ ? (action.update as (previous: T) => T)(previous.value)+ : action.update;+ return Object.is(previous.value, value)+ ? previous+ : { key: action.key, value };+}++/**+ * Local state that resets when its owner key changes.+ *+ * The key uses Object.is. NaN matches NaN, 0 differs from -0, and objects match+ * by reference. Keep the key stable between resets. An inline object such as+ * `{ id }` creates a new key on each render and causes a render loop.+ *+ * On a key change, this hook calls initialize() and schedules a state update+ * during render. React retries the calling component before rendering its+ * children. Children and effects receive the reset value without an intervening+ * commit of the old value. This resets only this hook's state. The component+ * stays mounted, and its other hooks keep their state.+ *+ * initialize must be pure. React can call it more than once in Strict Mode or+ * when retrying an interrupted render. A new initializer alone does not reset+ * state. The next key change uses the initializer from that render. After+ * committed key changes A -> B -> A, A starts fresh instead of restoring its+ * earlier value. If React abandons a pending render for B, the visible state+ * for A remains intact, including edits made while B was pending.+ *+ * The setter accepts values or pure updater functions, like useState. To store+ * a function, use setValue(() => callback). Its identity is stable for the same+ * key and changes with the key. Updates from a different key are ignored,+ * including their updater functions. After A -> B -> A, an old setter for A+ * can update A again. This hook does not cancel requests. For request results,+ * use a distinct key for each lifetime so late results stay invalid.+ *+ * React can still call the component for ignored or same-value updates.+ * Render counts do not indicate how many changes React commits to the screen.+ *+ * Use useInternalStateWithSync when the external value itself supplies the+ * reset value. Use this hook when a separate key controls the reset.+ *+ * @example+ * const [expanded, setExpanded] = useStateForKey(tree, () => new Set<string>());+ *+ * @see https://react.dev/reference/react/useState#storing-information-from-previous-renders+ */+export function useStateForKey<T>(key: unknown, initialize: () => T) {+ // useState can eagerly evaluate an updater against a suspended render's+ // state. A reducer checks the key when React processes each render's queue,+ // so the still-visible owner can accept edits during a transition.+ const [stored, dispatch] = useReducer(reduceKeyedState<T>, key, (key) => ({+ key,+ value: initialize(),+ }));+ const current = Object.is(stored.key, key)+ ? stored+ : { key, value: initialize() };+ if (current !== stored) {+ dispatch({ type: "reset", state: current });+ }++ const setValue = useCallback(+ (update: SetStateAction<T>) => {+ dispatch({ type: "update", key, update });+ },+ [key],+ );++ return [current.value, setValue] as const;+}diff --git a/frontend/src/plugins/impl/DataTablePlugin.tsx b/frontend/src/plugins/impl/DataTablePlugin.tsxindex 0f015faadd..612263ff9c 100644--- a/frontend/src/plugins/impl/DataTablePlugin.tsx+++ b/frontend/src/plugins/impl/DataTablePlugin.tsx@@ -546,10 +546,12 @@ export const LoadingDataTableComponent = memo(}}, [setValue, filters, searchQuery, sorting, props.hasStableRowId]);- // If pageSize changes, reset pagination state- useEffect(() => {+ const [previousPageSize, setPreviousPageSize] = useState(props.pageSize);+ // Reconcile before requesting data for the updated table configuration.+ if (previousPageSize !== props.pageSize) {+ setPreviousPageSize(props.pageSize);setPaginationState({ pageIndex: 0, pageSize: props.pageSize });- }, [props.pageSize]);+ }// Data loadingconst { data, error, isPending, isFetching } = useAsyncData<{@@ -697,12 +699,13 @@ export const LoadingDataTableComponent = memo([search, sorting, filters, searchQuery],);- // If total rows change, reset pageIndex- useEffect(() => {+ const [previousTotalRows, setPreviousTotalRows] = useState(data?.totalRows);+ if (previousTotalRows !== data?.totalRows) {+ setPreviousTotalRows(data?.totalRows);setPaginationState((state) =>state.pageIndex === 0 ? state : { ...state, pageIndex: 0 },);- }, [data?.totalRows]);+ }// Column summariesconst { data: columnSummaries, error: columnSummariesError } = useAsyncData<@@ -835,7 +838,7 @@ const DataTableComponent = ({sizeBytesIsLoading,maxColumns,pagination,- selection,+ selection: requestedSelection,value,showFilters,showDownload,@@ -843,7 +846,7 @@ const DataTableComponent = ({showColumnExplorer,showRowExplorer,showChartBuilder,- showDataTypes,+ showDataTypes: requestedShowDataTypes,rowHeaders,fieldTypes,paginationState,@@ -975,15 +978,11 @@ const DataTableComponent = ({const fractionDigitsByColumn = useDeepCompareMemoize(computedFractionDigits);const shownColumns = memoizedClampedFieldTypes.length;- // If the field types are not set, we don't show them- if (!fieldTypes) {- showDataTypes = false;- }+ // Only show data types when they are explicitly supplied.+ const showDataTypes = Boolean(fieldTypes && requestedShowDataTypes);// Row/cell selection writes back to the kernel, absent in static exports.- if (isStatic) {- selection = null;- }+ const selection = isStatic ? null : requestedSelection;const columns = useMemo(() =>diff --git a/frontend/src/plugins/impl/FileBrowserPlugin.tsx b/frontend/src/plugins/impl/FileBrowserPlugin.tsxindex 05080111b2..3a5f4637d2 100644--- a/frontend/src/plugins/impl/FileBrowserPlugin.tsx+++ b/frontend/src/plugins/impl/FileBrowserPlugin.tsx@@ -1,7 +1,7 @@/* Copyright 2026 Marimo. All rights reserved. */import { type LucideIcon, ChevronRightIcon, CornerLeftUp } from "lucide-react";-import { type JSX, useEffect, useLayoutEffect, useRef, useState } from "react";+import { type JSX, useLayoutEffect, useRef, useState } from "react";import { z } from "zod";import {FILE_ICON as FILE_TYPE_ICONS,@@ -16,6 +16,7 @@ import { Table, TableBody, TableCell, TableRow } from "@/components/ui/table";import { toast } from "@/components/ui/use-toast";import { RANDOM_ID_ATTR } from "@/core/dom/ui-element-constants";import { useAsyncData } from "@/hooks/useAsyncData";+import { useDelayElapsed } from "@/hooks/useDelayElapsed";import { useInternalStateWithSync } from "@/hooks/useInternalStateWithSync";import { cn } from "@/utils/cn";import { type FilePath, PathBuilder, Paths } from "@/utils/paths";@@ -200,7 +201,6 @@ export const FileBrowser = ({}: FileBrowserProps): JSX.Element | null => {const [path, setPath] = useInternalStateWithSync(initialPath);const [isUpdatingPath, setIsUpdatingPath] = useState(false);- const [showLoadingOverlay, setShowLoadingOverlay] = useState(false);const [activeIndex, setActiveIndex] = useState(0);const rowRefs = useRef<(HTMLTableRowElement | null)[]>([]);const gridRef = useRef<HTMLTableElement | null>(null);@@ -219,20 +219,8 @@ export const FileBrowser = ({return list_directory({ path: path });}, [path, randomId, list_directory]);- useEffect(() => {- if (!isPending) {- setShowLoadingOverlay(false);- return;- }-- const timeout = window.setTimeout(() => {- setShowLoadingOverlay(true);- }, 200);-- return () => {- window.clearTimeout(timeout);- };- }, [isPending]);+ const loadingDelayElapsed = useDelayElapsed(isPending ? 200 : 0);+ const showLoadingOverlay = isPending && loadingDelayElapsed;// Reset the roving tabindex whenever the listing reloads (a new path or a// same-path refresh) so activeIndex never points past the current rows.diff --git a/frontend/src/plugins/impl/SliderPlugin.tsx b/frontend/src/plugins/impl/SliderPlugin.tsxindex 6254cbcfe6..72147e87fa 100644--- a/frontend/src/plugins/impl/SliderPlugin.tsx+++ b/frontend/src/plugins/impl/SliderPlugin.tsx@@ -1,8 +1,9 @@/* Copyright 2026 Marimo. All rights reserved. */-import { type JSX, useEffect, useId, useMemo, useState } from "react";+import { type JSX, useId, useMemo } from "react";import { useLocale } from "react-aria";import { z } from "zod";import { NumberField } from "@/components/ui/number-field";+import { useInternalStateWithSync } from "@/hooks/useInternalStateWithSync";import { cn } from "@/utils/cn";import { clamp } from "@/utils/math";import {@@ -156,13 +157,10 @@ const SliderComponent = ({const { locale } = useLocale();// Hold internal value- const [internalValue, setInternalValue] = useState(value);- // Update internal value on prop change- useEffect(() => {- // TODO: Replace this synchronization with a controlled-state primitive.- // oxlint-disable-next-line react/no-deriving-state-in-effects -- Synchronize the editable buffer when the controlled value changes.- setInternalValue(value);- }, [value]);+ const [internalValue, setInternalValue] = useInternalStateWithSync(+ value,+ Object.is,+ );const stepsConfig = useMemo(() => computeStepsConfig(steps), [steps]);diff --git a/frontend/src/plugins/impl/__tests__/DataTablePlugin.test.tsx b/frontend/src/plugins/impl/__tests__/DataTablePlugin.test.tsxindex c093c0c682..65602ab477 100644--- a/frontend/src/plugins/impl/__tests__/DataTablePlugin.test.tsx+++ b/frontend/src/plugins/impl/__tests__/DataTablePlugin.test.tsx@@ -12,11 +12,13 @@ import {waitFor,} from "@testing-library/react";import { Provider } from "jotai";+import { useState } from "react";import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";import { SetupMocks } from "@/__mocks__/common";import type { DownloadAsFunction } from "@/components/data-table/schemas";import type { FieldTypesWithExternalType } from "@/components/data-table/types";import { store } from "@/core/state/jotai";+import { Deferred } from "@/utils/Deferred";import {type GetDataUrl,type GetRowIds,@@ -463,7 +465,7 @@ describe("LoadingDataTableComponent", () => {});});-describe("static notebook control suppression", () => {+describe("table pagination and static notebook control suppression", () => {const fieldTypes: FieldTypesWithExternalType = [["id", ["integer", "integer"]],["name", ["string", "string"]],@@ -538,6 +540,120 @@ describe("static notebook control suppression", () => {mockIsStatic.mockReturnValue(false);});+ it("requests only the first page with the new configured page size", async () => {+ const props = makeProps();+ const view = (pageSize: number) => (+ <Wrapper>+ <LoadingDataTableComponent {...props} pageSize={pageSize} />+ </Wrapper>+ );+ const { rerender } = render(view(PAGE_SIZE));+ await waitFor(() =>+ expect(screen.getByTestId("next-page-button")).toBeEnabled(),+ );+ fireEvent.click(screen.getByTestId("next-page-button"));+ await waitFor(() =>+ expect(props.search).toHaveBeenLastCalledWith(+ expect.objectContaining({ page_number: 1, page_size: PAGE_SIZE }),+ ),+ );+ await waitFor(() =>+ expect(screen.getByTestId("next-page-button")).toBeEnabled(),+ );+ props.search.mockClear();++ rerender(view(5));+ await waitFor(() => expect(props.search).toHaveBeenCalled());+ expect(+ props.search.mock.calls.every(+ ([request]) => request.page_number === 0 && request.page_size === 5,+ ),+ ).toBe(true);+ });++ it("preserves a new page size when a pending response changes the row count in the same batch", async () => {+ const props = makeProps();+ const Harness = () => {+ const [pageSize, setPageSize] = useState(PAGE_SIZE);+ return (+ <Wrapper>+ <button type="button" onClick={() => setPageSize(5)}>+ Change configured page size+ </button>+ <LoadingDataTableComponent {...props} pageSize={pageSize} />+ </Wrapper>+ );+ };+ render(<Harness />);+ await waitFor(() =>+ expect(screen.getByTestId("next-page-button")).toBeEnabled(),+ );+ const response = {+ data: firstPage,+ total_rows: 25,+ cell_styles: null,+ cell_hover_texts: null,+ };+ const pendingPage = new Deferred<typeof response>();+ props.search.mockReturnValueOnce(pendingPage.promise);+ fireEvent.click(screen.getByTestId("next-page-button"));+ await waitFor(() =>+ expect(props.search).toHaveBeenLastCalledWith(+ expect.objectContaining({ page_number: 1, page_size: PAGE_SIZE }),+ ),+ );+ props.search.mockClear();++ await act(async () => {+ pendingPage.resolve(response);+ // Settle the table-loading promises without committing the queued render.+ await new Promise((resolve) => setTimeout(resolve, 0));+ fireEvent.click(+ screen.getByRole("button", { name: "Change configured page size" }),+ );+ });++ await waitFor(() => expect(props.search).toHaveBeenCalled());+ expect(props.search).toHaveBeenLastCalledWith(+ expect.objectContaining({ page_number: 0, page_size: 5 }),+ );+ });++ it("returns to the first page when a refreshed result changes the row count", async () => {+ const props = makeProps();+ const view = () => (+ <Wrapper>+ <LoadingDataTableComponent {...props} />+ </Wrapper>+ );+ const { rerender } = render(view());+ await waitFor(() =>+ expect(screen.getByTestId("next-page-button")).toBeEnabled(),+ );+ fireEvent.click(screen.getByTestId("next-page-button"));+ await waitFor(() =>+ expect(props.search).toHaveBeenLastCalledWith(+ expect.objectContaining({ page_number: 1 }),+ ),+ );+ await waitFor(() =>+ expect(screen.getByTestId("next-page-button")).toBeEnabled(),+ );+ props.search = vi.fn().mockResolvedValue({+ data: firstPage,+ total_rows: 25,+ cell_styles: null,+ cell_hover_texts: null,+ });++ rerender(view());+ await waitFor(() =>+ expect(props.search).toHaveBeenLastCalledWith(+ expect.objectContaining({ page_number: 0, page_size: PAGE_SIZE }),+ ),+ );+ });+it("renders kernel-dependent controls in normal mode", async () => {const props = makeProps();render(diff --git a/frontend/src/plugins/impl/__tests__/FileBrowserPlugin.test.tsx b/frontend/src/plugins/impl/__tests__/FileBrowserPlugin.test.tsxindex 2b420dd478..96986e57a9 100644--- a/frontend/src/plugins/impl/__tests__/FileBrowserPlugin.test.tsx+++ b/frontend/src/plugins/impl/__tests__/FileBrowserPlugin.test.tsx@@ -1,6 +1,7 @@/* Copyright 2026 Marimo. All rights reserved. */import {+ act,fireEvent,render,screen,@@ -88,6 +89,50 @@ beforeAll(() => {});describe("FileBrowserPlugin session cache recovery", () => {+ it("delays the initial loading overlay and hides it when listing completes", async () => {+ vi.useFakeTimers();+ try {+ let resolveListing: (value: {+ files: MockFile[];+ total_count: number;+ is_truncated: boolean;+ }) => void = () => undefined;+ const listDirectory = vi.fn(+ () =>+ new Promise((resolve) => {+ resolveListing = resolve;+ }),+ );+ const { unmount } = renderBrowser({ list_directory: listDirectory });++ await act(async () => {+ vi.advanceTimersByTime(199);+ });+ expect(screen.queryByText("Listing files...")).not.toBeInTheDocument();+ await act(async () => {+ vi.advanceTimersByTime(1);+ });+ expect(screen.getByText("Listing files...")).toBeInTheDocument();++ await act(async () => {+ resolveListing({+ files: FILES,+ total_count: FILES.length,+ is_truncated: false,+ });+ });+ expect(screen.queryByText("Listing files...")).not.toBeInTheDocument();+ expect(screen.getByText("docs")).toBeInTheDocument();+ await act(async () => {+ vi.advanceTimersByTime(200);+ });+ expect(screen.queryByText("Listing files...")).not.toBeInTheDocument();+ unmount();+ } finally {+ vi.useRealTimers();+ }+ });+it("retries a failed cached listing when the plugin resets", async () => {const host = document.createElement("marimo-file-browser");const wrapper = document.createElement("marimo-ui-element");diff --git a/frontend/src/plugins/impl/__tests__/SliderPlugin.test.tsx b/frontend/src/plugins/impl/__tests__/SliderPlugin.test.tsxindex f86736c962..50318a33a7 100644--- a/frontend/src/plugins/impl/__tests__/SliderPlugin.test.tsx+++ b/frontend/src/plugins/impl/__tests__/SliderPlugin.test.tsx@@ -212,6 +212,28 @@ describe("SliderPlugin", () => {expect(setValue).toHaveBeenCalledWith(9);});+ it("preserves an uncommitted drag until the controlled value changes", () => {+ const plugin = new SliderPlugin();+ const setValue = vi.fn();+ const props = createProps({+ debounce: true,+ includeInput: false,+ setValue,+ });+ const { getByRole, rerender } = render(plugin.render(props));++ fireEvent.click(getByRole("button", { name: "Slider change" }));+ rerender(+ plugin.render({ ...props, data: { ...props.data, label: "Updated" } }),+ );+ fireEvent.click(getByRole("button", { name: "Slider commit" }));+ expect(setValue).toHaveBeenLastCalledWith(6);++ rerender(plugin.render({ ...props, value: 2 }));+ fireEvent.click(getByRole("button", { name: "Slider commit" }));+ expect(setValue).toHaveBeenLastCalledWith(2);+ });+describe("editable input with steps (regression for #9850)", () => {it("displays the actual step value, not the index", () => {const plugin = new SliderPlugin();@@ -381,9 +403,8 @@ describe("SliderPlugin", () => {vi.advanceTimersByTime(0);});- // Shrink `steps` so the held index (4) is now out of range. The index- // syncs in an effect after this render, so the render must not throw on- // the stale, out-of-range index.+ // Shrink `steps` so the held index (4) is now out of range. Updating+ // the controlled index must render the new valid step without throwing.const shrunkProps = createStepsProps({steps: [10, 20],valueIndex: 1,diff --git a/frontend/src/plugins/impl/chat/__tests__/chat-prompts.test.tsx b/frontend/src/plugins/impl/chat/__tests__/chat-prompts.test.tsxnew file mode 100644index 0000000000..11b066d667--- /dev/null+++ b/frontend/src/plugins/impl/chat/__tests__/chat-prompts.test.tsx@@ -0,0 +1,93 @@+/* Copyright 2026 Marimo. All rights reserved. */++import { fireEvent, render, screen } from "@testing-library/react";+import type { ComponentProps } from "react";+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";+import type { PopoverContent } from "@/components/ui/popover";+import { TooltipProvider } from "@/components/ui/tooltip";+import { Chatbot } from "../chat-ui";++vi.mock("@/components/editor/ai/add-cell-with-ai", () => ({+ PromptInput: ({ value }: { value: string }) => (+ <textarea aria-label="Chat prompt" value={value} readOnly={true} />+ ),+}));++vi.mock("@/components/ui/popover", async (importOriginal) => {+ const actual =+ await importOriginal<typeof import("@/components/ui/popover")>();+ return {+ ...actual,+ // Keep the form mounted when the prompt menu takes focus so this tests+ // the prompt reset rather than the overlay's incidental unmount.+ PopoverContent: (props: ComponentProps<typeof PopoverContent>) => (+ <actual.PopoverContent+ {...props}+ onInteractOutside={(event) => event.preventDefault()}+ />+ ),+ };+});++describe("chat prompt variables", () => {+ const originalScrollTo = HTMLElement.prototype.scrollTo;+ beforeAll(() => {+ HTMLElement.prototype.scrollTo = vi.fn();+ });+ afterAll(() => {+ HTMLElement.prototype.scrollTo = originalScrollTo;+ });++ it("clears entered values and replaces the fields when selecting another prompt", async () => {+ const firstPrompt = "Tell {{name}} about {{topic}}";+ const secondPrompt = "Send {{name}} to {{destination}}";+ render(+ <TooltipProvider>+ <Chatbot+ prompts={[firstPrompt, secondPrompt]}+ config={{+ max_tokens: null,+ temperature: null,+ top_p: null,+ top_k: null,+ frequency_penalty: null,+ presence_penalty: null,+ }}+ showConfigurationControls={false}+ maxHeight={undefined}+ allowAttachments={false}+ disabled={false}+ value={[]}+ setValue={vi.fn()}+ host={document.createElement("div")}+ get_chat_history={vi.fn().mockResolvedValue({ messages: [] })}+ delete_chat_history={vi.fn().mockResolvedValue(null)}+ delete_chat_message={vi.fn().mockResolvedValue(null)}+ send_prompt={vi.fn().mockResolvedValue(null)}+ cancel_prompt={vi.fn().mockResolvedValue(null)}+ />+ </TooltipProvider>,+ );++ const promptMenu = screen.getByRole("button", { expanded: false });+ fireEvent.keyDown(promptMenu, { key: "ArrowDown" });+ fireEvent.click(await screen.findByRole("menuitem", { name: firstPrompt }));+ fireEvent.change(await screen.findByLabelText("name"), {+ target: { value: "Ada" },+ });+ fireEvent.change(screen.getByLabelText("topic"), {+ target: { value: "Python" },+ });+ expect(screen.getByRole("button", { name: "Submit" })).toBeEnabled();++ fireEvent.keyDown(promptMenu, { key: "ArrowDown" });+ fireEvent.click(+ await screen.findByRole("menuitem", { name: secondPrompt }),+ );++ expect(await screen.findByLabelText("destination")).toHaveValue("");+ expect(screen.getByLabelText("name")).toHaveValue("");+ expect(screen.queryByLabelText("topic")).not.toBeInTheDocument();+ expect(screen.getByRole("button", { name: "Submit" })).toBeDisabled();+ });+});diff --git a/frontend/src/plugins/impl/chat/chat-ui.tsx b/frontend/src/plugins/impl/chat/chat-ui.tsxindex 8b501c07bf..d78b1a689d 100644--- a/frontend/src/plugins/impl/chat/chat-ui.tsx+++ b/frontend/src/plugins/impl/chat/chat-ui.tsx@@ -24,7 +24,7 @@ import {Trash2Icon,X,} from "lucide-react";-import React, { useEffect, useRef, useState } from "react";+import React, { useEffect, useLayoutEffect, useRef, useState } from "react";import { z } from "zod";import {describeChatAbortReason,@@ -163,7 +163,9 @@ export const Chatbot: React.FC<Props> = (props) => {// Use a ref to avoid stale closure in the fetch callbackconst configRef = useRef<ChatConfig>(config);- configRef.current = config;+ useLayoutEffect(() => {+ configRef.current = config;+ }, [config]);// For frontend-managed streaming, create a controller to enqueue chunks to.const frontendStreamControllerRef =@@ -411,9 +413,8 @@ export const Chatbot: React.FC<Props> = (props) => {});}, [messages.length, scrollContainerRef]);- const codemirrorView = codeMirrorInputRef.current?.view;-const resetInput = () => {+ const codemirrorView = codeMirrorInputRef.current?.view;// Clear input immediately by directly manipulating the editor// There is some delay if we use setInput("") onlyif (codemirrorView) {@@ -566,6 +567,7 @@ export const Chatbot: React.FC<Props> = (props) => {onSelect={(prompt) => {setInput(prompt);requestAnimationFrame(() => {+ const codemirrorView = codeMirrorInputRef.current?.view;codemirrorView?.focus();moveToEndOfEditor(codemirrorView);});@@ -862,6 +864,7 @@ const PromptsPopover: React.FC<{<PopoverContent side="right" align="end" className="min-w-80 px-2"><PromptVariablesForm+ key={selectedPrompt}prompt={selectedPrompt}onClose={() => setIsPopoverOpen(false)}onSelect={onSelect}@@ -876,9 +879,7 @@ const PromptVariablesForm: React.FC<{onClose: () => void;onSelect: (prompt: string) => void;}> = ({ prompt, onClose, onSelect }) => {- const [variables, setVariables] = useState<{ [key: string]: string }>({});-- useEffect(() => {+ const [variables, setVariables] = useState<{ [key: string]: string }>(() => {const variableRegex = /{{(\w+)}}/g;const matches = [...prompt.matchAll(variableRegex)];const initialVariables = matches.reduce<{ [key: string]: string }>(@@ -888,8 +889,8 @@ const PromptVariablesForm: React.FC<{},{},);- setVariables(initialVariables);- }, [prompt]);+ return initialVariables;+ });const handleVariableChange = (variable: string, value: string) => {setVariables((prev) => ({ ...prev, [variable]: value }));