vde-open 0.1.4 → 0.1.6

package/dist/{main-DlLPjYZZ.js → main-C3SHFgNa.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.4";
+var version = "0.1.6";
 //#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 = {};