diff --git a/src/commands.test.ts b/src/commands.test.ts
index c4a40c26..a5322fc2 100644
--- a/src/commands.test.ts
+++ b/src/commands.test.ts
@@ -608,6 +608,31 @@ describe("capture", () => {
 			expect(said()).toEqual(["Timestamp added to Saved Episode", REFUSED]);
 		});
 
+		it("leaves the timestamp once another open editor of the note holds other text, and says so", async () => {
+			const { editor, openNote, read } = await intoEditor("Notes\n");
+			const other = openNote("Journal.md", "Notes\nUnsaved in the other pane");
+
+			await undo();
+
+			expect(editor.getValue()).toBe("Notes\n- 00:20:34");
+			expect(other.editor.getValue()).toBe("Notes\nUnsaved in the other pane");
+			expect(read("Journal.md")).toBe("Notes\n");
+			expect(said()).toEqual(["Timestamp added to Journal", REFUSED]);
+		});
+
+		it("takes the timestamp out when every open editor of the note holds it as captured", async () => {
+			const { editor, openNote } = await intoEditor("Notes\n");
+			const other = openNote("Journal.md", editor.getValue());
+
+			await undo();
+
+			expect([editor.getValue(), other.editor.getValue()]).toEqual([
+				"Notes\n",
+				"Notes\n- 00:20:34",
+			]);
+			expect(said()).toEqual(["Timestamp added to Journal"]);
+		});
+
 		it("takes the timestamp out through the episode note's open editor", async () => {
 			const { plugin, notes, openNote, read } = await loadPlugin(playing);
 			notes.set(NOTE_PATH, { file: vaultFile(NOTE_PATH), content: "# Mine\n" });
diff --git a/src/services/CaptureService.ts b/src/services/CaptureService.ts
index 2e1e6a88..a9d2cf24 100644
--- a/src/services/CaptureService.ts
+++ b/src/services/CaptureService.ts
@@ -169,11 +169,18 @@ export class CaptureService {
 		// An open editor's buffer is the note: a vault write behind it could lose what it
 		// has not saved yet. Obsidian saves a note as it leaves editing, so once that save
 		// lands, a closed tab or one in Reading view leaves the file as the note.
-		const editing = this.plugin.app.workspace
-			.getLeavesOfType("markdown")
-			.map((leaf) => this.editingView(leaf))
-			.find((view) => view?.file === file);
-		if (editing) return revertIn(editing.editor, snapshot);
+		// Every open editor of the note has to hold the text as the capture left it.
+		const editing = this.plugin.app.workspace.getLeavesOfType("markdown").flatMap((leaf) => {
+			const view = this.editingView(leaf);
+			return view?.file === file ? [view] : [];
+		});
+		const [first] = editing;
+		if (first) {
+			return (
+				editing.every((view) => view.editor.getValue() === snapshot.after) &&
+				revertIn(first.editor, snapshot)
+			);
+		}
 		try {
 			await this.plugin.app.vault.process(file, (content) => {
 				if (content !== snapshot.after) throw new Error("The note changed");
diff --git a/src/ui/PodcastView/Player.svelte b/src/ui/PodcastView/Player.svelte
index 536db736..23748738 100644
--- a/src/ui/PodcastView/Player.svelte
+++ b/src/ui/PodcastView/Player.svelte
@@ -1,5 +1,4 @@
 <script lang="ts">
-	import { Scope } from "obsidian";
 	import { tick } from "svelte";
 	import type { Chapter } from "src/types/Chapter";
 	import type { Episode } from "src/types/Episode";
@@ -22,7 +21,7 @@
 
 	let { viewRoot, layout }: { viewRoot: HTMLElement; layout: Layout } = $props();
 	const services = useServices();
-	const { app, api, player, navigation, settings, library, rowHasNote, captureTimestamp } =
+	const { api, player, navigation, settings, library, rowHasNote, captureTimestamp, scope } =
 		services;
 	const playerState = player.state;
 	const { savedFeeds } = library;
@@ -90,65 +89,35 @@
 		if (failed) volumeOpen = false;
 	});
 
-	// Obsidian's keymap gives a key to the newest scope, so a menu or modal opened
-	// over the player takes Escape first. It keeps one stack per window and pushes
-	// onto the active window's, so the scope goes onto the stack of the view's
-	// window once that window is active, and moves when the view moves to another
-	// window. It is pushed once: pushing it again on a later focus would lift it over
-	// a modal opened since. Keys typed elsewhere, as in an editor, stay there.
+	// The view's own scope gets the keys typed while the view's leaf is active, which focus
+	// or a press in the view makes it. A menu or modal over the player takes Escape first.
 	$effect(() => {
-		const scope = new Scope(app.scope);
-		const ours = (evt: KeyboardEvent) => {
-			const target = evt.target as Element | null;
-			return target === viewRoot.ownerDocument.body || viewRoot.contains(target);
-		};
-		scope.register(null, "Escape", (evt) => {
-			if (!ours(evt)) return true;
+		const escape = scope.register(null, "Escape", () => {
 			if (volumeOpen) {
 				volumeOpen = false;
 				volumeButton?.focus();
 			} else void collapse();
 			return false;
 		});
-		scope.register(null, " ", (evt) => {
-			const target = evt.target as Element | null;
+		const space = scope.register(null, " ", (evt) => {
 			const control = "input, textarea, select, button, a, [contenteditable], [role=slider]";
-			if (!ours(evt) || target?.closest?.(control)) return true;
+			if ((evt.target as Element | null)?.closest?.(control)) return true;
 			player.toggle();
 			return false;
 		});
-		let win = viewRoot.win;
-		let pushed = false;
-		// Obsidian's own focus listener runs first and makes the window active.
-		const push = () => {
-			if (pushed || activeWindow !== win) return;
-			app.keymap.pushScope(scope);
-			pushed = true;
-		};
-		const pop = () => {
-			app.keymap.popScope(scope);
-			pushed = false;
-		};
-		const follow = (next: Window) => {
-			win = next;
-			// The video plays in the main window, so a popout shows the artwork.
-			inMainWindow = next === window;
-			win.addEventListener("focus", push);
-			push();
-		};
-		follow(win);
-		const stopFollowing = viewRoot.onWindowMigrated((next) => {
-			win.removeEventListener("focus", push);
-			pop();
-			follow(next);
-		});
 		return () => {
-			stopFollowing();
-			win.removeEventListener("focus", push);
-			pop();
+			scope.unregister(escape);
+			scope.unregister(space);
 		};
 	});
 
+	$effect(() => {
+		// The video plays in the main window, so a popout shows the artwork.
+		const follow = (win: Window) => (inMainWindow = win === window);
+		follow(viewRoot.win);
+		return viewRoot.onWindowMigrated(follow);
+	});
+
 	/** A keyboard user who collapses the player lands on the mini player that opens it again. */
 	async function collapse() {
 		const hadFocus = !!section?.contains(viewRoot.ownerDocument.activeElement);
diff --git a/src/ui/PodcastView/PodcastView.integration.test.ts b/src/ui/PodcastView/PodcastView.integration.test.ts
index db73d382..50a8d8e7 100644
--- a/src/ui/PodcastView/PodcastView.integration.test.ts
+++ b/src/ui/PodcastView/PodcastView.integration.test.ts
@@ -35,6 +35,7 @@ function renderView() {
 				player,
 				feeds,
 				navigation,
+				scope: new obsidian.Scope(app.scope),
 				library: pluginLibrary,
 				actions: createLibraryActions({
 					app,
diff --git a/src/ui/PodcastView/PodcastView.shell.test.ts b/src/ui/PodcastView/PodcastView.shell.test.ts
index bd4ffc24..6a5f072d 100644
--- a/src/ui/PodcastView/PodcastView.shell.test.ts
+++ b/src/ui/PodcastView/PodcastView.shell.test.ts
@@ -15,6 +15,7 @@ import {
 	type FakeResizeObservers,
 } from "../../../tests/mocks/resizeObserver";
 import {
+	activateLeaf,
 	createTestServices,
 	pluginLibrary,
 	type TestLibrary,
@@ -667,52 +668,65 @@ describe("full player", () => {
 			expect(await escape()).toBe(true);
 		});
 
-		test("leaves a modal above the player when its window regains focus", async () => {
-			renderView();
-			playing();
-			await tick();
-			await fireEvent.click(button(`Open player: ${episode.title}`));
-			const modal = new obsidian.Scope(services.app.scope);
-			modal.register(null, "Escape", () => false);
-			services.app.keymap.pushScope(modal);
-
-			window.dispatchEvent(new Event("focus"));
-			await escape();
-
-			expect(services.navigation.current.expanded).toBe(true);
-			services.app.keymap.popScope(modal);
-		});
+		/** A note's tab whose own keys, as its find bar's, record what reaches them. */
+		function noteLeaf() {
+			const scope = new obsidian.Scope(services.app.scope);
+			const keys: string[] = [];
+			for (const key of ["Enter", "Escape"]) {
+				scope.register(null, key, () => {
+					keys.push(key);
+					return false;
+				});
+			}
+			return { scope, keys };
+		}
 
-		test("typed outside the view stays there", async () => {
+		test("typed in a note reach the note, and the player stays open (#467)", async () => {
 			const note = document.body.appendChild(document.createElement("textarea"));
 			renderView();
 			playing();
 			await tick();
+			await fireEvent.click(button(`Open player: ${episode.title}`));
+			const tab = noteLeaf();
+			activateLeaf(services.app, tab.scope);
 			note.focus();
 
-			services.navigation.expand();
-			await tick();
-			expect(document.activeElement).toBe(note);
+			await fireEvent.keyDown(note, { key: "Enter" });
+			await escape(note);
 
-			expect(await escape()).toBe(true);
+			expect(tab.keys).toEqual(["Enter", "Escape"]);
 			expect(services.navigation.current.expanded).toBe(true);
 			note.remove();
 		});
 
-		test("from outside the view passes through, even with focus left in the player", async () => {
-			const note = document.body.appendChild(document.createElement("textarea"));
-			renderView();
-			playing();
-			await tick();
-			await fireEvent.click(button(`Open player: ${episode.title}`));
-			expect(document.activeElement).toBe(button("Collapse player"));
-
-			expect(await escape(note)).toBe(true);
-			expect(services.navigation.current.expanded).toBe(true);
-			note.remove();
-		});
+		test.each([
+			["a note's editor", "textarea", true],
+			["an empty tab", "div", false],
+		] as const)(
+			"typed in %s, which has no use for Escape or Space, leave the player open and playing (#467)",
+			async (_, tag, viewHasScope) => {
+				const at = document.body.appendChild(document.createElement(tag));
+				renderView();
+				playing();
+				await tick();
+				await fireEvent.click(button(`Open player: ${episode.title}`));
+				const pause = vi.spyOn(doc.media, "pause");
+				activateLeaf(
+					services.app,
+					viewHasScope ? new obsidian.Scope(services.app.scope) : null,
+				);
+
+				await fireEvent.keyDown(at, { key: " " });
+				expect(get(services.player.state).status).toBe("playing");
+				expect(pause).not.toHaveBeenCalled();
+
+				await escape(at);
+				expect(services.navigation.current.expanded).toBe(true);
+				at.remove();
+			},
+		);
 
-		test("follows the player to a popout window, and Escape in the main window passes it by", async () => {
+		test("reach the player in a popout through that window's base scope, and a note's Escape passes it by", async () => {
 			const popout = openPopout();
 			popout.win.document.addEventListener("keydown", dispatch);
 			const note = document.body.appendChild(document.createElement("textarea"));
@@ -720,11 +734,14 @@ describe("full player", () => {
 			playing();
 			await tick();
 			await fireEvent.click(button(`Open player: ${episode.title}`));
-
 			popout.moveIn(container);
-			expect(await escape(note)).toBe(true);
+			const tab = noteLeaf();
+			activateLeaf(services.app, tab.scope);
+			await escape(note);
+			expect(tab.keys).toEqual(["Escape"]);
 			expect(services.navigation.current.expanded).toBe(true);
 
+			activateLeaf(services.app, services.scope);
 			popout.focus();
 			const collapseButton = within(container).getByRole("button", {
 				name: "Collapse player",
diff --git a/src/ui/PodcastView/QueueList.svelte b/src/ui/PodcastView/QueueList.svelte
index 7538871e..7b46f207 100644
--- a/src/ui/PodcastView/QueueList.svelte
+++ b/src/ui/PodcastView/QueueList.svelte
@@ -56,7 +56,7 @@
 			if (cancelled.pointerId === pointerId) end();
 		};
 		// Obsidian's keymap gives Escape to the newest scope and stops it there, so a
-		// window listener would not hear an Escape the full player's scope takes.
+		// window listener would not hear an Escape the view's scope takes.
 		const escape = new Scope(app.scope);
 		escape.register(null, "Escape", () => {
 			end();
diff --git a/src/ui/PodcastView/context.ts b/src/ui/PodcastView/context.ts
index 8c1e8b2a..9cd6e0af 100644
--- a/src/ui/PodcastView/context.ts
+++ b/src/ui/PodcastView/context.ts
@@ -1,4 +1,4 @@
-import type { App } from "obsidian";
+import type { App, Scope } from "obsidian";
 import { createContext } from "svelte";
 import type { Readable, Writable } from "svelte/store";
 import type { IAPI } from "src/API/IAPI";
@@ -35,6 +35,8 @@ export interface ShellServices {
 	readonly player: PlayerController;
 	readonly feeds: FeedRepository;
 	readonly navigation: Navigation;
+	/** The view's own keys. Obsidian hands them every key typed while the view's leaf is active. */
+	readonly scope: Scope;
 	readonly library: Library;
 	readonly actions: LibraryActions;
 	readonly search: PodcastSearch;
diff --git a/src/ui/PodcastView/index.test.ts b/src/ui/PodcastView/index.test.ts
index 6cac6a4a..06905e11 100644
--- a/src/ui/PodcastView/index.test.ts
+++ b/src/ui/PodcastView/index.test.ts
@@ -122,6 +122,15 @@ describe("MainView mobile startup mounting", () => {
 		});
 	});
 
+	it("gives its components the view's own key scope, the one Obsidian hands keys to", async () => {
+		const { view } = createView({ shouldMount: true });
+
+		await openView(view);
+
+		expect(view.scope).not.toBeNull();
+		expect(mountedServices().scope).toBe(view.scope);
+	});
+
 	it("mountPodcastView wakes a dormant restored view exactly once", () => {
 		const { contentEl, plugin, view } = createView({ shouldMount: false });
 
diff --git a/src/ui/PodcastView/index.ts b/src/ui/PodcastView/index.ts
index cebd9a61..87148fd8 100644
--- a/src/ui/PodcastView/index.ts
+++ b/src/ui/PodcastView/index.ts
@@ -1,4 +1,4 @@
-import { debounce, ItemView } from "obsidian";
+import { debounce, ItemView, Scope } from "obsidian";
 import type { ViewStateResult, WorkspaceLeaf } from "obsidian";
 import type { IPodNotes } from "../../types/IPodNotes";
 import { VIEW_TYPE } from "../../constants";
@@ -110,12 +110,15 @@ export class MainView extends ItemView {
 				notesChangedSoon();
 			}),
 		);
+		const scope = new Scope(app.scope);
+		this.scope = scope;
 		return {
 			app,
 			api: plugin.api,
 			player: plugin.player,
 			feeds: plugin.feeds,
 			navigation: plugin.navigation,
+			scope,
 			library: {
 				savedFeeds,
 				queue,
diff --git a/tests/e2e/journey-notes.test.ts b/tests/e2e/journey-notes.test.ts
index 444f7d8d..500fb1fe 100644
--- a/tests/e2e/journey-notes.test.ts
+++ b/tests/e2e/journey-notes.test.ts
@@ -860,6 +860,55 @@ describe("episode note and capture journeys", () => {
 		expect(await notices(obsidian)).toContain(REFUSED);
 	});
 
+	test("J-TS-20 Undo leaves a note open in two panes when the other pane changed in the same moment, and says so", async () => {
+		const { obsidian, sandbox } = getContext();
+		const journey = await setUp("Journey Undo Two Panes");
+		const draft = sandbox.path("Two pane draft.md");
+		await writeVaultFile(obsidian, draft, "First line\nSecond line\n");
+		await playFromList(journey.show, ORIGINAL.title);
+		await writeIn(draft, 0, 10);
+		await obsidian.dev.evalJsonAsync(`(async () => {
+			const file = app.vault.getAbstractFileByPath(${jsLiteral(draft)});
+			await app.workspace.getLeaf("split").openFile(file, { state: { mode: "source" } });
+			return true;
+		})()`);
+		// The click lands in the first pane, which the capture then writes in.
+		expect(await clickInEditor(obsidian, draft, 0, 10)).toEqual({ line: 0, ch: 10 });
+		const panes = `app.workspace.getLeavesOfType("markdown").filter((leaf) => leaf.view.file?.path === ${jsLiteral(draft)})`;
+		const texts = () =>
+			obsidian.dev.evalJson<string[]>(`${panes}.map((leaf) => leaf.view.editor.getValue())`);
+		const line = capture(journey, ORIGINAL, (await pauseInView()).seconds);
+
+		await click(obsidian, ui.playerTimestamp);
+		const captured = `First line${line}\nSecond line\n`;
+		expect(await eventually(obsidian, texts, [captured, captured]), "both panes").toEqual([
+			captured,
+			captured,
+		]);
+		// A pane other than the one the capture wrote in changes as Undo is pressed.
+		await obsidian.dev.evalJson(`(() => {
+			${panes}.at(-1).view.editor.replaceRange("Late ", { line: 0, ch: 0 });
+			[...document.querySelectorAll(".notice button.pn-undo")].at(-1).click();
+			return true;
+		})()`);
+
+		await obsidian.waitFor(async () => (await notices(obsidian)).includes(REFUSED), {
+			timeoutMs: 5_000,
+			intervalMs: 100,
+			message: "the Notice that Undo left the note",
+		});
+		const edited = `Late ${captured}`;
+		expect(await eventually(obsidian, texts, [edited, edited]), "both panes").toEqual([
+			edited,
+			edited,
+		]);
+		await waitForText(
+			draft,
+			(text) => text === edited,
+			"the late edit saved, with the capture",
+		);
+	});
+
 	test("J-TS-14 Capture Timestamp with nothing loaded says to play an episode, and writes nothing", async () => {
 		const { obsidian, sandbox } = getContext();
 		const journey = await setUp("Journey Nothing Loaded");
diff --git a/tests/e2e/journey-player.test.ts b/tests/e2e/journey-player.test.ts
index d522ea45..0e55670b 100644
--- a/tests/e2e/journey-player.test.ts
+++ b/tests/e2e/journey-player.test.ts
@@ -1,7 +1,13 @@
 import { describe, expect, onTestFinished, test } from "vitest";
 import { createPodNotesE2EHarness } from "./harness";
-import { closePodNotes, openInEditor, revealInFileExplorer, showPodNotes } from "./journey/actions";
-import { cdp, click, pointOn, pressKey, pressMouse } from "./journey/input";
+import {
+	clickInEditor,
+	closePodNotes,
+	openInEditor,
+	revealInFileExplorer,
+	showPodNotes,
+} from "./journey/actions";
+import { cdp, click, pointOn, pressHotkey, pressKey, pressMouse, typeText } from "./journey/input";
 import { PLAYER_VIEW, ui, type UiTarget } from "./journey/targets";
 import { eventually, holdsFor, isShown, waitUntilFocused, waitUntilShown } from "./journey/wait";
 import {
@@ -13,6 +19,7 @@ import {
 	wav,
 } from "./journey/fixtures";
 import {
+	observePlayback,
 	readLibrary,
 	recordWrites,
 	seedLibrary,
@@ -311,6 +318,15 @@ describe("player journeys", () => {
 		await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyDown", text: "\r", ...enter });
 		await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyUp", ...enter });
 		await waitUntilShown(obsidian, ui.menuItem("Add to queue"));
+		// Obsidian gives a menu the keys a timer tick after it shows; an Escape before then
+		// goes to the view under it.
+		await obsidian.waitFor(
+			() =>
+				obsidian.dev.evalJson<boolean>(
+					'(app.keymap.getWindowStack(activeWindow).scope.keys ?? []).some((key) => key.key === "ArrowDown")',
+				),
+			{ timeoutMs: 5_000, intervalMs: 50, message: "the menu to take the keys" },
+		);
 
 		await pressKey(obsidian, "Escape");
 		expect(
@@ -337,4 +353,83 @@ describe("player journeys", () => {
 		expect(await isShown(obsidian, ui.fullPlayer)).toBe(false);
 		await waitUntilFocused(obsidian, ui.openPlayer);
 	});
+
+	test("#467 keys typed in a note reach it while the full player is open", async () => {
+		const { obsidian, sandbox } = getContext();
+		const note = sandbox.path("Find in note.md");
+		await writeVaultFile(obsidian, note, "alpha one\nalpha two\nalpha three\n");
+		await openInEditor(obsidian, note);
+		await openPlayer([ONE]);
+		await clickInEditor(obsidian, note, 0, 0);
+		const search = () =>
+			obsidian.dev.evalJson<{ open: boolean; count: string | null }>(`(() => {
+				const leaf = app.workspace.getLeavesOfType("markdown").find((leaf) => leaf.view.file?.path === ${jsLiteral(note)});
+				const bar = leaf.view.containerEl.querySelector(".document-search-container");
+				return { open: Boolean(bar), count: bar?.querySelector(".document-search-count")?.textContent ?? null };
+			})()`);
+		await pressHotkey(obsidian, "f");
+		await typeText(obsidian, "alpha");
+		expect(await eventually(obsidian, search, { open: true, count: "1 / 3" })).toEqual({
+			open: true,
+			count: "1 / 3",
+		});
+
+		await pressKey(obsidian, "Enter");
+		expect(await eventually(obsidian, search, { open: true, count: "2 / 3" }), "Enter").toEqual(
+			{ open: true, count: "2 / 3" },
+		);
+		await pressKey(obsidian, "Escape");
+		expect(await eventually(obsidian, search, { open: false, count: null }), "Escape").toEqual({
+			open: false,
+			count: null,
+		});
+		expect(await isShown(obsidian, ui.fullPlayer), "the player stays open").toBe(true);
+	});
+
+	test("#467 Space and Escape typed in a plain note or a new tab leave the full player open and paused", async () => {
+		const { obsidian, sandbox } = getContext();
+		const note = sandbox.path("Plain note.md");
+		await writeVaultFile(obsidian, note, "A plain note\n");
+		await openInEditor(obsidian, note);
+		await openPlayer([ONE]);
+		expect(await clickInEditor(obsidian, note, 0, 12)).toEqual({ line: 0, ch: 12 });
+		const text = () =>
+			obsidian.dev.evalJson<string>(
+				`app.workspace.getLeavesOfType("markdown").find((leaf) => leaf.view.file?.path === ${jsLiteral(note)}).view.editor.getValue()`,
+			);
+		const activeView = () =>
+			obsidian.dev.evalJson<string>("app.workspace.activeLeaf.view.getViewType()");
+		const playerAsItWas = async (after: string) => {
+			expect(
+				await holdsFor(obsidian, () => isShown(obsidian, ui.fullPlayer), true, 1000),
+				`${after}: the player stays open`,
+			).toBe(true);
+			expect(
+				await holdsFor(
+					obsidian,
+					async () => (await observePlayback(obsidian)).playing,
+					false,
+					500,
+				),
+				`${after}: still paused`,
+			).toBe(false);
+		};
+
+		await pressKey(obsidian, "Space");
+		expect(await eventually(obsidian, text, "A plain note \n"), "Space types in the note").toBe(
+			"A plain note \n",
+		);
+		await playerAsItWas("Space in the note");
+		await pressKey(obsidian, "Escape");
+		await playerAsItWas("Escape in the note");
+
+		await pressHotkey(obsidian, "t");
+		expect(await eventually(obsidian, activeView, "empty")).toBe("empty");
+		await pressKey(obsidian, "Space");
+		await playerAsItWas("Space in the new tab");
+		await pressKey(obsidian, "Escape");
+		await playerAsItWas("Escape in the new tab");
+		expect(await activeView(), "the new tab stays active").toBe("empty");
+		expect(await text(), "the note is as Space left it").toBe("A plain note \n");
+	});
 });
diff --git a/tests/e2e/journey/actions.ts b/tests/e2e/journey/actions.ts
index fe8f792e..3fdefb09 100644
--- a/tests/e2e/journey/actions.ts
+++ b/tests/e2e/journey/actions.ts
@@ -11,7 +11,7 @@ import {
 } from "obsidian-e2e/runner";
 import { jsLiteral, PLUGIN_ID, VIEW_TYPE, waitForPodNotesReady } from "../runtime";
 import { collectRuntimeErrors, POPOUT_RESIZE_LOOP } from "../runtime-evidence";
-import { cdp, click, clickAt, type Point, typeInto } from "./input";
+import { cdp, click, clickAt, type Point, pressHotkey, typeInto } from "./input";
 import { ui } from "./targets";
 import { isShown, waitUntilShown } from "./wait";
 
@@ -27,14 +27,7 @@ export async function dismissNotices(obsidian: ObsidianClient): Promise<void> {
  */
 export async function runFromPalette(obsidian: ObsidianClient, name: string): Promise<void> {
 	await obsidian.plugin("command-palette").enable({ filter: "core" });
-	const hotkey = {
-		key: "p",
-		code: "KeyP",
-		windowsVirtualKeyCode: 80,
-		modifiers: process.platform === "darwin" ? 4 : 2,
-	};
-	for (const type of ["keyDown", "keyUp"])
-		await cdp(obsidian, "Input.dispatchKeyEvent", { type, ...hotkey });
+	await pressHotkey(obsidian, "p");
 	await typeInto(obsidian, ui.promptInput, name);
 	await click(obsidian, ui.paletteCommand(name));
 }
diff --git a/tests/e2e/journey/input.ts b/tests/e2e/journey/input.ts
index 60a7e5c8..77d5ce50 100644
--- a/tests/e2e/journey/input.ts
+++ b/tests/e2e/journey/input.ts
@@ -203,6 +203,19 @@ const KEYS = {
 	Space: { key: " ", windowsVirtualKeyCode: 32, text: " " },
 } as const;
 
+/** Presses Mod, which is Cmd on macOS and Ctrl elsewhere, with the letter `key`, as a hotkey. */
+export async function pressHotkey(obsidian: ObsidianClient, key: string): Promise<void> {
+	const letter = key.toUpperCase();
+	const event = {
+		key,
+		code: `Key${letter}`,
+		windowsVirtualKeyCode: letter.charCodeAt(0),
+		modifiers: process.platform === "darwin" ? 4 : 2,
+	};
+	await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyDown", ...event });
+	await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyUp", ...event });
+}
+
 /** Presses and releases the key with this `code` on whatever has focus. */
 export async function pressKey(obsidian: ObsidianClient, code: keyof typeof KEYS): Promise<void> {
 	const event = { code, ...KEYS[code] };
diff --git a/tests/mocks/obsidian.ts b/tests/mocks/obsidian.ts
index 948accc7..d60d02d6 100644
--- a/tests/mocks/obsidian.ts
+++ b/tests/mocks/obsidian.ts
@@ -28,7 +28,11 @@ export class Scope {
 	win: Window | null = null;
 	private handlers: KeymapEventHandler[] = [];
 
-	constructor(private readonly parent?: Scope) {}
+	/** `delegate`, as Obsidian's workspace scope has, gets every key while it gives a scope. */
+	constructor(
+		private readonly parent?: Scope,
+		private readonly delegate?: () => Scope | null,
+	) {}
 
 	register(_modifiers: string[] | null, key: string | null, func: KeymapEventListener) {
 		const handler = { key, func };
@@ -42,6 +46,8 @@ export class Scope {
 
 	/** As Obsidian: the first handler for the key decides, else the parent scope does. */
 	handleKey(evt: KeyboardEvent): unknown {
+		const delegated = this.delegate?.();
+		if (delegated) return delegated.handleKey(evt);
 		for (const { key, func } of this.handlers) {
 			if (key !== null && key !== evt.key) continue;
 			const result = func(evt, {});
@@ -98,6 +104,8 @@ interface EventRef {
 }
 
 export class Workspace {
+	/** Obsidian makes a leaf active on focus or a press in it. */
+	activeLeaf: { view: { scope: Scope | null } } | null = null;
 	private readonly refs = new Set<EventRef & { name: string; callback(): unknown }>();
 
 	on(name: string, callback: () => unknown): EventRef {
@@ -118,8 +126,9 @@ export class Workspace {
 export class App {
 	secretStorage = new SecretStorage();
 	scope = new Scope();
-	keymap = new Keymap(this.scope);
 	workspace = new Workspace();
+	/** Each window's base scope, as Obsidian's workspace scope, hands keys to the active view's scope. */
+	keymap = new Keymap(new Scope(this.scope, () => this.workspace.activeLeaf?.view.scope ?? null));
 }
 export class Plugin {}
 
@@ -202,6 +211,7 @@ export const normalizePath = (path: string): string => {
 
 export class WorkspaceLeaf {}
 export class ItemView extends Component {
+	scope: Scope | null = null;
 	/** Obsidian loads a view before onOpen and unloads it before onClose. */
 	async open(): Promise<void> {
 		this.load();
diff --git a/tests/mocks/popout.ts b/tests/mocks/popout.ts
index 0ee9bba2..186aad3f 100644
--- a/tests/mocks/popout.ts
+++ b/tests/mocks/popout.ts
@@ -5,7 +5,7 @@ export interface FakePopout {
 	readonly win: Window;
 	/** Moves `el` into the popout as Obsidian moves a leaf, telling the listeners in it. */
 	moveIn(el: HTMLElement): void;
-	/** Makes the popout the active window, as Obsidian's focus listener does, then fires `focus`. */
+	/** Makes the popout the active window, as Obsidian does when it gets focus. */
 	focus(): void;
 }
 
@@ -43,7 +43,6 @@ export function openPopout(): FakePopout {
 		},
 		focus() {
 			activeWindow = win;
-			win.dispatchEvent(new Event("focus"));
 		},
 	};
 }
diff --git a/tests/mocks/services.ts b/tests/mocks/services.ts
index 59f7c213..b72a302d 100644
--- a/tests/mocks/services.ts
+++ b/tests/mocks/services.ts
@@ -1,4 +1,4 @@
-import { App } from "obsidian";
+import { App, Scope } from "obsidian";
 import { vi } from "vitest";
 import { DEFAULT_EPISODE_LIST_LIMIT, DEFAULT_SETTINGS } from "src/constants";
 import { PlayerController } from "src/player/PlayerController";
@@ -26,6 +26,17 @@ import { PodcastSearch } from "src/ui/PodcastView/podcastSearch";
 import { FakeDocument } from "./fakeMedia";
 import { feedDocument, MemoryStorage } from "./feeds";
 
+/**
+ * Makes the leaf whose view has `scope` the active one, as focus or a press in it does
+ * in Obsidian, which hands that scope every key. A view with no scope, as a new tab's,
+ * leaves them to the app's scope.
+ */
+export function activateLeaf(app: App, scope: Scope | null): void {
+	(app.workspace as unknown as { activeLeaf: { view: { scope: Scope | null } } }).activeLeaf = {
+		view: { scope },
+	};
+}
+
 /** A library the test seeds, with the stores' setters. */
 export type TestLibrary = {
 	readonly [K in keyof Library]: Library[K] extends Readable<infer T> ? Writable<T> : never;
@@ -105,8 +116,12 @@ export function createTestServices(
 		now: Date.now,
 	});
 	const online = writable(true);
+	const scope = new Scope(app.scope);
+	// The view's leaf is active, as after a press in it.
+	activateLeaf(app, scope);
 	const services = {
 		app,
+		scope,
 		api: { skipBackward: vi.fn(), skipForward: vi.fn() } as never,
 		player,
 		feeds,