@oh-my-pi/pi-coding-agent 17.3.3 → 17.3.4

package/dist/types/markit/converters/pdf/index.d.ts

@@ -1,6 +1,7 @@
 import type { ConversionResult, Converter, StreamInfo } from "../../types.js";
+/** Converts PDF buffers to Markdown through the native `pdf-inspector` bridge. */
 export declare class PdfConverter implements Converter {
     name: string;
     accepts(streamInfo: StreamInfo): boolean;
-    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+    convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult>;
 }

package/dist/types/tools/read-pdf.d.ts

@@ -0,0 +1,15 @@
+import type { ToolSession } from "../sdk.js";
+import type { ScreenshotResult } from "./browser/tab-protocol.js";
+/** A legacy PDF image-member path interpreted as a page screenshot request. */
+export interface PdfImageReadTarget {
+    /** PDF path before the member delimiter. */
+    pdfPath: string;
+    /** Original member text after the delimiter. */
+    member: string;
+    /** One-indexed page inferred from names such as `p2-img0.png`; defaults to page 1. */
+    page: number;
+}
+/** Parse a former PDF image-member path as a Chromium page screenshot request. */
+export declare function splitPdfImageReadPath(readPath: string): PdfImageReadTarget | null;
+/** Render one PDF page through the browser tool's shared headless Chromium. */
+export declare function renderPdfPageScreenshot(session: ToolSession, absolutePdfPath: string, page: number, signal?: AbortSignal): Promise<ScreenshotResult>;

package/dist/types/utils/external-editor.d.ts

@@ -18,6 +18,13 @@ export interface OpenInEditorOptions {
     /** Keep the file's trailing newline instead of trimming it from the returned text. */
     trimTrailingNewline?: boolean;
 }
+/** Subprocess argv and Windows quoting mode used to launch an external editor. */
+export interface EditorSpawnCommand {
+    cmd: string[];
+    windowsVerbatimArguments: boolean;
+}
+/** Resolves shell argv without letting the host runtime re-quote the editor command. */
+export declare function resolveEditorSpawnCommand(editorCmd: string, tmpFile: string, platform?: NodeJS.Platform): EditorSpawnCommand;
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.

package/dist/types/utils/markit.d.ts

@@ -18,10 +18,9 @@ export interface MarkitConversionResult {
 }
 export interface MarkitFileConversionOptions {
     /**
-     * Directory the PDF converter writes extracted images/diagrams into. When
-     * set, each embedded image is rendered to `<id>.png` and referenced by path
-     * in the markdown; when unset, markit emits an `<!-- image: <id> ... -->`
-     * placeholder comment instead.
+     * Directory converters may use for extracted image or diagram files. Since
+     * those files are conversion side effects, conversions using this option
+     * bypass the markdown cache.
      */
     imageDir?: string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.3.3",
+	"version": "17.3.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -41,8 +41,6 @@
 		"format-prompts": "bun scripts/format-prompts.ts",
 		"gen:tool-views": "bun --cwd=../collab-web run gen:tool-views",
 		"gen:bundle": "bun scripts/bundle-dist.ts",
-		"gen:mupdf": "bun scripts/embed-mupdf-wasm.ts --generate",
-		"gen:mupdf:reset": "bun scripts/embed-mupdf-wasm.ts --reset",
 		"gen:native": "bun --cwd=../natives run gen:native",
 		"gen:native:reset": "bun --cwd=../natives run gen:native:reset",
 		"prepack": "bun run gen:tool-views && bun run gen:bundle",
@@ -50,18 +48,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.3.3",
-		"@oh-my-pi/omp-stats": "17.3.3",
-		"@oh-my-pi/omptype": "17.3.3",
-		"@oh-my-pi/pi-agent-core": "17.3.3",
-		"@oh-my-pi/pi-ai": "17.3.3",
-		"@oh-my-pi/pi-catalog": "17.3.3",
-		"@oh-my-pi/pi-mnemopi": "17.3.3",
-		"@oh-my-pi/pi-natives": "17.3.3",
-		"@oh-my-pi/pi-tui": "17.3.3",
-		"@oh-my-pi/pi-utils": "17.3.3",
-		"@oh-my-pi/pi-wire": "17.3.3",
-		"@oh-my-pi/snapcompact": "17.3.3",
+		"@oh-my-pi/hashline": "17.3.4",
+		"@oh-my-pi/omp-stats": "17.3.4",
+		"@oh-my-pi/omptype": "17.3.4",
+		"@oh-my-pi/pi-agent-core": "17.3.4",
+		"@oh-my-pi/pi-ai": "17.3.4",
+		"@oh-my-pi/pi-catalog": "17.3.4",
+		"@oh-my-pi/pi-mnemopi": "17.3.4",
+		"@oh-my-pi/pi-natives": "17.3.4",
+		"@oh-my-pi/pi-tui": "17.3.4",
+		"@oh-my-pi/pi-utils": "17.3.4",
+		"@oh-my-pi/pi-wire": "17.3.4",
+		"@oh-my-pi/snapcompact": "17.3.4",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
@@ -73,7 +71,6 @@
 		"@opentelemetry/sdk-metrics": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@opentelemetry/sdk-trace-node": "^2.9.0",
-		"mupdf": "^1.28.0",
 		"puppeteer-core": "25.3.0"
 	},
 	"optionalDependencies": {

package/scripts/build-binary.ts

@@ -88,7 +88,6 @@ async function main(): Promise<void> {
 			["bun", "--cwd=../natives", "run", "gen:native"],
 			crossBuild ? { ...Bun.env, TARGET_PLATFORM: crossBuild.platform, TARGET_ARCH: crossBuild.arch } : Bun.env,
 		);
-		await runCommand(["bun", "run", "gen:mupdf"]);
 		try {
 			await compileCodingAgent({
 				repoRoot,
@@ -104,7 +103,6 @@ async function main(): Promise<void> {
 				await runCommand(["codesign", "--force", "--sign", "-", outputPath]);
 			}
 		} finally {
-			await runCommand(["bun", "run", "gen:mupdf:reset"]);
 			await runCommand(["bun", "--cwd=../natives", "run", "gen:native:reset"]);
 		}
 	} finally {

package/scripts/bundle-dist.ts

@@ -15,7 +15,6 @@ const legacyHtmlExportAssetPattern = /^(?:template-[^.]+\.(?:css|html|js)|tool-v
 // `omp-legacy-pi-modules` exists only in compiled binaries via the build plugin;
 // the npm bundle never executes that `isCompiledBinary()` branch.
 const ALWAYS_EXTERNAL = [
-	"mupdf",
 	"@oh-my-pi/pi-natives",
 	"@huggingface/transformers",
 	"fastembed",

package/src/cli/read-cli.ts

@@ -10,6 +10,7 @@ import chalk from "@oh-my-pi/pi-utils/chalk";
 import { Settings } from "../config/settings";
 import { extractUriScheme } from "../internal-urls/parse";
 import { InternalUrlRouter } from "../internal-urls/router";
+import { closeDaemonClients } from "../launch/client";
 import { discoverAndLoadMCPTools } from "../mcp/loader";
 import { MCPManager } from "../mcp/manager";
 import { discoverAuthStorage } from "../session/auth-broker-config";
@@ -93,6 +94,7 @@ export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
 			if (MCPManager.instance() === mcpManager) MCPManager.setInstance(undefined);
 		}
 		authStorage?.close();
+		await closeDaemonClients();
 	}
 
 	if (failed) process.exit(1);

package/src/markit/NOTICE

@@ -1,15 +1,15 @@
-This directory contains an in-house document-to-markdown engine adapted from
+Portions of this in-house document-to-markdown engine are adapted from
 markit-ai (https://github.com/Michaelliv/markit), used under the MIT License.
+This attribution covers the shared registry/types and the DOCX, PPTX, XLSX,
+and EPUB converters. The PDF converter is implemented separately and is not
+derived from markit-ai.
 
   Copyright (c) 2026 Michael Liv
 
-Only the converters for the document formats omp supports are ported (pdf,
-docx, pptx, xlsx, epub); the CLI, plugin/provider, and unused converters
-(html, image, audio, plain-text, rss, github, wikipedia, csv, json, yaml,
-ipynb, iwork, zip, xml) were dropped. Legacy binary `.doc`/`.ppt`/`.xls` and
-`.rtf` are routed by the read/fetch tools but have no converter — they surface
-a conversion error, exactly as upstream markit did. Logic is ported faithfully
-so conversion output matches the upstream package.
+The CLI, plugin/provider, and unused converters (html, image, audio,
+plain-text, rss, github, wikipedia, csv, json, yaml, ipynb, iwork, zip, xml)
+were dropped. Legacy binary `.doc`/`.ppt`/`.xls` and `.rtf` have no converter
+and surface a conversion error.
 
 MIT License
 

package/src/markit/converters/pdf/index.ts

@@ -1,48 +1,10 @@
-// Adapted from markit-ai (MIT). See ../../NOTICE.
-
-/**
- * PDF to Markdown converter.
- *
- * Uses mupdf (native WASM) for fast PDF parsing and a custom pipeline for
- * table detection via vector line extraction + raycasting.
- *
- * Pipeline:
- *   1. Extract text boxes + vector segments + image regions per page (mupdf)
- *   2. Detect column layout (single vs multi-column)
- *   3. Per column: detect table grids from segments (grid detection + raycasting)
- *   4. Render diagrams as PNG files (if output directory provided)
- *   5. Render tables as markdown tables, free text as paragraphs/headings
- */
-import * as path from "node:path";
+import { pdfToMarkdown } from "@oh-my-pi/pi-natives";
 import type { ConversionResult, Converter, StreamInfo } from "../../types";
-import { detectColumns } from "./columns";
-import { extractPages, renderImageRegion } from "./extract";
-import { resolveTableGrids } from "./grid";
-import { stripHeadersFooters } from "./headers";
-import { renderPageContent } from "./render";
-import type { Segment, TextBox } from "./types";
 
 const EXTENSIONS = [".pdf"];
 const MIMETYPES = ["application/pdf", "application/x-pdf"];
 
-type ImageBlock = { topY: number; markdown: string };
-
-/**
- * Process a set of text boxes (one column or full page): run table detection,
- * separate free text, and render to markdown.
- */
-function processColumn(
-	pageNumber: number,
-	textBoxes: TextBox[],
-	segments: Segment[],
-	imageBlocks: ImageBlock[],
-): string {
-	const { grids, consumedIds } = resolveTableGrids(pageNumber, textBoxes, segments);
-	const consumedSet = new Set(consumedIds);
-	const freeTextBoxes = textBoxes.filter(tb => !consumedSet.has(tb.id));
-	return renderPageContent(freeTextBoxes, grids, imageBlocks, textBoxes);
-}
-
+/** Converts PDF buffers to Markdown through the native `pdf-inspector` bridge. */
 export class PdfConverter implements Converter {
 	name = "pdf";
 
@@ -56,91 +18,17 @@ export class PdfConverter implements Converter {
 		return false;
 	}
 
-	async convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult> {
-		const pdfBytes = new Uint8Array(input);
-		const pages = await extractPages(pdfBytes);
-		// Remove running headers/footers before processing.
-		stripHeadersFooters(pages);
-		const imageDir = streamInfo.imageDir;
-
-		const pageMarkdowns: string[] = [];
-		for (const page of pages) {
-			// Build image blocks for this page.
-			const imageBlocks: ImageBlock[] = [];
-			if (imageDir && page.images.length > 0) {
-				for (const img of page.images) {
-					const filename = `${img.id}.png`;
-					const filepath = path.join(imageDir, filename);
-					try {
-						const png = await renderImageRegion(pdfBytes, img);
-						await Bun.write(filepath, png);
-						imageBlocks.push({ topY: img.topY, markdown: `![${img.id}](${filepath})` });
-					} catch {
-						// Image rendering failed — skip.
-					}
-				}
-			} else if (page.images.length > 0) {
-				for (const img of page.images) {
-					imageBlocks.push({
-						topY: img.topY,
-						markdown: `<!-- image: ${img.id} (page ${img.pageNumber}, ${img.bbox.w}x${img.bbox.h}pt) -->`,
-					});
-				}
-			}
-
-			// Detect column layout.
-			// If the page has vertical segments (tables), suppress column detection
-			// when one detected column is very narrow — that's a table's first column,
-			// not a page layout column.
-			const layout = detectColumns(page.textBoxes);
-			if (layout.columnCount > 1 && page.segments.some(s => Math.abs(s.x1 - s.x2) <= 0.8)) {
-				const pageXMin = Math.min(...page.textBoxes.map(tb => tb.bounds.left));
-				const pageXMax = Math.max(...page.textBoxes.map(tb => tb.bounds.right));
-				const pageWidth = pageXMax - pageXMin;
-				const minColFraction = 0.3;
-				const tooNarrow = layout.columns.some(col => {
-					const colXMin = Math.min(...col.map(tb => tb.bounds.left));
-					const colXMax = Math.max(...col.map(tb => tb.bounds.right));
-					return (colXMax - colXMin) / pageWidth < minColFraction;
-				});
-				if (tooNarrow) {
-					layout.columnCount = 1;
-					layout.columns = [page.textBoxes];
-					layout.boundaries = [];
-				}
-			}
-
-			if (layout.columnCount === 1) {
-				// Single column — process normally.
-				const md = processColumn(page.pageNumber, page.textBoxes, page.segments, imageBlocks);
-				if (md.length > 0) pageMarkdowns.push(md);
-			} else {
-				// Multi-column — process each column independently, then join.
-				const columnMarkdowns: string[] = [];
-				for (const colBoxes of layout.columns) {
-					// Filter segments to those within this column's X range.
-					const colXMin = Math.min(...colBoxes.map(tb => tb.bounds.left));
-					const colXMax = Math.max(...colBoxes.map(tb => tb.bounds.right));
-					const margin = 10;
-					const colSegments = page.segments.filter(seg => {
-						const segXMin = Math.min(seg.x1, seg.x2);
-						const segXMax = Math.max(seg.x1, seg.x2);
-						return segXMax >= colXMin - margin && segXMin <= colXMax + margin;
-					});
-					// Images go with the first column only (no X info to split by).
-					const md = processColumn(
-						page.pageNumber,
-						colBoxes,
-						colSegments,
-						columnMarkdowns.length === 0 ? imageBlocks : [],
-					);
-					if (md.length > 0) columnMarkdowns.push(md);
-				}
-				const joined = columnMarkdowns.join("\n\n");
-				if (joined.length > 0) pageMarkdowns.push(joined);
-			}
-		}
-
-		return { markdown: pageMarkdowns.join("\n\n") };
+	async convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult> {
+		const result = await pdfToMarkdown(input);
+		const notice =
+			result.pagesNeedingOcr.length > 0
+				? `Text extraction is incomplete for PDF pages ${result.pagesNeedingOcr.join(", ")}. Use the browser tool to render those pages or OCR them.`
+				: undefined;
+
+		const conversion: ConversionResult = {
+			markdown: notice ? [result.markdown, notice].filter(Boolean).join("\n\n") : result.markdown,
+		};
+		if (result.title !== undefined) conversion.title = result.title;
+		return conversion;
 	}
 }

package/src/mcp/client.ts

@@ -92,7 +92,7 @@ async function initializeConnection(
 	transport: MCPTransport,
 	options?: {
 		signal?: AbortSignal;
-		/** Called after the initialize response (which sets the session ID) but before notifications/initialized. */
+		/** Called after notifications/initialized succeeds. */
 		onInitialized?: () => void | Promise<void>;
 	},
 ): Promise<MCPInitializeResult> {
@@ -119,14 +119,13 @@ async function initializeConnection(
 	// initialize; transports that don't need it ignore this.
 	transport.setProtocolVersion?.(result.protocolVersion);
 
-	// Hook point: the transport now has the session ID from the initialize response.
-	// For HTTP, this is the moment to open the SSE stream so server-to-client requests
-	// triggered by notifications/initialized (e.g. roots/list) can be delivered.
-	await options?.onInitialized?.();
-
-	// Send initialized notification
+	// Send initialized before opening the optional GET SSE stream. Servers may
+	// reject or terminate sessions that receive session traffic before this
+	// notification; POST response streams already carry messages during setup.
 	await transport.notify("notifications/initialized");
 
+	await options?.onInitialized?.();
+
 	return result;
 }
 
@@ -162,8 +161,8 @@ export async function connectToServer(
 			const initResult = await initializeConnection(transport, {
 				signal: options?.signal,
 				async onInitialized() {
-					// Open the SSE stream before sending initialized, so server-to-client
-					// requests triggered by on_initialized (e.g. roots/list) are delivered.
+					// Open the optional GET SSE stream only after the initialized
+					// notification makes the session ready for further traffic.
 					if ("startSSEListener" in transport! && typeof transport!.startSSEListener === "function") {
 						await (transport as { startSSEListener(): Promise<void> }).startSSEListener();
 					}

package/src/modes/rpc/rpc-client.ts

@@ -353,6 +353,13 @@ export class RpcClient {
 			// failures are reaped by the readyPromise catch below; established
 			// workers are reaped here so pending requests cannot hang indefinitely.
 			if (!readySettled) {
+				// Stdout can close before the exit reaper finishes draining stderr.
+				// child.exited settles only after the stderr tail is complete (for
+				// nonzero exits), so give it a bounded head start: the exit watcher
+				// below was registered first and rejects with the real stderr text
+				// instead of an empty "Stderr:" (flaked under full-suite load).
+				await Promise.race([child.exited.catch(() => {}), Bun.sleep(250)]);
+				if (readySettled) return;
 				readySettled = true;
 				readyReject(new Error(`Agent output stream ended before ready. Stderr: ${child.peekStderr()}`));
 				return;

package/src/modes/utils/hotkeys-markdown.ts

@@ -39,7 +39,7 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		"| `Tab` | Path completion / accept autocomplete |",
 		`| \`${appKey(bindings, "app.interrupt")}\` | Cancel autocomplete / interrupt active work |`,
 		`| \`${appKey(bindings, "app.clear")}\` | Clear editor (first) / exit (second) |`,
-		`| \`${appKey(bindings, "app.exit")}\` | Exit (when editor is empty) |`,
+		`| \`${appKey(bindings, "app.exit")}\` | Exit (saves current prompt as draft) |`,
 		`| \`${appKey(bindings, "app.suspend")}\` | Suspend to background |`,
 		`| \`${appKey(bindings, "app.display.reset")}\` | Reset terminal display |`,
 		`| \`${appKey(bindings, "app.thinking.cycle")}\` | Cycle thinking level |`,

package/src/tools/read-pdf.ts

@@ -0,0 +1,135 @@
+import { pathToFileURL } from "node:url";
+import { untilAborted } from "@oh-my-pi/pi-utils";
+import type { ToolSession } from "../sdk";
+import type { BrowserHandle } from "./browser/registry";
+import type { ScreenshotResult } from "./browser/tab-protocol";
+import { ToolAbortError, ToolError } from "./tool-errors";
+
+const PDF_IMAGE_MEMBER_RE = /^(.*\.pdf):(.*)$/i;
+const PDF_PAGE_MEMBER_RE = /^(?:p|page[-_]?)(\d+)(?:[-_].*)?\.png$/i;
+const PDF_RENDER_TIMEOUT_MS = 30_000;
+
+// Chromium's PDF plugin paints in an out-of-process frame after navigation has
+// completed. Wait for document dimensions, then cross compositor boundaries
+// before capturing; otherwise the screenshot can contain only the viewer shell.
+const PDF_SCREENSHOT_CODE = `
+let viewerFrame;
+await wait(async () => {
+	for (const frame of page.frames()) {
+		try {
+			const loaded = await frame.evaluate(() => {
+				const viewer = document.querySelector("pdf-viewer");
+				const toolbar = viewer?.shadowRoot?.querySelector("viewer-toolbar");
+				const pageLength = toolbar
+					?.shadowRoot?.querySelector("viewer-page-selector")
+					?.shadowRoot?.querySelector("#pagelength")
+					?.textContent;
+				if (Number(pageLength) > 0 && !toolbar?.hasAttribute("loading_")) return true;
+
+				const plugin = document.querySelector('embed[type="application/x-google-chrome-pdf"]');
+				const sizer = document.querySelector("#sizer");
+				return plugin !== null && sizer !== null && sizer.clientWidth > 0 && sizer.clientHeight > 0;
+			});
+			if (loaded) {
+				viewerFrame = frame;
+				return true;
+			}
+		} catch {}
+	}
+	return false;
+});
+await page.screenshot({ type: "png" });
+await viewerFrame.evaluate(() => {
+	const { promise, resolve } = Promise.withResolvers();
+	requestAnimationFrame(() =>
+		requestAnimationFrame(() =>
+			requestAnimationFrame(() => requestAnimationFrame(resolve)),
+		),
+	);
+	return promise;
+});
+return await tab.screenshot({ fullPage: true, silent: true });
+`;
+
+/** A legacy PDF image-member path interpreted as a page screenshot request. */
+export interface PdfImageReadTarget {
+	/** PDF path before the member delimiter. */
+	pdfPath: string;
+	/** Original member text after the delimiter. */
+	member: string;
+	/** One-indexed page inferred from names such as `p2-img0.png`; defaults to page 1. */
+	page: number;
+}
+
+/** Parse a former PDF image-member path as a Chromium page screenshot request. */
+export function splitPdfImageReadPath(readPath: string): PdfImageReadTarget | null {
+	const match = PDF_IMAGE_MEMBER_RE.exec(readPath);
+	const pdfPath = match?.[1];
+	const member = match?.[2];
+	if (!pdfPath || member === undefined) return null;
+	const pageText = PDF_PAGE_MEMBER_RE.exec(member)?.[1];
+	const parsedPage = pageText === undefined ? 1 : Number(pageText);
+	const page = Number.isSafeInteger(parsedPage) && parsedPage > 0 ? parsedPage : 1;
+	return { pdfPath, member, page };
+}
+
+/** Render one PDF page through the browser tool's shared headless Chromium. */
+export async function renderPdfPageScreenshot(
+	session: ToolSession,
+	absolutePdfPath: string,
+	page: number,
+	signal?: AbortSignal,
+): Promise<ScreenshotResult> {
+	const [{ acquireBrowser, holdBrowser, releaseBrowser }, { acquireTab, releaseTab, runInTab }] = await Promise.all([
+		import("./browser/registry"),
+		import("./browser/tab-supervisor"),
+	]);
+	const timeoutSignal = AbortSignal.timeout(PDF_RENDER_TIMEOUT_MS);
+	const renderSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+	const tabName = `read-pdf-${Bun.randomUUIDv7()}`;
+	const url = pathToFileURL(absolutePdfPath);
+	url.hash = `page=${page}&toolbar=0&navpanes=0&view=Fit`;
+
+	let browserLease = false;
+	let tabOpened = false;
+	let browser: BrowserHandle | undefined;
+	try {
+		const acquiredBrowser = await untilAborted(renderSignal, () =>
+			acquireBrowser({ kind: "headless", headless: true }, { cwd: session.cwd, signal: renderSignal }),
+		);
+		browser = acquiredBrowser;
+		holdBrowser(acquiredBrowser);
+		browserLease = true;
+		await untilAborted(renderSignal, () =>
+			acquireTab(tabName, acquiredBrowser, {
+				url: url.href,
+				waitUntil: "load",
+				timeoutMs: PDF_RENDER_TIMEOUT_MS,
+				signal: renderSignal,
+				ownerSessionId: session.getSessionId?.() ?? undefined,
+			}),
+		);
+		tabOpened = true;
+		await releaseBrowser(acquiredBrowser, { kill: false });
+		browserLease = false;
+
+		const result = await runInTab(tabName, {
+			code: PDF_SCREENSHOT_CODE,
+			timeoutMs: PDF_RENDER_TIMEOUT_MS,
+			signal: renderSignal,
+			session,
+		});
+		const screenshot = result.screenshots.at(-1);
+		if (!screenshot) throw new ToolError(`Chromium did not capture PDF page ${page}.`);
+		return screenshot;
+	} catch (error) {
+		if (signal?.aborted) throw new ToolAbortError();
+		if (timeoutSignal.aborted) {
+			throw new ToolError(`Timed out rendering PDF page ${page} in Chromium.`);
+		}
+		throw error;
+	} finally {
+		if (tabOpened) await releaseTab(tabName, { kill: false });
+		if (browserLease && browser) await releaseBrowser(browser, { kill: false });
+	}
+}