@shotkit/shotium 0.0.1 → 0.1.0

package/README.md

@@ -1,3 +1,171 @@
 # @shotkit/shotium
 
-Placeholder release. Real content is published via CI (OIDC).
+> High-performance static HTML/CSS screenshot engine powered by a stripped Chromium Blink core.
+
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://github.com/sj817/shotium/blob/main/LICENSE)
+[![npm version](https://img.shields.io/npm/v/@shotkit/shotium.svg)](https://www.npmjs.com/package/@shotkit/shotium)
+
+---
+
+## Overview
+
+`@shotkit/shotium` provides Node.js / TypeScript bindings for **shotium**, a stripped-down Chromium engine built specifically for fast static page rendering. By completely removing V8 and browser chrome overhead, Shotium delivers cold starts under 350 ms, single-shot captures in ~47 ms, and an idle memory footprint of ~58 MB.
+
+```ts
+import shotium from '@shotkit/shotium';
+
+shotium.runtime.start({ workers: 4 });
+
+const png = await shotium.screenshot({
+  file: 'https://example.com',
+  viewport: { width: 1280, height: 720 },
+  fullPage: true,
+});
+
+await shotium.runtime.stop();
+```
+
+---
+
+## Installation
+
+```bash
+npm install @shotkit/shotium
+```
+
+Prebuilt platform binaries are installed automatically via npm optional dependencies.
+
+---
+
+## Usage
+
+### 1. Multi-Process Pool (`runtime`)
+
+Recommended for standard backend servers and continuous job queues.
+
+```ts
+import { runtime, screenshot } from '@shotkit/shotium';
+
+// Optional: listen to runtime lifecycle events
+runtime.on('crash', ({ worker }) => console.warn(`Worker ${worker} recovered from crash`));
+runtime.on('timeout', ({ worker, timeout }) => console.warn(`Worker ${worker} timed out (${timeout}ms)`));
+
+// Start pool
+runtime.start({
+  workers: 4,                        // Default: Math.max(1, Math.floor(cpuCount / 2))
+  cacheDir: '/var/tmp/shotium-cache' // Optional HTTP disk cache
+});
+
+// Take screenshot (returns Buffer or writes to disk if 'path' is specified)
+const buffer = await screenshot({
+  file: 'https://example.com',
+  viewport: { width: 1280, height: 720 },
+  type: 'webp',
+  quality: 85,
+});
+
+await runtime.stop();
+```
+
+---
+
+### 2. Resident Daemon (`daemon`)
+
+Recommended for CLI tools, ephemeral CI tasks, or serverless workers where startup latency is critical.
+
+`daemon` keeps a pre-warmed worker pool listening behind a local socket (Named Pipe on Windows, Unix domain socket on POSIX).
+
+```ts
+import { daemon } from '@shotkit/shotium';
+
+// Connect to existing daemon (automatically starts one if none is running)
+const client = await daemon.connect({ workers: 4 });
+
+const png = await client.screenshot({
+  file: 'https://example.com',
+  viewport: { width: 1280, height: 720 },
+});
+
+client.close();
+
+// Check status or stop daemon
+const status = await daemon.status();
+await daemon.stop();
+```
+
+---
+
+### 3. In-Process Native Engine (`@shotkit/shotium/native`)
+
+Recommended for single-process, single-threaded batch rendering with minimum overhead (~31 ms per shot).
+
+```ts
+import { native } from '@shotkit/shotium/native';
+
+const png = await native.screenshot({
+  file: 'https://example.com',
+  viewport: { width: 1280, height: 720 },
+});
+
+// Purge cache and release working set after batch
+native.purge({ releaseWorkingSet: true });
+await native.stop();
+```
+
+---
+
+## API Reference
+
+### `ScreenshotOptions`
+
+```ts
+interface ScreenshotOptions {
+  /** Target URL (http/https/file) or local file path */
+  file: string;
+
+  /** Output format (default: 'png') */
+  type?: 'png' | 'jpeg' | 'webp';
+
+  /** Viewport dimensions (default: 1280x720) */
+  viewport?: { width?: number; height?: number };
+
+  /** Capture full scrollable document */
+  fullPage?: boolean;
+
+  /** Capture element bounding box matching selector */
+  selector?: string;
+
+  /** Capture specific rectangular crop */
+  clip?: { x: number; y: number; width: number; height: number };
+
+  /** Image compression quality: 1-100 (jpeg and webp only, default: 90) */
+  quality?: number;
+
+  /** Device scale factor: 0.01 - 8.0 (default: 1.0) */
+  scale?: number;
+
+  /** Preserve transparent background (png/webp only) */
+  omitBackground?: boolean;
+
+  /** Output file destination path (returns null if specified) */
+  path?: string;
+
+  /** Navigation & wait options */
+  pageGotoParams?: {
+    timeout?: number;
+    waitUntil?: 'load' | 'networkidle';
+  };
+
+  /** Allow document to access local file:// resources (default: false) */
+  allowFileAccess?: boolean;
+
+  /** Auto retry count on failure (default: 0) */
+  retry?: number;
+}
+```
+
+---
+
+## License
+
+BSD-3-Clause. See [LICENSE](https://github.com/sj817/shotium/blob/main/LICENSE) for details.

package/dist/daemon_main.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/daemon_main.js

@@ -0,0 +1,322 @@
+import { a as resolveStartOptions, i as endpointFor, n as FrameReader, r as encodeFrame, t as Pool } from "./pool-BSgS6vkr.js";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import net from "node:net";
+
+//#region src/lib/daemon.ts
+const VERSION = (() => {
+	try {
+		const manifest = fs.readFileSync(new URL("../package.json", import.meta.url), "utf8");
+		return JSON.parse(manifest).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+})();
+const SUPERVISOR_MARGIN_MS = 1e4;
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+var Daemon = class extends EventEmitter {
+	options;
+	endpointPath;
+	idleTimeoutMs;
+	prewarmOnStart;
+	pool = null;
+	server = null;
+	sockets = /* @__PURE__ */ new Set();
+	inFlight = 0;
+	served = 0;
+	warmed = false;
+	startedAt = Date.now();
+	idleTimer = null;
+	closing = false;
+	constructor(options = {}) {
+		super();
+		this.options = resolveStartOptions(options);
+		this.endpointPath = endpointFor({
+			...this.options,
+			name: options.name,
+			endpoint: options.endpoint
+		});
+		this.idleTimeoutMs = options.idleTimeoutMs === void 0 ? DEFAULT_IDLE_TIMEOUT_MS : options.idleTimeoutMs;
+		this.prewarmOnStart = options.prewarm !== false;
+	}
+	get endpoint() {
+		return this.endpointPath;
+	}
+	get warm() {
+		return this.warmed;
+	}
+	async listen() {
+		const pool = new Pool(this.options);
+		this.pool = pool;
+		for (const event of [
+			"exit",
+			"crash",
+			"timeout",
+			"worker-restart",
+			"worker-error",
+			"stderr"
+		]) pool.on(event, (payload) => this.emit(event, payload));
+		pool.start();
+		this.server = net.createServer((socket) => this.accept(socket));
+		this.server.on("error", (error) => this.emit("error", error));
+		await this.bind();
+		this.armIdleTimer();
+		this.emit("ready", {
+			endpoint: this.endpointPath,
+			workers: this.options.workers
+		});
+		if (this.prewarmOnStart) await this.prewarm();
+		return this;
+	}
+	bind() {
+		return new Promise((resolve, reject) => {
+			const server = this.server;
+			const onError = (error) => {
+				if (error.code === "EADDRINUSE" && process.platform !== "win32") {
+					const probe = net.connect(this.endpointPath);
+					probe.on("connect", () => {
+						probe.destroy();
+						reject(error);
+					});
+					probe.on("error", () => {
+						try {
+							fs.unlinkSync(this.endpointPath);
+						} catch {
+							reject(error);
+							return;
+						}
+						server.listen(this.endpointPath, () => {
+							this.restrict();
+							resolve();
+						});
+					});
+					return;
+				}
+				reject(error);
+			};
+			server.once("error", onError);
+			server.listen(this.endpointPath, () => {
+				server.removeListener("error", onError);
+				this.restrict();
+				resolve();
+			});
+		});
+	}
+	restrict() {
+		if (process.platform === "win32") return;
+		try {
+			fs.chmodSync(this.endpointPath, 384);
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+	async prewarm() {
+		const blank = "data:text/html,<!doctype html><title>shotium</title>";
+		await Promise.all(Array.from({ length: this.options.workers }, () => {
+			return this.pool.submit({
+				file: blank,
+				width: 16,
+				height: 16
+			}, {
+				timeout: 4e4,
+				retry: 1
+			}).catch(() => null);
+		}));
+		this.warmed = true;
+		this.emit("warm", { workers: this.options.workers });
+	}
+	status() {
+		return {
+			ok: true,
+			pid: process.pid,
+			endpoint: this.endpointPath,
+			binary: this.options.binary,
+			workers: this.options.workers,
+			cacheDir: this.options.cacheDir,
+			args: this.options.args,
+			warm: this.warmed,
+			uptimeMs: Date.now() - this.startedAt,
+			connections: this.sockets.size,
+			inFlight: this.inFlight,
+			served: this.served,
+			idleTimeoutMs: this.idleTimeoutMs,
+			version: VERSION
+		};
+	}
+	accept(socket) {
+		socket.on("error", () => socket.destroy());
+		this.sockets.add(socket);
+		this.armIdleTimer();
+		const reader = new FrameReader();
+		socket.on("data", (chunk) => {
+			reader.push(chunk);
+			for (;;) {
+				const frame = reader.next();
+				if (frame === null) return;
+				this.dispatch(socket, frame);
+			}
+		});
+		socket.on("close", () => {
+			this.sockets.delete(socket);
+			this.armIdleTimer();
+		});
+	}
+	dispatch(socket, frame) {
+		let message;
+		try {
+			message = JSON.parse(frame.toString("utf8"));
+		} catch {
+			this.reply(socket, {
+				id: null,
+				ok: false,
+				error: "shotium: request is not JSON"
+			});
+			return;
+		}
+		const id = message.id === void 0 ? null : message.id;
+		const op = message.op || "screenshot";
+		if (op === "status") {
+			this.reply(socket, {
+				...this.status(),
+				id
+			});
+			return;
+		}
+		if (op === "ping") {
+			this.reply(socket, {
+				id,
+				ok: true
+			});
+			return;
+		}
+		if (op === "shutdown") {
+			this.reply(socket, {
+				id,
+				ok: true,
+				stopping: true
+			});
+			socket.end(() => void this.close());
+			return;
+		}
+		if (op !== "screenshot") {
+			this.reply(socket, {
+				id,
+				ok: false,
+				error: `shotium: unknown op "${op}"`
+			});
+			return;
+		}
+		const request = message.request || {};
+		const timeout = (typeof message.timeout === "number" ? message.timeout : DEFAULT_TIMEOUT_MS) + SUPERVISOR_MARGIN_MS;
+		const retry = typeof message.retry === "number" ? message.retry : 0;
+		this.inFlight += 1;
+		this.armIdleTimer();
+		this.emit("request", {
+			id,
+			file: request.file
+		});
+		this.pool.submit(request, {
+			timeout,
+			retry
+		}).then((result) => {
+			this.served += 1;
+			this.reply(socket, {
+				id,
+				ok: true,
+				bytes: result.image ? result.image.length : 0,
+				path: result.header ? result.header.path : void 0
+			}, result.image);
+		}).catch((error) => {
+			this.reply(socket, {
+				id,
+				ok: false,
+				error: String(error.message || error)
+			});
+		}).finally(() => {
+			this.inFlight -= 1;
+			this.emit("response", { id });
+			this.armIdleTimer();
+		});
+	}
+	reply(socket, header, payload) {
+		if (socket.destroyed) return;
+		socket.write(encodeFrame(Buffer.from(JSON.stringify(header), "utf8")));
+		socket.write(encodeFrame(payload || Buffer.alloc(0)));
+	}
+	armIdleTimer() {
+		if (this.idleTimer) {
+			clearTimeout(this.idleTimer);
+			this.idleTimer = null;
+		}
+		if (!this.idleTimeoutMs || this.closing) return;
+		if (this.sockets.size > 0 || this.inFlight > 0) return;
+		this.idleTimer = setTimeout(() => {
+			this.emit("idle-exit", { idleTimeoutMs: this.idleTimeoutMs });
+			this.close();
+		}, this.idleTimeoutMs);
+		this.idleTimer.unref();
+	}
+	async close() {
+		if (this.closing) return;
+		this.closing = true;
+		if (this.idleTimer) {
+			clearTimeout(this.idleTimer);
+			this.idleTimer = null;
+		}
+		for (const socket of this.sockets) socket.destroy();
+		this.sockets.clear();
+		await new Promise((resolve) => this.server.close(() => resolve()));
+		await this.pool.stop();
+		this.emit("close", {});
+	}
+};
+
+//#endregion
+//#region src/daemon_main.ts
+async function main() {
+	const encoded = process.argv[2];
+	if (!encoded) {
+		process.stderr.write("shotium: daemon_main expects a base64 config\n");
+		process.exit(2);
+	}
+	const options = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+	const daemon = new Daemon(options);
+	daemon.on("stderr", ({ worker, line }) => {
+		process.stderr.write(`shotium worker ${worker}: ${line}\n`);
+	});
+	for (const event of [
+		"crash",
+		"timeout",
+		"worker-restart",
+		"worker-error",
+		"idle-exit"
+	]) daemon.on(event, (payload) => {
+		const detail = payload && payload.error ? {
+			...payload,
+			error: String(payload.error.message ?? payload.error)
+		} : payload;
+		process.stderr.write(`shotium daemon ${event}: ${JSON.stringify(detail)}\n`);
+	});
+	daemon.on("error", (error) => {
+		process.stderr.write(`shotium daemon error: ${error && error.message || error}\n`);
+	});
+	try {
+		await daemon.listen();
+	} catch (error) {
+		if (error?.code === "EADDRINUSE") process.exit(0);
+		process.stderr.write(`shotium: daemon failed to start: ${error}\n`);
+		process.exit(1);
+	}
+	const shutdown = () => {
+		daemon.close().then(() => process.exit(0), () => process.exit(1));
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+	daemon.on("close", () => process.exit(0));
+}
+main();
+
+//#endregion
+export {  };
+//# sourceMappingURL=daemon_main.js.map

package/dist/daemon_main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon_main.js","names":[],"sources":["../src/lib/daemon.ts","../src/daemon_main.ts"],"sourcesContent":["import {EventEmitter} from 'node:events';\nimport fs from 'node:fs';\nimport net from 'node:net';\n\nimport type {DaemonOptions, DaemonStatus} from '../types.js';\n\nimport {resolveStartOptions} from './config.js';\nimport type {ResolvedStartOptions} from './config.js';\nimport {endpointFor} from './endpoint.js';\nimport {Pool} from './pool.js';\nimport {FrameReader, encodeFrame} from './protocol.js';\nimport type {WireRequest} from './request.js';\n\n// Our own version, for status(). Read rather than imported: an import\n// attribute would do it too, but only on a node new enough that this package\n// would not run on the rest. The URL is relative to the built module, which\n// sits one directory below the manifest.\nconst VERSION = (() => {\n  try {\n    const manifest =\n        fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8');\n    return (JSON.parse(manifest) as {version?: string}).version ?? '0.0.0';\n  } catch {\n    return '0.0.0';\n  }\n})();\n\n// How much longer than the page's own deadline the daemon waits before it\n// decides a worker is not going to answer at all. Same margin, same reasoning\n// as index.ts: the worker fails a slow page by itself and replies.\nconst SUPERVISOR_MARGIN_MS = 10000;\nconst DEFAULT_TIMEOUT_MS = 30000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 300000;\n\n// One message off the socket. `op` defaults to screenshot because that is what\n// almost every message is.\ninterface DaemonMessage {\n  id?: number|null;\n  op?: 'screenshot'|'status'|'ping'|'shutdown';\n  request?: WireRequest;\n  timeout?: number;\n  retry?: number;\n}\n\ninterface DaemonReply {\n  id: number|null;\n  ok?: boolean;\n  error?: string;\n  bytes?: number;\n  path?: string;\n  stopping?: boolean;\n}\n\n// A worker pool that outlives the process that asked for it.\n//\n// The pool in index.ts is already resident, but only for as long as the Node\n// process holding it: a command-line invocation, a CI step, a serverless\n// handler and a `node -e` all pay for starting workers and then throw them\n// away. This is the same pool behind a socket, so the second caller -- in a\n// different process, minutes later -- pays a connect() and nothing else.\n//\n// The wire format is the worker's own, one level up: a request frame of JSON,\n// answered by a header frame and a payload frame. What it adds is `id`, so one\n// connection can have several requests in flight; the worker protocol cannot,\n// because a worker renders one document at a time, and multiplexing is exactly\n// what the pool in the middle is for.\n//\n//   ->  [len][{\"id\":7,\"op\":\"screenshot\",\"request\":{...}}]\n//   <-  [len][{\"id\":7,\"ok\":true,\"bytes\":97756}]  [len][<PNG>]\n//\n// Events: ready, request, response, idle-exit, error, plus the pool's own.\nclass Daemon extends EventEmitter {\n  private readonly options: ResolvedStartOptions;\n  private readonly endpointPath: string;\n  private readonly idleTimeoutMs: number;\n  private readonly prewarmOnStart: boolean;\n  private pool: Pool|null = null;\n  private server: net.Server|null = null;\n  private sockets = new Set<net.Socket>();\n  private inFlight = 0;\n  private served = 0;\n  private warmed = false;\n  private startedAt = Date.now();\n  private idleTimer: NodeJS.Timeout|null = null;\n  private closing = false;\n\n  constructor(options: DaemonOptions = {}) {\n    super();\n    this.options = resolveStartOptions(options);\n    this.endpointPath = endpointFor({\n      ...this.options,\n      name: options.name,\n      endpoint: options.endpoint,\n    });\n    this.idleTimeoutMs = options.idleTimeoutMs === undefined ?\n        DEFAULT_IDLE_TIMEOUT_MS :\n        options.idleTimeoutMs;\n    this.prewarmOnStart = options.prewarm !== false;\n  }\n\n  get endpoint(): string {\n    return this.endpointPath;\n  }\n\n  get warm(): boolean {\n    return this.warmed;\n  }\n\n  // Brings the pool up and starts listening. The pipe existing *is* the\n  // readiness signal -- a client's connect() either succeeds or the daemon is\n  // not up -- so nothing is bound until the pool has been asked to start.\n  async listen(): Promise<this> {\n    const pool = new Pool(this.options);\n    this.pool = pool;\n    for (const event of ['exit', 'crash', 'timeout', 'worker-restart',\n                         'worker-error', 'stderr']) {\n      pool.on(event, (payload) => this.emit(event, payload));\n    }\n    pool.start();\n\n    this.server = net.createServer((socket) => this.accept(socket));\n    this.server.on('error', (error) => this.emit('error', error));\n    await this.bind();\n    this.armIdleTimer();\n    this.emit('ready',\n              {endpoint: this.endpointPath, workers: this.options.workers});\n    if (this.prewarmOnStart) {\n      await this.prewarm();\n    }\n    return this;\n  }\n\n  private bind(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const server = this.server!;\n      const onError = (error: NodeJS.ErrnoException) => {\n        // A unix socket file outlives the process that made it, so EADDRINUSE\n        // means either a live daemon or a leftover path. Connecting is the only\n        // way to tell them apart: refused means nobody is home, and the file\n        // can go.\n        if (error.code === 'EADDRINUSE' && process.platform !== 'win32') {\n          const probe = net.connect(this.endpointPath);\n          probe.on('connect', () => {\n            probe.destroy();\n            reject(error);\n          });\n          probe.on('error', () => {\n            try {\n              fs.unlinkSync(this.endpointPath);\n            } catch {\n              reject(error);\n              return;\n            }\n            server.listen(this.endpointPath, () => {\n              this.restrict();\n              resolve();\n            });\n          });\n          return;\n        }\n        reject(error);\n      };\n      server.once('error', onError);\n      server.listen(this.endpointPath, () => {\n        server.removeListener('error', onError);\n        this.restrict();\n        resolve();\n      });\n    });\n  }\n\n  // Who may talk to this daemon.\n  //\n  // It matters because a request may set `allowFileAccess`, so a stranger who\n  // can connect can have a document read this machine's filesystem and get the\n  // result back as a picture. On POSIX the socket is a file and 0600 says only\n  // its owner may connect.\n  //\n  // On Windows it is a named pipe, and node exposes no way to give one an ACL:\n  // the default lets any account on the machine open it. A daemon on a shared\n  // Windows host is therefore as trusted as the machine's users are -- render\n  // in-process, or with a binary that has no file access, if that is not\n  // acceptable.\n  private restrict(): void {\n    if (process.platform === 'win32') {\n      return;\n    }\n    try {\n      fs.chmodSync(this.endpointPath, 0o600);\n    } catch (error) {\n      this.emit('error', error);\n    }\n  }\n\n  // Renders one throwaway document per worker so that the first real request\n  // does not pay for whatever each process initialises lazily. The pool hands\n  // one request to each free worker, and there are exactly as many requests as\n  // workers, so every process is touched.\n  //\n  // `data:` rather than a file, because a daemon started without\n  // --allow-file-access would otherwise be prewarmed by a request it refuses.\n  async prewarm(): Promise<void> {\n    const blank = 'data:text/html,<!doctype html><title>shotium</title>';\n    await Promise.all(Array.from({length: this.options.workers}, () => {\n      return this.pool!\n          .submit({file: blank, width: 16, height: 16},\n                  {timeout: DEFAULT_TIMEOUT_MS + SUPERVISOR_MARGIN_MS, retry: 1})\n          .catch(() => null);\n    }));\n    this.warmed = true;\n    this.emit('warm', {workers: this.options.workers});\n  }\n\n  status(): DaemonStatus {\n    return {\n      ok: true,\n      pid: process.pid,\n      endpoint: this.endpointPath,\n      binary: this.options.binary,\n      workers: this.options.workers,\n      cacheDir: this.options.cacheDir,\n      args: this.options.args,\n      warm: this.warmed,\n      uptimeMs: Date.now() - this.startedAt,\n      connections: this.sockets.size,\n      inFlight: this.inFlight,\n      served: this.served,\n      idleTimeoutMs: this.idleTimeoutMs,\n      version: VERSION,\n    };\n  }\n\n  private accept(socket: net.Socket): void {\n    socket.on('error', () => socket.destroy());\n    this.sockets.add(socket);\n    this.armIdleTimer();\n\n    const reader = new FrameReader();\n    socket.on('data', (chunk: Buffer) => {\n      reader.push(chunk);\n      for (;;) {\n        const frame = reader.next();\n        if (frame === null) {\n          return;\n        }\n        this.dispatch(socket, frame);\n      }\n    });\n    socket.on('close', () => {\n      this.sockets.delete(socket);\n      this.armIdleTimer();\n    });\n  }\n\n  private dispatch(socket: net.Socket, frame: Buffer): void {\n    let message: DaemonMessage;\n    try {\n      message = JSON.parse(frame.toString('utf8')) as DaemonMessage;\n    } catch {\n      this.reply(\n          socket, {id: null, ok: false, error: 'shotium: request is not JSON'});\n      return;\n    }\n\n    const id = message.id === undefined ? null : message.id;\n    const op = message.op || 'screenshot';\n    if (op === 'status') {\n      this.reply(socket, {...this.status(), id});\n      return;\n    }\n    if (op === 'ping') {\n      this.reply(socket, {id, ok: true});\n      return;\n    }\n    if (op === 'shutdown') {\n      this.reply(socket, {id, ok: true, stopping: true});\n      // After the reply is on the wire, not before: a client that asked for a\n      // shutdown is entitled to hear that it happened.\n      socket.end(() => void this.close());\n      return;\n    }\n    if (op !== 'screenshot') {\n      this.reply(socket, {id, ok: false, error: `shotium: unknown op \"${op}\"`});\n      return;\n    }\n\n    const request = message.request || ({} as WireRequest);\n    const timeout = (typeof message.timeout === 'number' ? message.timeout :\n                                                           DEFAULT_TIMEOUT_MS) +\n        SUPERVISOR_MARGIN_MS;\n    const retry = typeof message.retry === 'number' ? message.retry : 0;\n\n    this.inFlight += 1;\n    this.armIdleTimer();\n    this.emit('request', {id, file: request.file});\n    this.pool!.submit(request, {timeout, retry})\n        .then((result) => {\n          this.served += 1;\n          this.reply(\n              socket,\n              {\n                id,\n                ok: true,\n                bytes: result.image ? result.image.length : 0,\n                path: result.header ? result.header.path : undefined,\n              },\n              result.image);\n        })\n        .catch((error: Error) => {\n          this.reply(\n              socket, {id, ok: false, error: String(error.message || error)});\n        })\n        .finally(() => {\n          this.inFlight -= 1;\n          this.emit('response', {id});\n          this.armIdleTimer();\n        });\n  }\n\n  private reply(\n      socket: net.Socket, header: DaemonReply|(DaemonStatus&{id: number|null}),\n      payload?: Buffer|null): void {\n    if (socket.destroyed) {\n      return;\n    }\n    socket.write(encodeFrame(Buffer.from(JSON.stringify(header), 'utf8')));\n    socket.write(encodeFrame(payload || Buffer.alloc(0)));\n  }\n\n  // Idle is \"nobody connected and nothing rendering\". A client that holds its\n  // socket open -- a long-lived service using connect() -- keeps the daemon\n  // alive without having to poll it.\n  private armIdleTimer(): void {\n    if (this.idleTimer) {\n      clearTimeout(this.idleTimer);\n      this.idleTimer = null;\n    }\n    if (!this.idleTimeoutMs || this.closing) {\n      return;\n    }\n    if (this.sockets.size > 0 || this.inFlight > 0) {\n      return;\n    }\n    this.idleTimer = setTimeout(() => {\n      this.emit('idle-exit', {idleTimeoutMs: this.idleTimeoutMs});\n      void this.close();\n    }, this.idleTimeoutMs);\n    this.idleTimer.unref();\n  }\n\n  async close(): Promise<void> {\n    if (this.closing) {\n      return;\n    }\n    this.closing = true;\n    if (this.idleTimer) {\n      clearTimeout(this.idleTimer);\n      this.idleTimer = null;\n    }\n    for (const socket of this.sockets) {\n      socket.destroy();\n    }\n    this.sockets.clear();\n    await new Promise<void>((resolve) => this.server!.close(() => resolve()));\n    await this.pool!.stop();\n    this.emit('close', {});\n  }\n}\n\nexport {Daemon, DEFAULT_IDLE_TIMEOUT_MS};\n","// The entry point of a detached daemon process.\n//\n// The configuration arrives as one base64 argument rather than as flags,\n// because it contains paths that a Windows command line would otherwise quote\n// badly, and because the client and the daemon have to agree on it exactly:\n// the endpoint is a hash of these fields, so a value mangled in transit would\n// produce a daemon listening where nobody looks. See endpoint.ts.\n//\n// It is a build entry of its own, and not a chunk, because lib/client.ts\n// spawns it by path -- `node dist/daemon_main.js <base64 json>` -- and a name\n// the bundler chose would be a name that changes.\n\nimport {Daemon} from './lib/daemon.js';\nimport type {DaemonOptions} from './types.js';\n\nasync function main(): Promise<void> {\n  const encoded = process.argv[2];\n  if (!encoded) {\n    process.stderr.write('shotium: daemon_main expects a base64 config\\n');\n    process.exit(2);\n  }\n  const options = JSON.parse(Buffer.from(encoded, 'base64').toString('utf8')) as\n      DaemonOptions;\n  const daemon = new Daemon(options);\n\n  daemon.on('stderr', ({worker, line}: {worker: number, line: string}) => {\n    process.stderr.write(`shotium worker ${worker}: ${line}\\n`);\n  });\n  for (const event of ['crash', 'timeout', 'worker-restart', 'worker-error',\n                       'idle-exit']) {\n    daemon.on(event, (payload: {error?: unknown}) => {\n      // An Error does not survive JSON.stringify -- it comes out as {} -- and\n      // its message is the whole point of logging a worker that would not\n      // start.\n      const detail = payload && payload.error ?\n          {\n            ...payload,\n            error: String(\n                (payload.error as Error).message ?? payload.error),\n          } :\n          payload;\n      process.stderr.write(\n          `shotium daemon ${event}: ${JSON.stringify(detail)}\\n`);\n    });\n  }\n  // An 'error' with nobody listening is thrown by EventEmitter itself, which\n  // would turn a socket that failed after binding -- something the daemon can\n  // survive -- into a dead pool.\n  daemon.on('error', (error: Error) => {\n    process.stderr.write(\n        `shotium daemon error: ${(error && error.message) || error}\\n`);\n  });\n\n  try {\n    await daemon.listen();\n  } catch (error) {\n    // Losing the race to bind is the ordinary outcome when two clients start a\n    // daemon at the same moment: the other one is up, this one is not needed,\n    // and the client that spawned it will connect to the winner. Anything else\n    // is a real failure and says so.\n    if ((error as NodeJS.ErrnoException | null)?.code === 'EADDRINUSE') {\n      process.exit(0);\n    }\n    process.stderr.write(`shotium: daemon failed to start: ${error}\\n`);\n    process.exit(1);\n  }\n\n  const shutdown = () => {\n    daemon.close().then(() => process.exit(0), () => process.exit(1));\n  };\n  process.on('SIGINT', shutdown);\n  process.on('SIGTERM', shutdown);\n  daemon.on('close', () => process.exit(0));\n}\n\nvoid main();\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,135 @@
+import { a as PageGotoParams, c as StartOptions, l as Viewport, n as DaemonOptions, o as PurgeOptions, r as DaemonStatus, s as ScreenshotOptions, t as Clip, u as WorkerEvent } from "./types-x9HtkzeE.js";
+import { EventEmitter } from "node:events";
+import net from "node:net";
+//#region src/lib/client.d.ts
+interface ClientReply {
+  id: number;
+  ok?: boolean;
+  error?: string;
+  path?: string;
+}
+interface ClientResult {
+  header: ClientReply;
+  image: Buffer | null;
+}
+declare class DaemonClient extends EventEmitter {
+  private readonly socket;
+  private readonly endpointPath;
+  private readonly pending;
+  private nextId;
+  private header;
+  private reader;
+  constructor(socket: net.Socket, endpoint: string);
+  get endpoint(): string;
+  get closed(): boolean;
+  private onData;
+  private settle;
+  private failAll;
+  send(message: Record<string, unknown>): Promise<ClientResult>;
+  /** Resolves to the image, or to null when `path` was given. */
+  screenshot(options: ScreenshotOptions): Promise<Buffer | null>;
+  status(): Promise<DaemonStatus>;
+  shutdown(): Promise<{
+    ok: boolean;
+  }>;
+  close(): void;
+}
+//#endregion
+//#region src/index.d.ts
+/** The five things a caller does with the resident pool. */
+interface Daemon {
+  /** Connects, starting a daemon if none is listening. */
+  connect(options?: DaemonOptions): Promise<DaemonClient>;
+  /** One screenshot through the daemon, connection and all. */
+  screenshot(options: ScreenshotOptions & {
+    daemon?: DaemonOptions;
+  }): Promise<Buffer | null>;
+  /** Starts one if it is not up, and reports what is there either way. */
+  start(options?: DaemonOptions): Promise<DaemonStatus & {
+    spawned: boolean;
+  }>;
+  status(options?: DaemonOptions): Promise<Partial<DaemonStatus> & {
+    running: boolean;
+    endpoint: string;
+  }>;
+  stop(options?: DaemonOptions): Promise<{
+    stopped: boolean;
+    endpoint: string;
+  }>;
+}
+interface Runtime {
+  on(event: 'ready', listener: (info: {
+    workers: number;
+  }) => void): this;
+  on(event: 'exit', listener: (event: WorkerEvent) => void): this;
+  on(event: 'crash', listener: (event: WorkerEvent) => void): this;
+  on(event: 'timeout', listener: (event: {
+    worker: number;
+    timeout: number;
+  }) => void): this;
+  on(event: 'worker-restart', listener: (event: {
+    worker: number;
+    reason: string;
+    delay: number;
+  }) => void): this;
+  /** A worker could not be started at all -- a missing or unusable binary. */
+  on(event: 'worker-error', listener: (event: {
+    worker: number;
+    error: Error;
+  }) => void): this;
+  on(event: 'stderr', listener: (event: {
+    worker: number;
+    line: string;
+  }) => void): this;
+}
+/**
+ * The library's one runtime: a pool of worker processes plus its lifecycle.
+ *
+ * `runtime` below is the singleton, because the expensive part is the
+ * processes and a second runtime would double them for no gain. Anyone who
+ * genuinely wants two constructs a Runtime directly.
+ *
+ * Its pool lives and dies with this process. `daemon` is the same pool behind
+ * a socket, for callers whose process does not live long enough to be worth
+ * starting one.
+ */
+declare class Runtime extends EventEmitter {
+  private pool;
+  get running(): boolean;
+  /**
+   * Starts the pool. Safe to call twice; the second call is a no-op, so that
+   * library code can call it defensively.
+   *
+   * Every option has a default: the binary is `$SHOTIUM_BINARY`, then the
+   * platform package, then `./bin/shotium.exe`; the worker count is half the
+   * cores, at least one and at most four; the cache root is a directory under
+   * the system temp, and `null` disables caching.
+   */
+  start(options?: StartOptions): this;
+  /** Stops every worker. The pool can be started again afterwards. */
+  stop(): Promise<void>;
+  /**
+   * Renders one screenshot. Resolves to the encoded image, or to `null` when
+   * `path` was given and the worker wrote the file itself.
+   */
+  screenshot(options: ScreenshotOptions): Promise<Buffer | null>;
+}
+/** The shared pool: one per process, started on first use. */
+declare const runtime: Runtime;
+/** One screenshot through the shared pool, starting it if it is not up. */
+declare const screenshot: (options: ScreenshotOptions) => Promise<Buffer | null>;
+/**
+ * The resident pool: workers that outlive the process that started them,
+ * reachable over a named pipe on Windows and a unix socket elsewhere. For
+ * callers that are short-lived themselves. See lib/daemon.ts.
+ */
+declare const daemon: Daemon;
+declare const _default: {
+  Runtime: typeof Runtime;
+  runtime: Runtime;
+  screenshot: (options: ScreenshotOptions) => Promise<Buffer | null>;
+  daemon: Daemon;
+};
+//#endregion
+export { type Clip, Daemon, type DaemonClient, type DaemonOptions, type DaemonStatus, type PageGotoParams, type PurgeOptions, Runtime, type ScreenshotOptions, type StartOptions, type Viewport, type WorkerEvent, daemon, _default as default, runtime, screenshot };
+//# sourceMappingURL=index.d.ts.map