From 5e08be5a79f15459fd18eb16d2acbbf6710640cc Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Wed, 14 Oct 2026 06:28:09 +0200
Subject: [PATCH 1/5] fix(ui): give the full player's keys to the PodNotes
 view's own scope

The full player pushed a key scope above Obsidian's workspace scope, so
while it was open a note never got Enter or Escape, as in its find bar.

The player now registers Escape and Space on the PodNotes view's own scope.
Obsidian hands a view's scope the keys typed while that view's leaf is
active, which focus or a press in the view makes it. A menu or modal over
the player still takes Escape first, and a queue drag still cancels on
Escape.

size: 98,781 gzip (-146 vs master 35461cd 98,927)
---
 src/ui/PodcastView/Player.svelte              | 61 +++++--------------
 .../PodcastView.integration.test.ts           |  1 +
 src/ui/PodcastView/PodcastView.shell.test.ts  | 49 +++++++++------
 src/ui/PodcastView/context.ts                 |  4 +-
 src/ui/PodcastView/index.ts                   |  3 +-
 tests/e2e/journey-player.test.ts              | 49 ++++++++++++++-
 tests/mocks/obsidian.ts                       | 13 +++-
 tests/mocks/services.ts                       |  6 +-
 8 files changed, 113 insertions(+), 73 deletions(-)

diff --git a/src/ui/PodcastView/Player.svelte b/src/ui/PodcastView/Player.svelte
index 536db736..2d6d1d04 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 focus is in the view, and a menu or
+	// modal opened 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..c97d90e1 100644
--- a/src/ui/PodcastView/PodcastView.shell.test.ts
+++ b/src/ui/PodcastView/PodcastView.shell.test.ts
@@ -683,36 +683,40 @@ describe("full player", () => {
 			services.app.keymap.popScope(modal);
 		});
 
-		test("typed outside the view stays there", async () => {
-			const note = document.body.appendChild(document.createElement("textarea"));
-			renderView();
-			playing();
-			await tick();
-			note.focus();
-
-			services.navigation.expand();
-			await tick();
-			expect(document.activeElement).toBe(note);
-
-			expect(await escape()).toBe(true);
-			expect(services.navigation.current.expanded).toBe(true);
-			note.remove();
-		});
+		/** 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 { view: { scope }, keys };
+		}
+		const workspace = () => services.app.workspace as unknown as { activeLeaf: object | null };
+		const activate = (leaf: object | null) => (workspace().activeLeaf = leaf);
 
-		test("from outside the view passes through, even with focus left in the player", 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}`));
-			expect(document.activeElement).toBe(button("Collapse player"));
+			const tab = noteLeaf();
+			activate(tab);
+			note.focus();
+
+			await fireEvent.keyDown(note, { key: "Enter" });
+			await escape(note);
 
-			expect(await escape(note)).toBe(true);
+			expect(tab.keys).toEqual(["Enter", "Escape"]);
 			expect(services.navigation.current.expanded).toBe(true);
 			note.remove();
 		});
 
-		test("follows the player to a popout window, and Escape in the main window passes it by", async () => {
+		test("follows the player to a popout window, and a note's Escape in the main window passes it by", async () => {
 			const popout = openPopout();
 			popout.win.document.addEventListener("keydown", dispatch);
 			const note = document.body.appendChild(document.createElement("textarea"));
@@ -720,11 +724,16 @@ describe("full player", () => {
 			playing();
 			await tick();
 			await fireEvent.click(button(`Open player: ${episode.title}`));
+			const view = workspace().activeLeaf;
 
 			popout.moveIn(container);
-			expect(await escape(note)).toBe(true);
+			const tab = noteLeaf();
+			activate(tab);
+			await escape(note);
+			expect(tab.keys).toEqual(["Escape"]);
 			expect(services.navigation.current.expanded).toBe(true);
 
+			activate(view);
 			popout.focus();
 			const collapseButton = within(container).getByRole("button", {
 				name: "Collapse player",
diff --git a/src/ui/PodcastView/context.ts b/src/ui/PodcastView/context.ts
index 8c1e8b2a..5fd64f7d 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 gives them only the keys typed while focus is in the view. */
+	readonly scope: Scope;
 	readonly library: Library;
 	readonly actions: LibraryActions;
 	readonly search: PodcastSearch;
diff --git a/src/ui/PodcastView/index.ts b/src/ui/PodcastView/index.ts
index cebd9a61..3a73ae07 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";
@@ -116,6 +116,7 @@ export class MainView extends ItemView {
 			player: plugin.player,
 			feeds: plugin.feeds,
 			navigation: plugin.navigation,
+			scope: (this.scope = new Scope(app.scope)),
 			library: {
 				savedFeeds,
 				queue,
diff --git a/tests/e2e/journey-player.test.ts b/tests/e2e/journey-player.test.ts
index d522ea45..287f7a60 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, 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 {
@@ -337,4 +343,43 @@ 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 };
+			})()`);
+		const find = {
+			key: "f",
+			code: "KeyF",
+			windowsVirtualKeyCode: 70,
+			modifiers: process.platform === "darwin" ? 4 : 2,
+		};
+		await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyDown", ...find });
+		await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyUp", ...find });
+		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);
+	});
 });
diff --git a/tests/mocks/obsidian.ts b/tests/mocks/obsidian.ts
index 4aa2f8cf..e79c195a 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 {}
 
diff --git a/tests/mocks/services.ts b/tests/mocks/services.ts
index 322b847d..aa5db812 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";
@@ -106,8 +106,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.
+	app.workspace.activeLeaf = { view: { scope } } as never;
 	const services = {
 		app,
+		scope,
 		api: { skipBackward: vi.fn(), skipForward: vi.fn() } as never,
 		player,
 		feeds,

From 717520be3b47902db6b2041e78b548b4475c1c97 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Wed, 14 Oct 2026 06:28:09 +0200
Subject: [PATCH 2/5] fix(capture): refuse Undo unless every open editor of the
 note matches

With a note open in two panes, Undo checked only the first editor it found.
It now leaves the note unless every open editor of it holds the text as the
capture left it.

size: 98,798 gzip (-129 vs master 35461cd 98,927)
---
 src/commands.test.ts           | 12 ++++++++++++
 src/services/CaptureService.ts | 10 ++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/commands.test.ts b/src/commands.test.ts
index c4a40c26..ac03d37c 100644
--- a/src/commands.test.ts
+++ b/src/commands.test.ts
@@ -608,6 +608,18 @@ 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 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 fe9277e5..2f5e89a2 100644
--- a/src/services/CaptureService.ts
+++ b/src/services/CaptureService.ts
@@ -169,11 +169,17 @@ 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.
+		// Every open editor of the note has to hold the text as the capture left it.
 		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);
+			.filter((view) => view?.file === file);
+		if (editing[0]) {
+			return (
+				editing.every((view) => view?.editor.getValue() === snapshot.after) &&
+				revertIn(editing[0].editor, snapshot)
+			);
+		}
 		try {
 			await this.plugin.app.vault.process(file, (content) => {
 				if (content !== snapshot.after) throw new Error("The note changed");

From 8fa11354c2f7a52a9b53de93b4c4f3906a2e6f66 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Wed, 14 Oct 2026 06:43:38 +0200
Subject: [PATCH 3/5] refactor: settle the review of the view's key scope

Tests now pin that the view's own scope is the one its components register
on, drop the scaffolding for the removed window-focus path, set the active
leaf through one helper, and press hotkeys through one e2e helper. Undo's
editor check gets a typed list and a test for two matching editors.
---
 src/commands.test.ts                         | 13 ++++++++
 src/services/CaptureService.ts               | 15 +++++-----
 src/ui/PodcastView/Player.svelte             |  4 +--
 src/ui/PodcastView/PodcastView.shell.test.ts | 31 ++++----------------
 src/ui/PodcastView/QueueList.svelte          |  2 +-
 src/ui/PodcastView/context.ts                |  2 +-
 src/ui/PodcastView/index.test.ts             |  9 ++++++
 src/ui/PodcastView/index.ts                  |  4 ++-
 tests/e2e/journey-player.test.ts             | 11 ++-----
 tests/e2e/journey/actions.ts                 | 11 ++-----
 tests/e2e/journey/input.ts                   | 13 ++++++++
 tests/mocks/obsidian.ts                      |  1 +
 tests/mocks/popout.ts                        |  3 +-
 tests/mocks/services.ts                      | 12 +++++++-
 14 files changed, 73 insertions(+), 58 deletions(-)

diff --git a/src/commands.test.ts b/src/commands.test.ts
index ac03d37c..a5322fc2 100644
--- a/src/commands.test.ts
+++ b/src/commands.test.ts
@@ -620,6 +620,19 @@ describe("capture", () => {
 			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 2f5e89a2..e737553b 100644
--- a/src/services/CaptureService.ts
+++ b/src/services/CaptureService.ts
@@ -170,14 +170,15 @@ export class CaptureService {
 		// 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.
 		// Every open editor of the note has to hold the text as the capture left it.
-		const editing = this.plugin.app.workspace
-			.getLeavesOfType("markdown")
-			.map((leaf) => this.editingView(leaf))
-			.filter((view) => view?.file === file);
-		if (editing[0]) {
+		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(editing[0].editor, snapshot)
+				editing.every((view) => view.editor.getValue() === snapshot.after) &&
+				revertIn(first.editor, snapshot)
 			);
 		}
 		try {
diff --git a/src/ui/PodcastView/Player.svelte b/src/ui/PodcastView/Player.svelte
index 2d6d1d04..23748738 100644
--- a/src/ui/PodcastView/Player.svelte
+++ b/src/ui/PodcastView/Player.svelte
@@ -89,8 +89,8 @@
 		if (failed) volumeOpen = false;
 	});
 
-	// The view's own scope gets the keys typed while focus is in the view, and a menu or
-	// modal opened over the player takes Escape first.
+	// 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 escape = scope.register(null, "Escape", () => {
 			if (volumeOpen) {
diff --git a/src/ui/PodcastView/PodcastView.shell.test.ts b/src/ui/PodcastView/PodcastView.shell.test.ts
index c97d90e1..e2139929 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,22 +668,6 @@ 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);
@@ -693,10 +678,8 @@ describe("full player", () => {
 					return false;
 				});
 			}
-			return { view: { scope }, keys };
+			return { scope, keys };
 		}
-		const workspace = () => services.app.workspace as unknown as { activeLeaf: object | null };
-		const activate = (leaf: object | null) => (workspace().activeLeaf = leaf);
 
 		test("typed in a note reach the note, and the player stays open (#467)", async () => {
 			const note = document.body.appendChild(document.createElement("textarea"));
@@ -705,7 +688,7 @@ describe("full player", () => {
 			await tick();
 			await fireEvent.click(button(`Open player: ${episode.title}`));
 			const tab = noteLeaf();
-			activate(tab);
+			activateLeaf(services.app, tab.scope);
 			note.focus();
 
 			await fireEvent.keyDown(note, { key: "Enter" });
@@ -716,7 +699,7 @@ describe("full player", () => {
 			note.remove();
 		});
 
-		test("follows the player to a popout window, and a note's 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"));
@@ -724,16 +707,14 @@ describe("full player", () => {
 			playing();
 			await tick();
 			await fireEvent.click(button(`Open player: ${episode.title}`));
-			const view = workspace().activeLeaf;
-
 			popout.moveIn(container);
 			const tab = noteLeaf();
-			activate(tab);
+			activateLeaf(services.app, tab.scope);
 			await escape(note);
 			expect(tab.keys).toEqual(["Escape"]);
 			expect(services.navigation.current.expanded).toBe(true);
 
-			activate(view);
+			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 5fd64f7d..9cd6e0af 100644
--- a/src/ui/PodcastView/context.ts
+++ b/src/ui/PodcastView/context.ts
@@ -35,7 +35,7 @@ export interface ShellServices {
 	readonly player: PlayerController;
 	readonly feeds: FeedRepository;
 	readonly navigation: Navigation;
-	/** The view's own keys. Obsidian gives them only the keys typed while focus is in the view. */
+	/** 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;
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 3a73ae07..87148fd8 100644
--- a/src/ui/PodcastView/index.ts
+++ b/src/ui/PodcastView/index.ts
@@ -110,13 +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: (this.scope = new Scope(app.scope)),
+			scope,
 			library: {
 				savedFeeds,
 				queue,
diff --git a/tests/e2e/journey-player.test.ts b/tests/e2e/journey-player.test.ts
index 287f7a60..2e9c5baa 100644
--- a/tests/e2e/journey-player.test.ts
+++ b/tests/e2e/journey-player.test.ts
@@ -7,7 +7,7 @@ import {
 	revealInFileExplorer,
 	showPodNotes,
 } from "./journey/actions";
-import { cdp, click, pointOn, pressKey, pressMouse, typeText } from "./journey/input";
+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 {
@@ -357,14 +357,7 @@ describe("player journeys", () => {
 				const bar = leaf.view.containerEl.querySelector(".document-search-container");
 				return { open: Boolean(bar), count: bar?.querySelector(".document-search-count")?.textContent ?? null };
 			})()`);
-		const find = {
-			key: "f",
-			code: "KeyF",
-			windowsVirtualKeyCode: 70,
-			modifiers: process.platform === "darwin" ? 4 : 2,
-		};
-		await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyDown", ...find });
-		await cdp(obsidian, "Input.dispatchKeyEvent", { type: "keyUp", ...find });
+		await pressHotkey(obsidian, "f");
 		await typeText(obsidian, "alpha");
 		expect(await eventually(obsidian, search, { open: true, count: "1 / 3" })).toEqual({
 			open: true,
diff --git a/tests/e2e/journey/actions.ts b/tests/e2e/journey/actions.ts
index 19f4bed1..85365b2e 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 b3b63dea..a58e1b30 100644
--- a/tests/e2e/journey/input.ts
+++ b/tests/e2e/journey/input.ts
@@ -202,6 +202,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 e79c195a..8121d39c 100644
--- a/tests/mocks/obsidian.ts
+++ b/tests/mocks/obsidian.ts
@@ -211,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 aa5db812..df68c4c9 100644
--- a/tests/mocks/services.ts
+++ b/tests/mocks/services.ts
@@ -26,6 +26,16 @@ 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; null for no leaf. Obsidian hands that view's scope every key.
+ */
+export function activateLeaf(app: App, scope: Scope | null): void {
+	(
+		app.workspace as unknown as { activeLeaf: { view: { scope: Scope | null } } | null }
+	).activeLeaf = scope && { 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;
@@ -108,7 +118,7 @@ export function createTestServices(
 	const online = writable(true);
 	const scope = new Scope(app.scope);
 	// The view's leaf is active, as after a press in it.
-	app.workspace.activeLeaf = { view: { scope } } as never;
+	activateLeaf(app, scope);
 	const services = {
 		app,
 		scope,

From 8f6a591a80eec619adc6129e2a5a00c55a80beff Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Wed, 14 Oct 2026 08:24:23 +0200
Subject: [PATCH 4/5] test: cover Escape and Space in a plain note and a new
 tab, and Undo across two panes

The note-key tests used a find bar, whose scope consumes Escape, so player
keys registered on app.scope passed both suites. A plain note's editor and
a new tab have no use for Escape or Space: the unit cases and a trusted-input
journey now check that both leave the full player open and paused.

J-TS-20 presses Undo in the same moment a second pane of the note changes,
which the every-editor check refuses.
---
 src/ui/PodcastView/PodcastView.shell.test.ts | 27 +++++++++++
 tests/e2e/journey-notes.test.ts              | 49 ++++++++++++++++++++
 tests/e2e/journey-player.test.ts             | 48 +++++++++++++++++++
 tests/mocks/services.ts                      |  9 ++--
 4 files changed, 129 insertions(+), 4 deletions(-)

diff --git a/src/ui/PodcastView/PodcastView.shell.test.ts b/src/ui/PodcastView/PodcastView.shell.test.ts
index e2139929..6a5f072d 100644
--- a/src/ui/PodcastView/PodcastView.shell.test.ts
+++ b/src/ui/PodcastView/PodcastView.shell.test.ts
@@ -699,6 +699,33 @@ describe("full player", () => {
 			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("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);
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 2e9c5baa..bfacd8e9 100644
--- a/tests/e2e/journey-player.test.ts
+++ b/tests/e2e/journey-player.test.ts
@@ -19,6 +19,7 @@ import {
 	wav,
 } from "./journey/fixtures";
 import {
+	observePlayback,
 	readLibrary,
 	recordWrites,
 	seedLibrary,
@@ -375,4 +376,51 @@ describe("player journeys", () => {
 		});
 		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/mocks/services.ts b/tests/mocks/services.ts
index 6b8be690..b72a302d 100644
--- a/tests/mocks/services.ts
+++ b/tests/mocks/services.ts
@@ -28,12 +28,13 @@ 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; null for no leaf. Obsidian hands that view's scope every key.
+ * 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 } } | null }
-	).activeLeaf = scope && { view: { scope } };
+	(app.workspace as unknown as { activeLeaf: { view: { scope: Scope | null } } }).activeLeaf = {
+		view: { scope },
+	};
 }
 
 /** A library the test seeds, with the stores' setters. */

From 852f37e2913645e041abfbf5ff67cc9393dc8a9f Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Wed, 14 Oct 2026 08:24:23 +0200
Subject: [PATCH 5/5] test(e2e): wait for the menu to take the keys before
 pressing Escape

Obsidian's menu pushes its key scope in a timer after it shows, and CDP input
runs before that timer. An Escape sent as soon as the menu showed could reach
the view under it, which closed the volume slider and left the menu open.
---
 tests/e2e/journey-player.test.ts | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/e2e/journey-player.test.ts b/tests/e2e/journey-player.test.ts
index bfacd8e9..0e55670b 100644
--- a/tests/e2e/journey-player.test.ts
+++ b/tests/e2e/journey-player.test.ts
@@ -318,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(