@shotkit/shotium 0.0.1 → 0.2.0

package/dist/index.js

@@ -0,0 +1,355 @@
+import { a as encodeFrame, i as FrameReader, n as timeoutFor, o as endpointFor, r as toRequest, s as resolveStartOptions, t as Engine } from "./engine-Xe7nH-1i.js";
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/lib/client.ts
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const DAEMON_MAIN = path.join(HERE, "daemon_main.js");
+const START_TIMEOUT_MS = 2e4;
+const CONNECT_RETRY_MS = 20;
+var DaemonClient = class extends EventEmitter {
+	socket;
+	endpointPath;
+	pending = /* @__PURE__ */ new Map();
+	nextId = 1;
+	header = null;
+	reader = new FrameReader();
+	constructor(socket, endpoint) {
+		super();
+		this.socket = socket;
+		this.endpointPath = endpoint;
+		socket.on("data", (chunk) => this.onData(chunk));
+		socket.on("error", (error) => this.failAll(error));
+		socket.on("close", () => {
+			this.failAll(/* @__PURE__ */ new Error("shotium: the daemon closed the connection"));
+			this.emit("close", {});
+		});
+	}
+	get endpoint() {
+		return this.endpointPath;
+	}
+	get closed() {
+		return this.socket.destroyed;
+	}
+	onData(chunk) {
+		this.reader.push(chunk);
+		for (;;) {
+			const frame = this.reader.next();
+			if (frame === null) return;
+			if (this.header === null) {
+				try {
+					this.header = JSON.parse(frame.toString("utf8"));
+				} catch {
+					this.failAll(/* @__PURE__ */ new Error("shotium: the daemon sent a header that is not JSON"));
+					return;
+				}
+				continue;
+			}
+			const header = this.header;
+			this.header = null;
+			this.settle(header, frame);
+		}
+	}
+	settle(header, payload) {
+		const pending = this.pending.get(header.id);
+		if (!pending) return;
+		this.pending.delete(header.id);
+		if (header.ok) pending.resolve({
+			header,
+			image: header.path ? null : payload
+		});
+		else pending.reject(new Error(header.error || "shotium: request failed"));
+	}
+	failAll(error) {
+		for (const [, pending] of this.pending) pending.reject(error);
+		this.pending.clear();
+	}
+	send(message) {
+		return new Promise((resolve, reject) => {
+			if (this.socket.destroyed) {
+				reject(/* @__PURE__ */ new Error("shotium: not connected to a daemon"));
+				return;
+			}
+			const id = this.nextId++;
+			this.pending.set(id, {
+				resolve,
+				reject
+			});
+			this.socket.write(encodeFrame(Buffer.from(JSON.stringify({
+				...message,
+				id
+			}), "utf8")));
+		});
+	}
+	/** Resolves to the image, or to null when `path` was given. */
+	async screenshot(options) {
+		const request = toRequest(options);
+		return (await this.send({
+			op: "screenshot",
+			request,
+			timeout: timeoutFor(options)
+		})).image;
+	}
+	async status() {
+		const { header } = await this.send({ op: "status" });
+		return header;
+	}
+	async shutdown() {
+		const { header } = await this.send({ op: "shutdown" });
+		return { ok: header.ok === true };
+	}
+	close() {
+		this.socket.end();
+		this.socket.destroy();
+	}
+};
+function connectOnly(endpoint) {
+	return new Promise((resolve, reject) => {
+		const socket = net.connect(endpoint);
+		const onError = (error) => {
+			socket.destroy();
+			reject(error);
+		};
+		socket.once("error", onError);
+		socket.once("connect", () => {
+			socket.removeListener("error", onError);
+			resolve(new DaemonClient(socket, endpoint));
+		});
+	});
+}
+function resolveDaemonOptions(options = {}) {
+	const resolved = resolveStartOptions(options);
+	return {
+		...resolved,
+		name: options.name,
+		endpoint: endpointFor({
+			...resolved,
+			name: options.name,
+			endpoint: options.endpoint
+		}),
+		idleTimeoutMs: options.idleTimeoutMs,
+		prewarm: options.prewarm,
+		logFile: options.logFile || process.env.SHOTIUM_DAEMON_LOG || null
+	};
+}
+function spawnDaemon(options) {
+	const config = {
+		cacheDir: options.cacheDir,
+		userAgent: options.userAgent,
+		resourceDir: options.resourceDir,
+		endpoint: options.endpoint,
+		idleTimeoutMs: options.idleTimeoutMs,
+		prewarm: options.prewarm
+	};
+	const encoded = Buffer.from(JSON.stringify(config), "utf8").toString("base64");
+	let stdio = "ignore";
+	let logFd = null;
+	if (options.logFile) {
+		logFd = fs.openSync(options.logFile, "a");
+		stdio = [
+			"ignore",
+			logFd,
+			logFd
+		];
+	}
+	spawn(process.execPath, [DAEMON_MAIN, encoded], {
+		detached: true,
+		stdio,
+		windowsHide: true
+	}).unref();
+	if (logFd !== null) fs.closeSync(logFd);
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function ensureClient(options = {}) {
+	const resolved = resolveDaemonOptions(options);
+	try {
+		return {
+			client: await connectOnly(resolved.endpoint),
+			spawned: false,
+			endpoint: resolved.endpoint
+		};
+	} catch {
+		if (options.spawn === false) throw new Error(`shotium: no daemon at ${resolved.endpoint}`);
+	}
+	spawnDaemon(resolved);
+	const deadline = Date.now() + (options.startTimeoutMs === void 0 ? START_TIMEOUT_MS : options.startTimeoutMs);
+	for (;;) try {
+		return {
+			client: await connectOnly(resolved.endpoint),
+			spawned: true,
+			endpoint: resolved.endpoint
+		};
+	} catch {
+		if (Date.now() >= deadline) throw new Error(`shotium: the daemon did not come up at ${resolved.endpoint}`);
+		await sleep(CONNECT_RETRY_MS);
+	}
+}
+async function connect(options = {}) {
+	const { client } = await ensureClient(options);
+	return client;
+}
+async function start(options = {}) {
+	const { client, spawned, endpoint } = await ensureClient(options);
+	try {
+		return {
+			...await client.status(),
+			endpoint,
+			spawned
+		};
+	} finally {
+		client.close();
+	}
+}
+async function status(options = {}) {
+	const resolved = resolveDaemonOptions(options);
+	let client;
+	try {
+		client = await connectOnly(resolved.endpoint);
+	} catch {
+		return {
+			running: false,
+			endpoint: resolved.endpoint
+		};
+	}
+	try {
+		return {
+			...await client.status(),
+			running: true
+		};
+	} finally {
+		client.close();
+	}
+}
+async function stop(options = {}) {
+	const resolved = resolveDaemonOptions(options);
+	let client;
+	try {
+		client = await connectOnly(resolved.endpoint);
+	} catch {
+		return {
+			stopped: false,
+			endpoint: resolved.endpoint
+		};
+	}
+	try {
+		await client.shutdown();
+		return {
+			stopped: true,
+			endpoint: resolved.endpoint
+		};
+	} finally {
+		client.close();
+	}
+}
+async function screenshot$1(options) {
+	const { daemon, ...rest } = options;
+	const client = await connect(daemon || {});
+	try {
+		return await client.screenshot(rest);
+	} finally {
+		client.close();
+	}
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* The engine, and its lifecycle, in this process.
+*
+*     import shotium from '@shotkit/shotium';
+*
+*     shotium.runtime.start();
+*     const png = await shotium.screenshot({file: 'https://example.com'});
+*     await shotium.runtime.stop();
+*
+* `start` and `stop` are explicit because starting Blink is the expensive part
+* -- tens of milliseconds and a working set that stays resident -- and only
+* the caller knows whether the next screenshot is coming in a moment or never.
+* Neither call is required: a screenshot starts the engine if it is not up.
+* What they buy is control over when that cost is paid, and the certainty that
+* it has been given back.
+*
+* `runtime` below is the singleton because there is nothing else it could be:
+* Blink starts once per process and cannot be restarted, so a second Runtime
+* in the same process has no engine to have. Construct one directly only to
+* own the lifecycle yourself instead of using `runtime`. Parallelism is more
+* processes, not more Runtimes.
+*
+* `daemon` is the same engine in a process of its own, behind a socket, for
+* callers whose own process does not live long enough to be worth starting
+* one.
+*/
+var Runtime = class {
+	engine = new Engine();
+	get running() {
+		return this.engine.running;
+	}
+	/**
+	* Starts the engine. Safe to call twice; the second call is a no-op, so that
+	* library code can call it defensively. Not safe after `stop()` -- see there.
+	*
+	* Every option has a default. `cacheDir` is the HTTP disk cache and `null`
+	* disables it; `resourceDir` is where `shotium_data.pak` and
+	* `shotium_strings.pak` are, and defaults to the directory the engine was
+	* loaded from, which is where they ship.
+	*/
+	start(options = {}) {
+		this.engine.start(options);
+		return this;
+	}
+	/**
+	* Stops the engine, after whatever is queued.
+	*
+	* Final for this process. Blink writes process-wide state that it has no
+	* path to undo, so starting again -- here or on another Runtime -- throws
+	* rather than quietly handing back something that cannot render. A program
+	* that wants another screenshot later should stay started and `purge()`.
+	*/
+	stop() {
+		return this.engine.stop();
+	}
+	/**
+	* Hands back what the engine is holding but can rebuild. Worth calling when
+	* a batch has ended and the next one may be a while away.
+	*/
+	purge(options = {}) {
+		this.engine.purge(options);
+	}
+	/**
+	* Renders one screenshot. Resolves to the encoded image, or to `null` when
+	* `path` was given and the engine wrote the file itself.
+	*/
+	screenshot(options) {
+		return this.engine.screenshot(options);
+	}
+};
+/** The shared engine: one per process, started on first use. */
+const runtime = new Runtime();
+/** One screenshot through the shared engine, starting it if it is not up. */
+const screenshot = (options) => runtime.screenshot(options);
+/**
+* The resident engine: a process that outlives the one that started it,
+* reachable over a named pipe on Windows and a unix socket elsewhere. For
+* callers that are short-lived themselves. See lib/daemon.ts.
+*/
+const daemon = {
+	connect,
+	screenshot: screenshot$1,
+	start,
+	status,
+	stop
+};
+var src_default = {
+	Runtime,
+	runtime,
+	screenshot,
+	daemon
+};
+
+//#endregion
+export { Runtime, daemon, src_default as default, runtime, screenshot };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["screenshot","client.connect","client.screenshot","client.start","client.status","client.stop"],"sources":["../src/lib/client.ts","../src/index.ts"],"sourcesContent":["import {spawn} from 'node:child_process';\nimport {EventEmitter} from 'node:events';\nimport fs from 'node:fs';\nimport net from 'node:net';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nimport type {\n  DaemonOptions,\n  DaemonStatus,\n  ScreenshotOptions,\n} from '../types.js';\n\nimport {resolveStartOptions} from './config.js';\nimport {endpointFor} from './endpoint.js';\nimport {FrameReader, encodeFrame} from './protocol.js';\nimport {timeoutFor, toRequest} from './request.js';\n\n// ESM has no __dirname. This is the same thing, from the module's own URL.\nconst HERE = path.dirname(fileURLToPath(import.meta.url));\n\n// The detached daemon's entry point, which is a build output beside this one.\n// It is spawned as `node <path>`, so it has to be a file on disk with a name\n// that does not move -- see tsdown.config.ts, where it is an entry of its own\n// for exactly that reason.\nconst DAEMON_MAIN = path.join(HERE, 'daemon_main.js');\n// How long to wait for a daemon this process just started to bind its\n// endpoint. Binding happens after the workers are spawned but before they are\n// warm, so this covers process startup and nothing else.\nconst START_TIMEOUT_MS = 20000;\nconst CONNECT_RETRY_MS = 20;\n\ninterface ClientReply {\n  id: number;\n  ok?: boolean;\n  error?: string;\n  path?: string;\n}\n\ninterface ClientResult {\n  header: ClientReply;\n  image: Buffer|null;\n}\n\ninterface Pending {\n  resolve: (result: ClientResult) => void;\n  reject: (error: Error) => void;\n}\n\ninterface ResolvedDaemonOptions {\n  cacheDir: string|null;\n  userAgent?: string;\n  resourceDir?: string;\n  name: string|undefined;\n  endpoint: string;\n  idleTimeoutMs: number|undefined;\n  prewarm: boolean|undefined;\n  logFile: string|null;\n}\n\n// The client half of the resident daemon.\n//\n// One connection can carry several requests at once: every message carries an\n// `id` and the answers are matched back by it, so a caller can fire ten\n// screenshots down one socket without waiting between them. They still come\n// back one at a time -- there is one renderer on the other side -- so this\n// saves the round trips, not the renders.\nclass DaemonClient extends EventEmitter {\n  private readonly socket: net.Socket;\n  private readonly endpointPath: string;\n  private readonly pending = new Map<number, Pending>();\n  private nextId = 1;\n  private header: ClientReply|null = null;\n  private reader = new FrameReader();\n\n  constructor(socket: net.Socket, endpoint: string) {\n    super();\n    this.socket = socket;\n    this.endpointPath = endpoint;\n\n    socket.on('data', (chunk: Buffer) => this.onData(chunk));\n    socket.on('error', (error: Error) => this.failAll(error));\n    socket.on('close', () => {\n      this.failAll(new Error('shotium: the daemon closed the connection'));\n      this.emit('close', {});\n    });\n  }\n\n  get endpoint(): string {\n    return this.endpointPath;\n  }\n\n  get closed(): boolean {\n    return this.socket.destroyed;\n  }\n\n  private onData(chunk: Buffer): void {\n    this.reader.push(chunk);\n    for (;;) {\n      const frame = this.reader.next();\n      if (frame === null) {\n        return;\n      }\n      if (this.header === null) {\n        try {\n          this.header = JSON.parse(frame.toString('utf8')) as ClientReply;\n        } catch {\n          this.failAll(\n              new Error('shotium: the daemon sent a header that is not JSON'));\n          return;\n        }\n        continue;\n      }\n      const header = this.header;\n      this.header = null;\n      this.settle(header, frame);\n    }\n  }\n\n  private settle(header: ClientReply, payload: Buffer): void {\n    const pending = this.pending.get(header.id);\n    if (!pending) {\n      return;\n    }\n    this.pending.delete(header.id);\n    if (header.ok) {\n      pending.resolve({header, image: header.path ? null : payload});\n    } else {\n      pending.reject(new Error(header.error || 'shotium: request failed'));\n    }\n  }\n\n  private failAll(error: Error): void {\n    for (const [, pending] of this.pending) {\n      pending.reject(error);\n    }\n    this.pending.clear();\n  }\n\n  // Sends one message and resolves with {header, image}.\n  send(message: Record<string, unknown>): Promise<ClientResult> {\n    return new Promise<ClientResult>((resolve, reject) => {\n      if (this.socket.destroyed) {\n        reject(new Error('shotium: not connected to a daemon'));\n        return;\n      }\n      const id = this.nextId++;\n      this.pending.set(id, {resolve, reject});\n      this.socket.write(\n          encodeFrame(Buffer.from(JSON.stringify({...message, id}), 'utf8')));\n    });\n  }\n\n  /** Resolves to the image, or to null when `path` was given. */\n  async screenshot(options: ScreenshotOptions): Promise<Buffer|null> {\n    const request = toRequest(options);\n    const result = await this.send({\n      op: 'screenshot',\n      request,\n      timeout: timeoutFor(options),\n    });\n    return result.image;\n  }\n\n  async status(): Promise<DaemonStatus> {\n    const {header} = await this.send({op: 'status'});\n    return header as unknown as DaemonStatus;\n  }\n\n  async shutdown(): Promise<{ok: boolean}> {\n    const {header} = await this.send({op: 'shutdown'});\n    return {ok: header.ok === true};\n  }\n\n  close(): void {\n    this.socket.end();\n    this.socket.destroy();\n  }\n}\n\n// Opens a connection to a daemon that is already listening, and fails if there\n// is not one. Nothing is spawned here: a caller that wants a daemon started\n// says so, because starting one is a side effect on the machine and not the\n// sort of thing a status query should do.\nfunction connectOnly(endpoint: string): Promise<DaemonClient> {\n  return new Promise<DaemonClient>((resolve, reject) => {\n    const socket = net.connect(endpoint);\n    const onError = (error: Error) => {\n      socket.destroy();\n      reject(error);\n    };\n    socket.once('error', onError);\n    socket.once('connect', () => {\n      socket.removeListener('error', onError);\n      resolve(new DaemonClient(socket, endpoint));\n    });\n  });\n}\n\nfunction resolveDaemonOptions(options: DaemonOptions = {}):\n    ResolvedDaemonOptions {\n  const resolved = resolveStartOptions(options);\n  return {\n    ...resolved,\n    name: options.name,\n    endpoint: endpointFor({\n      ...resolved,\n      name: options.name,\n      endpoint: options.endpoint,\n    }),\n    idleTimeoutMs: options.idleTimeoutMs,\n    prewarm: options.prewarm,\n    logFile: options.logFile || process.env.SHOTIUM_DAEMON_LOG || null,\n  };\n}\n\nfunction spawnDaemon(options: ResolvedDaemonOptions): void {\n  const config = {\n    cacheDir: options.cacheDir,\n    userAgent: options.userAgent,\n    resourceDir: options.resourceDir,\n    endpoint: options.endpoint,\n    idleTimeoutMs: options.idleTimeoutMs,\n    prewarm: options.prewarm,\n  };\n  const encoded =\n      Buffer.from(JSON.stringify(config), 'utf8').toString('base64');\n\n  // Detached, with the standard streams let go of: the daemon has to outlive\n  // the process that started it, and a child still holding this process's pipes\n  // would keep it from exiting -- the exact failure that makes a \"background\"\n  // daemon hang a shell.\n  let stdio: 'ignore'|['ignore', number, number] = 'ignore';\n  let logFd: number|null = null;\n  if (options.logFile) {\n    logFd = fs.openSync(options.logFile, 'a');\n    stdio = ['ignore', logFd, logFd];\n  }\n  const child = spawn(process.execPath, [DAEMON_MAIN, encoded], {\n    detached: true,\n    stdio,\n    windowsHide: true,\n  });\n  child.unref();\n  if (logFd !== null) {\n    fs.closeSync(logFd);\n  }\n}\n\nconst sleep = (ms: number) =>\n    new Promise<void>((resolve) => setTimeout(resolve, ms));\n\nexport interface EnsuredClient {\n  client: DaemonClient;\n  spawned: boolean;\n  endpoint: string;\n}\n\n// Connects, starting a daemon if none answers.\n//\n// The endpoint existing is the readiness signal, so this is a connect loop\n// rather than a handshake: a daemon that has bound can be talked to, and one\n// that has not is indistinguishable from one that was never started. Several\n// processes racing here is fine -- the losers' daemons exit on EADDRINUSE and\n// everyone ends up on the winner.\nasync function ensureClient(options: DaemonOptions = {}):\n    Promise<EnsuredClient> {\n  const resolved = resolveDaemonOptions(options);\n  try {\n    const client = await connectOnly(resolved.endpoint);\n    return {client, spawned: false, endpoint: resolved.endpoint};\n  } catch {\n    if (options.spawn === false) {\n      throw new Error(`shotium: no daemon at ${resolved.endpoint}`);\n    }\n  }\n\n  spawnDaemon(resolved);\n  const deadline = Date.now() +\n      (options.startTimeoutMs === undefined ? START_TIMEOUT_MS :\n                                              options.startTimeoutMs);\n  for (;;) {\n    try {\n      const client = await connectOnly(resolved.endpoint);\n      return {client, spawned: true, endpoint: resolved.endpoint};\n    } catch {\n      if (Date.now() >= deadline) {\n        throw new Error(\n            `shotium: the daemon did not come up at ${resolved.endpoint}`);\n      }\n      await sleep(CONNECT_RETRY_MS);\n    }\n  }\n}\n\n// The five things a caller does with a daemon. Each opens a connection, does\n// one thing and closes it, which is the shape a short-lived process wants; a\n// service that will send more than one request calls connect() and keeps the\n// client.\nasync function connect(options: DaemonOptions = {}): Promise<DaemonClient> {\n  const {client} = await ensureClient(options);\n  return client;\n}\n\nasync function start(options: DaemonOptions = {}):\n    Promise<DaemonStatus&{spawned: boolean}> {\n  const {client, spawned, endpoint} = await ensureClient(options);\n  try {\n    const status = await client.status();\n    return {...status, endpoint, spawned};\n  } finally {\n    client.close();\n  }\n}\n\nasync function status(options: DaemonOptions = {}):\n    Promise<Partial<DaemonStatus>&{running: boolean, endpoint: string}> {\n  const resolved = resolveDaemonOptions(options);\n  let client: DaemonClient;\n  try {\n    client = await connectOnly(resolved.endpoint);\n  } catch {\n    return {running: false, endpoint: resolved.endpoint};\n  }\n  try {\n    return {...(await client.status()), running: true};\n  } finally {\n    client.close();\n  }\n}\n\nasync function stop(options: DaemonOptions = {}):\n    Promise<{stopped: boolean, endpoint: string}> {\n  const resolved = resolveDaemonOptions(options);\n  let client: DaemonClient;\n  try {\n    client = await connectOnly(resolved.endpoint);\n  } catch {\n    return {stopped: false, endpoint: resolved.endpoint};\n  }\n  try {\n    await client.shutdown();\n    return {stopped: true, endpoint: resolved.endpoint};\n  } finally {\n    client.close();\n  }\n}\n\n// One screenshot through the daemon, connection and all. `daemon` carries the\n// pool's configuration -- binary, workers, cache root -- and is stripped out\n// here rather than sent, because it says which daemon to talk to and not what\n// to photograph.\nasync function screenshot(options: ScreenshotOptions&{daemon?: DaemonOptions}):\n    Promise<Buffer|null> {\n  const {daemon, ...rest} = options;\n  const client = await connect(daemon || {});\n  try {\n    return await client.screenshot(rest);\n  } finally {\n    client.close();\n  }\n}\n\nexport {\n  DaemonClient,\n  connect,\n  ensureClient,\n  resolveDaemonOptions,\n  screenshot,\n  start,\n  status,\n  stop,\n};\n","import * as client from './lib/client.js';\nimport type {DaemonClient} from './lib/client.js';\nimport {Engine} from './lib/engine.js';\nimport type {\n  DaemonOptions,\n  DaemonStatus,\n  PurgeOptions,\n  ScreenshotOptions,\n  StartOptions,\n} from './types.js';\n\nexport type {\n  Clip,\n  DaemonOptions,\n  DaemonStatus,\n  PageGotoParams,\n  PurgeOptions,\n  ScreenshotOptions,\n  StartOptions,\n  Viewport,\n} from './types.js';\nexport type {DaemonClient} from './lib/client.js';\n\n/** The five things a caller does with the resident engine. */\nexport interface Daemon {\n  /** Connects, starting a daemon if none is listening. */\n  connect(options?: DaemonOptions): Promise<DaemonClient>;\n  /** One screenshot through the daemon, connection and all. */\n  screenshot(options: ScreenshotOptions&{daemon?: DaemonOptions}):\n      Promise<Buffer|null>;\n  /** Starts one if it is not up, and reports what is there either way. */\n  start(options?: DaemonOptions): Promise<DaemonStatus&{spawned: boolean}>;\n  status(options?: DaemonOptions):\n      Promise<Partial<DaemonStatus>&{running: boolean, endpoint: string}>;\n  stop(options?: DaemonOptions): Promise<{stopped: boolean, endpoint: string}>;\n}\n\n/**\n * The engine, and its lifecycle, in this process.\n *\n *     import shotium from '@shotkit/shotium';\n *\n *     shotium.runtime.start();\n *     const png = await shotium.screenshot({file: 'https://example.com'});\n *     await shotium.runtime.stop();\n *\n * `start` and `stop` are explicit because starting Blink is the expensive part\n * -- tens of milliseconds and a working set that stays resident -- and only\n * the caller knows whether the next screenshot is coming in a moment or never.\n * Neither call is required: a screenshot starts the engine if it is not up.\n * What they buy is control over when that cost is paid, and the certainty that\n * it has been given back.\n *\n * `runtime` below is the singleton because there is nothing else it could be:\n * Blink starts once per process and cannot be restarted, so a second Runtime\n * in the same process has no engine to have. Construct one directly only to\n * own the lifecycle yourself instead of using `runtime`. Parallelism is more\n * processes, not more Runtimes.\n *\n * `daemon` is the same engine in a process of its own, behind a socket, for\n * callers whose own process does not live long enough to be worth starting\n * one.\n */\nexport class Runtime {\n  private engine = new Engine();\n\n  get running(): boolean {\n    return this.engine.running;\n  }\n\n  /**\n   * Starts the engine. Safe to call twice; the second call is a no-op, so that\n   * library code can call it defensively. Not safe after `stop()` -- see there.\n   *\n   * Every option has a default. `cacheDir` is the HTTP disk cache and `null`\n   * disables it; `resourceDir` is where `shotium_data.pak` and\n   * `shotium_strings.pak` are, and defaults to the directory the engine was\n   * loaded from, which is where they ship.\n   */\n  start(options: StartOptions = {}): this {\n    this.engine.start(options);\n    return this;\n  }\n\n  /**\n   * Stops the engine, after whatever is queued.\n   *\n   * Final for this process. Blink writes process-wide state that it has no\n   * path to undo, so starting again -- here or on another Runtime -- throws\n   * rather than quietly handing back something that cannot render. A program\n   * that wants another screenshot later should stay started and `purge()`.\n   */\n  stop(): Promise<void> {\n    return this.engine.stop();\n  }\n\n  /**\n   * Hands back what the engine is holding but can rebuild. Worth calling when\n   * a batch has ended and the next one may be a while away.\n   */\n  purge(options: PurgeOptions = {}): void {\n    this.engine.purge(options);\n  }\n\n  /**\n   * Renders one screenshot. Resolves to the encoded image, or to `null` when\n   * `path` was given and the engine wrote the file itself.\n   */\n  screenshot(options: ScreenshotOptions): Promise<Buffer|null> {\n    return this.engine.screenshot(options);\n  }\n}\n\n/** The shared engine: one per process, started on first use. */\nconst runtime = new Runtime();\n\n/** One screenshot through the shared engine, starting it if it is not up. */\nconst screenshot = (options: ScreenshotOptions): Promise<Buffer|null> =>\n    runtime.screenshot(options);\n\n/**\n * The resident engine: a process that outlives the one that started it,\n * reachable over a named pipe on Windows and a unix socket elsewhere. For\n * callers that are short-lived themselves. See lib/daemon.ts.\n */\nconst daemon: Daemon = {\n  connect: client.connect,\n  screenshot: client.screenshot,\n  start: client.start,\n  status: client.status,\n  stop: client.stop,\n};\n\nexport {runtime, screenshot, daemon};\n\n// A default as well as the names, because `import shotium from` is what a\n// caller coming from `require` writes first, and the two have to be the same\n// object rather than two views that drift.\nexport default {Runtime, runtime, screenshot, daemon};\n"],"mappings":"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"}

package/native/binding.cc

@@ -0,0 +1,283 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// shotium's node addon: shot in this process, over shot_api.h.
+//
+// It is deliberately thin. Everything about what a screenshot means -- which
+// fields exist, what they default to, what an unknown one is -- lives in
+// shotium/src/lib/request.ts and shot/shot_request.cc, and this file carries
+// JSON between them without reading it. Anything it understood would be a
+// third opinion about the request format, and the third opinion is always the
+// one that drifts.
+//
+// Node-API rather than V8: the ABI is stable across node versions, so one
+// prebuilt .node per platform is enough and the addon does not have to be
+// rebuilt every time node's internals move.
+
+#include <node_api.h>
+
+#include <cstring>
+#include <string>
+#include <utility>
+
+#include "shot_api.h"
+
+namespace {
+
+// A shot_engine, as node sees it.
+//
+// Wrapped rather than handed over as a bare pointer so that a script dropping
+// the handle on the floor still shuts the engine down: the finalizer runs when
+// the object is collected. `engine` is cleared by an explicit destroy() so the
+// finalizer does not do it twice.
+struct EngineHandle {
+  shot_engine* engine = nullptr;
+};
+
+void FinalizeEngine(napi_env env, void* data, void* hint) {
+  auto* handle = static_cast<EngineHandle*>(data);
+  if (handle->engine) {
+    shot_engine_destroy(handle->engine);
+  }
+  delete handle;
+}
+
+// One capture in flight: a promise, and the strings on both sides of it.
+//
+// The request is copied rather than referenced because Execute runs on a
+// libuv thread where no JS value may be touched, and the JS string it came
+// from can be collected before then.
+struct CaptureTask {
+  napi_deferred deferred = nullptr;
+  napi_async_work work = nullptr;
+  shot_engine* engine = nullptr;
+  std::string request;
+  shot_status status = SHOT_ERR_CAPTURE;
+  shot_buffer* image = nullptr;
+  shot_buffer* error = nullptr;
+};
+
+bool ReadUtf8(napi_env env, napi_value value, std::string* out) {
+  size_t length = 0;
+  if (napi_get_value_string_utf8(env, value, nullptr, 0, &length) != napi_ok) {
+    return false;
+  }
+  // Room for the NUL node insists on writing, then cut back to what it says
+  // it wrote.
+  std::string text(length + 1, '\0');
+  size_t written = 0;
+  if (napi_get_value_string_utf8(env, value, text.data(), length + 1,
+                                 &written) != napi_ok) {
+    return false;
+  }
+  text.resize(written);
+  *out = std::move(text);
+  return true;
+}
+
+napi_value Undefined(napi_env env) {
+  napi_value value = nullptr;
+  napi_get_undefined(env, &value);
+  return value;
+}
+
+// Turns a shot_buffer carrying a message into a thrown JS error. Freeing it is
+// this function's job either way, because every caller is on its way out.
+void ThrowFromBuffer(napi_env env, shot_buffer* message, const char* fallback) {
+  const char* text = fallback;
+  if (message && shot_buffer_size(message) > 0) {
+    text = reinterpret_cast<const char*>(shot_buffer_data(message));
+  }
+  napi_throw_error(env, nullptr, text);
+  shot_buffer_free(message);
+}
+
+bool ReadHandle(napi_env env, napi_value value, EngineHandle** out) {
+  void* data = nullptr;
+  if (napi_get_value_external(env, value, &data) != napi_ok || !data) {
+    napi_throw_type_error(env, nullptr, "shotium: expected an engine handle");
+    return false;
+  }
+  *out = static_cast<EngineHandle*>(data);
+  if (!(*out)->engine) {
+    napi_throw_error(env, nullptr, "shotium: this engine has been destroyed");
+    return false;
+  }
+  return true;
+}
+
+napi_value Create(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1] = {};
+  napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+
+  std::string options;
+  if (argc > 0 && !ReadUtf8(env, argv[0], &options)) {
+    napi_throw_type_error(env, nullptr,
+                          "shotium: create(optionsJson) wants a string");
+    return nullptr;
+  }
+
+  if (shot_abi_version() != SHOT_ABI_VERSION) {
+    napi_throw_error(env, nullptr,
+                     "shotium: the shot library beside this addon speaks a "
+                     "different ABI version; they ship together and one of "
+                     "them has been replaced");
+    return nullptr;
+  }
+
+  shot_engine* engine = nullptr;
+  shot_buffer* error = nullptr;
+  if (shot_engine_create(options.c_str(), &engine, &error) != SHOT_OK) {
+    ThrowFromBuffer(env, error, "shotium: the engine would not start");
+    return nullptr;
+  }
+
+  auto* handle = new EngineHandle{engine};
+  napi_value external = nullptr;
+  if (napi_create_external(env, handle, FinalizeEngine, nullptr, &external) !=
+      napi_ok) {
+    shot_engine_destroy(engine);
+    delete handle;
+    napi_throw_error(env, nullptr, "shotium: could not wrap the engine");
+    return nullptr;
+  }
+  return external;
+}
+
+napi_value Destroy(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1] = {};
+  napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+
+  void* data = nullptr;
+  if (argc < 1 || napi_get_value_external(env, argv[0], &data) != napi_ok ||
+      !data) {
+    napi_throw_type_error(env, nullptr, "shotium: expected an engine handle");
+    return nullptr;
+  }
+  auto* handle = static_cast<EngineHandle*>(data);
+  if (handle->engine) {
+    shot_engine_destroy(handle->engine);
+    handle->engine = nullptr;
+  }
+  return Undefined(env);
+}
+
+// Runs on a libuv thread. No napi call is legal here beyond the ones that take
+// no env, which is why everything it needs was copied out first.
+void ExecuteCapture(napi_env env, void* data) {
+  auto* task = static_cast<CaptureTask*>(data);
+  task->status = shot_engine_capture(task->engine, task->request.c_str(),
+                                     &task->image, &task->error);
+}
+
+void CompleteCapture(napi_env env, napi_status status, void* data) {
+  auto* task = static_cast<CaptureTask*>(data);
+
+  if (status == napi_ok && task->status == SHOT_OK) {
+    // Copied into a node Buffer rather than handed over as external memory.
+    // An external buffer would save a memcpy of a few hundred kilobytes
+    // against a render that took tens of milliseconds, and would put the
+    // lifetime of shot's allocation in the hands of node's GC -- across an
+    // allocator boundary the whole C ABI exists to keep closed.
+    napi_value buffer = nullptr;
+    napi_create_buffer_copy(env, shot_buffer_size(task->image),
+                            shot_buffer_data(task->image), nullptr, &buffer);
+    napi_resolve_deferred(env, task->deferred, buffer);
+  } else {
+    const char* text = "shotium: the capture failed";
+    if (task->error && shot_buffer_size(task->error) > 0) {
+      text = reinterpret_cast<const char*>(shot_buffer_data(task->error));
+    }
+    napi_value message = nullptr;
+    napi_value error_value = nullptr;
+    napi_create_string_utf8(env, text, NAPI_AUTO_LENGTH, &message);
+    napi_create_error(env, nullptr, message, &error_value);
+    napi_reject_deferred(env, task->deferred, error_value);
+  }
+
+  shot_buffer_free(task->image);
+  shot_buffer_free(task->error);
+  napi_delete_async_work(env, task->work);
+  delete task;
+}
+
+napi_value Capture(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2] = {};
+  napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+
+  EngineHandle* handle = nullptr;
+  if (argc < 2 || !ReadHandle(env, argv[0], &handle)) {
+    return nullptr;
+  }
+
+  auto* task = new CaptureTask;
+  task->engine = handle->engine;
+  if (!ReadUtf8(env, argv[1], &task->request)) {
+    delete task;
+    napi_throw_type_error(env, nullptr,
+                          "shotium: capture(engine, requestJson) wants a "
+                          "string");
+    return nullptr;
+  }
+
+  napi_value promise = nullptr;
+  if (napi_create_promise(env, &task->deferred, &promise) != napi_ok) {
+    delete task;
+    napi_throw_error(env, nullptr, "shotium: could not make a promise");
+    return nullptr;
+  }
+
+  napi_value name = nullptr;
+  napi_create_string_utf8(env, "shot:capture", NAPI_AUTO_LENGTH, &name);
+  napi_create_async_work(env, nullptr, name, ExecuteCapture, CompleteCapture,
+                         task, &task->work);
+  napi_queue_async_work(env, task->work);
+  return promise;
+}
+
+// Synchronous on purpose. A purge is milliseconds and happens when the caller
+// has decided it has nothing else to do; queuing it behind the event loop
+// would mean the process that just went idle stays large until something wakes
+// it up.
+napi_value Purge(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2] = {};
+  napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+
+  EngineHandle* handle = nullptr;
+  if (argc < 1 || !ReadHandle(env, argv[0], &handle)) {
+    return nullptr;
+  }
+
+  bool release = false;
+  if (argc > 1) {
+    napi_get_value_bool(env, argv[1], &release);
+  }
+  shot_engine_purge(handle->engine, release ? 1 : 0);
+  return Undefined(env);
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  const napi_property_descriptor properties[] = {
+      {"create", nullptr, Create, nullptr, nullptr, nullptr, napi_default,
+       nullptr},
+      {"destroy", nullptr, Destroy, nullptr, nullptr, nullptr, napi_default,
+       nullptr},
+      {"capture", nullptr, Capture, nullptr, nullptr, nullptr, napi_default,
+       nullptr},
+      {"purge", nullptr, Purge, nullptr, nullptr, nullptr, napi_default,
+       nullptr},
+  };
+  napi_define_properties(env, exports,
+                         sizeof(properties) / sizeof(properties[0]),
+                         properties);
+  return exports;
+}
+
+}  // namespace
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)