@shotkit/shotium 0.0.1 → 0.2.0

package/README.md

@@ -1,3 +1,170 @@
 # @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.
+
+The engine is loaded into your own process as a Node-API addon over a C ABI. Nothing is spawned, no image crosses a process boundary, and `screenshot()` returns the bytes Blink just encoded.
+
+```ts
+import shotium from '@shotkit/shotium';
+
+shotium.runtime.start();
+
+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 — six of them, covering Windows, macOS and Linux on x64 and arm64. There is no build step and no postinstall download.
+
+The package is ESM. `import` works on Node 18 and up; `require()` of it needs Node 22.12 or 20.19, and anything older should use `await import('@shotkit/shotium')`.
+
+---
+
+## Usage
+
+### 1. In-Process Engine (`runtime`)
+
+```ts
+import { runtime, screenshot } from '@shotkit/shotium';
+
+runtime.start({
+  cacheDir: '/var/tmp/shotium-cache' // Optional HTTP disk cache. Default: null (off)
+});
+
+// Returns a Buffer, or null when `path` was given and the engine wrote the file
+const buffer = await screenshot({
+  file: 'https://example.com',
+  viewport: { width: 1280, height: 720 },
+  type: 'webp',
+  quality: 85,
+});
+
+// Hand memory back between batches without giving up the engine
+runtime.purge({ releaseWorkingSet: true });
+
+await runtime.stop();
+```
+
+**One engine per process, ever, and not one at a time.** Starting Blink writes process-wide statics it has no path to undo, so `stop()` is final: a `start()` after it throws, and so does a second `Runtime`. Concurrent callers are queued and served one at a time, because there is one renderer. Parallelism is therefore more processes, and a program that will want another screenshot later should stay started and call `purge()` rather than stopping.
+
+#### `StartOptions`
+
+```ts
+interface StartOptions {
+  /** Root of the HTTP disk cache. null (the default) disables caching. */
+  cacheDir?: string | null;
+
+  /** User-Agent sent with every request. */
+  userAgent?: string;
+
+  /** Where the engine looks for its resource packs. Defaults to the
+   *  directory the addon was loaded from, which is right for an install. */
+  resourceDir?: string;
+}
+```
+
+---
+
+### 2. Resident Daemon (`daemon`)
+
+Recommended for CLI tools, ephemeral CI tasks, or serverless workers where startup latency is critical.
+
+The daemon is the same engine in a process of its own, behind a local socket (Named Pipe on Windows, Unix domain socket on POSIX). It renders a blank page on start, so it is warm before the first real request arrives.
+
+```ts
+import { daemon } from '@shotkit/shotium';
+
+// Connect to an existing daemon (automatically starts one if none is running)
+const client = await daemon.connect();
+
+const png = await client.screenshot({
+  file: 'https://example.com',
+  viewport: { width: 1280, height: 720 },
+});
+
+client.close();
+
+// Check status or stop the daemon
+const status = await daemon.status(); // { running: true, pid: 12345, warm: true, ... }
+await daemon.stop();
+```
+
+One connection may have several requests outstanding, because every message carries an `id`. That is a convenience for the client rather than concurrency: the daemon holds one renderer too, and answers in the order it finished them. Two at once means two daemons, told apart by `name`.
+
+---
+
+## 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;
+}
+```
+
+An option this interface does not list is a typo, and a typo that was quietly dropped is a screenshot that ignored what you asked for — so an unknown key is a `TypeError` rather than a silent no-op. `fullPage`, `selector` and `clip` are mutually exclusive.
+
+---
+
+## 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,305 @@
+import { a as encodeFrame, i as FrameReader, o as endpointFor, s as resolveStartOptions, t as Engine } from "./engine-Xe7nH-1i.js";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import os from "node:os";
+
+//#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 DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+var Daemon = class extends EventEmitter {
+	options;
+	endpointPath;
+	idleTimeoutMs;
+	prewarmOnStart;
+	engine = new Engine();
+	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() {
+		this.engine.start(this.options);
+		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 });
+		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 = path.join(os.tmpdir(), `shotium-prewarm-${process.pid}.html`);
+		try {
+			fs.writeFileSync(blank, "<!doctype html><title>shotium</title><p>shotium");
+			await this.engine.capture({
+				file: blank,
+				width: 16,
+				height: 16
+			});
+			this.warmed = true;
+		} catch (error) {
+			this.emit("error", error);
+		} finally {
+			fs.rmSync(blank, { force: true });
+		}
+		this.emit("warm", { warm: this.warmed });
+	}
+	status() {
+		return {
+			ok: true,
+			pid: process.pid,
+			endpoint: this.endpointPath,
+			cacheDir: this.options.cacheDir,
+			userAgent: this.options.userAgent,
+			resourceDir: this.options.resourceDir,
+			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 || {};
+		this.inFlight += 1;
+		this.armIdleTimer();
+		this.emit("request", {
+			id,
+			file: request.file
+		});
+		this.engine.capture(request).then((image) => {
+			this.served += 1;
+			this.reply(socket, {
+				id,
+				ok: true,
+				bytes: image ? image.length : 0,
+				path: request.path
+			}, 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.engine.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';\nimport os from 'node:os';\nimport path from 'node:path';\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 {Engine} from './engine.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\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// An engine that outlives the process that asked for it.\n//\n// The engine 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 Blink and then throw it away.\n// This is the same engine behind a socket, so the second caller -- in a\n// different process, minutes later -- pays a connect() and nothing else.\n//\n// A request frame of JSON, answered by a header frame and a payload frame:\n//\n//   ->  [len][{\"id\":7,\"op\":\"screenshot\",\"request\":{...}}]\n//   <-  [len][{\"id\":7,\"ok\":true,\"bytes\":97756}]  [len][<PNG>]\n//\n// `id` is on the wire so that a client may have several requests outstanding\n// on one connection. That is a convenience for the client, not concurrency:\n// there is one renderer here, because Blink is a process-wide singleton, so\n// the requests queue and come back in the order the engine finished them.\n// Wanting two at once means wanting two daemons, addressed by `name`.\n//\n// Nothing supervises a capture. The pool this replaced could time a worker out\n// and kill it; an in-process engine has no such seam -- there is no way to\n// abandon a render without abandoning the process. A page's own deadline\n// (`pageGotoParams.timeout`) is what bounds it, and the engine answers slow\n// pages by itself. `timeout` and `retry` on the wire are accepted and ignored,\n// so that an older client still talks to this.\n//\n// Events: ready, warm, request, response, idle-exit, error, close.\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 readonly engine = new Engine();\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 engine 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 engine has started.\n  //\n  // Starting it here rather than on the first request is deliberate: a machine\n  // with no engine for its platform should fail while the caller is still\n  // watching, not answer a connect() and then reject every request on it.\n  async listen(): Promise<this> {\n    this.engine.start(this.options);\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', {endpoint: this.endpointPath});\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 -- use the\n  // engine in your own process, where nothing is listening, 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 so that the first real request does not pay\n  // for whatever the engine initialises lazily. One is enough: there is one\n  // renderer, and it is the same one every request lands on.\n  //\n  // A temporary file, not a `data:` URL. This used to send\n  // `data:text/html,...`, which the renderer rejects -- shot_capture.cc takes\n  // file, http and https and nothing else -- so every prewarm failed into the\n  // catch below and the step had never once done anything. The failure was\n  // invisible because a prewarm that does not work looks exactly like one that\n  // does, only slower on the first request.\n  //\n  // The document names no subresources, so it renders identically whether or\n  // not this daemon allows file access -- which is what the `data:` URL was\n  // reaching for. A top-level file: URL always loads; `allowFileAccess` gates\n  // what the document may then pull in.\n  async prewarm(): Promise<void> {\n    const blank = path.join(\n        os.tmpdir(), `shotium-prewarm-${process.pid}.html`);\n    try {\n      fs.writeFileSync(\n          blank, '<!doctype html><title>shotium</title><p>shotium');\n      await this.engine.capture({file: blank, width: 16, height: 16});\n      this.warmed = true;\n    } catch (error) {\n      // Not fatal: a daemon that could not prewarm still serves. But it is not\n      // warm, and status() should not claim it is.\n      this.emit('error', error);\n    } finally {\n      fs.rmSync(blank, {force: true});\n    }\n    this.emit('warm', {warm: this.warmed});\n  }\n\n  status(): DaemonStatus {\n    return {\n      ok: true,\n      pid: process.pid,\n      endpoint: this.endpointPath,\n      cacheDir: this.options.cacheDir,\n      userAgent: this.options.userAgent,\n      resourceDir: this.options.resourceDir,\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\n    this.inFlight += 1;\n    this.armIdleTimer();\n    this.emit('request', {id, file: request.file});\n    this.engine.capture(request)\n        .then((image) => {\n          this.served += 1;\n          this.reply(\n              socket,\n              {\n                id,\n                ok: true,\n                bytes: image ? image.length : 0,\n                path: request.path,\n              },\n              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.engine.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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"}