@storyshelf/core 0.6.2 → 0.7.0

package/dist/capture/forked/forked-capture.d.mts

@@ -0,0 +1,40 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Logger } from "../../logger.mjs";
+import { ConsumerJob, KindHandler } from "../consumer/types.mjs";
+import { ChildProcessHandle } from "./channel.mjs";
+//#region src/capture/forked/forked-capture.d.ts
+/** Options of {@link createForkedCaptureHandler}. */
+interface ForkedCaptureOptions {
+  /** Start the capture child. Throwing counts as "fork failed" and trips the fallback. */
+  spawn: () => ChildProcessHandle;
+  /** Runs jobs in this process when forking stops being viable. */
+  fallback: KindHandler;
+  /** Longest a pushed job may go without progress before the child is declared hung and killed (0 disables). */
+  leaseMs?: number;
+  /** Non-zero exits within `crashWindowMs` that trip the fallback (default 3). */
+  crashLimit?: number;
+  crashWindowMs?: number;
+  /** Delay before pushing again after a crash (default 250 ms). */
+  restartDelayMs?: number;
+  /** Retries assumed for jobs that do not state `maxAttempts` (the consumer's `maxRetries`). */
+  maxRetries?: number;
+  /**
+   * The child kept dying on this job's last attempt, so it never recorded the failure: write it
+   * (the build, or the shard, fails). Runs before the job is failed on the queue.
+   */
+  onCrashed?: (job: ConsumerJob, error: string) => Promise<void>;
+  logger?: Logger;
+}
+/** A `capture` handler that runs jobs in a forked child. */
+interface ForkedCaptureHandler extends KindHandler {
+  /** Whether forking was given up and jobs run in-process. */
+  readonly tripped: boolean;
+  /** Stop the child (SIGTERM, escalating to SIGKILL). Call after the consumer has drained. */
+  close(): Promise<void>;
+}
+/** Create the handler; the child is forked when the first job arrives. */
+declare function createForkedCaptureHandler(options: ForkedCaptureOptions): ForkedCaptureHandler;
+//#endregion
+export { ForkedCaptureHandler, ForkedCaptureOptions, createForkedCaptureHandler };
+//# sourceMappingURL=forked-capture.d.mts.map

package/dist/capture/forked/forked-capture.mjs

@@ -0,0 +1,240 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { isFinalAttempt } from "../consumer/retry.mjs";
+import "../db-queue/types.mjs";
+import { isChildMessage } from "./protocol.mjs";
+import { CrashTracker } from "./crash-tracker.mjs";
+import { describeExit } from "./exit.mjs";
+import { LeaseBook } from "./lease-book.mjs";
+import { RunBook, jobKey } from "./runs.mjs";
+//#region src/capture/forked/forked-capture.ts
+/** Create the handler; the child is forked when the first job arrives. */
+function createForkedCaptureHandler(options) {
+	const forked = new ForkedCapture(options);
+	return {
+		get tripped() {
+			return forked.tripped;
+		},
+		accepts: (job) => forked.accepts(job),
+		run: async (job, context) => {
+			await forked.run(job, context);
+		},
+		cancel: async (job) => {
+			await forked.cancel(job);
+		},
+		close: async () => {
+			await forked.close();
+		}
+	};
+}
+var ForkedCapture = class {
+	#options;
+	#runs = new RunBook();
+	#crashes;
+	#leases;
+	/** Jobs the consumer gave up on (lease lost, cancelled) that may still wait to be pushed. */
+	#abandoned = /* @__PURE__ */ new Set();
+	#child = null;
+	/** The run whose lease ran out, while its child is being killed; that run alone is at fault. */
+	#hung = null;
+	#tripped = false;
+	#closed = false;
+	constructor(options) {
+		this.#options = options;
+		this.#crashes = new CrashTracker(options.crashLimit ?? 3, options.crashWindowMs ?? 3e5);
+		this.#leases = new LeaseBook(options.leaseMs ?? 3e5, (runId) => {
+			this.#onHung(runId);
+		});
+	}
+	get tripped() {
+		return this.#tripped;
+	}
+	accepts(job) {
+		return this.#options.fallback.accepts?.(job) !== false;
+	}
+	async run(job, context) {
+		const key = jobKey(job);
+		try {
+			await this.#runUntilSettled(job, context);
+		} finally {
+			this.#abandoned.delete(key);
+		}
+	}
+	/** Push the job until it settles: a crash that was not this run's fault pushes it again, alone. */
+	async #runUntilSettled(job, context, solo = false) {
+		if (this.#tripped || this.#closed) {
+			await this.#options.fallback.run(job, context);
+			return;
+		}
+		const verdict = await this.#pushWhenAllowed(job, context, solo);
+		if (verdict !== null && await this.#conclude(job, verdict)) return;
+		if (verdict !== null) await delay(this.#options.restartDelayMs ?? 250);
+		await this.#runUntilSettled(job, context, solo || verdict !== null);
+	}
+	/** Whether the push is over: true for a done run; a failed or charged one throws; false = push again. */
+	async #conclude(job, verdict) {
+		if (verdict.kind === "done") return true;
+		if (verdict.kind === "failed") throw new Error(verdict.error);
+		if (!verdict.charged) return false;
+		await this.#failCrashed(job, verdict.error);
+		throw new Error(verdict.error);
+	}
+	/** Wait for a place, push, and wait for the verdict; null when the situation changed (tripped). */
+	async #pushWhenAllowed(job, context, solo) {
+		const run = await this.#waitForPlace(job, context, solo);
+		return run === null ? null : await run.verdict;
+	}
+	async #waitForPlace(job, context, solo) {
+		while (!this.#tripped && !this.#closed) {
+			if (this.#abandoned.has(jobKey(job))) throw new Error("capture job was cancelled before it ran");
+			if (this.#runs.canStart(solo)) return this.#push(job, context, solo);
+			await this.#runs.changed();
+		}
+		return null;
+	}
+	/** The consumer stopped waiting for this job: stop the child's render, or keep it from starting. */
+	async cancel(job) {
+		const run = this.#runs.runOf(job);
+		if (run) {
+			this.#child?.send({
+				type: "cancel",
+				runId: run.runId
+			});
+			return;
+		}
+		this.#abandoned.add(jobKey(job));
+		this.#runs.wake();
+		if (this.#tripped) await this.#options.fallback.cancel?.(job);
+	}
+	async close() {
+		this.#closed = true;
+		this.#shutDown();
+		for (const run of this.#runs.takeAll()) run.settle({
+			kind: "failed",
+			error: "capture child stopped"
+		});
+		await Promise.resolve();
+	}
+	#push(job, context, solo) {
+		const child = this.#ensureChild();
+		if (child === null) return null;
+		const run = this.#runs.add(job, context, solo);
+		this.#leases.start(run.runId);
+		child.send({
+			type: "run",
+			runId: run.runId,
+			job
+		});
+		return run;
+	}
+	#ensureChild() {
+		if (this.#child) return this.#child;
+		try {
+			this.#child = this.#attach(this.#options.spawn());
+			return this.#child;
+		} catch (error) {
+			this.#options.logger?.error({ err: error }, "failed to start capture child");
+			this.#trip("spawn failed");
+			return null;
+		}
+	}
+	#attach(child) {
+		child.onMessage((message) => {
+			this.#onMessage(message);
+		});
+		child.onExit((info) => {
+			this.#onExit(child, info);
+		});
+		return child;
+	}
+	#onMessage(message) {
+		if (!isChildMessage(message)) return;
+		const run = this.#runs.get(message.runId);
+		if (!run) return;
+		this.#onRunMessage(run, message);
+	}
+	#onRunMessage(run, message) {
+		if (message.type === "progress") {
+			this.#leases.touch(run.runId);
+			run.context.touch();
+			return;
+		}
+		this.#leases.stop(run.runId);
+		this.#runs.finish(run.runId, message.type === "done" ? { kind: "done" } : {
+			kind: "failed",
+			error: message.error
+		});
+	}
+	#onExit(child, info) {
+		if (this.#child !== child) return;
+		this.#child = null;
+		const crashed = info.code !== 0 || this.#runs.size > 0;
+		this.#settleCrashedRuns(info);
+		if (crashed && !this.#closed && this.#crashes.record()) this.#trip(`capture child crashed repeatedly (last: ${describeExit(info)})`);
+		this.#runs.wake();
+	}
+	/** Charge the crash to the hung run, or to the only run out; the others go back uncharged. */
+	#settleCrashedRuns(info) {
+		const runs = this.#runs.takeAll();
+		const hung = this.#hung;
+		this.#hung = null;
+		for (const run of runs) {
+			this.#leases.stop(run.runId);
+			run.settle({
+				kind: "crashed",
+				charged: hung === null ? runs.length === 1 : run.runId === hung,
+				error: crashMessage(info, hung === run.runId)
+			});
+		}
+	}
+	/** On its last attempt a job the child kept killing is failed here: the child never recorded it. */
+	async #failCrashed(job, error) {
+		if (!isFinalAttempt(job, this.#options.maxRetries)) return;
+		try {
+			await this.#options.onCrashed?.(job, error);
+		} catch (hookError) {
+			this.#options.logger?.error({
+				err: hookError,
+				buildId: job.buildId
+			}, "crash hook failed");
+		}
+	}
+	/** A pushed job went a full lease without progress: the child is hung, so kill it like a crash. */
+	#onHung(runId) {
+		if (!this.#runs.get(runId) || !this.#child || this.#hung !== null) return;
+		this.#options.logger?.error({
+			runId,
+			leaseMs: this.#options.leaseMs
+		}, "capture child made no progress; killing it");
+		this.#hung = runId;
+		this.#child.kill(true);
+	}
+	/** Forking is no longer viable: stop the child; waiting and crashed runs go to the fallback. */
+	#trip(reason) {
+		if (this.#tripped) return;
+		this.#tripped = true;
+		this.#options.logger?.error({ reason }, "capture child unavailable; falling back to in-process capture");
+		this.#shutDown();
+	}
+	#shutDown() {
+		this.#hung = null;
+		this.#leases.stopAll();
+		const child = this.#child;
+		this.#child = null;
+		child?.kill();
+		this.#runs.wake();
+	}
+};
+function crashMessage(info, hung) {
+	return hung ? `capture worker made no progress and was killed (${describeExit(info)})` : `capture worker exited (${describeExit(info)})`;
+}
+async function delay(ms) {
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms).unref();
+	});
+}
+//#endregion
+export { createForkedCaptureHandler };
+
+//# sourceMappingURL=forked-capture.mjs.map

package/dist/capture/forked/forked-capture.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"forked-capture.mjs","names":[],"sources":["../../../src/capture/forked/forked-capture.ts"],"sourcesContent":["/**\n * The parent side of forked capture (ADR 0006, decision 5). The app's consumer polls the queue and\n * holds the slots; its `capture` handler is this one, which pushes each leased job to a child over\n * IPC and waits for the child's `done` or `failed`. The child's `progress` messages become the\n * job's progress, which renews the lease the consumer keeps.\n *\n * One limit covers failed attempts, lost leases and child crashes, so a crash simply fails the\n * run and the consumer retries it. A crash is charged only to the run that caused it (the hung one,\n * or the only one out); runs that shared a crashed child are pushed again, uncharged, one at a time,\n * so a repeat crash names its culprit. A crash loop, or a child that cannot start, hands everything\n * to the in-process handler.\n */\nimport type { Logger } from \"../../logger.ts\";\nimport { isFinalAttempt } from \"../consumer/retry.ts\";\nimport type { ConsumerJob, JobRunContext, KindHandler } from \"../consumer/types.ts\";\nimport { DEFAULT_LEASE_MS } from \"../db-queue/types.ts\";\nimport type { ChildProcessHandle } from \"./channel.ts\";\nimport { CrashTracker } from \"./crash-tracker.ts\";\nimport { describeExit, type ChildExit } from \"./exit.ts\";\nimport { LeaseBook } from \"./lease-book.ts\";\nimport { isChildMessage, type ChildMessage } from \"./protocol.ts\";\nimport { jobKey, RunBook, type Run, type RunVerdict } from \"./runs.ts\";\n\n/** Options of {@link createForkedCaptureHandler}. */\nexport interface ForkedCaptureOptions {\n  /** Start the capture child. Throwing counts as \"fork failed\" and trips the fallback. */\n  spawn: () => ChildProcessHandle;\n  /** Runs jobs in this process when forking stops being viable. */\n  fallback: KindHandler;\n  /** Longest a pushed job may go without progress before the child is declared hung and killed (0 disables). */\n  leaseMs?: number;\n  /** Non-zero exits within `crashWindowMs` that trip the fallback (default 3). */\n  crashLimit?: number;\n  crashWindowMs?: number;\n  /** Delay before pushing again after a crash (default 250 ms). */\n  restartDelayMs?: number;\n  /** Retries assumed for jobs that do not state `maxAttempts` (the consumer's `maxRetries`). */\n  maxRetries?: number;\n  /**\n   * The child kept dying on this job's last attempt, so it never recorded the failure: write it\n   * (the build, or the shard, fails). Runs before the job is failed on the queue.\n   */\n  onCrashed?: (job: ConsumerJob, error: string) => Promise<void>;\n  logger?: Logger;\n}\n\n/** A `capture` handler that runs jobs in a forked child. */\nexport interface ForkedCaptureHandler extends KindHandler {\n  /** Whether forking was given up and jobs run in-process. */\n  readonly tripped: boolean;\n  /** Stop the child (SIGTERM, escalating to SIGKILL). Call after the consumer has drained. */\n  close(): Promise<void>;\n}\n\n/** Create the handler; the child is forked when the first job arrives. */\nexport function createForkedCaptureHandler(options: ForkedCaptureOptions): ForkedCaptureHandler {\n  const forked = new ForkedCapture(options);\n  // Plain closures, so the pieces can be passed around detached from the instance.\n  return {\n    get tripped() {\n      return forked.tripped;\n    },\n    accepts: (job) => forked.accepts(job),\n    run: async (job, context) => {\n      await forked.run(job, context);\n    },\n    cancel: async (job) => {\n      await forked.cancel(job);\n    },\n    close: async () => {\n      await forked.close();\n    },\n  };\n}\n\nclass ForkedCapture {\n  readonly #options: ForkedCaptureOptions;\n  readonly #runs = new RunBook();\n  readonly #crashes: CrashTracker;\n  readonly #leases: LeaseBook;\n  /** Jobs the consumer gave up on (lease lost, cancelled) that may still wait to be pushed. */\n  readonly #abandoned = new Set<string>();\n  #child: ChildProcessHandle | null = null;\n  /** The run whose lease ran out, while its child is being killed; that run alone is at fault. */\n  #hung: string | null = null;\n  #tripped = false;\n  #closed = false;\n\n  constructor(options: ForkedCaptureOptions) {\n    this.#options = options;\n    this.#crashes = new CrashTracker(options.crashLimit ?? 3, options.crashWindowMs ?? 300_000);\n    this.#leases = new LeaseBook(options.leaseMs ?? DEFAULT_LEASE_MS, (runId) => {\n      this.#onHung(runId);\n    });\n  }\n\n  get tripped(): boolean {\n    return this.#tripped;\n  }\n\n  accepts(job: ConsumerJob): boolean {\n    return this.#options.fallback.accepts?.(job) !== false;\n  }\n\n  async run(job: ConsumerJob, context: JobRunContext): Promise<void> {\n    const key = jobKey(job);\n    try {\n      await this.#runUntilSettled(job, context);\n    } finally {\n      this.#abandoned.delete(key);\n    }\n  }\n\n  /** Push the job until it settles: a crash that was not this run's fault pushes it again, alone. */\n  async #runUntilSettled(job: ConsumerJob, context: JobRunContext, solo = false): Promise<void> {\n    if (this.#tripped || this.#closed) {\n      await this.#options.fallback.run(job, context);\n      return;\n    }\n    const verdict = await this.#pushWhenAllowed(job, context, solo);\n    if (verdict !== null && (await this.#conclude(job, verdict))) {\n      return;\n    }\n    if (verdict !== null) {\n      await delay(this.#options.restartDelayMs ?? 250);\n    }\n    await this.#runUntilSettled(job, context, solo || verdict !== null);\n  }\n\n  /** Whether the push is over: true for a done run; a failed or charged one throws; false = push again. */\n  async #conclude(job: ConsumerJob, verdict: RunVerdict): Promise<boolean> {\n    if (verdict.kind === \"done\") {\n      return true;\n    }\n    if (verdict.kind === \"failed\") {\n      throw new Error(verdict.error);\n    }\n    if (!verdict.charged) {\n      return false;\n    }\n    await this.#failCrashed(job, verdict.error);\n    throw new Error(verdict.error);\n  }\n\n  /** Wait for a place, push, and wait for the verdict; null when the situation changed (tripped). */\n  async #pushWhenAllowed(\n    job: ConsumerJob,\n    context: JobRunContext,\n    solo: boolean,\n  ): Promise<RunVerdict | null> {\n    const run = await this.#waitForPlace(job, context, solo);\n    return run === null ? null : await run.verdict;\n  }\n\n  async #waitForPlace(\n    job: ConsumerJob,\n    context: JobRunContext,\n    solo: boolean,\n  ): Promise<Run | null> {\n    while (!this.#tripped && !this.#closed) {\n      if (this.#abandoned.has(jobKey(job))) {\n        throw new Error(\"capture job was cancelled before it ran\");\n      }\n      if (this.#runs.canStart(solo)) {\n        // Check and registration share one synchronous block: two waiters never both start solo.\n        return this.#push(job, context, solo);\n      }\n      // oxlint-disable-next-line no-await-in-loop -- wait for a place\n      await this.#runs.changed();\n    }\n    return null;\n  }\n\n  /** The consumer stopped waiting for this job: stop the child's render, or keep it from starting. */\n  async cancel(job: ConsumerJob): Promise<void> {\n    const run = this.#runs.runOf(job);\n    if (run) {\n      this.#child?.send({ type: \"cancel\", runId: run.runId });\n      return;\n    }\n    this.#abandoned.add(jobKey(job));\n    this.#runs.wake();\n    if (this.#tripped) {\n      await this.#options.fallback.cancel?.(job);\n    }\n  }\n\n  async close(): Promise<void> {\n    this.#closed = true;\n    this.#shutDown();\n    for (const run of this.#runs.takeAll()) {\n      run.settle({ kind: \"failed\", error: \"capture child stopped\" });\n    }\n    await Promise.resolve();\n  }\n\n  #push(job: ConsumerJob, context: JobRunContext, solo: boolean): Run | null {\n    const child = this.#ensureChild();\n    if (child === null) {\n      return null;\n    }\n    const run = this.#runs.add(job, context, solo);\n    this.#leases.start(run.runId);\n    child.send({ type: \"run\", runId: run.runId, job });\n    return run;\n  }\n\n  #ensureChild(): ChildProcessHandle | null {\n    if (this.#child) {\n      return this.#child;\n    }\n    try {\n      this.#child = this.#attach(this.#options.spawn());\n      return this.#child;\n    } catch (error) {\n      this.#options.logger?.error({ err: error }, \"failed to start capture child\");\n      this.#trip(\"spawn failed\");\n      return null;\n    }\n  }\n\n  #attach(child: ChildProcessHandle): ChildProcessHandle {\n    child.onMessage((message) => {\n      this.#onMessage(message);\n    });\n    child.onExit((info) => {\n      this.#onExit(child, info);\n    });\n    return child;\n  }\n\n  #onMessage(message: unknown): void {\n    if (!isChildMessage(message)) {\n      return;\n    }\n    const run = this.#runs.get(message.runId);\n    if (!run) {\n      return;\n    }\n    this.#onRunMessage(run, message);\n  }\n\n  #onRunMessage(run: Run, message: ChildMessage): void {\n    if (message.type === \"progress\") {\n      this.#leases.touch(run.runId);\n      run.context.touch();\n      return;\n    }\n    this.#leases.stop(run.runId);\n    this.#runs.finish(\n      run.runId,\n      message.type === \"done\" ? { kind: \"done\" } : { kind: \"failed\", error: message.error },\n    );\n  }\n\n  #onExit(child: ChildProcessHandle, info: ChildExit): void {\n    if (this.#child !== child) {\n      return;\n    }\n    this.#child = null;\n    // An exit the parent did not ask for while work was out is a crash whatever its code: a child\n    // that returns cleanly before answering (a broken entry module) would otherwise loop forever.\n    const crashed = info.code !== 0 || this.#runs.size > 0;\n    this.#settleCrashedRuns(info);\n    if (crashed && !this.#closed && this.#crashes.record()) {\n      this.#trip(`capture child crashed repeatedly (last: ${describeExit(info)})`);\n    }\n    this.#runs.wake();\n  }\n\n  /** Charge the crash to the hung run, or to the only run out; the others go back uncharged. */\n  #settleCrashedRuns(info: ChildExit): void {\n    const runs = this.#runs.takeAll();\n    const hung = this.#hung;\n    this.#hung = null;\n    for (const run of runs) {\n      this.#leases.stop(run.runId);\n      run.settle({\n        kind: \"crashed\",\n        charged: hung === null ? runs.length === 1 : run.runId === hung,\n        error: crashMessage(info, hung === run.runId),\n      });\n    }\n  }\n\n  /** On its last attempt a job the child kept killing is failed here: the child never recorded it. */\n  async #failCrashed(job: ConsumerJob, error: string): Promise<void> {\n    if (!isFinalAttempt(job, this.#options.maxRetries)) {\n      return;\n    }\n    try {\n      await this.#options.onCrashed?.(job, error);\n    } catch (hookError) {\n      this.#options.logger?.error({ err: hookError, buildId: job.buildId }, \"crash hook failed\");\n    }\n  }\n\n  /** A pushed job went a full lease without progress: the child is hung, so kill it like a crash. */\n  #onHung(runId: string): void {\n    if (!this.#runs.get(runId) || !this.#child || this.#hung !== null) {\n      return;\n    }\n    this.#options.logger?.error(\n      { runId, leaseMs: this.#options.leaseMs },\n      \"capture child made no progress; killing it\",\n    );\n    this.#hung = runId;\n    this.#child.kill(true);\n  }\n\n  /** Forking is no longer viable: stop the child; waiting and crashed runs go to the fallback. */\n  #trip(reason: string): void {\n    if (this.#tripped) {\n      return;\n    }\n    this.#tripped = true;\n    this.#options.logger?.error(\n      { reason },\n      \"capture child unavailable; falling back to in-process capture\",\n    );\n    this.#shutDown();\n  }\n\n  #shutDown(): void {\n    this.#hung = null;\n    this.#leases.stopAll();\n    const child = this.#child;\n    this.#child = null;\n    child?.kill();\n    this.#runs.wake();\n  }\n}\n\nfunction crashMessage(info: ChildExit, hung: boolean): string {\n  return hung\n    ? `capture worker made no progress and was killed (${describeExit(info)})`\n    : `capture worker exited (${describeExit(info)})`;\n}\n\nasync function delay(ms: number): Promise<void> {\n  await new Promise<void>((resolve) => {\n    setTimeout(resolve, ms).unref();\n  });\n}\n"],"mappings":"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"}

package/dist/capture/forked/lease-book.mjs

@@ -0,0 +1,46 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { ProgressLease } from "../job-lease.mjs";
+//#region src/capture/forked/lease-book.ts
+/** Progress leases for jobs out with the capture child: no progress within the lease means the child is hung. */
+/** One {@link ProgressLease} per in-flight receipt. A `leaseMs` of 0 disables the whole book. */
+var LeaseBook = class {
+	#leaseMs;
+	#onExpired;
+	#leases = /* @__PURE__ */ new Map();
+	constructor(leaseMs, onExpired) {
+		this.#leaseMs = leaseMs;
+		this.#onExpired = onExpired;
+	}
+	/** Start watching a delivered job. */
+	start(receipt) {
+		if (this.#leaseMs <= 0) return;
+		this.stop(receipt);
+		const lease = new ProgressLease(this.#leaseMs);
+		this.#leases.set(receipt, lease);
+		lease.expired.then(() => {
+			if (this.#leases.get(receipt) === lease) {
+				this.#leases.delete(receipt);
+				this.#onExpired(receipt);
+			}
+		}, () => {});
+	}
+	/** The job under `receipt` made progress. */
+	touch(receipt) {
+		this.#leases.get(receipt)?.touch();
+	}
+	/** The job ended (or was taken back); stop watching it. */
+	stop(receipt) {
+		this.#leases.get(receipt)?.stop();
+		this.#leases.delete(receipt);
+	}
+	stopAll() {
+		for (const lease of this.#leases.values()) lease.stop();
+		this.#leases.clear();
+	}
+};
+//#endregion
+export { LeaseBook };
+
+//# sourceMappingURL=lease-book.mjs.map

package/dist/capture/forked/lease-book.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lease-book.mjs","names":[],"sources":["../../../src/capture/forked/lease-book.ts"],"sourcesContent":["/** Progress leases for jobs out with the capture child: no progress within the lease means the child is hung. */\nimport { ProgressLease } from \"../job-lease.ts\";\n\n/** One {@link ProgressLease} per in-flight receipt. A `leaseMs` of 0 disables the whole book. */\nexport class LeaseBook {\n  readonly #leaseMs: number;\n  readonly #onExpired: (receipt: string) => void;\n  readonly #leases = new Map<string, ProgressLease>();\n\n  constructor(leaseMs: number, onExpired: (receipt: string) => void) {\n    this.#leaseMs = leaseMs;\n    this.#onExpired = onExpired;\n  }\n\n  /** Start watching a delivered job. */\n  start(receipt: string): void {\n    if (this.#leaseMs <= 0) {\n      return;\n    }\n    this.stop(receipt);\n    const lease = new ProgressLease(this.#leaseMs);\n    this.#leases.set(receipt, lease);\n    lease.expired.then(\n      () => {\n        if (this.#leases.get(receipt) === lease) {\n          this.#leases.delete(receipt);\n          this.#onExpired(receipt);\n        }\n      },\n      () => {},\n    );\n  }\n\n  /** The job under `receipt` made progress. */\n  touch(receipt: string): void {\n    this.#leases.get(receipt)?.touch();\n  }\n\n  /** The job ended (or was taken back); stop watching it. */\n  stop(receipt: string): void {\n    this.#leases.get(receipt)?.stop();\n    this.#leases.delete(receipt);\n  }\n\n  stopAll(): void {\n    for (const lease of this.#leases.values()) {\n      lease.stop();\n    }\n    this.#leases.clear();\n  }\n}\n"],"mappings":";;;;;;;AAIA,IAAa,YAAb,MAAuB;CACrB;CACA;CACA,0BAAmB,IAAI,IAA2B;CAElD,YAAY,SAAiB,WAAsC;EACjE,KAAK,WAAW;EAChB,KAAK,aAAa;CACpB;;CAGA,MAAM,SAAuB;EAC3B,IAAI,KAAK,YAAY,GACnB;EAEF,KAAK,KAAK,OAAO;EACjB,MAAM,QAAQ,IAAI,cAAc,KAAK,QAAQ;EAC7C,KAAK,QAAQ,IAAI,SAAS,KAAK;EAC/B,MAAM,QAAQ,WACN;GACJ,IAAI,KAAK,QAAQ,IAAI,OAAO,MAAM,OAAO;IACvC,KAAK,QAAQ,OAAO,OAAO;IAC3B,KAAK,WAAW,OAAO;GACzB;EACF,SACM,CAAC,CACT;CACF;;CAGA,MAAM,SAAuB;EAC3B,KAAK,QAAQ,IAAI,OAAO,CAAC,EAAE,MAAM;CACnC;;CAGA,KAAK,SAAuB;EAC1B,KAAK,QAAQ,IAAI,OAAO,CAAC,EAAE,KAAK;EAChC,KAAK,QAAQ,OAAO,OAAO;CAC7B;CAEA,UAAgB;EACd,KAAK,MAAM,SAAS,KAAK,QAAQ,OAAO,GACtC,MAAM,KAAK;EAEb,KAAK,QAAQ,MAAM;CACrB;AACF"}

package/dist/capture/forked/protocol.d.mts

@@ -0,0 +1,38 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConsumerJob } from "../consumer/types.mjs";
+//#region src/capture/forked/protocol.d.ts
+/** Parent to child. `runId` names one push of a job; a re-push after a crash gets a new one. */
+type ParentMessage =
+/** Run this leased job. The child holds the same database, storage and runner configuration. */
+{
+  type: "run";
+  runId: string;
+  job: ConsumerJob;
+} |
+/** The lease is lost or the job was cancelled: stop the render (`runner.cancel`). */
+{
+  type: "cancel";
+  runId: string;
+};
+/** Child to parent. */
+type ChildMessage =
+/** The run made progress; the parent renews the job's lease. */
+{
+  type: "progress";
+  runId: string;
+} |
+/** The run finished; the parent acknowledges the job. */
+{
+  type: "done";
+  runId: string;
+} |
+/** The run threw; the parent retries or fails the job by its attempt count. */
+{
+  type: "failed";
+  runId: string;
+  error: string;
+};
+//#endregion
+export { ChildMessage, ParentMessage };
+//# sourceMappingURL=protocol.d.mts.map

package/dist/capture/forked/protocol.mjs

@@ -0,0 +1,25 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/capture/forked/protocol.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isJob(value) {
+	return isRecord(value) && typeof value["buildId"] === "string" && value["buildId"].length > 0;
+}
+/** Runtime guard for a message arriving from the child (never trust an IPC payload's shape). */
+function isChildMessage(value) {
+	if (!isRecord(value) || typeof value["runId"] !== "string") return false;
+	const type = value["type"];
+	return type === "progress" || type === "done" || type === "failed" && typeof value["error"] === "string";
+}
+/** Runtime guard for a message arriving from the parent. */
+function isParentMessage(value) {
+	if (!isRecord(value) || typeof value["runId"] !== "string") return false;
+	return value["type"] === "cancel" || value["type"] === "run" && isJob(value["job"]);
+}
+//#endregion
+export { isChildMessage, isParentMessage };
+
+//# sourceMappingURL=protocol.mjs.map

package/dist/capture/forked/protocol.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.mjs","names":[],"sources":["../../../src/capture/forked/protocol.ts"],"sourcesContent":["/**\n * Wire protocol between the app's forked capture handler (parent) and `runCaptureChild` (child).\n * Plain JSON only. The parent owns the queue: it pushes each leased job to the child, and the\n * child only reports on it (ADR 0006, decision 5), so there is no `poll`, `enqueue`, `ack` or `nack`.\n */\nimport type { ConsumerJob } from \"../consumer/types.ts\";\n\n/** Parent to child. `runId` names one push of a job; a re-push after a crash gets a new one. */\nexport type ParentMessage =\n  /** Run this leased job. The child holds the same database, storage and runner configuration. */\n  | { type: \"run\"; runId: string; job: ConsumerJob }\n  /** The lease is lost or the job was cancelled: stop the render (`runner.cancel`). */\n  | { type: \"cancel\"; runId: string };\n\n/** Child to parent. */\nexport type ChildMessage =\n  /** The run made progress; the parent renews the job's lease. */\n  | { type: \"progress\"; runId: string }\n  /** The run finished; the parent acknowledges the job. */\n  | { type: \"done\"; runId: string }\n  /** The run threw; the parent retries or fails the job by its attempt count. */\n  | { type: \"failed\"; runId: string; error: string };\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\nfunction isJob(value: unknown): value is ConsumerJob {\n  return isRecord(value) && typeof value[\"buildId\"] === \"string\" && value[\"buildId\"].length > 0;\n}\n\n/** Runtime guard for a message arriving from the child (never trust an IPC payload's shape). */\nexport function isChildMessage(value: unknown): value is ChildMessage {\n  if (!isRecord(value) || typeof value[\"runId\"] !== \"string\") {\n    return false;\n  }\n  const type = value[\"type\"];\n  return (\n    type === \"progress\" ||\n    type === \"done\" ||\n    (type === \"failed\" && typeof value[\"error\"] === \"string\")\n  );\n}\n\n/** Runtime guard for a message arriving from the parent. */\nexport function isParentMessage(value: unknown): value is ParentMessage {\n  if (!isRecord(value) || typeof value[\"runId\"] !== \"string\") {\n    return false;\n  }\n  return value[\"type\"] === \"cancel\" || (value[\"type\"] === \"run\" && isJob(value[\"job\"]));\n}\n"],"mappings":";;;;AAuBA,SAAS,SAAS,OAAkD;CAClE,OAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAEA,SAAS,MAAM,OAAsC;CACnD,OAAO,SAAS,KAAK,KAAK,OAAO,MAAM,eAAe,YAAY,MAAM,UAAU,CAAC,SAAS;AAC9F;;AAGA,SAAgB,eAAe,OAAuC;CACpE,IAAI,CAAC,SAAS,KAAK,KAAK,OAAO,MAAM,aAAa,UAChD,OAAO;CAET,MAAM,OAAO,MAAM;CACnB,OACE,SAAS,cACT,SAAS,UACR,SAAS,YAAY,OAAO,MAAM,aAAa;AAEpD;;AAGA,SAAgB,gBAAgB,OAAwC;CACtE,IAAI,CAAC,SAAS,KAAK,KAAK,OAAO,MAAM,aAAa,UAChD,OAAO;CAET,OAAO,MAAM,YAAY,YAAa,MAAM,YAAY,SAAS,MAAM,MAAM,MAAM;AACrF"}

package/dist/capture/forked/runs.mjs

@@ -0,0 +1,75 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/capture/forked/runs.ts
+/** In-flight runs by id, plus the admission rule for solo runs and a signal for waiters. */
+var RunBook = class {
+	#runs = /* @__PURE__ */ new Map();
+	#waiters = [];
+	#ids = 0;
+	/** Register a run (call right after {@link canStart}, with no await between). */
+	add(job, context, solo) {
+		this.#ids += 1;
+		const { promise, resolve } = Promise.withResolvers();
+		const run = {
+			runId: `run-${this.#ids}`,
+			job,
+			context,
+			solo,
+			settle: resolve,
+			verdict: promise
+		};
+		this.#runs.set(run.runId, run);
+		return run;
+	}
+	get(runId) {
+		return this.#runs.get(runId);
+	}
+	/** The run of `job` (by lease receipt, else build and shard), when it is out with the child. */
+	runOf(job) {
+		return [...this.#runs.values()].find((run) => jobKey(run.job) === jobKey(job));
+	}
+	get size() {
+		return this.#runs.size;
+	}
+	/** A solo run waits for an empty child and then runs alone; nothing starts beside it. */
+	canStart(solo) {
+		const runs = [...this.#runs.values()];
+		if (runs.some((run) => run.solo)) return false;
+		return solo ? runs.length === 0 : true;
+	}
+	/** Settle and remove one run, then wake whoever waits for a place. */
+	finish(runId, verdict) {
+		const run = this.#runs.get(runId);
+		if (run) {
+			this.#runs.delete(runId);
+			run.settle(verdict);
+		}
+		this.wake();
+	}
+	/** Remove every run (the child that held them is gone), returning them. */
+	takeAll() {
+		const runs = [...this.#runs.values()];
+		this.#runs.clear();
+		return runs;
+	}
+	/** Resolves at the next {@link wake}. */
+	async changed() {
+		await new Promise((resolve) => {
+			this.#waiters.push(resolve);
+		});
+	}
+	wake() {
+		const waiters = this.#waiters;
+		this.#waiters = [];
+		for (const resolve of waiters) resolve();
+	}
+};
+/** Identity of a job across redeliveries of the same push loop: its lease receipt, else build and shard. */
+function jobKey(job) {
+	return job.receipt ?? `${job.buildId}:${job.shard ?? ""}`;
+}
+//#endregion
+export { RunBook, jobKey };
+
+//# sourceMappingURL=runs.mjs.map

package/dist/capture/forked/runs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.mjs","names":[],"sources":["../../../src/capture/forked/runs.ts"],"sourcesContent":["/** The runs pushed to the capture child and not yet settled, and who may start next. */\nimport type { ConsumerJob, JobRunContext } from \"../consumer/types.ts\";\n\n/** How a push ended. */\nexport type RunVerdict =\n  | { kind: \"done\" }\n  | { kind: \"failed\"; error: string }\n  /** The child died under it; `charged` when this run is the one that took it down. */\n  | { kind: \"crashed\"; charged: boolean; error: string };\n\n/** One push of a job to the child. */\nexport interface Run {\n  runId: string;\n  job: ConsumerJob;\n  context: JobRunContext;\n  /** Runs alone: it shared a crashed child, so a repeat crash will name its culprit. */\n  solo: boolean;\n  settle: (verdict: RunVerdict) => void;\n  verdict: Promise<RunVerdict>;\n}\n\n/** In-flight runs by id, plus the admission rule for solo runs and a signal for waiters. */\nexport class RunBook {\n  readonly #runs = new Map<string, Run>();\n  #waiters: (() => void)[] = [];\n  #ids = 0;\n\n  /** Register a run (call right after {@link canStart}, with no await between). */\n  add(job: ConsumerJob, context: JobRunContext, solo: boolean): Run {\n    this.#ids += 1;\n    const { promise, resolve } = Promise.withResolvers<RunVerdict>();\n    const run: Run = {\n      runId: `run-${this.#ids}`,\n      job,\n      context,\n      solo,\n      settle: resolve,\n      verdict: promise,\n    };\n    this.#runs.set(run.runId, run);\n    return run;\n  }\n\n  get(runId: string): Run | undefined {\n    return this.#runs.get(runId);\n  }\n\n  /** The run of `job` (by lease receipt, else build and shard), when it is out with the child. */\n  runOf(job: ConsumerJob): Run | undefined {\n    return [...this.#runs.values()].find((run) => jobKey(run.job) === jobKey(job));\n  }\n\n  get size(): number {\n    return this.#runs.size;\n  }\n\n  /** A solo run waits for an empty child and then runs alone; nothing starts beside it. */\n  canStart(solo: boolean): boolean {\n    const runs = [...this.#runs.values()];\n    if (runs.some((run) => run.solo)) {\n      return false;\n    }\n    return solo ? runs.length === 0 : true;\n  }\n\n  /** Settle and remove one run, then wake whoever waits for a place. */\n  finish(runId: string, verdict: RunVerdict): void {\n    const run = this.#runs.get(runId);\n    if (run) {\n      this.#runs.delete(runId);\n      run.settle(verdict);\n    }\n    this.wake();\n  }\n\n  /** Remove every run (the child that held them is gone), returning them. */\n  takeAll(): Run[] {\n    const runs = [...this.#runs.values()];\n    this.#runs.clear();\n    return runs;\n  }\n\n  /** Resolves at the next {@link wake}. */\n  async changed(): Promise<void> {\n    await new Promise<void>((resolve) => {\n      this.#waiters.push(resolve);\n    });\n  }\n\n  wake(): void {\n    const waiters = this.#waiters;\n    this.#waiters = [];\n    for (const resolve of waiters) {\n      resolve();\n    }\n  }\n}\n\n/** Identity of a job across redeliveries of the same push loop: its lease receipt, else build and shard. */\nexport function jobKey(job: ConsumerJob): string {\n  return job.receipt ?? `${job.buildId}:${job.shard ?? \"\"}`;\n}\n"],"mappings":";;;;;AAsBA,IAAa,UAAb,MAAqB;CACnB,wBAAiB,IAAI,IAAiB;CACtC,WAA2B,CAAC;CAC5B,OAAO;;CAGP,IAAI,KAAkB,SAAwB,MAAoB;EAChE,KAAK,QAAQ;EACb,MAAM,EAAE,SAAS,YAAY,QAAQ,cAA0B;EAC/D,MAAM,MAAW;GACf,OAAO,OAAO,KAAK;GACnB;GACA;GACA;GACA,QAAQ;GACR,SAAS;EACX;EACA,KAAK,MAAM,IAAI,IAAI,OAAO,GAAG;EAC7B,OAAO;CACT;CAEA,IAAI,OAAgC;EAClC,OAAO,KAAK,MAAM,IAAI,KAAK;CAC7B;;CAGA,MAAM,KAAmC;EACvC,OAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC,CAAC,CAAC,MAAM,QAAQ,OAAO,IAAI,GAAG,MAAM,OAAO,GAAG,CAAC;CAC/E;CAEA,IAAI,OAAe;EACjB,OAAO,KAAK,MAAM;CACpB;;CAGA,SAAS,MAAwB;EAC/B,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC;EACpC,IAAI,KAAK,MAAM,QAAQ,IAAI,IAAI,GAC7B,OAAO;EAET,OAAO,OAAO,KAAK,WAAW,IAAI;CACpC;;CAGA,OAAO,OAAe,SAA2B;EAC/C,MAAM,MAAM,KAAK,MAAM,IAAI,KAAK;EAChC,IAAI,KAAK;GACP,KAAK,MAAM,OAAO,KAAK;GACvB,IAAI,OAAO,OAAO;EACpB;EACA,KAAK,KAAK;CACZ;;CAGA,UAAiB;EACf,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC;EACpC,KAAK,MAAM,MAAM;EACjB,OAAO;CACT;;CAGA,MAAM,UAAyB;EAC7B,MAAM,IAAI,SAAe,YAAY;GACnC,KAAK,SAAS,KAAK,OAAO;EAC5B,CAAC;CACH;CAEA,OAAa;EACX,MAAM,UAAU,KAAK;EACrB,KAAK,WAAW,CAAC;EACjB,KAAK,MAAM,WAAW,SACpB,QAAQ;CAEZ;AACF;;AAGA,SAAgB,OAAO,KAA0B;CAC/C,OAAO,IAAI,WAAW,GAAG,IAAI,QAAQ,GAAG,IAAI,SAAS;AACvD"}