fix(editor): let blank-area clicks clear a select-all selection

This commit is contained in:
zipg authored and GitHub committed 2026-09-28 21:17:17 +08:00
1 parent 3e681fe61b
commit e90186b48c
5 files changed
+748 -42

No files matched your search

@@ -1,7 +1,7 @@
// @vitest-environment happy-dom
import { describe, expect, it, vi } from "vitest";
import type { EditorView } from "@codemirror/view";
import { NATIVE_SELECTION_PARK_MIN_CHARS, parkEditorNativeSelection } from "../queryEditorNativeSelection";
import { NATIVE_SELECTION_PARK_MIN_CHARS, isLargeEditorSelection, keepNativeSelectionParkedDuringDrag, parkEditorNativeSelection } from "../queryEditorNativeSelection";
const DOC = `SELECT ${"x".repeat(NATIVE_SELECTION_PARK_MIN_CHARS)}`;
@@ -10,9 +10,38 @@ interface FakeView {
contentDOM: HTMLElement;
dispatch: ReturnType<typeof vi.fn>;
selectedText: () => string;
/** Move the editor's own selection, as a pointer gesture would. */
setSelection: (from: number, to: number) => void;
/** Re-publish the state selection as the browser selection. */
publishSelection: () => void;
/** The private CodeMirror internals the drag park shadows, when requested. */
docView: { updateSelection: ReturnType<typeof vi.fn> } | null;
observer: { selectionRange: { focusNode: Node | null }; readSelectionRange: ReturnType<typeof vi.fn> } | null;
}
function fakeView(from: number, to: number): FakeView {
/** Runs the park module's `requestAnimationFrame` loop by hand. */
function manualFrames() {
const queue: Array<{ id: number; callback: () => void }> = [];
let nextId = 0;
vi.spyOn(window, "requestAnimationFrame").mockImplementation((callback: FrameRequestCallback) => {
const id = ++nextId;
queue.push({ id, callback: () => callback(performance.now()) });
return id;
});
vi.spyOn(window, "cancelAnimationFrame").mockImplementation((id: number) => {
const index = queue.findIndex((entry) => entry.id === id);
if (index >= 0) queue.splice(index, 1);
});
return {
runFrame: () => {
const next = queue.shift();
expect(next).toBeDefined();
next!.callback();
},
};
}
function fakeView(from: number, to: number, options: { withSelectionInternals?: boolean } = {}): FakeView {
const dom = document.createElement("div");
const contentDOM = document.createElement("div");
const paragraph = document.createElement("p");
@@ -30,6 +59,10 @@ function fakeView(from: number, to: number): FakeView {
readOnly: false,
sliceDoc: (start: number, end: number) => DOC.slice(start, end),
};
// CodeMirror keeps `updateSelection` on the doc view's prototype, which is what
// the suppression shadows on the instance and deletes again on release.
const docView = options.withSelectionInternals ? (Object.create({ updateSelection: vi.fn() }) as { updateSelection: ReturnType<typeof vi.fn> }) : null;
const observer = options.withSelectionInternals ? { selectionRange: { focusNode: null as Node | null }, readSelectionRange: vi.fn(() => true) } : null;
const view = {
root: document,
dom,
@@ -37,13 +70,26 @@ function fakeView(from: number, to: number): FakeView {
state,
dispatch,
domAtPos: (pos: number) => ({ node: text, offset: Math.min(pos, DOC.length) }),
docView,
observer,
} as unknown as EditorView;
const selection = document.getSelection()!;
selection.collapse(text, from);
selection.extend(text, to);
const publishSelection = () => {
const selection = document.getSelection()!;
selection.collapse(text, range.from);
selection.extend(text, range.to);
};
publishSelection();
return { view, contentDOM, dispatch, selectedText: () => document.getSelection()?.toString() ?? "" };
const setSelection = (nextFrom: number, nextTo: number) => {
range.from = nextFrom;
range.to = nextTo;
range.empty = nextFrom === nextTo;
range.anchor = nextFrom;
range.head = nextTo;
};
return { view, contentDOM, dispatch, selectedText: () => document.getSelection()?.toString() ?? "", setSelection, publishSelection, docView, observer };
}
function copyEvent(target: EventTarget, type = "copy") {
@@ -118,3 +164,199 @@ describe("parkEditorNativeSelection", () => {
expect(data.setData).not.toHaveBeenCalled();
});
});
describe("isLargeEditorSelection", () => {
it("only counts selections long enough to be worth parking", () => {
const short = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS - 1);
expect(isLargeEditorSelection(short.view)).toBe(false);
const long = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);
expect(isLargeEditorSelection(long.view)).toBe(true);
const caret = fakeView(10, 10);
expect(isLargeEditorSelection(caret.view)).toBe(false);
});
});
describe("keepNativeSelectionParkedDuringDrag", () => {
it("parks once the gesture has dragged out enough lines to be worth it", () => {
const frames = manualFrames();
const { view, contentDOM, setSelection } = fakeView(0, 4);
const park = keepNativeSelectionParkedDuringDrag(view);
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
setSelection(0, NATIVE_SELECTION_PARK_MIN_CHARS);
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
park.release();
});
it("leaves a gesture that never grows past a few lines alone", () => {
const frames = manualFrames();
const { view, contentDOM, setSelection, publishSelection } = fakeView(0, 4);
const park = keepNativeSelectionParkedDuringDrag(view);
setSelection(0, 40);
publishSelection();
frames.runFrame();
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
park.release();
});
it("stops parking once the caller reports the gesture is over", () => {
const frames = manualFrames();
const { view, contentDOM, publishSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);
let dragging = true;
const park = keepNativeSelectionParkedDuringDrag(view, { shouldKeepParked: () => dragging });
publishSelection();
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
dragging = false;
publishSelection();
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
park.release();
});
it("fills the clipboard for a copy taken while the gesture is still running", () => {
manualFrames();
const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);
const park = keepNativeSelectionParkedDuringDrag(view);
const { data } = copyEvent(contentDOM);
expect(data.setData).toHaveBeenCalledWith("text/plain", DOC.slice(0, NATIVE_SELECTION_PARK_MIN_CHARS));
park.release();
});
it("re-parks after CodeMirror rewrites the browser selection from its own state", () => {
const frames = manualFrames();
const { view, contentDOM, publishSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);
const park = keepNativeSelectionParkedDuringDrag(view);
// CodeMirror writes the browser selection on every selection update, which
// puts a long selection back on the text services the parking exists to
// keep away from it.
publishSelection();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
park.release();
});
});
describe("drag park selection-write suppression", () => {
it("shadows CodeMirror's browser-selection write for the length of the park", () => {
manualFrames();
const { view, contentDOM, docView, observer } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });
const park = keepNativeSelectionParkedDuringDrag(view);
// CodeMirror rewrites the browser selection on every selection update, and
// a parked selection always looks stale to it, so the write is shadowed and
// the read half is kept.
expect(Object.prototype.hasOwnProperty.call(docView, "updateSelection")).toBe(true);
docView!.updateSelection(true);
expect(observer!.readSelectionRange).toHaveBeenCalled();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
park.release();
expect(Object.prototype.hasOwnProperty.call(docView, "updateSelection")).toBe(false);
});
it("leaves a view that does not expose the internals it was written against untouched", () => {
manualFrames();
const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);
const park = keepNativeSelectionParkedDuringDrag(view);
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
park.release();
});
it("does not shadow the write when the caller opts out", () => {
manualFrames();
const { view, docView } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });
const park = keepNativeSelectionParkedDuringDrag(view, { suppressEditorSelectionWrites: false });
expect(Object.prototype.hasOwnProperty.call(docView, "updateSelection")).toBe(false);
park.release();
});
it("never clobbers a write somebody else already owns", () => {
manualFrames();
const { view, docView } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });
const existing = vi.fn();
docView!.updateSelection = existing;
const park = keepNativeSelectionParkedDuringDrag(view);
expect(docView!.updateSelection).toBe(existing);
park.release();
expect(docView!.updateSelection).toBe(existing);
});
it("waits for the gesture's own write and only restores when the selection is still parked", () => {
const frames = manualFrames();
const { view, contentDOM, setSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });
const park = keepNativeSelectionParkedDuringDrag(view);
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
// The click that ends the gesture collapses the editor selection, and that
// collapse is what CodeMirror writes into the browser. Restoring first would
// re-create the whole selection only to have CodeMirror collapse it again.
setSelection(0, 0);
park.release();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
});
it("leaves a browser selection CodeMirror wrote itself alone", () => {
const frames = manualFrames();
const { view, contentDOM, setSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });
const park = keepNativeSelectionParkedDuringDrag(view);
setSelection(0, 0);
document.getSelection()!.collapse(view.contentDOM.querySelector("p")!.firstChild!, 7);
park.release();
frames.runFrame();
// The parked selection is gone, so there is nothing to put back.
expect(document.getSelection()!.anchorOffset).toBe(7);
expect(contentDOM.contains(document.getSelection()!.anchorNode)).toBe(true);
});
it("still restores the menu park inside release, before the caller's next task", () => {
const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);
const park = parkEditorNativeSelection(view);
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
park!.release();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
});
it("leaves the browser selection to a park that started before its deferred restore ran", () => {
const frames = manualFrames();
const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });
const first = keepNativeSelectionParkedDuringDrag(view);
first.release();
const second = keepNativeSelectionParkedDuringDrag(view);
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
second.release();
frames.runFrame();
expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
});
});
@@ -14,9 +14,16 @@ import { appendDebugLog } from "@/lib/backend/debugLog";
* The browser selection does not have to cover the selection for the editor to
* behave: CodeMirror paints the selection itself (`drawSelection` keeps the
* native one transparent), it copies from its own state, and it ignores a
* selection parked outside its content element. So while an overlay menu is
* shown on top of the editor the browser selection is parked on the editor
* chrome and restored as soon as the menu closes.
* selection parked outside its content element. So the browser selection is
* parked on the editor chrome while an overlay menu covers the editor, and for
* as long as a pointer gesture is dragging a long selection out, and restored
* as soon as the menu closes or the pointer is released.
*
* The drag is the case that is easiest to misread from a bug report: sweeping
* the pointer to the edge of the editor autoscrolls and never leaves the
* pointer on the text, so it stays smooth, while moving back up into the
* already selected lines pays the serialization cost on every mouse move
* (smooth in Chrome/Blink, which does not make that request at all).
*
* Parking outside `contentDOM` is what makes CodeMirror leave the editor state
* alone (it maps a foreign selection back to the selection it already has), so
@@ -27,15 +34,38 @@ import { appendDebugLog } from "@/lib/backend/debugLog";
/**
* Selections shorter than this are serialized cheaply enough that parking them
* would only trade a measurable cost for an invisible one.
* would only trade a measurable cost for an invisible one. Dragging a selection
* out keeps the browser selection live until it crosses this length, so a drag
* over a few lines behaves exactly as it did before.
*/
export const NATIVE_SELECTION_PARK_MIN_CHARS = 1000;
/** Whether the editor's primary selection is long enough to be worth parking. */
export function isLargeEditorSelection(currentView: EditorView): boolean {
const main = currentView.state.selection.main;
return !main.empty && main.to - main.from >= NATIVE_SELECTION_PARK_MIN_CHARS;
}
export interface EditorNativeSelectionPark {
/** Put the browser selection back where the editor state has it. */
release(): void;
}
export interface EditorNativeSelectionDragParkOptions extends EditorNativeSelectionParkOptions {
/**
* Parking is suspended while this returns false, which lets a caller keep one
* handle for a whole gesture and still let a short selection behave normally.
*/
shouldKeepParked?: () => boolean;
/**
* Whether CodeMirror's own browser-selection writes are suspended while the
* park holds. Only the drag park wants this, because only the drag park is
* re-collapsed in a frame loop that CodeMirror then writes against. See
* `suppressEditorSelectionWrites`.
*/
suppressEditorSelectionWrites?: boolean;
}
export interface EditorNativeSelectionParkOptions {
/**
* Applied to the text the parked copy path puts on the clipboard. Pass the
@@ -63,6 +93,48 @@ function isParkedOutsideContent(currentView: EditorView, selection: Selection):
return !!anchor && !currentView.contentDOM.contains(anchor);
}
interface EditorViewSelectionInternals {
docView?: { updateSelection?: (mustRead?: boolean, fromPointer?: boolean) => void };
observer?: { selectionRange: { focusNode: Node | null }; readSelectionRange: () => boolean };
}
const UPDATE_SELECTION = "updateSelection";
/**
* Stops CodeMirror from writing its selection into the browser while parked.
*
* Parking alone is not enough for a drag. CodeMirror rewrites the browser
* selection whenever it differs from the editor state, and a parked selection
* always differs, so every pointer move issues a fresh `collapse` inside the
* editable — which is exactly the operation that costs tens of milliseconds on
* macOS 26/27. Measured on a 2500 line document: 21 writes over a 300 line
* drag, 23–167 ms each, all of the web process main thread. Those writes buy
* nothing while parked: CodeMirror draws and copies the selection from its own
* state, a parked selection is by definition not what the user sees.
*
* The suppression is narrow on purpose — it shadows the single method that
* performs the write and keeps its read half, so CodeMirror still notices a
* selection the browser moved on its own. It is restored by the park's
* `release()`, and it refuses to touch a view whose internals do not look like
* the ones it was written against.
*/
function suppressEditorSelectionWrites(currentView: EditorView): (() => void) | null {
const internals = currentView as unknown as EditorViewSelectionInternals;
const docView = internals.docView;
const observer = internals.observer;
if (!docView || typeof docView[UPDATE_SELECTION] !== "function" || !observer) return null;
// Never clobber a patch somebody else owns; without our shadow the prototype
// method is what CodeMirror calls, and that is exactly what we restore.
if (Object.prototype.hasOwnProperty.call(docView, UPDATE_SELECTION)) return null;
const suppressed = (mustRead?: boolean) => {
if (mustRead || !observer.selectionRange.focusNode) observer.readSelectionRange();
};
docView[UPDATE_SELECTION] = suppressed;
return () => {
if (docView[UPDATE_SELECTION] === suppressed) delete docView[UPDATE_SELECTION];
};
}
function parkSelection(currentView: EditorView, selection: Selection): void {
try {
// `view.dom` (the editor element) sits outside `view.contentDOM`, so
@@ -138,38 +210,89 @@ function handleParkedClipboardEvent(currentView: EditorView, finalizeClipboardTe
}
/**
* Parks the browser selection while an overlay menu covers the editor.
* The machinery both parking windows share.
*
* @returns a handle that restores the browser selection, or `null` when there
* was nothing worth parking.
* Parking is idempotent and self-healing: the browser can put a selection back
* into the editor on its own (focus, a redraw, the platform moving a caret), so
* the collapse is repeated for as long as the window lasts. Reading `anchorNode`
* costs no layout, so the frame loop is cheap enough to run for the length of a
* gesture. A drag park additionally stops CodeMirror from writing the browser
* selection at all while it holds — see `suppressEditorSelectionWrites` — which
* is what removes the per-pointer-move cost of re-collapsing a large selection.
*/
export function parkEditorNativeSelection(currentView: EditorView, options: EditorNativeSelectionParkOptions = {}): EditorNativeSelectionPark | null {
const main = currentView.state.selection.main;
if (main.empty || main.to - main.from < NATIVE_SELECTION_PARK_MIN_CHARS) return null;
const selection = editorRootSelection(currentView);
if (!selection || !selection.anchorNode || !currentView.dom.contains(selection.anchorNode)) return null;
// Kept for field diagnosis: it only writes while debug logging is switched
// on, and it is the one line that shows whether the parked window was even
// entered when somebody reports the editor still stuttering.
appendDebugLog("info", "[DBX][QueryEditor:native-selection:park]", { chars: main.to - main.from });
interface NativeSelectionParkConfig {
/** Whether the window should still hold. Re-read on every frame. */
shouldKeepParked: () => boolean;
finalizeClipboardText: (text: string) => string;
/** See `suppressEditorSelectionWrites`. */
suppressWrites?: boolean;
/**
* Restore the browser selection on the next frame instead of inside
* `release()`, and skip the restore when the browser selection is no longer
* parked by then.
*
* A gesture ends by dispatching: CodeMirror collapses the selection for a
* click and rewrites the browser selection for a drag. Either way its own
* write lands first, after which there is nothing left to restore — and
* restoring first would put the whole long selection back into the browser
* only to have CodeMirror write over it. On macOS 26/27 each of those writes
* is the expensive text-services operation this module exists to avoid, so a
* click that clears a long drag paid for three of them. The frame is the
* safety net for the gestures that end without any dispatch — a release
* outside the window, a focus change — where the parked selection would
* otherwise stay parked. The restore re-reads the editor state when it runs.
*/
deferReleaseRestore?: boolean;
}
parkSelection(currentView, selection);
let released = false;
let frame = 0;
const finalizeClipboardText = options.finalizeClipboardText ?? ((text: string) => text);
// `copy`/`cut` bubble through the document, so listening there catches the
// event no matter which editor chrome inside the view holds focus.
/**
* Which park most recently took the browser selection. A deferred restore only
* acts while its own park is still the newest one: a park that starts before the
* microtask runs owns the browser selection, and restoring under it would hand
* the selection back to the text services for a frame.
*/
let latestParkSequence = 0;
function createNativeSelectionPark(currentView: EditorView, config: NativeSelectionParkConfig): EditorNativeSelectionPark {
const { shouldKeepParked, finalizeClipboardText, suppressWrites = false, deferReleaseRestore = false } = config;
const sequence = ++latestParkSequence;
const doc = currentView.dom.ownerDocument;
const win = doc.defaultView ?? window;
let released = false;
let frame = 0;
let parkedOnce = false;
let parkedSince = 0;
let restoreWrites: (() => void) | null = null;
const park = () => {
if (released || !shouldKeepParked()) return;
const selection = editorRootSelection(currentView);
if (!selection || isParkedOutsideContent(currentView, selection)) return;
parkSelection(currentView, selection);
if (!parkedOnce) {
parkedOnce = true;
parkedSince = performance.now();
if (suppressWrites) restoreWrites = suppressEditorSelectionWrites(currentView);
// Kept for field diagnosis: it only writes while debug logging is
// switched on, and it is the one line that shows whether the parking
// window was even entered when somebody reports the editor stuttering.
appendDebugLog("info", "[DBX][QueryEditor:native-selection:park]", {
chars: currentView.state.selection.main.to - currentView.state.selection.main.from,
suppressesEditorWrites: !!restoreWrites,
});
}
};
park();
const onCopy = (event: ClipboardEvent) => handleParkedClipboardEvent(currentView, finalizeClipboardText, () => released, event);
// `copy`/`cut` bubble through the document, so listening there catches the
// event no matter which editor chrome inside the view holds focus.
doc.addEventListener("copy", onCopy);
doc.addEventListener("cut", onCopy);
// CodeMirror rewrites the browser selection from its own state on every
// selection update (menu actions, diagnostics re-anchoring, typing), so a
// single collapse does not stick. Reading `anchorNode` costs no layout.
const keepParked = () => {
if (released) return;
if (!isParkedOutsideContent(currentView, selection)) parkSelection(currentView, selection);
park();
frame = win.requestAnimationFrame(keepParked);
};
frame = win.requestAnimationFrame(keepParked);
@@ -181,8 +304,60 @@ export function parkEditorNativeSelection(currentView: EditorView, options: Edit
doc.removeEventListener("copy", onCopy);
doc.removeEventListener("cut", onCopy);
win.cancelAnimationFrame(frame);
const live = editorRootSelection(currentView);
if (live && isParkedOutsideContent(currentView, live)) restoreSelectionFromState(currentView, live);
restoreWrites?.();
restoreWrites = null;
const restore = () => {
if (sequence !== latestParkSequence) return;
const live = editorRootSelection(currentView);
if (live && isParkedOutsideContent(currentView, live)) restoreSelectionFromState(currentView, live);
};
if (deferReleaseRestore) win.requestAnimationFrame(restore);
else restore();
if (parkedOnce) {
// Field diagnosis for "the selection took seconds to clear": how long a
// park lived says whether a gesture was still parked while the user
// thought it had ended, and how many frame-collapses it took.
appendDebugLog("info", "[DBX][QueryEditor:native-selection:release]", {
ms: Math.round(performance.now() - parkedSince),
chars: currentView.state.selection.main.to - currentView.state.selection.main.from,
suppressedEditorWrites: suppressWrites,
});
}
},
};
}
/**
* Parks the browser selection while an overlay menu covers the editor.
*
* @returns a handle that restores the browser selection, or `null` when there
* was nothing worth parking.
*/
export function parkEditorNativeSelection(currentView: EditorView, options: EditorNativeSelectionParkOptions = {}): EditorNativeSelectionPark | null {
if (!isLargeEditorSelection(currentView)) return null;
const selection = editorRootSelection(currentView);
if (!selection || !selection.anchorNode || !currentView.dom.contains(selection.anchorNode)) return null;
return createNativeSelectionPark(currentView, { shouldKeepParked: () => true, finalizeClipboardText: options.finalizeClipboardText ?? ((text: string) => text) });
}
/**
* Parks the browser selection for the length of a pointer gesture.
*
* Call this on pointer down and `release()` on pointer up: the browser
* selection stays parked only while the editor's own selection is long enough
* to be worth it (`isLargeEditorSelection`), so a gesture that never grows past
* a few lines — or one that starts by shrinking a selection back down — keeps
* behaving exactly as it did before. The editor keeps its own selection while
* this runs, so the highlight, the selection that survives the release and the
* text on the clipboard are unchanged.
*/
export function keepNativeSelectionParkedDuringDrag(currentView: EditorView, options: EditorNativeSelectionDragParkOptions = {}): EditorNativeSelectionPark {
return createNativeSelectionPark(currentView, {
shouldKeepParked: () => isLargeEditorSelection(currentView) && (options.shouldKeepParked?.() ?? true),
finalizeClipboardText: options.finalizeClipboardText ?? ((text: string) => text),
suppressWrites: options.suppressEditorSelectionWrites ?? true,
// A gesture ends by dispatching a selection change, and that write is both
// the correct one and the cheap one to land first. See `deferReleaseRestore`.
deferReleaseRestore: true,
});
}