Skip to content

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.

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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.ts
new file mode 100644
index 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.ts
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
index 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.ts
index 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.tsx
new file mode 100644
index 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.tsx
index 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.ts
index 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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.ts
index 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 input
useEffect(() => {
if (disabled) {
diff --git a/frontend/src/hooks/useDeepCompareMemoize.ts b/frontend/src/hooks/useDeepCompareMemoize.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.tsx
index 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 loading
const { 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 summaries
const { 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
index 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 callback
const 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("") only
if (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 }));