@segnavia/render 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 modstudio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { Deck, PageInput } from "@segnavia/format";
+import { PrintOptions } from "@segnavia/frame/print-document";
+import { Page as Page$1 } from "playwright-core";
+//#region src/index.d.ts
+export declare const RENDER_BOUND_MS = 60000;
+export declare const PAGE_READY_BOUND_MS = 10000;
+export declare const CONTAINER_ARGS: string[];
+export declare class RendererUnavailableError extends Error {
+  name: string;
+}
+export declare class RenderTimeoutError extends Error {
+  name: string;
+}
+export declare class RenderRefusedError extends Error {
+  name: string;
+}
+export interface Font {
+  family: string;
+  data: Uint8Array;
+  format: 'woff2' | 'woff' | 'truetype' | 'opentype';
+  weight?: number | string;
+  style?: 'normal' | 'italic';
+}
+export interface RenderLimits {
+  maxSheets?: number;
+  maxBytes?: number;
+}
+export interface RenderOptions {
+  css?: string;
+  fonts?: Font[];
+  limits?: RenderLimits;
+  boundMs?: number;
+  waitForPageReady?: boolean;
+  preferCssPageSize?: boolean;
+  beforeOutput?: (tab: Page$1) => Promise<void>;
+}
+export interface ImageOptions extends RenderOptions {
+  format?: 'png' | 'jpeg' | 'webp';
+  quality?: number[];
+  scale?: number;
+  width?: number;
+}
+export interface RendererOptions {
+  executablePath: string;
+  args?: string[];
+  concurrency?: number;
+  jsHeapMb?: number;
+}
+export interface Renderer {
+  pagePdf(page: PageInput, options?: RenderOptions): Promise<Uint8Array>;
+  pageImage(page: PageInput, options?: ImageOptions): Promise<Uint8Array>;
+  deckPdf(deck: Deck, options?: RenderOptions & PrintOptions): Promise<Uint8Array>;
+  slideImage(deck: Deck, index: number, options?: ImageOptions & Pick<PrintOptions, 'inline'>): Promise<Uint8Array>;
+  close(): Promise<void>;
+}
+export declare function fontFaces(fonts?: Font[]): string;
+export declare function captureImage(tab: Page$1, options: Pick<ImageOptions, 'format' | 'quality' | 'limits'>, fullPage: boolean): Promise<Uint8Array>;
+export declare function openRenderer(options: RendererOptions): Promise<Renderer>;
+//#endregion

package/dist/index.js

@@ -0,0 +1,311 @@
+import { PX_PER_MM, Page, sheetMm } from "@segnavia/format";
+import { frameDocument, newNonce } from "@segnavia/frame/bridge";
+import { printableDeck } from "@segnavia/frame/print-document";
+import { PDFDocument } from "pdf-lib";
+import { chromium } from "playwright-core";
+//#region src/index.ts
+const RENDER_BOUND_MS = 6e4;
+const PAGE_READY_BOUND_MS = 1e4;
+const FLUID_WIDTH = 1024;
+const CONTAINER_ARGS = [
+	"--no-sandbox",
+	"--disable-setuid-sandbox",
+	"--disable-dev-shm-usage",
+	"--disable-gpu"
+];
+const NO_NETWORK_ARGS = [
+	"--proxy-server=socks5://127.0.0.1:9",
+	"--proxy-bypass-list=<-loopback>",
+	"--force-webrtc-ip-handling-policy=disable_non_proxied_udp"
+];
+var RendererUnavailableError = class extends Error {
+	name = "RendererUnavailableError";
+};
+var RenderTimeoutError = class extends Error {
+	name = "RenderTimeoutError";
+};
+var RenderRefusedError = class extends Error {
+	name = "RenderRefusedError";
+};
+function fontFaces(fonts = []) {
+	return fonts.map((font) => `@font-face{font-family:${JSON.stringify(font.family)};src:url(data:font/${font.format === "truetype" ? "ttf" : font.format === "opentype" ? "otf" : font.format};base64,${Buffer.from(font.data).toString("base64")}) format(${JSON.stringify(font.format)});font-weight:${font.weight ?? "normal"};font-style:${font.style ?? "normal"};font-display:block}`).join("");
+}
+async function withinBound(ms, work) {
+	let timer;
+	const bound = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(new RenderTimeoutError(`The render did not finish within ${ms / 1e3}s.`)), ms);
+	});
+	try {
+		return await Promise.race([work, bound]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function sheets(pdf) {
+	return (await PDFDocument.load(pdf)).getPageCount();
+}
+async function enforce(pdf, limits) {
+	if (limits?.maxBytes !== void 0 && pdf.byteLength > limits.maxBytes) throw new RenderRefusedError(`The PDF is ${pdf.byteLength} bytes; the limit is ${limits.maxBytes}.`);
+	if (limits?.maxSheets !== void 0) {
+		const count = await sheets(pdf);
+		if (count > limits.maxSheets) throw new RenderRefusedError(`The PDF has ${count} sheets; the limit is ${limits.maxSheets}.`);
+	}
+	return pdf;
+}
+async function captureImage(tab, options, fullPage) {
+	const format = options.format ?? "png";
+	if (format !== "webp") return tab.screenshot({
+		type: format,
+		fullPage,
+		...format === "jpeg" ? { quality: options.quality?.[0] ?? 90 } : {}
+	});
+	const session = await tab.context().newCDPSession(tab);
+	try {
+		const clip = await tab.evaluate((wholePage) => {
+			const scale = devicePixelRatio;
+			if (wholePage) return {
+				x: 0,
+				y: 0,
+				width: document.documentElement.scrollWidth,
+				height: document.documentElement.scrollHeight,
+				scale
+			};
+			return {
+				x: scrollX,
+				y: scrollY,
+				width: innerWidth,
+				height: innerHeight,
+				scale
+			};
+		}, fullPage);
+		for (const quality of options.quality ?? [
+			90,
+			80,
+			70
+		]) {
+			const { data } = await session.send("Page.captureScreenshot", {
+				format: "webp",
+				quality,
+				captureBeyondViewport: fullPage,
+				clip
+			});
+			const bytes = Buffer.from(data, "base64");
+			if (options.limits?.maxBytes === void 0 || bytes.byteLength <= options.limits.maxBytes) return bytes;
+		}
+	} finally {
+		await session.detach();
+	}
+	throw new RenderRefusedError(`The image is larger than ${options.limits?.maxBytes} bytes at every quality tried.`);
+}
+async function contentHeight(tab) {
+	const width = tab.viewportSize()?.width ?? FLUID_WIDTH;
+	await tab.setViewportSize({
+		width,
+		height: 1
+	});
+	const height = await tab.evaluate(() => Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0));
+	await tab.setViewportSize({
+		width,
+		height
+	});
+	return height;
+}
+async function openRenderer(options) {
+	let browser;
+	try {
+		browser = await chromium.launch({
+			executablePath: options.executablePath,
+			args: [
+				...options.args ?? [],
+				...NO_NETWORK_ARGS,
+				...options.jsHeapMb ? [`--js-flags=--max-old-space-size=${options.jsHeapMb}`] : []
+			]
+		});
+	} catch (error) {
+		throw new RendererUnavailableError(`Chromium at ${options.executablePath} could not start: ${error.message}`);
+	}
+	const limit = options.concurrency ?? 2;
+	let running = 0;
+	const waiting = [];
+	const acquire = () => {
+		if (running < limit) {
+			running++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => waiting.push(resolve));
+	};
+	const release = () => {
+		const next = waiting.shift();
+		if (next) next();
+		else running--;
+	};
+	async function withTab(setup, body) {
+		await acquire();
+		let context;
+		try {
+			return await withinBound(setup.boundMs ?? 6e4, (async () => {
+				context = await browser.newContext({
+					viewport: setup.viewport,
+					deviceScaleFactor: setup.scale ?? 1,
+					javaScriptEnabled: setup.scripts,
+					offline: true
+				});
+				await context.route("**/*", (route) => route.request().url().startsWith("data:") ? route.continue() : route.abort("blockedbyclient"));
+				await context.routeWebSocket("**/*", (socket) => socket.close());
+				const tab = await context.newPage();
+				let ready;
+				const readyPromise = new Promise((resolve) => {
+					ready = resolve;
+				});
+				if (setup.waitForReady) await tab.exposeFunction("pageReady", () => ready?.());
+				await tab.setContent(setup.html, { waitUntil: "load" });
+				if (setup.waitForReady) await withinBound(PAGE_READY_BOUND_MS, readyPromise).catch(() => {
+					throw new RenderRefusedError(`The page did not call window.pageReady() within ${PAGE_READY_BOUND_MS / 1e3}s.`);
+				});
+				await tab.evaluate(() => document.fonts.ready.then(() => true)).catch(() => {});
+				await setup.beforeOutput?.(tab);
+				return body(tab);
+			})());
+		} finally {
+			await context?.close().catch(() => {});
+			release();
+		}
+	}
+	function pageDocument(page, options) {
+		const css = `${fontFaces(options.fonts)}${options.css ?? ""}`;
+		return frameDocument(page.html, {
+			scripts: page.scripts,
+			nonce: newNonce(),
+			dir: page.dir,
+			lang: page.lang,
+			css,
+			relayKeys: false,
+			reportHeight: false
+		});
+	}
+	function pageViewport(page, width) {
+		if (page.print) {
+			const mm = sheetMm(page.print);
+			return {
+				width: Math.round(mm.width * PX_PER_MM),
+				height: Math.round(mm.height * PX_PER_MM)
+			};
+		}
+		if (page.size === "fluid") return {
+			width: width ?? FLUID_WIDTH,
+			height: 800
+		};
+		return {
+			width: page.size.width,
+			height: page.size.height === "auto" ? 800 : page.size.height
+		};
+	}
+	const image = captureImage;
+	return {
+		async pagePdf(input, opts = {}) {
+			const page = Page.parse(input);
+			const viewport = pageViewport(page);
+			return enforce(await withTab({
+				viewport,
+				scripts: page.scripts === "sandboxed",
+				html: pageDocument(page, opts),
+				waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
+				boundMs: opts.boundMs,
+				beforeOutput: opts.beforeOutput
+			}, async (tab) => {
+				if (page.print) {
+					const mm = sheetMm(page.print);
+					const margin = page.print.margin;
+					return tab.pdf({
+						width: `${mm.width}mm`,
+						height: `${mm.height}mm`,
+						printBackground: true,
+						preferCSSPageSize: opts.preferCssPageSize ?? false,
+						margin: margin ? {
+							top: `${margin.top}mm`,
+							right: `${margin.right}mm`,
+							bottom: `${margin.bottom}mm`,
+							left: `${margin.left}mm`
+						} : void 0
+					});
+				}
+				const fixedHeight = typeof page.size === "object" && page.size.height !== "auto" ? page.size.height : null;
+				const height = fixedHeight ?? await contentHeight(tab);
+				return tab.pdf({
+					width: `${viewport.width}px`,
+					height: `${height}px`,
+					printBackground: true,
+					pageRanges: fixedHeight ? void 0 : "1"
+				});
+			}), opts.limits);
+		},
+		async pageImage(input, opts = {}) {
+			const page = Page.parse(input);
+			const viewport = pageViewport(page, opts.width);
+			const grows = page.size === "fluid" || typeof page.size === "object" && page.size.height === "auto";
+			return withTab({
+				viewport,
+				scripts: page.scripts === "sandboxed",
+				scale: opts.scale,
+				html: pageDocument(page, opts),
+				waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
+				boundMs: opts.boundMs,
+				beforeOutput: opts.beforeOutput
+			}, async (tab) => {
+				if (grows) await contentHeight(tab);
+				return image(tab, opts, false);
+			});
+		},
+		async deckPdf(deck, opts = {}) {
+			const css = `${fontFaces(opts.fonts)}${opts.css ?? ""}`;
+			const html = printableDeck(deck, {
+				...opts,
+				css
+			});
+			return enforce(await withTab({
+				viewport: opts.layout === "notes" ? pageViewport({
+					html: "",
+					size: "fluid",
+					scripts: "refuse",
+					print: opts.notesPaper ?? {
+						paper: "letter",
+						orientation: "portrait"
+					}
+				}) : deck.size,
+				scripts: deck.scripts === "sandboxed",
+				html,
+				waitForReady: false,
+				boundMs: opts.boundMs,
+				beforeOutput: opts.beforeOutput
+			}, (tab) => tab.pdf({
+				preferCSSPageSize: true,
+				printBackground: true
+			})), opts.limits);
+		},
+		async slideImage(deck, index, opts = {}) {
+			const slide = deck.slides[index];
+			if (!slide) throw new RangeError(`The deck has no slide ${index + 1}.`);
+			const single = {
+				...deck,
+				slides: [slide]
+			};
+			const css = `${fontFaces(opts.fonts)}${opts.css ?? ""}`;
+			const html = printableDeck(single, {
+				inline: opts.inline,
+				css
+			});
+			return withTab({
+				viewport: deck.size,
+				scripts: deck.scripts === "sandboxed",
+				scale: opts.scale,
+				html,
+				waitForReady: false,
+				boundMs: opts.boundMs,
+				beforeOutput: opts.beforeOutput
+			}, (tab) => image(tab, opts, false));
+		},
+		close: () => browser.close()
+	};
+}
+//#endregion
+export { CONTAINER_ARGS, PAGE_READY_BOUND_MS, RENDER_BOUND_MS, RenderRefusedError, RenderTimeoutError, RendererUnavailableError, captureImage, fontFaces, openRenderer };

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@segnavia/render",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modstudio/segnavia.git",
+    "directory": "packages/render"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "@segnavia/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@segnavia/format": "0.1.0",
+    "@segnavia/frame": "0.1.0",
+    "playwright-core": "1.55.1",
+    "pdf-lib": "^1.17.1"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.