@narumitw/pi-chrome-devtools 0.52.2 → 0.53.0

package/src/browser-manager.ts

@@ -8,16 +8,20 @@ import {
 	BROWSER_SHUTDOWN_WAIT_MS,
 	type BrowserCandidate,
 	type BrowserCandidateDefinition,
+	type BrowserLaunchAttempt,
 	DEFAULT_ENDPOINT_RETRY_MS,
 	DEFAULT_ENDPOINT_WAIT_MS,
 	DEFAULT_HTTP_TIMEOUT_MS,
 	DEVTOOLS_ACTIVE_PORT_FILE,
 	type DevToolsPage,
+	invalidateWebMcpOperations,
 	MANAGED_BROWSER_PROFILE_PREFIX,
 	type ManagedBrowser,
 	state,
 } from "./runtime.js";
 
+// Endpoint attachment, managed launch, dynamic-port publication, and shutdown intentionally remain
+// together because they form one ownership state machine behind the testable operations boundary.
 interface BrowserSpawnOptions {
 	shell: false;
 	stdio: "ignore";
@@ -49,6 +53,80 @@ const DEFAULT_BROWSER_MANAGER_OPERATIONS: BrowserManagerOperations = {
 
 let browserManagerOperations = DEFAULT_BROWSER_MANAGER_OPERATIONS;
 
+interface ManagedBrowserScope {
+	controller: AbortController;
+	generation: number;
+	launchPromise?: Promise<void>;
+	managedBrowser?: ManagedBrowser;
+	port: number;
+	lastLaunchAttempt?: BrowserLaunchAttempt;
+}
+
+const managedBrowserScopes = new WeakMap<object, ManagedBrowserScope>();
+
+function managedBrowserScope(owner: object) {
+	const existing = managedBrowserScopes.get(owner);
+	if (existing) return existing;
+	const created: ManagedBrowserScope = {
+		controller: new AbortController(),
+		generation: 0,
+		port: state.configuredPort,
+	};
+	managedBrowserScopes.set(owner, created);
+	return created;
+}
+
+export function startManagedBrowserSession(owner: object) {
+	const scope = managedBrowserScope(owner);
+	scope.controller.abort(new DOMException("Chrome DevTools session replaced", "AbortError"));
+	scope.controller = new AbortController();
+	scope.generation += 1;
+	scope.port = state.configuredPort;
+	scope.lastLaunchAttempt = undefined;
+}
+
+export function managedBrowserForOwner(owner?: object) {
+	if (!owner) return state.managedBrowser;
+	const scopedBrowser = managedBrowserScope(owner).managedBrowser;
+	if (scopedBrowser) return scopedBrowser;
+	return state.managedBrowser?.sessionOwner === owner ? state.managedBrowser : undefined;
+}
+
+function setManagedBrowser(owner: object | undefined, browser: ManagedBrowser | undefined) {
+	if (owner) managedBrowserScope(owner).managedBrowser = browser;
+	else state.managedBrowser = browser;
+}
+
+function launchPromiseForOwner(owner?: object) {
+	return owner ? managedBrowserScope(owner).launchPromise : state.launchPromise;
+}
+
+function setLaunchPromise(owner: object | undefined, launchPromise: Promise<void> | undefined) {
+	if (owner) managedBrowserScope(owner).launchPromise = launchPromise;
+	else state.launchPromise = launchPromise;
+}
+
+function managedBrowserPort(owner?: object) {
+	return owner ? managedBrowserScope(owner).port : state.port;
+}
+
+function setManagedBrowserPort(owner: object | undefined, port: number) {
+	if (owner) managedBrowserScope(owner).port = port;
+	else state.port = port;
+}
+
+function lastLaunchAttempt(owner?: object) {
+	return owner ? managedBrowserScope(owner).lastLaunchAttempt : state.lastLaunchAttempt;
+}
+
+function setLastLaunchAttempt(
+	owner: object | undefined,
+	attempt: BrowserLaunchAttempt | undefined,
+) {
+	if (owner) managedBrowserScope(owner).lastLaunchAttempt = attempt;
+	else state.lastLaunchAttempt = attempt;
+}
+
 export function setBrowserManagerOperationsForTests(overrides: Partial<BrowserManagerOperations>) {
 	const previous = browserManagerOperations;
 	browserManagerOperations = { ...DEFAULT_BROWSER_MANAGER_OPERATIONS, ...overrides };
@@ -69,19 +147,28 @@ function normalizePathForComparison(value: string) {
 	return process.platform === "win32" ? value.toLowerCase() : value;
 }
 
-export async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS) {
+export async function ensureDevToolsEndpoint(
+	waitMs = DEFAULT_ENDPOINT_WAIT_MS,
+	callerSignal?: AbortSignal,
+	owner?: object,
+) {
+	callerSignal?.throwIfAborted();
 	if (extensionsConfigured()) {
 		validateExtensionLaunchMode();
-		await ensureManagedBrowserLaunched(waitMs);
+		await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
 		return;
 	}
 	if (canAutoLaunchBrowser()) {
 		try {
-			await withEndpointRetry(() => fetchDevToolsJson<unknown>("/json/version"), waitMs);
+			await withEndpointRetry(
+				() => fetchDevToolsJson<unknown>("/json/version", { signal: callerSignal }, owner),
+				waitMs,
+				callerSignal,
+			);
 			return;
 		} catch (error) {
 			if (shouldAutoLaunchAfterEndpointError(error)) {
-				await ensureManagedBrowserLaunched(waitMs);
+				await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
 				return;
 			}
 			throw error;
@@ -89,7 +176,7 @@ export async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS)
 	}
 
 	try {
-		await fetchDevToolsJson<unknown>("/json/version");
+		await fetchDevToolsJson<unknown>("/json/version", { signal: callerSignal }, owner);
 	} catch (error) {
 		if (isRetryableEndpointError(error)) return;
 		throw error;
@@ -114,51 +201,97 @@ function validateExtensionLaunchMode() {
 	}
 }
 
-async function ensureManagedBrowserLaunched(waitMs: number) {
-	if (state.launchPromise) return state.launchPromise;
-	if (state.managedBrowser && !state.managedBrowser.exited && state.managedBrowser.ready) return;
-	const generation = state.sessionGeneration;
-	const signal = state.sessionController.signal;
-	throwIfBrowserLaunchCancelled(generation, signal);
-
-	const launchPromise = prepareManagedBrowserLaunch(waitMs, generation, signal);
+async function ensureManagedBrowserLaunched(
+	waitMs: number,
+	callerSignal?: AbortSignal,
+	owner?: object,
+) {
+	const existingLaunch = launchPromiseForOwner(owner);
+	if (existingLaunch) {
+		await waitForCaller(existingLaunch, callerSignal);
+		return;
+	}
+	const existingBrowser = managedBrowserForOwner(owner);
+	if (existingBrowser && !existingBrowser.exited && existingBrowser.ready) return;
+	const generation = owner ? managedBrowserScope(owner).generation : state.sessionGeneration;
+	const signal = owner
+		? managedBrowserScope(owner).controller.signal
+		: state.sessionController.signal;
+	throwIfBrowserLaunchCancelled(generation, signal, owner);
+
+	const launchPromise = prepareManagedBrowserLaunch(waitMs, generation, signal, owner);
 	const wrappedPromise = launchPromise.finally(() => {
-		if (state.launchPromise === wrappedPromise) state.launchPromise = undefined;
+		if (launchPromiseForOwner(owner) === wrappedPromise) setLaunchPromise(owner, undefined);
+	});
+	setLaunchPromise(owner, wrappedPromise);
+	await waitForCaller(wrappedPromise, callerSignal);
+}
+
+function waitForCaller<T>(operation: Promise<T>, signal?: AbortSignal) {
+	if (!signal) return operation;
+	signal.throwIfAborted();
+	return new Promise<T>((resolve, reject) => {
+		let settled = false;
+		const onAbort = () => settle(() => reject(signal.reason));
+		const settle = (callback: () => void) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			callback();
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		operation.then(
+			(value) => settle(() => resolve(value)),
+			(error) => settle(() => reject(error)),
+		);
 	});
-	state.launchPromise = wrappedPromise;
-	return wrappedPromise;
 }
 
 async function prepareManagedBrowserLaunch(
 	waitMs: number,
 	generation: number,
 	signal: AbortSignal,
+	owner?: object,
 ) {
-	if (state.managedBrowser) {
-		await shutdownManagedBrowser(state.managedBrowser, { awaitLaunch: false });
-		throwIfBrowserLaunchCancelled(generation, signal);
+	const existingBrowser = managedBrowserForOwner(owner);
+	if (existingBrowser) {
+		await shutdownManagedBrowser(existingBrowser, { awaitLaunch: false, owner });
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 	}
 	if (state.portConfigured) {
-		const available = await browserManagerOperations.isPortAvailable(state.host, state.port);
-		throwIfBrowserLaunchCancelled(generation, signal);
+		const available = await browserManagerOperations.isPortAvailable(
+			state.host,
+			managedBrowserPort(owner),
+		);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		if (!available) {
 			throw new DevToolsEndpointError(
-				`Cannot launch the extension-owned browser because explicit port ${state.port} is already in use. Choose a free browser.endpoint port or reset the endpoint to use a dynamic managed port.`,
+				`Cannot launch the extension-owned browser because explicit port ${managedBrowserPort(owner)} is already in use. Choose a free browser.endpoint port or reset the endpoint to use a dynamic managed port.`,
 			);
 		}
 	}
-	return launchManagedBrowser(waitMs, generation, signal);
+	return launchManagedBrowser(waitMs, generation, signal, owner);
 }
 
-async function launchManagedBrowser(waitMs: number, generation: number, signal: AbortSignal) {
-	throwIfBrowserLaunchCancelled(generation, signal);
+async function launchManagedBrowser(
+	waitMs: number,
+	generation: number,
+	signal: AbortSignal,
+	owner?: object,
+) {
+	throwIfBrowserLaunchCancelled(generation, signal, owner);
 	const candidateDefinitions = browserCandidateDefinitions();
-	const candidates = await resolveBrowserCandidates(candidateDefinitions, generation, signal);
-	throwIfBrowserLaunchCancelled(generation, signal);
-	state.lastLaunchAttempt = {
+	const candidates = await resolveBrowserCandidates(
+		candidateDefinitions,
+		generation,
+		signal,
+		owner,
+	);
+	throwIfBrowserLaunchCancelled(generation, signal, owner);
+	setLastLaunchAttempt(owner, {
 		candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
 		mode: state.portConfigured ? "explicit-port" : "dynamic-port",
-	};
+	});
 
 	if (candidates.length === 0) {
 		throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions));
@@ -166,33 +299,41 @@ async function launchManagedBrowser(waitMs: number, generation: number, signal:
 
 	let lastError: unknown;
 	for (const candidate of candidates) {
-		throwIfBrowserLaunchCancelled(generation, signal);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		try {
 			if (extensionsConfigured())
-				await requireSupportedExtensionBrowser(candidate, generation, signal);
-			await launchBrowserCandidate(candidate, waitMs, generation, signal);
-			throwIfBrowserLaunchCancelled(generation, signal);
-			state.lastLaunchAttempt = {
-				...state.lastLaunchAttempt,
+				await requireSupportedExtensionBrowser(candidate, generation, signal, owner);
+			await launchBrowserCandidate(candidate, waitMs, generation, signal, owner);
+			throwIfBrowserLaunchCancelled(generation, signal, owner);
+			setLastLaunchAttempt(owner, {
+				...lastLaunchAttempt(owner),
+				candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
+				mode: state.portConfigured ? "explicit-port" : "dynamic-port",
 				selectedCandidate: formatBrowserCandidate(candidate),
-				userDataDir: state.managedBrowser?.userDataDir,
-			};
+				userDataDir: managedBrowserForOwner(owner)?.userDataDir,
+			});
 			return;
 		} catch (error) {
 			try {
-				throwIfBrowserLaunchCancelled(generation, signal);
+				throwIfBrowserLaunchCancelled(generation, signal, owner);
 			} catch (cancellation) {
-				state.lastLaunchAttempt = {
-					...state.lastLaunchAttempt,
+				setLastLaunchAttempt(owner, {
+					...(lastLaunchAttempt(owner) ?? {
+						candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
+						mode: state.portConfigured ? "explicit-port" : "dynamic-port",
+					}),
 					lastError: formatError(cancellation),
-				};
+				});
 				throw cancellation;
 			}
 			lastError = error;
-			state.lastLaunchAttempt = {
-				...state.lastLaunchAttempt,
+			setLastLaunchAttempt(owner, {
+				...(lastLaunchAttempt(owner) ?? {
+					candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
+					mode: state.portConfigured ? "explicit-port" : "dynamic-port",
+				}),
 				lastError: formatError(error),
-			};
+			});
 		}
 	}
 
@@ -214,6 +355,7 @@ async function requireSupportedExtensionBrowser(
 	candidate: BrowserCandidate,
 	generation: number,
 	signal: AbortSignal,
+	owner?: object,
 ) {
 	let version: string;
 	try {
@@ -221,12 +363,12 @@ async function requireSupportedExtensionBrowser(
 			await browserManagerOperations.inspectBrowserVersion(candidate.resolvedExecutable, signal)
 		).trim();
 	} catch (error) {
-		throwIfBrowserLaunchCancelled(generation, signal);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		throw new DevToolsEndpointError(
 			`Unable to identify the configured extension browser ${candidate.resolvedExecutable}: ${formatError(error)}. Configure Chrome for Testing or Chromium.`,
 		);
 	}
-	throwIfBrowserLaunchCancelled(generation, signal);
+	throwIfBrowserLaunchCancelled(generation, signal, owner);
 	const classification = classifyExtensionBrowserVersion(version);
 	if (!classification.supported) {
 		throw new DevToolsEndpointError(
@@ -252,15 +394,16 @@ async function launchBrowserCandidate(
 	waitMs: number,
 	generation: number,
 	signal: AbortSignal,
+	owner?: object,
 ) {
-	throwIfBrowserLaunchCancelled(generation, signal);
+	throwIfBrowserLaunchCancelled(generation, signal, owner);
 	const userDataDir = await browserManagerOperations.mkdtemp(
 		join(tmpdir(), MANAGED_BROWSER_PROFILE_PREFIX),
 	);
 	let managedBrowser: ManagedBrowser | undefined;
 	try {
-		throwIfBrowserLaunchCancelled(generation, signal);
-		const portArgument = state.portConfigured ? String(state.port) : "0";
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
+		const portArgument = state.portConfigured ? String(managedBrowserPort(owner)) : "0";
 		const args = buildManagedBrowserLaunchArguments(
 			userDataDir,
 			portArgument,
@@ -276,22 +419,26 @@ async function launchBrowserCandidate(
 			exited: false,
 			ready: false,
 			ownerGeneration: generation,
+			...(owner ? { sessionOwner: owner } : {}),
 		};
 		managedBrowser = launchedBrowser;
-		state.managedBrowser = launchedBrowser;
+		setManagedBrowser(owner, launchedBrowser);
 
 		child.once("exit", () => {
+			if (managedBrowserForOwner(owner) === launchedBrowser && owner) {
+				invalidateWebMcpOperations(owner, "Chrome DevTools managed browser exited");
+			}
 			launchedBrowser.exited = true;
 			launchedBrowser.ready = false;
-			if (!state.portConfigured && launchedBrowser.port === state.port) {
-				state.port = state.configuredPort;
+			if (!state.portConfigured && launchedBrowser.port === managedBrowserPort(owner)) {
+				setManagedBrowserPort(owner, state.configuredPort);
 			}
 		});
 
 		await waitForBrowserSpawn(child);
-		throwIfBrowserLaunchCancelled(generation, signal);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		if (state.portConfigured) {
-			launchedBrowser.port = state.port;
+			launchedBrowser.port = managedBrowserPort(owner);
 		} else {
 			launchedBrowser.port = await readManagedBrowserPort(
 				userDataDir,
@@ -299,15 +446,16 @@ async function launchBrowserCandidate(
 				waitMs,
 				generation,
 				signal,
+				owner,
 			);
-			throwIfBrowserLaunchCancelled(generation, signal);
-			state.port = launchedBrowser.port;
+			throwIfBrowserLaunchCancelled(generation, signal, owner);
+			setManagedBrowserPort(owner, launchedBrowser.port);
 		}
-		await waitForDevToolsEndpoint(waitMs, launchedBrowser, generation, signal);
-		throwIfBrowserLaunchCancelled(generation, signal);
+		await waitForDevToolsEndpoint(waitMs, launchedBrowser, generation, signal, owner);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		launchedBrowser.ready = true;
 	} catch (error) {
-		if (managedBrowser) await shutdownManagedBrowser(managedBrowser, { awaitLaunch: false });
+		if (managedBrowser) await shutdownManagedBrowser(managedBrowser, { awaitLaunch: false, owner });
 		else {
 			await browserManagerOperations
 				.rm(userDataDir, { recursive: true, force: true })
@@ -362,6 +510,7 @@ async function readManagedBrowserPort(
 	waitMs: number,
 	generation: number,
 	signal: AbortSignal,
+	owner?: object,
 ) {
 	const activePortFile = join(userDataDir, DEVTOOLS_ACTIVE_PORT_FILE);
 	const deadline = Date.now() + waitMs;
@@ -373,7 +522,7 @@ async function readManagedBrowserPort(
 				if (isNodeError(error) && error.code === "ENOENT") return undefined;
 				throw error;
 			});
-		throwIfBrowserLaunchCancelled(generation, signal);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		const portText = text?.split(/\r?\n/, 1)[0]?.trim();
 		const port = Number(portText);
 		if (Number.isInteger(port) && port > 0) return port;
@@ -397,24 +546,25 @@ async function waitForDevToolsEndpoint(
 	managedBrowser: ManagedBrowser,
 	generation: number,
 	signal: AbortSignal,
+	owner?: object,
 ) {
 	const deadline = Date.now() + waitMs;
 	while (true) {
 		throwIfManagedBrowserExited(managedBrowser);
 		try {
-			await fetchDevToolsJson<unknown>("/json/version", { signal });
-			throwIfBrowserLaunchCancelled(generation, signal);
+			await fetchDevToolsJson<unknown>("/json/version", { signal }, owner);
+			throwIfBrowserLaunchCancelled(generation, signal, owner);
 			return;
 		} catch (error) {
 			if (!isRetryableEndpointError(error)) throw error;
 		}
 
-		throwIfBrowserLaunchCancelled(generation, signal);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		const remainingMs = deadline - Date.now();
 		if (remainingMs <= 0) {
 			throw new DevToolsEndpointError(
 				[
-					`Timed out waiting for auto-launched browser at ${devToolsEndpoint()}.`,
+					`Timed out waiting for auto-launched browser at ${devToolsEndpoint(owner)}.`,
 					launchHint(),
 				].join("\n"),
 			);
@@ -428,36 +578,52 @@ function throwIfManagedBrowserExited(managedBrowser: ManagedBrowser) {
 	throw new DevToolsEndpointError("Auto-launched browser exited before DevTools became available.");
 }
 
-function throwIfBrowserLaunchCancelled(generation: number, signal: AbortSignal) {
-	if (!state.shuttingDown && generation === state.sessionGeneration && !signal.aborted) {
-		return;
-	}
+function throwIfBrowserLaunchCancelled(generation: number, signal: AbortSignal, owner?: object) {
+	const currentGeneration = owner ? managedBrowserScope(owner).generation : state.sessionGeneration;
+	const shuttingDown = owner ? signal.aborted : state.shuttingDown;
+	if (!shuttingDown && generation === currentGeneration && !signal.aborted) return;
 	throw new DevToolsEndpointError(
-		generation === state.sessionGeneration
+		generation === currentGeneration
 			? "Chrome DevTools browser launch cancelled during shutdown."
 			: "Chrome DevTools browser launch cancelled because the session was replaced.",
 	);
 }
 
 export async function shutdownManagedBrowser(
-	managedBrowser = state.managedBrowser,
-	options: { awaitLaunch?: boolean; cancelLaunch?: boolean } = {},
+	managedBrowser?: ManagedBrowser,
+	options: { awaitLaunch?: boolean; cancelLaunch?: boolean; owner?: object } = {},
 ) {
-	if (options.cancelLaunch) state.shuttingDown = true;
+	const owner = options.owner ?? managedBrowser?.sessionOwner;
+	if (options.cancelLaunch) {
+		if (owner) {
+			const scope = managedBrowserScope(owner);
+			scope.controller.abort(
+				new DOMException("Chrome DevTools browser launch cancelled during shutdown", "AbortError"),
+			);
+			scope.generation += 1;
+		} else {
+			state.shuttingDown = true;
+		}
+	}
+	managedBrowser ??= managedBrowserForOwner(owner);
 	if (options.awaitLaunch !== false) {
-		await state.launchPromise?.catch(() => undefined);
-		managedBrowser = managedBrowser ?? state.managedBrowser;
+		await launchPromiseForOwner(owner)?.catch(() => undefined);
+		managedBrowser ??= managedBrowserForOwner(owner);
 	}
 	if (!managedBrowser) return;
 	if (managedBrowser.cleanupPromise) return managedBrowser.cleanupPromise;
 
-	const cleanup = cleanupManagedBrowser(managedBrowser);
+	const cleanup = cleanupManagedBrowser(managedBrowser, owner);
 	managedBrowser.cleanupPromise = cleanup;
 	return cleanup;
 }
 
-async function cleanupManagedBrowser(managedBrowser: ManagedBrowser) {
-	if (state.managedBrowser === managedBrowser) state.managedBrowser = undefined;
+async function cleanupManagedBrowser(managedBrowser: ManagedBrowser, owner?: object) {
+	if (managedBrowserForOwner(owner) === managedBrowser) {
+		if (owner) invalidateWebMcpOperations(owner, "Chrome DevTools managed browser closed");
+		if (state.managedBrowser === managedBrowser) state.managedBrowser = undefined;
+		else setManagedBrowser(owner, undefined);
+	}
 	if (!managedBrowser.exited) {
 		killManagedBrowserProcess(managedBrowser);
 		await waitForManagedBrowserExit(managedBrowser, BROWSER_SHUTDOWN_WAIT_MS).catch(async () => {
@@ -470,8 +636,8 @@ async function cleanupManagedBrowser(managedBrowser: ManagedBrowser) {
 	await browserManagerOperations
 		.rm(managedBrowser.userDataDir, { recursive: true, force: true })
 		.catch(() => undefined);
-	if (!state.portConfigured && managedBrowser.port === state.port) {
-		state.port = state.configuredPort;
+	if (!state.portConfigured && managedBrowser.port === managedBrowserPort(owner)) {
+		setManagedBrowserPort(owner, state.configuredPort);
 	}
 }
 
@@ -505,8 +671,8 @@ function waitForManagedBrowserExit(managedBrowser: ManagedBrowser, waitMs: numbe
 	});
 }
 
-export async function fetchDevToolsJson<T>(path: string, init?: RequestInit) {
-	const url = `${devToolsEndpoint()}${path}`;
+export async function fetchDevToolsJson<T>(path: string, init?: RequestInit, owner?: object) {
+	const url = `${devToolsEndpoint(owner)}${path}`;
 	let response: Response;
 	try {
 		const timeoutSignal = AbortSignal.timeout(DEFAULT_HTTP_TIMEOUT_MS);
@@ -515,7 +681,7 @@ export async function fetchDevToolsJson<T>(path: string, init?: RequestInit) {
 			signal: init?.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal,
 		});
 	} catch (error) {
-		throw new DevToolsEndpointError(endpointConnectionErrorMessage(error), {
+		throw new DevToolsEndpointError(endpointConnectionErrorMessage(error, owner), {
 			launchable: true,
 			retryable: true,
 		});
@@ -545,9 +711,14 @@ export async function fetchDevToolsJson<T>(path: string, init?: RequestInit) {
 	}
 }
 
-export async function withEndpointRetry<T>(operation: () => Promise<T>, waitMs: number) {
+export async function withEndpointRetry<T>(
+	operation: () => Promise<T>,
+	waitMs: number,
+	signal?: AbortSignal,
+) {
 	const deadline = Date.now() + waitMs;
 	while (true) {
+		signal?.throwIfAborted();
 		try {
 			return await operation();
 		} catch (error) {
@@ -556,7 +727,10 @@ export async function withEndpointRetry<T>(operation: () => Promise<T>, waitMs:
 			const remainingMs = deadline - Date.now();
 			if (remainingMs <= 0) throw error;
 
-			await browserManagerOperations.sleep(Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs));
+			await browserManagerOperations.sleep(
+				Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs),
+				signal,
+			);
 		}
 	}
 }
@@ -586,10 +760,10 @@ function extensionsConfigured() {
 	return state.extensionPaths.length > 0;
 }
 
-function endpointConnectionErrorMessage(error: unknown) {
+function endpointConnectionErrorMessage(error: unknown, owner?: object) {
 	const reason = isTimeoutError(error) ? "request timed out" : "connection failed";
 	return [
-		`Cannot connect to Chrome DevTools endpoint at ${devToolsEndpoint()} (${reason}).`,
+		`Cannot connect to Chrome DevTools endpoint at ${devToolsEndpoint(owner)} (${reason}).`,
 		launchHint(),
 		endpointConfigHint(),
 	].join("\n");
@@ -599,8 +773,8 @@ function isTimeoutError(error: unknown) {
 	return error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name);
 }
 
-export function devToolsEndpoint() {
-	return `http://${formatHostForUrl(state.host)}:${state.port}`;
+export function devToolsEndpoint(owner?: object) {
+	return `http://${formatHostForUrl(state.host)}:${managedBrowserPort(owner)}`;
 }
 
 export function formatHostForUrl(host: string) {
@@ -614,19 +788,20 @@ export function endpointSourceLabel() {
 
 export type BrowserLifecycleState = "starting" | "running" | "exited" | "failed" | "unobserved";
 
-export function browserLifecycleState(): BrowserLifecycleState {
-	if (state.launchPromise) return "starting";
-	if (state.managedBrowser?.exited) return "exited";
-	if (state.managedBrowser?.ready) return "running";
-	if (state.lastLaunchAttempt?.lastError) return "failed";
+export function browserLifecycleState(owner?: object): BrowserLifecycleState {
+	if (launchPromiseForOwner(owner)) return "starting";
+	if (managedBrowserForOwner(owner)?.exited) return "exited";
+	if (managedBrowserForOwner(owner)?.ready) return "running";
+	if (lastLaunchAttempt(owner)?.lastError) return "failed";
 	return "unobserved";
 }
 
-export function launchModeLabel() {
+export function launchModeLabel(owner?: object) {
+	const managedBrowser = managedBrowserForOwner(owner);
 	if (extensionsConfigured()) {
 		if (!isLocalDevToolsHost(state.host)) return "invalid; extensions require a local endpoint";
 		if (!state.autoLaunchEnabled) return "invalid; extensions require auto-launch";
-		if (state.managedBrowser && !state.managedBrowser.exited) {
+		if (managedBrowser && !managedBrowser.exited) {
 			return state.portConfigured
 				? "extension-owned browser on explicit port"
 				: "extension-owned browser on dynamic port";
@@ -637,7 +812,7 @@ export function launchModeLabel() {
 	}
 	if (!isLocalDevToolsHost(state.host)) return "manual remote endpoint";
 	if (!state.autoLaunchEnabled) return "manual; auto-launch disabled";
-	if (state.managedBrowser && !state.managedBrowser.exited) {
+	if (managedBrowser && !managedBrowser.exited) {
 		return state.portConfigured
 			? "auto-launched on explicit port"
 			: "auto-launched on dynamic port";
@@ -647,21 +822,18 @@ export function launchModeLabel() {
 		: "attach first; auto-launch dynamic port";
 }
 
-export function launchAttemptLines() {
-	if (!state.lastLaunchAttempt) return [];
+export function launchAttemptLines(owner?: object) {
+	const attempt = lastLaunchAttempt(owner);
+	if (!attempt) return [];
 
-	const lines = [`Last launch attempt: ${state.lastLaunchAttempt.mode}`];
-	if (state.lastLaunchAttempt.selectedCandidate) {
-		lines.push(`Launched browser: ${state.lastLaunchAttempt.selectedCandidate}`);
+	const lines = [`Last launch attempt: ${attempt.mode}`];
+	if (attempt.selectedCandidate) {
+		lines.push(`Launched browser: ${attempt.selectedCandidate}`);
 	} else {
-		lines.push(`Tried browser candidates: ${state.lastLaunchAttempt.candidateLabels.join(", ")}`);
-	}
-	if (state.lastLaunchAttempt.userDataDir) {
-		lines.push(`Managed browser profile: ${state.lastLaunchAttempt.userDataDir}`);
-	}
-	if (state.lastLaunchAttempt.lastError) {
-		lines.push(`Last launch error: ${state.lastLaunchAttempt.lastError}`);
+		lines.push(`Tried browser candidates: ${attempt.candidateLabels.join(", ")}`);
 	}
+	if (attempt.userDataDir) lines.push(`Managed browser profile: ${attempt.userDataDir}`);
+	if (attempt.lastError) lines.push(`Last launch error: ${attempt.lastError}`);
 	return lines;
 }
 
@@ -828,11 +1000,12 @@ async function resolveBrowserCandidates(
 	definitions: BrowserCandidateDefinition[],
 	generation: number,
 	signal: AbortSignal,
+	owner?: object,
 ) {
 	const candidates: BrowserCandidate[] = [];
 	for (const definition of definitions) {
 		const resolvedExecutable = await resolveBrowserExecutable(definition.executable);
-		throwIfBrowserLaunchCancelled(generation, signal);
+		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		if (!resolvedExecutable) continue;
 		candidates.push({ ...definition, resolvedExecutable });
 	}