@projektemacher/vivliostyle-batch-cli 0.1.2 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,504 @@
1
+ // src/render/pdf.ts
2
+
3
+ // Copyright (c) 2026 Christian Mahnke
4
+ // Licensed under the MIT License.
5
+
6
+ /**
7
+ * PDF rendering on top of the Vivliostyle viewer and Chrome's print-to-PDF.
8
+ *
9
+ * The viewer page is served by our own static server (see src/server.ts), so
10
+ * the document's origin — and therefore the base URI of the scripts the page
11
+ * runs — is the site we serve, not an internal viewer base.
12
+ *
13
+ * Printed pages run through the post-processing step (see
14
+ * src/render/pdf-postprocess.ts), which stamps the document metadata and
15
+ * applies the requested PDF/A or PDF/X labeling.
16
+ */
17
+
18
+ import { mkdirSync, writeFileSync } from "node:fs";
19
+ import { dirname } from "node:path";
20
+ import puppeteer from "puppeteer-core";
21
+ import { PDFDocument } from "pdf-lib";
22
+ import log from "loglevel";
23
+ import { chromeArgs, resolveBrowserExecutable } from "./chrome.js";
24
+ import { postProcessPdf } from "./pdf-postprocess.js";
25
+ import type { PdfLabel } from "./xmp.js";
26
+
27
+ export type ViewerParams = Record<string, string | number | boolean | undefined>;
28
+
29
+ /** URL of the viewer page, with the publication and layout parameters. */
30
+ export function buildViewerUrl(viewerPageUrl: string, params: ViewerParams): string {
31
+ const parts: string[] = [];
32
+
33
+ for (const [key, value] of Object.entries(params)) {
34
+ if (value === undefined || value === "") continue;
35
+ parts.push(`${key}=${String(value).replaceAll("&", "%26")}`);
36
+ }
37
+
38
+ const query = parts.join("&");
39
+ return query === "" ? viewerPageUrl : `${viewerPageUrl}#${query}`;
40
+ }
41
+
42
+ export type RenderPdfRequest = {
43
+ /** Absolute URL of the document on our static server. */
44
+ documentUrl: string;
45
+ /** Absolute URL of the viewer page on our static server. */
46
+ viewerPageUrl: string;
47
+ /** Absolute path of the PDF to write. */
48
+ output: string;
49
+ viewerParams?: ViewerParams;
50
+ title?: string;
51
+ author?: string;
52
+ subject?: string;
53
+ keywords?: string;
54
+ language?: string;
55
+ /** Standards labeling applied to the printed PDF (PDF/A or PDF/X). */
56
+ pdfLabel?: PdfLabel;
57
+ /** ICC profile embedded as the OutputIntent; required whenever a label is set. */
58
+ iccProfile?: Uint8Array;
59
+ iccProfileName?: string;
60
+ /** Hard limit for the whole render. */
61
+ timeoutMs?: number;
62
+ /** Wait for the page to report that it settled before printing. */
63
+ waitForSettle?: boolean;
64
+ /**
65
+ * Redraw canvas/WebGL content at `clientSize * canvasScale` backing pixels
66
+ * before printing (layout/CSS size unchanged). Values `<= 1` skip the step.
67
+ * Wired from `--pixel-ratio` so `--pixel-ratio 2` stays sharp past 96dpi.
68
+ */
69
+ canvasScale?: number;
70
+ /** Pause after the upscale call so charts can repaint (default 500ms). */
71
+ canvasSettleMs?: number;
72
+ chromeExecutable?: string;
73
+ extraChromeArgs?: string[];
74
+ };
75
+
76
+ export type RenderPdfResult = {
77
+ output: string;
78
+ bytes: number;
79
+ pageCount: number;
80
+ settle: { reason: string; waitedMs: number } | null;
81
+ };
82
+
83
+ const DEFAULT_TIMEOUT_MS = 300_000;
84
+
85
+ /** The wrapper owns the producer/creator entries of every PDF it prints. */
86
+ const TOOL_IDENTITY = "vivliostyle-batch-cli";
87
+
88
+ function pdfMetadata(request: RenderPdfRequest) {
89
+ return {
90
+ ...(request.title === undefined ? {} : { title: request.title }),
91
+ ...(request.author === undefined ? {} : { author: request.author }),
92
+ ...(request.subject === undefined ? {} : { subject: request.subject }),
93
+ ...(request.keywords === undefined ? {} : { keywords: request.keywords }),
94
+ ...(request.language === undefined ? {} : { language: request.language }),
95
+ creator: TOOL_IDENTITY,
96
+ producer: TOOL_IDENTITY
97
+ };
98
+ }
99
+
100
+ type SettleState = { reason: string; at: number };
101
+
102
+ export type FrameRenderCapability = {
103
+ url: string;
104
+ ready: boolean;
105
+ fixture: string | null;
106
+ webgl: boolean;
107
+ webgl2: boolean;
108
+ webgpu: boolean;
109
+ canvasCount: number;
110
+ canvases: string;
111
+ iframeCount: number | null;
112
+ dpr: number;
113
+ resized: string | null;
114
+ /** A-Frame scenes materialized into 2D overlay canvases for print. */
115
+ materialized?: number;
116
+ /** Scene-graph state at print time (debug aid). */
117
+ sceneDiag?: string | null;
118
+ };
119
+
120
+ /**
121
+ * Runs inside one frame (viewer window or a document/iframe within it):
122
+ * scrolls JS-painted elements into view so out-of-process iframes rasterize,
123
+ * reports GPU capabilities and canvas sizes, and — when the page exposes the
124
+ * `window.__vivResize(factor)` hook — redraws at HiDPI backing resolution.
125
+ *
126
+ * Blindly rewriting `canvas.width` here would blank WebGL contexts without
127
+ * `preserveDrawingBuffer`, so generic canvases are left for the page to redraw
128
+ * via the dispatched `resize` event; only the explicit hook changes pixels.
129
+ */
130
+ export function buildFrameProbeScript(factor: number): string {
131
+ return `(async function(factor){
132
+ function nextFrame(){ return new Promise(function(r){ requestAnimationFrame(function(){ requestAnimationFrame(r); }); }); }
133
+ var canvases = Array.prototype.slice.call(document.querySelectorAll("canvas"));
134
+ var iframes = Array.prototype.slice.call(document.querySelectorAll("iframe"));
135
+ canvases.forEach(function(c){ try{ c.scrollIntoView({block:"nearest"}); }catch(e){} });
136
+ iframes.forEach(function(f){ try{ f.scrollIntoView({block:"nearest"}); }catch(e){} });
137
+ function canvasSizes(){
138
+ return Array.prototype.slice.call(document.querySelectorAll("canvas")).map(function(c){
139
+ return c.width+"x"+c.height+"@"+Math.round(c.clientWidth)+"x"+Math.round(c.clientHeight);
140
+ }).join(",");
141
+ }
142
+ var resized = null;
143
+ if (factor > 1 && typeof window.__vivResize === "function") {
144
+ try { window.__vivResize(factor); } catch(e){ resized = "error:"+String(e); }
145
+ }
146
+ try { window.dispatchEvent(new Event("resize")); } catch(e){}
147
+ // Bridge the viewer's broken page lifecycle. A-Frame scenes can end up
148
+ // loaded-but-never-playing in the paginated tree (render loop, default
149
+ // lights and asset loads all missed their window) while the same page
150
+ // renders fine in a real browser. Start the scene's own loop and give
151
+ // collapsed scenes a box (their display:block stylesheet does not reach
152
+ // the re-parented tree, so unsized unknown elements stay inline).
153
+ try {
154
+ var bridgeScenes = document.querySelectorAll("a-scene");
155
+ for (var bi = 0; bi < bridgeScenes.length; bi++) {
156
+ var bridgeScene = bridgeScenes[bi];
157
+ if (!bridgeScene.isPlaying && typeof bridgeScene.play === "function") {
158
+ try { bridgeScene.play(); } catch (e) {}
159
+ }
160
+ if (bridgeScene.clientWidth === 0 || bridgeScene.clientHeight === 0) {
161
+ var sized = bridgeScene.parentElement;
162
+ while (sized && (sized.clientWidth === 0 || sized.clientHeight === 0)) sized = sized.parentElement;
163
+ if (sized) {
164
+ bridgeScene.style.display = "block";
165
+ bridgeScene.style.width = sized.clientWidth + "px";
166
+ bridgeScene.style.height = sized.clientHeight + "px";
167
+ if (typeof bridgeScene.resize === "function") bridgeScene.resize();
168
+ }
169
+ }
170
+ }
171
+ await nextFrame();
172
+ } catch(e){}
173
+ // Give each scene what it needs to render like the browser does, then
174
+ // materialize its WebGL canvas into a 2D overlay (2D canvases always
175
+ // survive print-to-PDF): re-kick unloaded assets, swap unlit materials for
176
+ // flat ones when no lights exist, render, and blit synchronously.
177
+ var materialized = 0;
178
+ var sceneDiag = "";
179
+ try {
180
+ var scenes = document.querySelectorAll("a-scene");
181
+ for (var si = 0; si < scenes.length; si++) {
182
+ var sceneEl = scenes[si];
183
+ // The viewer clones scenes into its page boxes; only the VISIBLE one
184
+ // (with a box) is what the PDF will show. The hidden original's render
185
+ // would materialize nothing.
186
+ if (!(sceneEl.clientWidth > 0 && sceneEl.clientHeight > 0)) continue;
187
+ if (!sceneEl.renderer || !sceneEl.camera) continue;
188
+ try {
189
+ var gltfEl = sceneEl.querySelector("[gltf-model]");
190
+ if (gltfEl) {
191
+ var gmObj = gltfEl.object3D;
192
+ sceneDiag += " gmKids=" + gmObj.children.length + "/" + (gltfEl.components["gltf-model"] ? String(gltfEl.components["gltf-model"].model !== null) : "nocomp");
193
+ }
194
+ sceneDiag += " tree=" + sceneEl.object3D.children.map(function (c) { return c.type + (c.children ? ":" + c.children.length : ""); }).join("|").slice(0, 110);
195
+ } catch (e) {
196
+ sceneDiag += " diagErr " + String(e).slice(0, 50);
197
+ }
198
+ try {
199
+ var assetItems = sceneEl.querySelectorAll("a-asset-item");
200
+ var assetWaits = [];
201
+ for (var ai = 0; ai < assetItems.length; ai++) {
202
+ var assetEl = assetItems[ai];
203
+ if (assetEl.hasLoaded) continue;
204
+ assetWaits.push(
205
+ new Promise(function (resolve) {
206
+ var settled = false;
207
+ var finish = function () {
208
+ if (settled) return;
209
+ settled = true;
210
+ resolve();
211
+ };
212
+ assetEl.addEventListener("loaded", finish, { once: true });
213
+ assetEl.addEventListener("error", finish, { once: true });
214
+ setTimeout(finish, 8000);
215
+ var src = assetEl.getAttribute("src");
216
+ if (src) assetEl.setAttribute("src", src);
217
+ })
218
+ );
219
+ }
220
+ if (assetWaits.length > 0) {
221
+ await Promise.race([Promise.all(assetWaits), new Promise(function (r) { setTimeout(r, 9000); })]);
222
+ }
223
+ } catch (e) {}
224
+ try {
225
+ var lightsFound = 0;
226
+ sceneEl.object3D.traverse(function (n) { if (n.isLight) lightsFound++; });
227
+ if (lightsFound === 0) {
228
+ var basicCtor = null;
229
+ sceneEl.object3D.traverse(function (n) {
230
+ if (n.isMesh && n.material && n.material.isMeshBasicMaterial && basicCtor === null) basicCtor = n.material.constructor;
231
+ });
232
+ if (basicCtor) {
233
+ sceneEl.object3D.traverse(function (n) {
234
+ if (!n.isMesh || !n.material || n.material.isMeshBasicMaterial) return;
235
+ try {
236
+ var m = n.material;
237
+ var flat = new basicCtor({ color: m.color ? m.color.clone() : undefined });
238
+ flat.side = m.side;
239
+ flat.transparent = m.transparent;
240
+ flat.opacity = m.opacity;
241
+ if (m.map) flat.map = m.map;
242
+ n.material = flat;
243
+ } catch (e) {}
244
+ });
245
+ }
246
+ }
247
+ } catch(e){}
248
+ try {
249
+ sceneEl.renderer.render(sceneEl.object3D, sceneEl.camera);
250
+ var glCanvas = sceneEl.canvas;
251
+ if (!glCanvas || glCanvas.width === 0 || glCanvas.height === 0) continue;
252
+ var overlay = document.createElement("canvas");
253
+ overlay.setAttribute("data-viv-gl-overlay", "");
254
+ overlay.width = glCanvas.width;
255
+ overlay.height = glCanvas.height;
256
+ overlay.style.position = "absolute";
257
+ overlay.style.pointerEvents = "none";
258
+ overlay.style.width = glCanvas.clientWidth + "px";
259
+ overlay.style.height = glCanvas.clientHeight + "px";
260
+ var cr = glCanvas.getBoundingClientRect();
261
+ var pr = (glCanvas.offsetParent || document.body).getBoundingClientRect();
262
+ overlay.style.left = cr.left - pr.left + "px";
263
+ overlay.style.top = cr.top - pr.top + "px";
264
+ overlay.style.zIndex = "1";
265
+ (glCanvas.parentNode || document.body).appendChild(overlay);
266
+ overlay.getContext("2d").drawImage(glCanvas, 0, 0);
267
+ // Empty capture = the scene never initialized in this tree (its
268
+ // framework lifecycle was lost to the viewer's re-parenting). Replace
269
+ // it with a fresh copy: the custom-element upgrade re-runs the full
270
+ // framework lifecycle (assets, lights, render loop) in the now-sized
271
+ // tree.
272
+ var empty = true;
273
+ try {
274
+ var dd = overlay.getContext("2d").getImageData(0, 0, overlay.width, overlay.height).data;
275
+ for (var di = 3; di < dd.length; di += 256) {
276
+ if (dd[di] > 0) {
277
+ empty = false;
278
+ break;
279
+ }
280
+ }
281
+ } catch (e) {
282
+ empty = false;
283
+ }
284
+ if (empty) {
285
+ var fresh = sceneEl.cloneNode(true);
286
+ sceneEl.parentNode.replaceChild(fresh, sceneEl);
287
+ sceneEl = fresh;
288
+ // Enough time for the fresh scene's asset fetches (a real GLB over
289
+ // the network) + first renders.
290
+ await new Promise(function (r) {
291
+ setTimeout(r, 8000);
292
+ });
293
+ if (!sceneEl.renderer || !sceneEl.camera) continue;
294
+ }
295
+ sceneEl.renderer.render(sceneEl.object3D, sceneEl.camera);
296
+ var gl2 = sceneEl.canvas;
297
+ if (!gl2 || gl2.width === 0 || gl2.height === 0) continue;
298
+ overlay.width = gl2.width;
299
+ overlay.height = gl2.height;
300
+ overlay.getContext("2d").drawImage(gl2, 0, 0);
301
+ materialized++;
302
+ try {
303
+ var od = overlay.getContext("2d").getImageData(0, 0, overlay.width, overlay.height).data;
304
+ var alphaN = 0;
305
+ var orangeN = 0;
306
+ for (var oi = 3; oi < od.length; oi += 16) {
307
+ if (od[oi] > 0) alphaN++;
308
+ if (od[oi - 3] > 150 && od[oi - 2] > 60 && od[oi - 2] < 200 && od[oi - 1] < 110 && od[oi - 3] > od[oi - 2] + 40) orangeN++;
309
+ }
310
+ glSample = [alphaN, orangeN];
311
+ } catch (e) {}
312
+ } catch (e) {}
313
+ }
314
+ } catch(e){}
315
+ // Hooks like echarts re-init dispose the canvas synchronously; let layout
316
+ // settle a frame before measuring so sizes reflect the repainted state.
317
+ // This also lets render loops refill their drawing buffers after the
318
+ // resize above — drawImage on a just-resized WebGL canvas would read the
319
+ // cleared buffer.
320
+ try { await nextFrame(); } catch(e){}
321
+ if (resized === null && factor > 1 && typeof window.__vivResize === "function") resized = canvasSizes();
322
+ var webgl = false, webgl2 = false;
323
+ try {
324
+ var t = document.createElement("canvas");
325
+ webgl = !!t.getContext("webgl");
326
+ var t2 = document.createElement("canvas");
327
+ webgl2 = !!t2.getContext("webgl2");
328
+ } catch(e){}
329
+ return {
330
+ url: String(location.href),
331
+ ready: window.__vivReady === true,
332
+ fixture: typeof window.__vivFixture === "string" ? window.__vivFixture : null,
333
+ webgl: webgl, webgl2: webgl2,
334
+ webgpu: typeof navigator !== "undefined" && "gpu" in navigator,
335
+ canvasCount: document.querySelectorAll("canvas").length, canvases: canvasSizes(),
336
+ iframeCount: document.querySelectorAll("iframe").length,
337
+ dpr: typeof window.devicePixelRatio === "number" ? window.devicePixelRatio : 1,
338
+ resized: resized,
339
+ materialized: materialized,
340
+ sceneDiag: sceneDiag
341
+ };
342
+ })(${JSON.stringify(factor)})`;
343
+ }
344
+
345
+ /** Best-effort capability + HiDPI pass over every frame before `page.pdf()`. */
346
+ export async function prepareForPrint(
347
+ page: {
348
+ frames: () => Array<{ url?: () => string; evaluate: (script: string) => Promise<unknown> }>;
349
+ },
350
+ options: { canvasScale?: number; settleMs?: number } = {}
351
+ ): Promise<FrameRenderCapability[]> {
352
+ const factor = options.settleMs !== undefined && options.canvasScale === undefined ? 1 : (options.canvasScale ?? 1);
353
+ const scale = Number.isFinite(factor) && factor > 1 ? factor : 1;
354
+ const script = buildFrameProbeScript(scale);
355
+ const out: FrameRenderCapability[] = [];
356
+ for (const frame of page.frames()) {
357
+ try {
358
+ out.push((await frame.evaluate(script)) as FrameRenderCapability);
359
+ } catch (err) {
360
+ // Cross-origin embeds that refuse evaluation still print as pixels.
361
+ log.trace("frame probe failed", frame.url?.() ?? "(frame)", err instanceof Error ? err.message : String(err));
362
+ continue;
363
+ }
364
+ }
365
+ if (scale > 1) {
366
+ await new Promise((resolve) => setTimeout(resolve, options.settleMs ?? 500));
367
+ }
368
+ return out;
369
+ }
370
+
371
+ /** One-line summary for logs: capabilities per frame that owns content. */
372
+ export function summarizeCapabilities(caps: FrameRenderCapability[]): string {
373
+ return caps
374
+ .filter((c) => c.canvasCount > 0 || (c.iframeCount ?? 0) > 0 || c.fixture !== null)
375
+ .map(
376
+ (c) =>
377
+ `${c.fixture ?? c.url} canvases=[${c.canvases}] iframes=${c.iframeCount} ` +
378
+ `webgl=${String(c.webgl)}/2=${String(c.webgl2)} webgpu=${String(c.webgpu)}` +
379
+ (c.resized !== null ? ` resized=[${c.resized}]` : "") +
380
+ (c.materialized ? ` materialized=${c.materialized} ${c.sceneDiag ?? ""}` : "")
381
+ )
382
+ .join(" | ");
383
+ }
384
+
385
+ export async function renderPdf(request: RenderPdfRequest): Promise<RenderPdfResult> {
386
+ const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
387
+ const executablePath = resolveBrowserExecutable(request.chromeExecutable);
388
+
389
+ if (executablePath === null) {
390
+ throw new Error(
391
+ "No Chrome/Chromium found. Install one (e.g. `npx @puppeteer/browsers install chrome@stable`) or pass --executable-browser <path>."
392
+ );
393
+ }
394
+
395
+ const viewerUrl = buildViewerUrl(request.viewerPageUrl, {
396
+ src: request.documentUrl,
397
+ bookMode: false,
398
+ renderAllPages: true,
399
+ ...request.viewerParams
400
+ });
401
+ log.trace("viewerUrl", viewerUrl);
402
+
403
+ const browser = await puppeteer.launch({
404
+ executablePath,
405
+ headless: true,
406
+ args: chromeArgs(request.extraChromeArgs ?? []),
407
+ acceptInsecureCerts: true
408
+ });
409
+
410
+ const startedAt = Date.now();
411
+ let settle: RenderPdfResult["settle"] = null;
412
+
413
+ try {
414
+ const page = await browser.newPage();
415
+ page.setDefaultTimeout(timeoutMs);
416
+ page.setDefaultNavigationTimeout(timeoutMs);
417
+
418
+ page.on("pageerror", (err: unknown) => log.warn(`[render] page error: ${err instanceof Error ? err.message : String(err)}`));
419
+ // Viewer and page errors are the usual reason a render produces nothing.
420
+ // Debug/info console messages (fetch traces from the runtime script) are
421
+ // shown at debug level, so -d traces every page-side request.
422
+ const debugConsole = log.getLevel() <= log.levels.DEBUG;
423
+ page.on("console", (message) => {
424
+ const type = message.type();
425
+ if (type !== "error" && type !== "warn" && !(debugConsole && (type === "debug" || type === "info"))) return;
426
+ const where = message.location();
427
+ log[debugConsole && type !== "error" && type !== "warn" ? "trace" : "warn"](
428
+ `[render] console.${type}: ${message.text()}${where.url === "" ? "" : ` (${where.url})`}`
429
+ );
430
+ });
431
+ page.on("requestfailed", (request) => {
432
+ log.warn(`[render] request failed: ${request.url()} (${request.failure()?.errorText ?? "unknown"})`);
433
+ });
434
+
435
+ // Print media has to be active *before* the document loads: the page's print
436
+ // stylesheet is what gives JS-driven containers their size, and a chart that
437
+ // initialises against a zero-sized box never recovers.
438
+ await page.emulateMediaType("print");
439
+
440
+ await page.goto(viewerUrl, { waitUntil: "domcontentloaded" });
441
+
442
+ // The viewer's contract: coreViewer exists and has finished typesetting.
443
+ await page.waitForFunction(() => (window as { coreViewer?: unknown }).coreViewer !== undefined);
444
+ await page.waitForFunction(() => (window as { coreViewer?: { readyState?: string } }).coreViewer?.readyState === "complete", {
445
+ polling: 500
446
+ });
447
+
448
+ if (request.waitForSettle === true) {
449
+ const handle = await page.waitForFunction(
450
+ () => {
451
+ const settleState = (window as { __vivSettle?: { done?: boolean; reason?: string; at?: number } }).__vivSettle;
452
+ // Pages with mocked/measured async work set __vivReady when painted;
453
+ // Vivliostyle re-runs document scripts in the viewer context, so both
454
+ // live on the same window the renderer polls here.
455
+ const ready = (window as { __vivReady?: boolean }).__vivReady === true;
456
+ if (ready) return { reason: "ready", at: 0 };
457
+ return settleState?.done === true ? { reason: settleState.reason ?? "settled", at: settleState.at ?? 0 } : false;
458
+ },
459
+ { polling: 200, timeout: timeoutMs }
460
+ );
461
+ const state = (await handle.jsonValue()) as SettleState;
462
+
463
+ settle = { reason: state.reason, waitedMs: Date.now() - startedAt };
464
+ log.trace("settle", settle);
465
+ }
466
+
467
+ // Iframes/canvas/WebGL/WebGPU rasterize as pixels in print-to-PDF: force
468
+ // off-screen frames to paint, redraw HiDPI-aware pages at backing scale.
469
+ try {
470
+ const caps = await prepareForPrint(page, {
471
+ canvasScale: request.canvasScale,
472
+ settleMs: request.canvasSettleMs
473
+ });
474
+ const summary = summarizeCapabilities(caps);
475
+ if (summary !== "") log.info(`[render] frames: ${summary}`);
476
+ if (caps.length > 0 && caps.every((c) => !c.webgpu)) {
477
+ log.trace("[render] WebGPU unavailable in this Chrome (best-effort software rendering)");
478
+ }
479
+ } catch (err) {
480
+ log.warn(`[render] pre-print probe failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
481
+ }
482
+
483
+ const pdf = await page.pdf({
484
+ margin: { top: 0, bottom: 0, left: 0, right: 0 },
485
+ printBackground: true,
486
+ preferCSSPageSize: true,
487
+ tagged: true
488
+ });
489
+
490
+ const stamped = await postProcessPdf(pdf, {
491
+ metadata: pdfMetadata(request),
492
+ ...(request.pdfLabel === undefined ? {} : { label: request.pdfLabel }),
493
+ ...(request.iccProfile === undefined ? {} : { iccProfile: request.iccProfile, iccProfileName: request.iccProfileName })
494
+ });
495
+ mkdirSync(dirname(request.output), { recursive: true });
496
+ writeFileSync(request.output, stamped);
497
+
498
+ const pageCount = await PDFDocument.load(stamped).then((doc) => doc.getPageCount());
499
+
500
+ return { output: request.output, bytes: stamped.length, pageCount, settle };
501
+ } finally {
502
+ await browser.close();
503
+ }
504
+ }
Binary file
@@ -0,0 +1,46 @@
1
+ // src/render/viewer.ts
2
+
3
+ // Copyright (c) 2026 Christian Mahnke
4
+ // Licensed under the MIT License.
5
+
6
+ /**
7
+ * Locates the Vivliostyle viewer that renders the document.
8
+ *
9
+ * The viewer is served by our own static server (see src/server.ts) so that the
10
+ * document's origin — and with it the base URI of the scripts the page runs — is
11
+ * the site we serve.
12
+ */
13
+
14
+ import { existsSync } from "node:fs";
15
+ import { createRequire } from "node:module";
16
+ import { dirname, join, resolve } from "node:path";
17
+
18
+ const require = createRequire(import.meta.url);
19
+
20
+ /** Directory of `@vivliostyle/viewer/lib`, which holds index.html and assets. */
21
+ export function resolveViewerLibDir(): string {
22
+ const candidates: string[] = [];
23
+
24
+ try {
25
+ candidates.push(dirname(require.resolve("@vivliostyle/viewer/package.json")));
26
+ } catch {
27
+ // fall through to the paths below
28
+ }
29
+
30
+ candidates.push(
31
+ resolve(dirname(fileURLOfSelf()), "../node_modules/@vivliostyle/viewer"),
32
+ "/usr/local/lib/node_modules/@vivliostyle/viewer",
33
+ "/usr/lib/node_modules/@vivliostyle/viewer"
34
+ );
35
+
36
+ for (const candidate of candidates) {
37
+ const libDir = join(candidate, "lib");
38
+ if (existsSync(join(libDir, "index.html"))) return libDir;
39
+ }
40
+
41
+ throw new Error("Could not find @vivliostyle/viewer. Install it as a dependency of this package.");
42
+ }
43
+
44
+ function fileURLOfSelf(): string {
45
+ return new URL(import.meta.url).pathname;
46
+ }