Create polished demo videos without editing skills. Mac/Windows/Linux
Merge the author's latest capture-picker fixes from PR #1090
webadderallc4a73f7580ce
diff --cc electron/ipc/register/capturePicker.test.tsindex 3733e7b9,00000000..1b5625c3mode 100644,000000..100644--- a/electron/ipc/register/capturePicker.test.ts+++ b/electron/ipc/register/capturePicker.test.ts@@@ -1,224 -1,0 +1,223 @@@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+const mocks = vi.hoisted(() => ({+ handlers: new Map<string, (...args: unknown[]) => unknown>(),+ list: vi.fn(),+ pickSourceList: vi.fn(),+ validate: vi.fn(),+ remember: vi.fn(),+ selected: vi.fn(),+ recording: false,+ currentSource: null as Record<string, unknown> | null,+ create: vi.fn(),+ close: vi.fn(),+ overlay: {},+ outsider: {},+ windows: [] as object[],+}));+vi.mock("electron", () => ({+ ipcMain: {+ handle: (name: string, handler: (...args: unknown[]) => unknown) =>+ mocks.handlers.set(name, handler),+ },- BrowserWindow: { fromWebContents: (sender: unknown) => sender },+}));+vi.mock("../../windows", () => ({+ createCapturePickerWindows: mocks.create,+ closeCapturePickerWindows: mocks.close,- getCapturePickerWindows: () => mocks.windows,++ isCapturePickerWebContents: (sender: object) => mocks.windows.includes(sender),+}));+vi.mock("../captureSelection", () => ({+ validateCaptureSource: mocks.validate,+ rememberCaptureSource: mocks.remember,+}));+vi.mock("../capturePickerSources", () => ({ listCapturePickerWindows: mocks.list }));+vi.mock("../cursor/bounds", () => ({ stopWindowBoundsCapture: vi.fn() }));+vi.mock("../state", () => ({+ setSelectedSource: mocks.selected,+ get isCursorCaptureActive() {+ return mocks.recording;+ },+ get selectedSource() {+ return mocks.currentSource;+ },+}));+vi.mock("../utils", () => ({+ getScreen: () => ({+ getAllDisplays: () => [{ id: 1, bounds: { x: 0, y: 0, width: 1440, height: 1000 } }],+ getPrimaryDisplay: () => ({ id: 1 }),+ getCursorScreenPoint: () => ({ x: 0, y: 0 }),+ }),+}));+vi.mock("./sources", () => ({+ bringSelectedWindowForward: vi.fn(),+ broadcastSelectedSourceChange: vi.fn(),+ getDesktopSources: vi.fn().mockResolvedValue([{ id: "screen:1:0", display_id: "1" }]),+}));+import { registerCapturePickerHandlers } from "./capturePicker";+const platform = process.platform;+afterEach(() => {+ Object.defineProperty(process, "platform", { value: platform });+ vi.unstubAllEnvs();+});+beforeEach(() => {+ vi.clearAllMocks();+ mocks.handlers.clear();+ mocks.currentSource = null;+ mocks.recording = false;+ mocks.windows = [mocks.overlay];+ Object.defineProperty(process, "platform", { value: "darwin" });+ mocks.list.mockResolvedValue([]);+ mocks.validate.mockImplementation(async (source) => source);+ registerCapturePickerHandlers({ pickSourceList: mocks.pickSourceList });+});+const call = (name: string, sender: object, input?: unknown) =>+ mocks.handlers.get(name)!({ sender }, input);+describe("selection-only picker IPC", () => {+ it("ignores completion from other windows and forces selection-only completion", async () => {+ const pending = call("pick-capture-target", mocks.outsider);+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());+ await call("complete-capture-pick", mocks.outsider, {+ kind: "screen",+ displayId: 1,+ record: true,+ });+ expect(mocks.selected).not.toHaveBeenCalled();+ await call("complete-capture-pick", mocks.overlay, {+ kind: "screen",+ displayId: 1,+ record: true,+ });+ expect(await pending).toMatchObject({ success: true, source: { id: "screen:1:0" } });+ expect(await pending).not.toHaveProperty("record");+ });+ it("coalesces simultaneous opens into one picker", async () => {+ const first = call("pick-capture-target", mocks.outsider);+ const second = call("pick-capture-target", mocks.outsider);+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());+ await call("complete-capture-pick", mocks.overlay, null);+ expect(await first).toEqual({ success: false, canceled: true });+ expect(await second).toEqual({ success: false, canceled: true });+ });+ it("keeps Wayland on the existing portal path without overlays or geometry probes", async () => {+ Object.defineProperty(process, "platform", { value: "linux" });+ vi.stubEnv("XDG_SESSION_TYPE", "wayland");+ expect(await call("pick-capture-target", mocks.outsider)).toMatchObject({+ success: true,+ source: { id: "screen:linux-portal" },+ });+ expect(mocks.create).not.toHaveBeenCalled();+ expect(mocks.list).not.toHaveBeenCalled();+ });+});++it("rejects a window that disappeared while the picker was open", async () => {+ mocks.list.mockResolvedValue([+ {+ id: "window:101:0",+ title: "Document",+ appName: "Notes",+ x: 0,+ y: 0,+ width: 400,+ height: 300,+ },+ ]);+ mocks.validate.mockResolvedValue(null);+ const pending = call("pick-capture-target", mocks.outsider);+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());+ await call("complete-capture-pick", mocks.overlay, {+ kind: "window",+ windowId: "window:101:0",+ displayId: 1,+ });+ expect(await pending).toMatchObject({+ success: false,+ message: "That window or screen is no longer available.",+ });+ expect(mocks.selected).not.toHaveBeenCalled();+ expect(mocks.remember).not.toHaveBeenCalled();+});+it("surfaces detection failures instead of opening a screen-only overlay", async () => {+ mocks.list.mockRejectedValue(new Error("Unable to detect windows"));+ expect(await call("pick-capture-target", mocks.outsider)).toMatchObject({+ success: false,+ message: "Unable to detect windows",+ });+ expect(mocks.create).not.toHaveBeenCalled();+ expect(mocks.selected).not.toHaveBeenCalled();+});++it("reopens the currently selected saved area, without reusing an old area for a window", async () => {+ mocks.currentSource = {+ id: "area:1",+ display_id: "1",+ area: { x: 100, y: 200, width: 400, height: 300 },+ };+ expect(await call("get-capture-picker-context", mocks.overlay, 1)).toMatchObject({+ lastArea: mocks.currentSource.area,+ });+ mocks.currentSource = { id: "window:101:0", display_id: "1" };+ expect(await call("get-capture-picker-context", mocks.overlay, 1)).toMatchObject({+ lastArea: null,+ });+});++it("does not open any source picker during recording or pause", async () => {+ mocks.recording = true;+ expect(await call("pick-capture-target", mocks.outsider)).toEqual({+ success: false,+ canceled: true,+ });+ expect(mocks.list).not.toHaveBeenCalled();+ expect(mocks.create).not.toHaveBeenCalled();+ expect(mocks.selected).not.toHaveBeenCalled();+});++it("rejects a pending selection if recording starts while the picker is open", async () => {+ const pending = call("pick-capture-target", mocks.outsider);+ await vi.waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());+ mocks.recording = true;+ await call("complete-capture-pick", mocks.overlay, { kind: "screen", displayId: 1 });+ expect(await pending).toEqual({ success: false, canceled: true });+ expect(mocks.selected).not.toHaveBeenCalled();+});++it("does not open overlays if recording starts while listing windows", async () => {+ mocks.list.mockImplementation(async () => {+ mocks.recording = true;+ return [];+ });+ expect(await call("pick-capture-target", mocks.outsider)).toEqual({+ success: false,+ canceled: true,+ });+ expect(mocks.create).not.toHaveBeenCalled();+});++it("keeps X11 on the source list and coalesces concurrent opens", async () => {+ Object.defineProperty(process, "platform", { value: "linux" });+ vi.stubEnv("XDG_SESSION_TYPE", "x11");+ let finish!: (result: unknown) => void;+ mocks.pickSourceList.mockReturnValue(+ new Promise((resolve) => {+ finish = resolve;+ }),+ );+ const first = call("pick-capture-target", mocks.outsider);+ const second = call("pick-capture-target", mocks.outsider);+ expect(mocks.pickSourceList).toHaveBeenCalledOnce();+ expect(mocks.list).not.toHaveBeenCalled();+ expect(mocks.create).not.toHaveBeenCalled();+ finish({ success: false, canceled: true });+ expect(await first).toEqual({ success: false, canceled: true });+ expect(await second).toEqual({ success: false, canceled: true });+});+it("keeps the X11 source list closed during recording", async () => {+ Object.defineProperty(process, "platform", { value: "linux" });+ vi.stubEnv("XDG_SESSION_TYPE", "x11");+ mocks.recording = true;+ expect(await call("pick-capture-target", mocks.outsider)).toEqual({+ success: false,+ canceled: true,+ });+ expect(mocks.pickSourceList).not.toHaveBeenCalled();+});diff --cc electron/ipc/register/capturePicker.tsindex 8c26ae39,4b93088b..9c6ead38--- a/electron/ipc/register/capturePicker.ts+++ b/electron/ipc/register/capturePicker.ts@@@ -1,27 -1,50 +1,27 @@@+import { rememberCaptureSource, validateCaptureSource } from "../captureSelection";+import { listCapturePickerWindows } from "../capturePickerSources";- import { BrowserWindow, ipcMain } from "electron";+ import { ipcMain } from "electron";+import type { SourceListPickResult } from "../../sourceListPicker";import {closeCapturePickerWindows,createCapturePickerWindows,- getCapturePickerWindows,+ isCapturePickerWebContents,} from "../../windows";-import { getNativeMacWindowsFrontToBack, stopWindowBoundsCapture } from "../cursor/bounds";-import { setSelectedSource } from "../state";-import { createAreaSource, createWindowSource, normalizeCapturePick } from "../sourceArea";-import type { AreaCapturePick, CapturePick, CapturePickerWindow, SelectedSource } from "../types";+import { stopWindowBoundsCapture } from "../cursor/bounds";+import { isCursorCaptureActive, selectedSource, setSelectedSource } from "../state";+import {+ createAreaSource,+ createWindowSource,+ getSourceArea,+ normalizeCapturePick,+} from "../sourceArea";+import type { CapturePick, CapturePickerWindow, SelectedSource } from "../types";import { getScreen } from "../utils";-import { getScreenSourceIdForDisplay } from "./sourceMapping";-import { bringSelectedWindowForward, broadcastSelectedSourceChange } from "./sources";--/** Windows the picker can offer, front to back, without Recordly's own. */-async function listPickableWindows(): Promise<CapturePickerWindow[]> {- const entries = await getNativeMacWindowsFrontToBack();- return entries.flatMap((entry) => {- const { x, y, width, height } = entry;- if (- entry.ownerPid === process.pid ||- typeof x !== "number" ||- typeof y !== "number" ||- typeof width !== "number" ||- typeof height !== "number" ||- width <= 0 ||- height <= 0- ) {- return [];- }- return [- {- id: entry.id,- appName: entry.appName ?? "",- title: entry.windowTitle ?? entry.name,- display_id: entry.display_id,- x,- y,- width,- height,- },- ];- });-}+import { getScreenSourceIdForDisplay, isLikelyLinuxWaylandSession } from "./sourceMapping";+import { broadcastSelectedSourceChange, getDesktopSources } from "./sources";/** The same source the screen list offers for this display. */-function createScreenSource(displayId: number): SelectedSource | null {+async function createScreenSource(displayId: number): Promise<SelectedSource | null> {const displays = getScreen().getAllDisplays();const index = displays.findIndex((display) => display.id === displayId);if (index < 0) return null;@@@ -149,34 -120,19 +149,32 @@@ export function registerCapturePickerHa});ipcMain.handle("complete-capture-pick", async (event, input: unknown) => {- if (!getCapturePickerWindows().includes(BrowserWindow.fromWebContents(event.sender)!))- return;- // Only the picker overlays answer a pick.+ if (!isCapturePickerWebContents(event.sender)) return;- if (!input) {+ if (+ input &&+ typeof input === "object" &&+ (input as { kind?: unknown }).kind === "area" &&+ process.platform !== "darwin"+ )+ return;+ if (!input || isCursorCaptureActive) {finishPick(null);return;}const displays = getScreen().getAllDisplays().map((display) => ({ id: display.id, bounds: display.bounds }));- finishPick(normalizeCapturePick(input, displays, await pickableWindows));+ finishPick(+ normalizeCapturePick(+ input && typeof input === "object" ? { ...input, record: false } : input,+ displays,+ await pickableWindows,+ ),+ );});- ipcMain.handle("get-capture-picker-context", async (_, displayId: unknown) => {+ ipcMain.handle("get-capture-picker-context", async (event, displayId: unknown) => {- if (!getCapturePickerWindows().includes(BrowserWindow.fromWebContents(event.sender)!))- throw new Error("Unknown picker window.");++ if (!isCapturePickerWebContents(event.sender)) throw new Error("Unknown picker window.");const display = getScreen().getAllDisplays().find((entry) => entry.id === Number(displayId));diff --cc tests/ui/capture-picker.spec.tsindex 25ac875a,8e32093f..e7d12c5a--- a/tests/ui/capture-picker.spec.ts+++ b/tests/ui/capture-picker.spec.ts@@@ -105,267 -101,3 +105,339 @@@ test("Escape cancels", async ({ page }await page.keyboard.press("Escape");expect(await pick(page)).toBeNull();});++test("selection has no recording toolbar", async ({ page }) => {+ await openPicker(page);+ await page.mouse.click(600, 300);+ await expect(page.getByRole("button", { name: "Record", exact: true })).toHaveCount(0);+ expect(await pick(page)).toMatchObject({ kind: "window", record: false });+});++test("platforms without area capture keep drag selection on an existing screen", async ({+ page,+}) => {+ await openPicker(page, false);+ await page.mouse.move(1300, 100);+ await page.mouse.down();+ await page.mouse.move(1380, 180, { steps: 8 });+ await page.mouse.up();+ expect(await pick(page)).toMatchObject({ kind: "screen", record: false });+});++for (const { selected, trigger } of [+ { selected: false, trigger: "source" },+ { selected: false, trigger: "record" },+ { selected: true, trigger: "source" },+]) {+ test(`HUD ${selected ? "keeps the selected source" : "starts without a selected source"} and opens the picker only on ${trigger} click`, async ({+ page,+ }) => {+ await installDesktopBridge(page);+ await page.addInitScript((selected) => {+ Object.assign(window.electronAPI, {+ getSelectedSource: async () =>+ selected ? { id: "screen:1:0", name: "Existing screen" } : null,+ pickCaptureTarget: async () => {+ const html = document.documentElement;+ html.dataset.pickerCalls = String(Number(html.dataset.pickerCalls ?? 0) + 1);+ return {+ success: true,+ source: { id: "window:101:0", name: "Selected window" },+ };+ },+ });+ }, selected);+ await page.goto("/?windowType=hud-overlay");+ const control = page.getByRole("button", { name: "Choose recording source" });+ await expect(control).toBeEnabled();+ if (selected) {+ await expect(control).toContainText("Existing screen");+ } else {+ await expect(control).toHaveText("Pick source");+ }+ await expect(page.locator("html")).not.toHaveAttribute("data-picker-calls");+ await (trigger === "source"+ ? control+ : page.getByRole("button", { name: "Record", exact: true })+ ).click();+ await expect(page.locator("html")).toHaveAttribute("data-picker-calls", "1");+ await expect(control).toContainText("Selected window");+ await expect(page.getByRole("button", { name: "Record", exact: true })).toBeVisible();+ });+}++test("a newer selected-source event wins over the startup response", async ({ page }) => {+ await installDesktopBridge(page);+ await page.addInitScript(() => {+ Object.assign(window.electronAPI, {+ getSelectedSource: async () => {+ await new Promise((resolve) => setTimeout(resolve, 100));+ document.documentElement.dataset.sourceResolved = "true";+ return null;+ },+ onSelectedSourceChanged: (listener: (source: { name: string }) => void) => {+ const timer = setTimeout(() => listener({ name: "Newer window" }), 10);+ return () => clearTimeout(timer);+ },+ pickCaptureTarget: async () => {+ document.documentElement.dataset.pickerCalls = "1";+ return { success: false, canceled: true };+ },+ });+ });+ await page.goto("/?windowType=hud-overlay");+ await expect(page.locator("html")).toHaveAttribute("data-source-resolved", "true");+ await expect(page.getByRole("button", { name: "Choose recording source" })).toContainText(+ "Newer window",+ );+ await expect(page.locator("html")).not.toHaveAttribute("data-picker-calls");+});++test("areas can be moved and resized before Enter confirms them", async ({ page }) => {+ await openPicker(page);+ await page.mouse.move(300, 200);+ await page.mouse.down();+ await page.mouse.move(700, 450, { steps: 8 });+ await page.mouse.up();+ await expect(page.getByText("Area · 400 × 250")).toBeVisible();+ await page.mouse.move(400, 300);+ await page.mouse.down();+ await page.mouse.move(450, 350, { steps: 5 });+ await page.mouse.up();+ expect(await pick(page)).toBeUndefined();+ const corner = page.locator('[data-area-handle="se"]');+ const bounds = await corner.boundingBox();+ if (!bounds) throw new Error("Missing area resize handle");+ await page.mouse.move(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);+ await page.mouse.down();+ await page.mouse.move(850, 600, { steps: 5 });+ await page.mouse.up();+ await expect(page.getByText("Area · 500 × 350")).toBeVisible();+ await page.keyboard.press("Enter");+ expect(await pick(page)).toMatchObject({+ kind: "area",+ x: 350,+ y: 250,+ width: 500,+ height: 350,+ record: false,+ });+});+++for (const resize of [false, true]) {++ test(`area ${resize ? "resize" : "movement"} tracks pointer updates before the next render`, async ({++ page,++ }) => {++ await openPicker(page);++ await page.mouse.move(300, 200);++ await page.mouse.down();++ await page.mouse.move(700, 450);++ await page.mouse.up();++ await expect(page.getByText("Area · 400 × 250")).toBeVisible();++ const start = resize ? { x: 700, y: 450 } : { x: 400, y: 300 };++ await page.mouse.move(start.x, start.y);++ await page.mouse.down();++ await page.locator("div.fixed.inset-0.select-none").evaluate((overlay, start) => {++ for (const delta of [50, 1]) {++ overlay.dispatchEvent(++ new PointerEvent("pointermove", {++ bubbles: true,++ pointerId: 1,++ pointerType: "mouse",++ buttons: 1,++ clientX: start.x + delta,++ clientY: start.y + delta,++ }),++ );++ }++ }, start);++ await page.mouse.up();++ await page.keyboard.press("Enter");++ expect(await pick(page)).toMatchObject({++ kind: "area",++ x: resize ? 300 : 301,++ y: resize ? 200 : 201,++ width: resize ? 401 : 400,++ height: resize ? 251 : 250,++ record: false,++ });++ });++}++++test("HUD reports a failed pick and keeps cancellation silent", async ({ page }) => {++ await installDesktopBridge(page);++ await page.addInitScript(() => {++ let canceled = false;++ Object.assign(window.electronAPI, {++ getSelectedSource: async () => null,++ pickCaptureTarget: async () => {++ const result = {++ success: false,++ canceled,++ message: "That window or screen is no longer available.",++ };++ canceled = true;++ return result;++ },++ });++ });++ await page.goto("/?windowType=hud-overlay");++ const source = page.getByRole("button", { name: "Choose recording source" });++ await source.click();++ await expect(++ page.getByText("That window or screen is no longer available.", { exact: true }),++ ).toBeVisible();++ await page.getByText("That window or screen is no longer available.", { exact: true }).hover();++ await page.locator('[data-slot="toast-close"]').click();++ await source.click();++ await expect(source).toBeEnabled();++ await expect(++ page.getByText("That window or screen is no longer available.", { exact: true }),++ ).toHaveCount(0);++});+++test("unselected source reads Pick source once and Record stays disabled while picking", async ({+ page,+}) => {+ await installDesktopBridge(page);+ await page.addInitScript(() => {+ Object.assign(window.electronAPI, {+ getSelectedSource: async () => null,+ pickCaptureTarget: async () =>+ new Promise((resolve) => {+ (window as unknown as { finishPicker: () => void }).finishPicker = () =>+ resolve({ success: false, canceled: true });+ document.documentElement.dataset.pickerPending = "true";+ }),+ });+ });+ await page.goto("/?windowType=hud-overlay");+ const source = page.getByRole("button", { name: "Choose recording source" });+ await expect(source).toBeEnabled();+ await expect(source).toHaveText("Pick source");+ await expect(page.locator("html")).not.toHaveAttribute("data-picker-pending");+ await source.click();+ await expect(page.locator("html")).toHaveAttribute("data-picker-pending", "true");+ await expect(page.getByRole("button", { name: "Record", exact: true })).toBeDisabled();+ await page.evaluate(() => (window as unknown as { finishPicker: () => void }).finishPicker());+ await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();+ await expect(source).toHaveText("Pick source");+});++test("changing source cancels countdown and discards native warm-up before opening the picker", async ({+ page,+}) => {+ await installDesktopBridge(page);+ await page.addInitScript(() => {+ let finishCountdown: (result: { success: boolean; cancelled: boolean }) => void;+ const events: string[] = [];+ Object.assign(window.electronAPI, {+ startNativeScreenRecording: async () => ({ success: true }),+ pauseNativeScreenRecording: async () => ({ success: true }),+ resumeNativeScreenRecording: async () => {+ events.push("resume");+ return { success: true };+ },+ startCountdown: async () => {+ document.documentElement.dataset.countdownStarted = "true";+ return new Promise((resolve) => {+ finishCountdown = resolve;+ });+ },+ cancelCountdown: async () => {+ events.push("cancel-countdown");+ finishCountdown({ success: false, cancelled: true });+ return { success: true };+ },+ stopNativeScreenRecording: async () => {+ events.push("stop-native");+ return { success: true, path: "/recordings/pending.mp4" };+ },+ deleteRecordingFile: async () => {+ events.push("delete-file");+ return { success: true };+ },+ setRecordingState: async (active: boolean) => {+ if (active) events.push("recording");+ },+ pickCaptureTarget: async () => {+ events.push("pick");+ document.documentElement.dataset.events = JSON.stringify(events);+ return { success: false, canceled: true };+ },+ });+ });+ await page.goto("/?windowType=hud-overlay");+ await page.getByRole("button", { name: "Record", exact: true }).click();+ await expect(page.locator("html")).toHaveAttribute("data-countdown-started", "true");+ const source = page.getByRole("button", { name: "Choose recording source" });+ await expect(source).toBeEnabled();+ await source.click();+ await expect(page.locator("html")).toHaveAttribute(+ "data-events",+ JSON.stringify(["cancel-countdown", "stop-native", "delete-file", "pick"]),+ );+ await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();+});++test("recording and pause expose no interactive source picker", async ({ page }) => {+ await installDesktopBridge(page);+ await page.addInitScript(() => {+ window.electronAPI.onRecordingStateChanged = (callback) => {+ const listener = (event: Event) => callback((event as CustomEvent).detail);+ window.addEventListener("test-recording", listener);+ return () => window.removeEventListener("test-recording", listener);+ };+ window.electronAPI.pickCaptureTarget = async () => {+ document.documentElement.dataset.pickerOpened = "true";+ return { success: false, canceled: true };+ };+ });+ await page.goto("/?windowType=hud-overlay");+ await expect(page.getByRole("button", { name: "Choose recording source" })).toBeEnabled();+ for (const paused of [false, true]) {+ await page.evaluate(+ (paused) =>+ window.dispatchEvent(+ new CustomEvent("test-recording", { detail: { recording: true, paused } }),+ ),+ paused,+ );+ await expect(+ page.getByRole("button", { name: "Choose recording source" }),+ ).not.toBeVisible();+ await expect(page.locator("html")).not.toHaveAttribute("data-picker-opened");+ }+});++test("changing source also cancels countdown on the browser capture path", async ({ page }) => {+ await installDesktopBridge(page);+ await page.addInitScript(() => {+ let finishCountdown: (result: { success: boolean; cancelled: boolean }) => void;+ Object.assign(window.electronAPI, {+ getPlatform: async () => "linux",+ startCountdown: async () => {+ document.documentElement.dataset.countdownStarted = "true";+ return new Promise((resolve) => {+ finishCountdown = resolve;+ });+ },+ cancelCountdown: async () => {+ document.documentElement.dataset.countdownCancelled = "true";+ finishCountdown({ success: false, cancelled: true });+ return { success: true };+ },+ pickCaptureTarget: async () => {+ document.documentElement.dataset.pickedAfterCancel =+ document.documentElement.dataset.countdownCancelled;+ return { success: false, canceled: true };+ },+ });+ });+ await page.goto("/?windowType=hud-overlay");+ await page.getByRole("button", { name: "Record", exact: true }).click();+ await expect(page.locator("html")).toHaveAttribute("data-countdown-started", "true");+ await page.getByRole("button", { name: "Choose recording source" }).click();+ await expect(page.locator("html")).toHaveAttribute("data-picked-after-cancel", "true");+ await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();+});