vde-open 0.1.2 → 0.1.5

package/README.md

@@ -30,7 +30,7 @@ To install from a clone of this repository (pins Node.js 24.21.0 in `mise.toml`)
 pnpm install --frozen-lockfile
 pnpm build
 pnpm test:pack                              # builds artifacts/vde-open-<version>.tgz and verifies an install in a separate directory
-bun add -g "$PWD/artifacts/vde-open-0.1.2.tgz"   # use an absolute path: bun add -g resolves relative paths from its global install directory, not the current one
+bun add -g "$PWD/artifacts/vde-open-0.1.5.tgz"   # use an absolute path: bun add -g resolves relative paths from its global install directory, not the current one
 ```
 
 ## Developing with a linked CLI
@@ -62,7 +62,7 @@ The same CLI is installed under two names. Both use the same state and daemon.
 
 If you already have a different `vo` (another tool's command, an alias, and so on), installing never overwrites or deletes it.
 
-- If the install target's bin directory (for `npm install -g`, npm's global bin) already has another `vo` file, npm stops with `EEXIST`. Do not use `--force`; it replaces the existing `vo`. Install with Bun instead, or into another prefix (for example `npm install -g --prefix ~/.local/vde-open ./artifacts/vde-open-0.1.2.tgz`) and use `vde-open` from that bin directory.
+- If the install target's bin directory (for `npm install -g`, npm's global bin) already has another `vo` file, npm stops with `EEXIST`. Do not use `--force`; it replaces the existing `vo`. Install with Bun instead, or into another prefix (for example `npm install -g --prefix ~/.local/vde-open ./artifacts/vde-open-0.1.5.tgz`) and use `vde-open` from that bin directory.
 - For a `vo` or alias elsewhere, whichever comes first on `PATH` runs. In that case, use `vde-open`. If you want a short name, define an alias in your shell (for example `alias vdo=vde-open`).
 
 ## Basic usage
@@ -115,6 +115,17 @@ Markdown is rendered with TanStack Markdown 1.0.0. It is not fully compatible wi
 - Code is highlighted only for JS, JSX, TS, TSX, JSON, YAML, HTML, CSS, Bash, and Markdown. Code larger than 256 KiB and other languages are not highlighted.
 - Documents that cannot be parsed within 2 seconds, or that have more than 100,000 elements or more than 64 levels of nesting, are shown as source.
 
+## Exporting Markdown to PDF
+
+"Export PDF" in the header of a Markdown document saves the shown revision as a PDF, without a print dialog.
+
+- The PDF is an A4 document on a white background (the color theme of the management UI is not used). Every page has the document title in the header and the page number ("3 / 12") in the footer, and the headings become the PDF bookmarks.
+- The daemon prints it with the Google Chrome or Microsoft Edge (131 or later) installed on the machine, run headless with a temporary profile that is removed afterwards. Nothing is downloaded. To use another Chromium-based browser, or one in another location, set `VDE_OPEN_BROWSER` to the absolute path of its executable for the daemon (after changing it, run `vo daemon restart`).
+- The rules of the view apply: raw HTML is shown as text, only images registered for the document are included (others show their alternative text), and links to other local documents become plain text.
+- The file name is the document's file name with `.pdf` (`README.md` → `README.pdf`). A document read from stdin uses its title.
+- Fonts are the ones installed on the machine (San Francisco with Hiragino Sans on macOS, Segoe UI with Yu Gothic on Windows, Noto Sans CJK on Linux), so the PDF looks slightly different on each OS.
+- HTML documents cannot be exported. Printing must finish within 60 seconds.
+
 ## Where the state is stored, and stopping
 
 - The state (open documents, revisions, questions and answers) is stored here. Change it with `VDE_OPEN_HOME`.
@@ -143,6 +154,7 @@ The person answers in the answer panel of the management UI. The answers are sub
 | Exit code 8 (cannot connect to or start the daemon) | Check with `vo daemon status`, and look for leftover files with `vo doctor` |
 | Images or CSS are not shown | Open "Differences from the original document" and register them with `--assets-root` or `--asset` |
 | Search does not find a document | Check with `vo list --json` that the document is open and its `searchState` is `ready` |
+| Export PDF says Google Chrome or Microsoft Edge is needed | Install Chrome or Edge 131 or later, or set `VDE_OPEN_BROWSER` to the absolute path of a Chromium-based browser and run `vo daemon restart` |
 
 ## Verified scope
 
@@ -154,6 +166,7 @@ The person answers in the answer panel of the management UI. The answers are sub
 | Browsers (macOS) | Chromium (Playwright's Chrome Headless Shell): the full suite is verified. Firefox 155 and WebKit 26.6 (Playwright 1.63.0): the view isolation, CSP, HTML bridge, and authentication tests (`pnpm test:e2e:cross`) are verified |
 | Browsers (not verified) | Other UI interactions in Firefox and WebKit (search, answer panel, narrow screens, a list of 1,000 documents) are not verified |
 | Markdown syntax | As described in "Markdown display limits" above. Full CommonMark and GFM are not verified |
+| PDF export | macOS (locally): verified with Google Chrome 154 and Microsoft Edge 154. Linux on CI (`ubuntu-latest`): verified with the runner's Google Chrome (e2e). Windows: printing with a real browser is not verified (the pack smoke test checks rendering the print document) |
 
 More details: [docs/performance.md](docs/performance.md) (measurements), [docs/architecture.md](docs/architecture.md) and [docs/security-model.md](docs/security-model.md) (design). Development records (in Japanese): [docs/implementation-status.md](docs/implementation-status.md), [docs/dependency-validation.md](docs/dependency-validation.md), and [docs/adr/](docs/adr/).
 

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { C as decodeStateFile, D as daemonEntryPath, E as resolveStateRoot, O as referencedBlobs, S as renameWithRetry, T as resolveRuntimeLocation, a as DAEMON_LOCK_NAME, b as proofMatches, c as readIpcKey, d as inspectOwner, f as readCurrentLock, g as encodeFrame, h as FrameDecoder, i as requirePrivateDirectoryIfExists, k as version, l as readPointer, m as systemProcessProbe, n as ensurePrivateDirectory, o as POINTER_FILE, p as releaseLock, r as inspectPrivateDirectory, s as START_LOCK_NAME, t as startDaemon, u as acquireLock, v as computeProof, w as currentPathEnvironment, x as removeWithRetry, y as createNonce } from "./main-CqENdUsw.js";
-import { A as successEnvelope, C as VdeError, D as ExitCode, E as isVdeError, O as envelopeSchema, T as isErrorCode, Y as LIMITS, k as errorEnvelope, w as exitCodeForError } from "./search-index-__laOomT.js";
+import { C as decodeStateFile, D as daemonEntryPath, E as resolveStateRoot, O as referencedBlobs, S as renameWithRetry, T as resolveRuntimeLocation, a as DAEMON_LOCK_NAME, b as proofMatches, c as readIpcKey, d as inspectOwner, f as readCurrentLock, g as encodeFrame, h as FrameDecoder, i as requirePrivateDirectoryIfExists, k as version, l as readPointer, m as systemProcessProbe, n as ensurePrivateDirectory, o as POINTER_FILE, p as releaseLock, r as inspectPrivateDirectory, s as START_LOCK_NAME, t as startDaemon, u as acquireLock, v as computeProof, w as currentPathEnvironment, x as removeWithRetry, y as createNonce } from "./main-BZ8Pvrn8.js";
+import { A as successEnvelope, C as VdeError, D as ExitCode, E as isVdeError, O as envelopeSchema, T as isErrorCode, Y as LIMITS, k as errorEnvelope, w as exitCodeForError } from "./search-index-B7DqaWh6.js";
 import fs, { fstatSync } from "node:fs";
 import { lstat, readFile, readdir, stat as stat$1, writeFile } from "node:fs/promises";
 import path, { join, resolve } from "node:path";

package/dist/daemon.js

@@ -1,5 +1,5 @@
-import { k as version, t as startDaemon, w as currentPathEnvironment } from "./main-CqENdUsw.js";
-import { E as isVdeError } from "./search-index-__laOomT.js";
+import { k as version, t as startDaemon, w as currentPathEnvironment } from "./main-BZ8Pvrn8.js";
+import { E as isVdeError } from "./search-index-B7DqaWh6.js";
 //#region src/daemon.ts
 function notifyParent(message) {
 	if (!process.send) return;

package/dist/{main-CqENdUsw.js → main-BZ8Pvrn8.js}

@@ -1,21 +1,23 @@
 import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DC62tzP2.js";
-import { $ as literal, A as successEnvelope, B as readParamsSchema, C as VdeError, D as ExitCode, E as isVdeError, F as htmlModeChangeParamsSchema, G as sha256Schema, H as reorderParamsSchema, I as htmlModeSchema, J as watchRuleSchema, K as sourceKindSchema, L as linkOpenParamsSchema, M as closeParamsSchema, N as documentFormatSchema, P as documentIdSchema, Q as boolean, R as listParamsSchema, S as validateAnswers, U as revisionSchema, V as renderGrantParamsSchema, W as searchParamsSchema, X as _enum, Y as LIMITS, Z as array, _ as feedbackWaitParamsSchema, a as uniqueTokens, at as canonicalJson, b as submissionSchema, c as feedbackAckParamsSchema, d as feedbackDraftParamsSchema, et as number, f as feedbackForgetParamsSchema, g as feedbackSubmitParamsSchema, h as feedbackStatusSchema, i as codePointLength, it as ZodError, j as assetRecordSchema, k as errorEnvelope, l as feedbackCancelParamsSchema, m as feedbackListParamsSchema, n as batchesOf, nt as strictObject, o as answersSchema, p as feedbackIdParamsSchema, q as sourceStateSchema, r as partsOf, rt as string, s as cancellationSchema, tt as record, u as feedbackCreateParamsSchema, v as questionnaireSchema, w as exitCodeForError, x as utf8Length, y as requestIdSchema, z as openParamsSchema } from "./search-index-__laOomT.js";
-import { a as analyzeDocument, c as classifyReference, d as hasHiddenSegment, f as isValidLogicalPath, i as ParseLimitError, l as dirnameOfLogicalPath, n as scanReferences, o as assetTypeOf, p as roleAllowed, r as extractTitle, s as classifyLink, u as encodeLogicalPath } from "./render-BNZz0CjQ.js";
+import { $ as literal, A as successEnvelope, B as readParamsSchema, C as VdeError, D as ExitCode, E as isVdeError, F as htmlModeChangeParamsSchema, G as sha256Schema, H as reorderParamsSchema, I as htmlModeSchema, J as watchRuleSchema, K as sourceKindSchema, L as linkOpenParamsSchema, M as closeParamsSchema, N as documentFormatSchema, P as documentIdSchema, Q as boolean, R as listParamsSchema, S as validateAnswers, U as revisionSchema, V as renderGrantParamsSchema, W as searchParamsSchema, X as _enum, Y as LIMITS, Z as array, _ as feedbackWaitParamsSchema, a as uniqueTokens, at as canonicalJson, b as submissionSchema, c as feedbackAckParamsSchema, d as feedbackDraftParamsSchema, et as number, f as feedbackForgetParamsSchema, g as feedbackSubmitParamsSchema, h as feedbackStatusSchema, i as codePointLength, it as ZodError, j as assetRecordSchema, k as errorEnvelope, l as feedbackCancelParamsSchema, m as feedbackListParamsSchema, n as batchesOf, nt as strictObject, o as answersSchema, p as feedbackIdParamsSchema, q as sourceStateSchema, r as partsOf, rt as string, s as cancellationSchema, tt as record, u as feedbackCreateParamsSchema, v as questionnaireSchema, w as exitCodeForError, x as utf8Length, y as requestIdSchema, z as openParamsSchema } from "./search-index-B7DqaWh6.js";
+import { C as roleAllowed, _ as dirnameOfLogicalPath, a as ParseLimitError, g as classifyReference, h as classifyLink, m as assetTypeOf, o as analyzeDocument, v as encodeLogicalPath, x as isValidLogicalPath, y as hasHiddenSegment } from "./rendering-rules-DiE2jI7I.js";
+import { n as scanReferences, r as extractTitle } from "./render-BJnuEfHt.js";
 import { n as measureHeap, t as collectGarbage } from "./heap-C3qHm7SE.js";
-import { constants, existsSync, stat, unwatchFile, watch, watchFile } from "node:fs";
-import { appendFile, chmod, link, lstat, mkdir, open, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat as stat$1, writeFile } from "node:fs/promises";
+import { accessSync, constants, existsSync, stat, statSync, unwatchFile, watch, watchFile } from "node:fs";
+import { appendFile, chmod, link, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat as stat$1, writeFile } from "node:fs/promises";
 import * as sp from "node:path";
-import { basename, dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
+import { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { EventEmitter } from "node:events";
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import * as nativeFs from "fs";
-import { readdir as readdir$1, readdirSync, realpath as realpath$1, realpathSync, stat as stat$2, statSync } from "fs";
+import { readdir as readdir$1, readdirSync, realpath as realpath$1, realpathSync, stat as stat$2, statSync as statSync$1 } from "fs";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, normalize, posix as posix$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
-import { fileURLToPath as fileURLToPath$1 } from "node:url";
+import { tmpdir, type } from "node:os";
+import { fileURLToPath as fileURLToPath$1, pathToFileURL } from "node:url";
 import { Worker } from "node:worker_threads";
 import { performance } from "node:perf_hooks";
 import { getHeapStatistics } from "node:v8";
@@ -23,7 +25,6 @@ import { STATUS_CODES, ServerResponse, createServer } from "node:http";
 import { Http2ServerRequest, constants as constants$1 } from "node:http2";
 import { Readable } from "node:stream";
 import { createServer as createServer$1 } from "node:net";
-import { type } from "node:os";
 //#region ../../packages/shared/src/bridge.ts
 const BRIDGE_HELLO = "vde-bridge-hello";
 const BRIDGE_PORT = "vde-bridge-port";
@@ -154,7 +155,7 @@ function parseStrictJson(text) {
 }
 //#endregion
 //#region package.json
-var version = "0.1.2";
+var version = "0.1.5";
 //#endregion
 //#region src/documents/cursor.ts
 function invalidCursor(reason) {
@@ -3354,7 +3355,7 @@ function getOptions(options) {
 		realpath: opts.fs.realpath || realpath$1,
 		realpathSync: opts.fs.realpathSync || realpathSync,
 		stat: opts.fs.stat || stat$2,
-		statSync: opts.fs.statSync || statSync
+		statSync: opts.fs.statSync || statSync$1
 	});
 	if (opts.debug) log("globbing with options:", opts);
 	return opts;
@@ -5445,6 +5446,454 @@ var DocumentService = class {
 	}
 };
 //#endregion
+//#region src/export/browser.ts
+function executableFile(path) {
+	try {
+		accessSync(path, constants.X_OK);
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+const MAC_APPS = [
+	"Google Chrome.app/Contents/MacOS/Google Chrome",
+	"Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+	"Chromium.app/Contents/MacOS/Chromium"
+];
+const LINUX_COMMANDS = [
+	"google-chrome",
+	"google-chrome-stable",
+	"chromium",
+	"chromium-browser",
+	"microsoft-edge",
+	"microsoft-edge-stable"
+];
+const WINDOWS_APPS = ["Google\\Chrome\\Application\\chrome.exe", "Microsoft\\Edge\\Application\\msedge.exe"];
+function candidates(lookup) {
+	const { env, platform, homeDir } = lookup;
+	if (platform === "darwin") return ["/Applications", join(homeDir, "Applications")].flatMap((dir) => MAC_APPS.map((app) => join(dir, app)));
+	if (platform === "win32") {
+		const roots = [
+			env["ProgramFiles"],
+			env["ProgramFiles(x86)"],
+			env["LOCALAPPDATA"]
+		].filter((root) => root !== void 0 && root !== "");
+		return WINDOWS_APPS.flatMap((app) => roots.map((root) => `${root}\\${app}`));
+	}
+	const dirs = (env["PATH"] ?? "").split(delimiter).filter((dir) => isAbsolute(dir));
+	return LINUX_COMMANDS.flatMap((command) => dirs.map((dir) => join(dir, command)));
+}
+function findBrowser(lookup) {
+	const isExecutable = lookup.isExecutable ?? executableFile;
+	const explicit = lookup.env["VDE_OPEN_BROWSER"];
+	if (explicit !== void 0 && explicit !== "") {
+		if (isAbsolute(explicit) && isExecutable(explicit)) return explicit;
+		throw new VdeError("E_BROWSER_NOT_FOUND", "VDE_OPEN_BROWSER is not the absolute path of an executable file.", { source: "VDE_OPEN_BROWSER" });
+	}
+	const found = candidates(lookup).find((path) => isExecutable(path));
+	if (found !== void 0) return found;
+	throw new VdeError("E_BROWSER_NOT_FOUND", "Exporting a PDF needs Google Chrome or Microsoft Edge. Set VDE_OPEN_BROWSER to use another Chromium-based browser.", { source: "search" });
+}
+//#endregion
+//#region src/export/cdp.ts
+const MAX_MESSAGE_BYTES = 16777216;
+var CdpError = class extends Error {
+	method;
+	constructor(method, message) {
+		super(`${method}: ${message}`);
+		this.name = "CdpError";
+		this.method = method;
+	}
+};
+function connectCdp(toBrowser, fromBrowser) {
+	let nextId = 1;
+	let failure = null;
+	const pending = /* @__PURE__ */ new Map();
+	const waiters = [];
+	let chunks = [];
+	let buffered = 0;
+	const close = (error) => {
+		if (failure !== null) return;
+		failure = error;
+		for (const waiter of pending.values()) waiter.reject(error);
+		pending.clear();
+		for (const waiter of waiters.splice(0)) waiter.reject(error);
+	};
+	const dispatch = (message) => {
+		if (message.id !== void 0) {
+			const waiter = pending.get(message.id);
+			if (!waiter) return;
+			pending.delete(message.id);
+			if (message.error) waiter.reject(new CdpError(waiter.method, message.error.message ?? "failed"));
+			else waiter.resolve(message.result);
+			return;
+		}
+		const index = waiters.findIndex((waiter) => waiter.method === message.method && waiter.sessionId === message.sessionId && waiter.accept(message.params));
+		if (index === -1) return;
+		const [waiter] = waiters.splice(index, 1);
+		waiter?.resolve(message.params);
+	};
+	fromBrowser.on("data", (chunk) => {
+		if (failure !== null) return;
+		let start = 0;
+		let end = chunk.indexOf(0, start);
+		try {
+			while (end !== -1) {
+				chunks.push(chunk.subarray(start, end));
+				const text = Buffer.concat(chunks).toString("utf8");
+				chunks = [];
+				buffered = 0;
+				dispatch(JSON.parse(text));
+				start = end + 1;
+				end = chunk.indexOf(0, start);
+			}
+			if (start < chunk.length) {
+				chunks.push(chunk.subarray(start));
+				buffered += chunk.length - start;
+				if (buffered > MAX_MESSAGE_BYTES) throw new Error("message too large");
+			}
+		} catch {
+			chunks = [];
+			close(new CdpError("protocol", "the browser sent a message that cannot be read"));
+		}
+	});
+	fromBrowser.on("error", () => void 0);
+	toBrowser.on("error", () => void 0);
+	return {
+		send(method, params = {}, sessionId) {
+			if (failure !== null) return Promise.reject(failure);
+			const id = nextId;
+			nextId += 1;
+			return new Promise((resolve, reject) => {
+				pending.set(id, {
+					method,
+					resolve,
+					reject
+				});
+				toBrowser.write(`${JSON.stringify({
+					id,
+					method,
+					params,
+					...sessionId === void 0 ? {} : { sessionId }
+				})}\0`);
+			});
+		},
+		waitFor(method, sessionId, accept) {
+			if (failure !== null) return Promise.reject(failure);
+			return new Promise((resolve, reject) => {
+				waiters.push({
+					method,
+					sessionId,
+					accept,
+					resolve,
+					reject
+				});
+			});
+		},
+		close
+	};
+}
+//#endregion
+//#region src/export/pdf-service.ts
+const BROWSER_FLAGS = [
+	"--headless",
+	"--remote-debugging-pipe",
+	"--no-first-run",
+	"--no-default-browser-check",
+	"--disable-background-networking",
+	"--disable-component-update",
+	"--disable-default-apps",
+	"--disable-extensions",
+	"--disable-sync",
+	"--password-store=basic",
+	"--use-mock-keychain"
+];
+const MIN_BROWSER_VERSION = 131;
+const EXIT_GRACE_MS = 5e3;
+const MAX_WAITING = 4;
+const READ_CHUNK_BYTES = 1048576;
+const MAX_PAGE_BYTES = 268435456;
+const TEMP_PREFIX$1 = "vde-open-pdf-";
+const STALE_TEMP_MS = 36e5;
+const PDF_HEAD = Buffer.from("%PDF-");
+const PDF_TAIL = Buffer.from("%%EOF");
+function exportFailed(reason, details = {}) {
+	return new VdeError("E_EXPORT_FAILED", "The browser could not print the PDF.", {
+		reason,
+		...details
+	});
+}
+const stopping = () => new VdeError("E_DAEMON_STOPPING", "The daemon is stopping.");
+const cancelled = () => new VdeError("E_INTERRUPTED", "The PDF export was cancelled.");
+function settledWithin(promise, ms) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => resolve(false), ms);
+		promise.then(() => {
+			clearTimeout(timer);
+			resolve(true);
+		});
+	});
+}
+async function printPage(cdp, url) {
+	const { product } = await cdp.send("Browser.getVersion");
+	if (Number(/\/(\d+)\./.exec(product)?.[1] ?? "0") < MIN_BROWSER_VERSION) throw new VdeError("E_BROWSER_NOT_FOUND", `Exporting a PDF needs Google Chrome or Microsoft Edge ${String(MIN_BROWSER_VERSION)} or later.`, {
+		source: "version",
+		version: product
+	});
+	const { targetId } = await cdp.send("Target.createTarget", { url: "about:blank" });
+	const { sessionId } = await cdp.send("Target.attachToTarget", {
+		targetId,
+		flatten: true
+	});
+	await cdp.send("Page.enable", {}, sessionId);
+	await cdp.send("Page.setLifecycleEventsEnabled", { enabled: true }, sessionId);
+	const seen = /* @__PURE__ */ new Set();
+	let loaderId = null;
+	const loaded = cdp.waitFor("Page.lifecycleEvent", sessionId, (event) => {
+		if (event.name !== "load") return false;
+		if (loaderId === null) seen.add(event.loaderId);
+		return event.loaderId === loaderId;
+	});
+	loaded.catch(() => void 0);
+	const navigation = await cdp.send("Page.navigate", { url }, sessionId);
+	if (navigation.errorText !== void 0 || navigation.loaderId === void 0) throw exportFailed("load");
+	loaderId = navigation.loaderId;
+	if (!seen.has(loaderId)) await loaded;
+	const { stream } = await cdp.send("Page.printToPDF", {
+		printBackground: true,
+		preferCSSPageSize: true,
+		displayHeaderFooter: false,
+		generateDocumentOutline: true,
+		generateTaggedPDF: true,
+		transferMode: "ReturnAsStream"
+	}, sessionId);
+	const parts = [];
+	for (;;) {
+		const chunk = await cdp.send("IO.read", {
+			handle: stream,
+			size: READ_CHUNK_BYTES
+		}, sessionId);
+		parts.push(Buffer.from(chunk.data, chunk.base64Encoded === true ? "base64" : "latin1"));
+		if (chunk.eof) break;
+	}
+	await cdp.send("IO.close", { handle: stream }, sessionId);
+	return {
+		product,
+		pdf: Buffer.concat(parts)
+	};
+}
+function isPdf(pdf) {
+	let end = pdf.length;
+	while (end > 0 && (pdf[end - 1] === 10 || pdf[end - 1] === 13 || pdf[end - 1] === 32)) end -= 1;
+	return pdf.subarray(0, PDF_HEAD.length).equals(PDF_HEAD) && pdf.subarray(end - PDF_TAIL.length, end).equals(PDF_TAIL);
+}
+function createPdfService(options) {
+	const { store, documents, printer } = options;
+	const platform = options.platform ?? process.platform;
+	const timeoutMs = options.timeoutMs ?? LIMITS.pdfExportTimeoutMs;
+	const tempRoot = options.tempRoot ?? tmpdir();
+	const maxPageBytes = options.maxPageBytes ?? MAX_PAGE_BYTES;
+	let closed = false;
+	let stopRunning = null;
+	let queue = Promise.resolve();
+	let waiting = 0;
+	const kill = (child) => {
+		if (child.pid === void 0) return;
+		if (platform === "win32") {
+			if (child.exitCode !== null || child.signalCode !== null) return;
+			spawn("taskkill", [
+				"/PID",
+				String(child.pid),
+				"/T",
+				"/F"
+			], {
+				stdio: "ignore",
+				windowsHide: true
+			}).once("error", () => child.kill());
+			return;
+		}
+		try {
+			process.kill(-child.pid, "SIGKILL");
+		} catch {}
+	};
+	const writePage = async (path, html, slot, images) => {
+		const file = await open(path, "wx", 384);
+		let written = 0;
+		const write = async (text) => {
+			written += Buffer.byteLength(text);
+			if (written > maxPageBytes) throw new VdeError("E_LIMIT_EXCEEDED", "The document is too large to print.", {
+				reason: "page-size",
+				limit: maxPageBytes
+			});
+			await file.write(text);
+		};
+		try {
+			let last = 0;
+			for (const match of html.matchAll(new RegExp(`${slot}-(\\d+)`, "g"))) {
+				await write(html.slice(last, match.index));
+				const image = images[Number(match[1])];
+				if (image !== void 0) {
+					await write(`data:${image.mime};base64,`);
+					await write((await store.readBlob(image.sha256)).toString("base64"));
+				}
+				last = match.index + match[0].length;
+			}
+			await write(html.slice(last));
+		} finally {
+			await file.close();
+		}
+	};
+	const uid = platform === "win32" ? null : process.getuid?.() ?? null;
+	const sweepStale = async () => {
+		const now = Date.now();
+		for (const name of await readdir(tempRoot).catch(() => [])) {
+			if (!name.startsWith(TEMP_PREFIX$1)) continue;
+			const path = join(tempRoot, name);
+			const info = await lstat(path).catch(() => null);
+			if (info === null || !info.isDirectory() || now - info.mtimeMs < STALE_TEMP_MS) continue;
+			if (uid !== null && info.uid !== uid) continue;
+			await rm(path, {
+				recursive: true,
+				force: true
+			}).catch(() => void 0);
+		}
+	};
+	sweepStale();
+	const print = async (browser, directory, url, signal) => {
+		if (closed) throw stopping();
+		if (signal?.aborted === true) throw cancelled();
+		const child = spawn(browser, [
+			...BROWSER_FLAGS,
+			`--user-data-dir=${join(directory, "profile")}`,
+			"about:blank"
+		], {
+			stdio: [
+				"ignore",
+				"ignore",
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			detached: platform !== "win32",
+			windowsHide: true
+		});
+		const cdp = connectCdp(child.stdio[3], child.stdio[4]);
+		let reason = null;
+		const stop = (why) => {
+			reason ??= why;
+			cdp.close(why);
+			kill(child);
+		};
+		const exited = new Promise((resolve) => {
+			child.once("exit", () => {
+				cdp.close(reason ?? exportFailed("exit"));
+				resolve();
+			});
+			child.once("error", () => {
+				stop(exportFailed("spawn"));
+				resolve();
+			});
+		});
+		const timer = setTimeout(() => stop(exportFailed("timeout", { timeoutMs })), timeoutMs);
+		const onAbort = () => stop(cancelled());
+		signal?.addEventListener("abort", onAbort, { once: true });
+		stopRunning = stop;
+		let printed = null;
+		try {
+			printed = await printPage(cdp, url);
+			await cdp.send("Browser.close").catch(() => void 0);
+			return printed;
+		} catch (error) {
+			if (reason !== null) throw reason;
+			if (error instanceof VdeError) throw error;
+			throw exportFailed("protocol");
+		} finally {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			stopRunning = null;
+			if (printed === null) kill(child);
+			if (!await settledWithin(exited, EXIT_GRACE_MS)) {
+				kill(child);
+				await settledWithin(exited, EXIT_GRACE_MS);
+			}
+		}
+	};
+	const run = async (documentId, revision, signal) => {
+		const started = Date.now();
+		const { record, entry } = documents.describeRevision(documentId, revision);
+		if (entry.format !== "markdown") throw new VdeError("E_UNSUPPORTED_FORMAT", "Only Markdown documents can be exported as PDF.", { format: entry.format });
+		const source = (await store.readBlob(entry.sourceSha256)).toString("utf8");
+		const images = entry.assets.filter((asset) => asset.role === "image" || asset.role === "svg");
+		const slot = randomBytes(16).toString("hex");
+		const html = await printer.print({
+			source,
+			title: record.title,
+			documentLogicalPath: entry.documentLogicalPath,
+			images: images.map((asset) => asset.logicalPath),
+			imageSlot: slot
+		});
+		const browser = options.findBrowser();
+		const directory = await mkdtemp(join(tempRoot, TEMP_PREFIX$1));
+		try {
+			const page = join(directory, "document.html");
+			await writePage(page, html, slot, images);
+			const { product, pdf } = await print(browser, directory, pathToFileURL(page).href, signal);
+			if (!isPdf(pdf)) throw exportFailed("output");
+			options.onEvent?.("pdf.exported", {
+				bytes: pdf.length,
+				elapsedMs: Date.now() - started,
+				browser: product.split("/", 1)[0] ?? ""
+			});
+			return pdf;
+		} finally {
+			await rm(directory, {
+				recursive: true,
+				force: true,
+				maxRetries: 10,
+				retryDelay: 100
+			}).catch((error) => {
+				options.onEvent?.("pdf.cleanup_failed", { code: error.code ?? "unknown" });
+			});
+		}
+	};
+	return {
+		exportMarkdown(documentId, revision, signal) {
+			if (closed) return Promise.reject(stopping());
+			if (waiting >= MAX_WAITING) return Promise.reject(new VdeError("E_LIMIT_EXCEEDED", "Too many PDF exports are waiting.", {
+				reason: "waiting",
+				limit: MAX_WAITING
+			}));
+			let counted = true;
+			const uncount = () => {
+				if (!counted) return;
+				counted = false;
+				waiting -= 1;
+			};
+			waiting += 1;
+			signal?.addEventListener("abort", uncount, { once: true });
+			const result = queue.then(() => {
+				signal?.removeEventListener("abort", uncount);
+				uncount();
+				if (closed) throw stopping();
+				if (signal?.aborted === true) throw cancelled();
+				return run(documentId, revision, signal);
+			});
+			queue = result.catch((error) => {
+				if (error instanceof VdeError && error.code !== "E_INTERRUPTED") options.onEvent?.("pdf.failed", {
+					code: error.code,
+					reason: String(error.details["reason"] ?? error.details["source"] ?? "")
+				});
+			});
+			return result;
+		},
+		async close() {
+			closed = true;
+			stopRunning?.(stopping());
+			await queue;
+		}
+	};
+}
+//#endregion
 //#region src/feedback/service.ts
 function sha256$1(text) {
 	return createHash("sha256").update(text).digest("hex");
@@ -10806,6 +11255,14 @@ async function startManagementServer(deps, options = {}) {
 	})));
 	api.post("/documents/:id/focus", async (c) => ok(c, "documents.focus", await deps.documents.focus({ documentId: c.req.param("id") })));
 	api.post("/documents/:id/refresh", async (c) => ok(c, "documents.refresh", await deps.documents.refresh({ documentId: c.req.param("id") })));
+	api.post("/documents/:id/pdf", async (c) => {
+		const body = strictObject({ revision: revisionSchema }).parse(await c.req.json());
+		const pdf = await deps.pdf.exportMarkdown(c.req.param("id"), body.revision, c.req.raw.signal);
+		return c.body(new Uint8Array(pdf), 200, {
+			"Content-Type": "application/pdf",
+			"Content-Disposition": "attachment"
+		});
+	});
 	api.get("/search", async (c) => {
 		const { query, mode, limit, maxBytes, cursor } = c.req.query();
 		const documents = c.req.queries("document") ?? [];
@@ -13346,6 +13803,10 @@ function createParseService(options = {}) {
 			op: "render",
 			input
 		}),
+		print: (input) => request({
+			op: "print",
+			input
+		}),
 		async close() {
 			closed = true;
 			collector.close(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));
@@ -13709,8 +14170,10 @@ async function startDaemon(options) {
 	let preview = null;
 	let watcher = null;
 	let parse = null;
+	let printer = null;
 	let search = null;
 	let feedback = null;
+	let pdf = null;
 	let announceStopping = () => void 0;
 	let lockTimer = null;
 	let heapWatch = null;
@@ -13753,9 +14216,11 @@ async function startDaemon(options) {
 		await step("drain", () => ipc?.drain());
 		announceStopping();
 		await step("management", () => management?.close(), SHUTDOWN_CLOSE_TIMEOUT_MS);
+		await step("pdf", () => pdf?.close(), SHUTDOWN_CLOSE_TIMEOUT_MS);
 		await step("preview", () => preview?.close(), SHUTDOWN_CLOSE_TIMEOUT_MS);
 		await step("store", () => store?.close());
 		await step("parse", () => parse?.close(), SHUTDOWN_CLOSE_TIMEOUT_MS);
+		await step("print", () => printer?.close(), SHUTDOWN_CLOSE_TIMEOUT_MS);
 		await step("search", () => search?.close(), SHUTDOWN_CLOSE_TIMEOUT_MS);
 		await step("ipc", () => ipc?.close());
 		let ownsLock = false;
@@ -13855,6 +14320,16 @@ async function startDaemon(options) {
 			})
 		});
 		pruneGrants = () => render.pruneClosed();
+		printer = createParseService({ timeoutMs: LIMITS.printRenderTimeoutMs });
+		const exporting = createPdfService({
+			store: openedStore,
+			documents,
+			printer,
+			findBrowser: () => findBrowser(environment),
+			platform: environment.platform,
+			onEvent: (event, fields) => logger.log(event, fields)
+		});
+		pdf = exporting;
 		preview = await startPreviewServer({
 			render,
 			frameAncestors: () => [managementOrigin, devOrigin].filter((origin) => origin !== null),
@@ -13870,6 +14345,7 @@ async function startDaemon(options) {
 			render,
 			search: searching,
 			feedback: answering,
+			pdf: exporting,
 			previewOrigin,
 			webRoot: webRootPath(),
 			devOrigin,
@@ -13907,7 +14383,8 @@ async function startDaemon(options) {
 				const { collectGarbage } = diagnosticsParamsSchema.parse(params ?? {});
 				const workers = {
 					search: await search?.diagnostics(collectGarbage, stopRequested.signal) ?? null,
-					parse: await parse?.diagnostics(collectGarbage, stopRequested.signal) ?? null
+					parse: await parse?.diagnostics(collectGarbage, stopRequested.signal) ?? null,
+					print: await printer?.diagnostics(collectGarbage, stopRequested.signal) ?? null
 				};
 				const heapUsedBytes = measureHeap(collectGarbage);
 				const activeResources = {};