zod-compiler 1.26.4 → 1.28.0

package/dist/unplugin/pool.d.ts

@@ -0,0 +1,162 @@
+import { CodegenMode } from "../core/codegen/context.js";
+import { HoistOptions } from "./hoist.js";
+import { BuildStats, TransformOptions } from "./types.js";
+import { TransformSourceMap } from "./transform.js";
+//#region src/unplugin/pool.d.ts
+/** The subset of TransformOptions that survives structured cloning. */
+interface PoolTransformOptions {
+  mode: CodegenMode;
+  runtimeId?: string | undefined;
+  zodCompat?: boolean | undefined;
+  compact?: boolean | undefined;
+  verbose?: boolean | undefined;
+  autoDiscover?: boolean | undefined;
+  hoist?: boolean | HoistOptions | undefined;
+}
+/** Main → worker. */
+type PoolRequest = {
+  type: "transform";
+  seq: number;
+  code: string;
+  id: string;
+  options: PoolTransformOptions;
+} | {
+  type: "invalidate";
+  seq: number;
+};
+/**
+ * What a worker observed while transforming one file: the output plus the
+ * signals the main thread's disk-cache bookkeeping needs, which arrive as
+ * callbacks in the in-process path and cannot cross a thread boundary.
+ */
+interface PoolTransformResult {
+  output: {
+    code: string;
+    map: TransformSourceMap | null;
+  } | null;
+  discoveryRan: boolean;
+  substantialWork: boolean;
+  uncacheable: boolean;
+  stats: BuildStats | null;
+  /**
+   * First-party modules this worker executed since its last report, or `null`
+   * when the worker cannot track them (Bun/Deno native import).
+   */
+  newModulePaths: string[] | null;
+}
+/** Worker → main. */
+type PoolResponse = {
+  type: "result";
+  seq: number;
+  result: PoolTransformResult;
+} | {
+  type: "error";
+  seq: number;
+  name: string;
+  message: string;
+  stack?: string | undefined;
+} | {
+  type: "invalidated";
+  seq: number;
+};
+/**
+ * Raised when the pool itself failed — a worker that would not spawn, or one
+ * that died mid-task (OOM is the realistic case; each worker holds a full
+ * module graph). Distinct from a transform's own error, which is rethrown with
+ * its original identity, because the caller's response differs: an
+ * infrastructure failure is worth retrying on the bundler thread, a schema
+ * that cannot compile is not.
+ */
+declare class PoolUnavailableError extends Error {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Resolve `parallel` to a worker count. `false`/`undefined` disable the pool.
+ *
+ * `true` leaves one core for the bundler itself — it is still parsing,
+ * resolving and generating chunks while transforms run — and then caps at
+ * {@link MAX_AUTO_WORKERS}.
+ */
+declare function resolvePoolSize(parallel: boolean | number | undefined): number;
+/** Strip the callbacks from TransformOptions; what remains is cloneable. */
+declare function poolTransformOptions(options: TransformOptions): PoolTransformOptions;
+/** Terminate every live transform pool. */
+declare function disposeAllPools(): Promise<void>;
+/**
+ * A lazily grown pool of transform workers.
+ *
+ * Not a general-purpose executor: it knows the transform protocol, and it
+ * knows that a broadcast invalidation has to be ordered ahead of every
+ * subsequent transform on every worker (per-worker message delivery is FIFO,
+ * so posting the broadcast before any later task is sufficient — and the only
+ * ordering guarantee available, since a worker mid-transform cannot be
+ * interrupted).
+ */
+declare class TransformPool {
+  private readonly size;
+  private readonly entry;
+  private readonly workers;
+  private readonly queue;
+  /** In-flight requests by seq, so a worker exit can reject exactly its own. */
+  private readonly inflight;
+  private readonly executedModules;
+  /** A worker reported it cannot track executed modules — the union is unusable. */
+  private moduleTrackingUnavailable;
+  private seq;
+  private disposed;
+  /** Worker deaths since the last successful result; trips MAX_CONSECUTIVE_FAILURES. */
+  private consecutiveFailures;
+  /** Set once the breaker trips: every later run() rejects without spawning. */
+  private brokenPool;
+  private constructor();
+  /**
+   * Build a pool of `size` workers, or return null when workers are
+   * unavailable in this installation (the entry could not be located). Callers
+   * treat null as "run in-process".
+   */
+  static create(size: number): TransformPool | null;
+  /** Transform one file on a worker. Rejects with the transform's own error, or PoolUnavailableError. */
+  run(code: string, id: string, options: PoolTransformOptions): Promise<PoolTransformResult>;
+  /**
+   * Drop every worker's executed-module cache, so the next discovery re-runs
+   * changed schema graphs. Mirrors the loader's invalidateModuleCache() for
+   * the in-process path; called from watchChange.
+   *
+   * Fire-and-forget: the broadcast is posted to every live worker before any
+   * later transform can be, and per-worker FIFO delivery does the rest. A
+   * transform ALREADY executing in a worker keeps its pre-change module cache
+   * — the same window the in-process path has, where invalidation lands
+   * between awaits — and the main thread's own result cache is cleared
+   * alongside, so the file is recomputed either way.
+   */
+  invalidate(): void;
+  /**
+   * Union of the first-party modules every worker has executed, or null when
+   * any worker cannot track them. Synchronous, because DiskCache.flushDeferred
+   * runs from `buildEnd` and from a process 'exit' hook, where only
+   * synchronous work is allowed — which is why workers push deltas rather than
+   * answering a query.
+   */
+  firstPartyModulePaths(): string[] | null;
+  /** Terminate every worker. Pending and queued tasks reject. */
+  dispose(): Promise<void>;
+  /** Hand a task to an idle worker, grow the pool, or queue it. */
+  private dispatch;
+  private send;
+  private spawn;
+  private onMessage;
+  /**
+   * A worker died — OOM while holding a large module graph is the realistic
+   * cause. Its task fails with PoolUnavailableError so the caller can retry
+   * in-process, and the worker is dropped from the pool; the next dispatch
+   * spawns a replacement.
+   */
+  private onWorkerGone;
+  private drain;
+  private recordModulePaths;
+}
+//#endregion
+export { PoolRequest, PoolResponse, PoolTransformOptions, PoolTransformResult, PoolUnavailableError, TransformPool, disposeAllPools, poolTransformOptions, resolvePoolSize };
+//# sourceMappingURL=pool.d.ts.map

package/dist/unplugin/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","names":[],"sources":["../../src/unplugin/pool.ts"],"mappings":";;;;;;UA8GiB;EACf,MAAM;EACN;EACA;EACA;EACA;EACA;EACA,kBAAkB;;;KAIR;EACN;EAAmB;EAAa;EAAc;EAAY,SAAS;;EACnE;EAAoB;;;;;;;UAOT;EACf;IAAU;IAAc,KAAK;;EAC7B;EACA;EACA;EACA,OAAO;;;;;EAKP;;;KAIU;EACN;EAAgB;EAAa,QAAQ;;EACrC;EAAe;EAAa;EAAc;EAAiB;;EAC3D;EAAqB;;;;;;;;;;cAUd,6BAA6B;EAC5B,YAAA,iBAAiB;IAAY;;;;;;;;;;iBAa3B,gBAAgB;;iBAUhB,qBAAqB,SAAS,mBAAmB;;iBA4F3C,mBAAmB;;;;;;;;;;;cA0B5B;mBACM;mBACA;mBACA;mBACA;;mBAEA;mBACA;;UAET;UACA;UACA;;UAEA;;UAEA;UAED;;;;;;SAUA,OAAO,eAAe;;EAU7B,IAAI,cAAc,YAAY,SAAS,uBAAuB,QAAQ;;;;;;;;;;;;;EA6BtE;;;;;;;;EAgBA;;EAUM,WAAW;;UAYT;UA0BA;UAUA;UAwBA;;;;;;;UAmCA;UAwBA;UA2BA"}

package/dist/unplugin/pool.js

@@ -0,0 +1,445 @@
+import * as fs$1 from "node:fs";
+import { availableParallelism } from "node:os";
+import { Worker } from "node:worker_threads";
+//#region src/unplugin/pool.ts
+/**
+* Worker-thread pool for the unplugin transform.
+*
+* Discovery — executing a schema file and its whole first-party import graph
+* so Zod's constructors run and produce the objects extract walks — is the
+* single most expensive phase of a cold build, and today it runs strictly one
+* file at a time: `loadQueue` in ../loader.ts serializes every jiti import so
+* concurrent transforms cannot double-execute a shared dependency, and the
+* bundler itself is one process. Nothing about the work requires that. Each
+* file's transform reads only `(code, id, options)` and returns
+* `{ code, map }` plus a few flags — the shape of a task, not of a stage.
+*
+* So the pool moves whole transforms off the bundler thread. Each worker owns
+* its own loader, its own jiti instance and its own copy of zod; nothing is
+* shared, which is exactly why the serialization inside a worker is harmless.
+* Measured on 120 files of deeply nested schemas: 3,633 ms sequential →
+* 1,508 ms at four workers. The pool is spawned LAZILY — a project with three
+* schema files starts three workers, not one per core.
+*
+* ## When it does NOT pay
+*
+* Independence is the whole bet, and it is a bet about the user's import
+* graph, not about their machine. In-process, the loader executes a shared
+* dependency ONCE for the whole build; N workers execute it N times. So the
+* win tracks how disjoint the schema files' graphs are, and it can invert: on
+* a fixture of the same size whose files form a 120-deep chain, four workers
+* measured 1,045 ms against 945 ms in-process — a small loss — and twelve
+* measured 3,332 ms, because each worker was re-executing most of the project
+* to compile its share of it. The same files with the chain removed went
+* 636 ms → 341 ms.
+*
+* That, plus N copies of the graph in memory, is why this is opt-in rather
+* than the default — see ZodCompilerPluginOptions.
+*
+* ## What still runs on the bundler thread
+*
+* Everything that touches shared state: the disk cache (one directory, one GC,
+* atomic writes), the static dependency crawl (pure over the filesystem, and
+* memoized across files — sharding it would multiply the memo instead of the
+* throughput), and the in-memory result cache. Workers do the executing and
+* the generating; the main thread does the bookkeeping.
+*
+* ## Executed-module reporting
+*
+* The disk cache needs `getFirstPartyModulePaths()` — the superset of modules
+* the loader has executed — to persist entries whose static dep crawl came
+* back incomplete (the common outcome on large graphs: one non-literal dynamic
+* import anywhere poisons the closure). With discovery in workers, the main
+* thread's loader executes nothing, so that superset would be empty and every
+* deferred entry would be silently dropped — no stale results, but a large
+* chunk of the cache quietly stops working.
+*
+* Workers therefore report the paths they have executed back with every
+* result, as a DELTA against what they have already reported (the full list
+* grows into the thousands and would be re-sent per file). The pool unions
+* those deltas into {@link TransformPool.firstPartyModulePaths}, which the
+* DiskCache reads synchronously at flush time exactly as it reads the loader's
+* own. A worker that cannot track modules at all — Bun/Deno, where native
+* import has no evictable cache — reports `null`, and the union degrades to
+* `null` so the cache declines to persist rather than guessing.
+*/
+/**
+* Upper bound on pool size for `parallel: true`.
+*
+* Four, and not "one per core", because throughput peaks there and then goes
+* BACKWARDS. Measured on 120 files of deeply nested schemas (960 schemas), on
+* a machine with 12 performance cores:
+*
+*   in-process 3,633 ms · n=2 2,263 · n=4 1,508 · n=6 1,568 · n=8 1,786 · n=12 2,119
+*
+* Past four the bottleneck stops being CPU. Every worker re-executes whatever
+* of the project graph its files reach, holds its own copy of it, and ships
+* megabytes of generated source back through structured cloning that the ONE
+* receiving thread has to deserialize. More workers multiply the first two
+* costs and contend on the third.
+*
+* The same effect makes the cap protective rather than merely tidy: on a
+* fixture whose files form a 120-deep import chain — where the in-process
+* loader executes the shared graph once and every worker re-executes most of
+* it — n=4 costs 1,045 ms against 945 ms in-process, while n=12 costs 3,332 ms.
+* Overshooting turns a small loss into a rout. An explicit `parallel: <n>`
+* overrides this for anyone who has measured their own graph.
+*/
+const MAX_AUTO_WORKERS = 4;
+/** Hard ceiling on an explicit `parallel: <n>`, guarding a typo'd 400. */
+const MAX_WORKERS = 32;
+/**
+* Consecutive worker deaths before the pool gives up for the rest of the build.
+*
+* Falling back per file is the right response to ONE unlucky worker (an OOM
+* under a particularly large graph). It is the wrong response to a pool that
+* cannot work at all — a partial install, a Node build without worker support
+* — where every file would spawn a worker, wait for it to die, warn, and then
+* do the transform in-process anyway. Tripping the breaker converts that into
+* a normal serial build after the first few files.
+*/
+const MAX_CONSECUTIVE_FAILURES = 3;
+/**
+* Raised when the pool itself failed — a worker that would not spawn, or one
+* that died mid-task (OOM is the realistic case; each worker holds a full
+* module graph). Distinct from a transform's own error, which is rethrown with
+* its original identity, because the caller's response differs: an
+* infrastructure failure is worth retrying on the bundler thread, a schema
+* that cannot compile is not.
+*/
+var PoolUnavailableError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "PoolUnavailableError";
+	}
+};
+/**
+* Resolve `parallel` to a worker count. `false`/`undefined` disable the pool.
+*
+* `true` leaves one core for the bundler itself — it is still parsing,
+* resolving and generating chunks while transforms run — and then caps at
+* {@link MAX_AUTO_WORKERS}.
+*/
+function resolvePoolSize(parallel) {
+	if (parallel === void 0 || parallel === false) return 0;
+	if (parallel === true) return Math.min(Math.max(availableParallelism() - 1, 1), MAX_AUTO_WORKERS);
+	if (!Number.isFinite(parallel)) return 0;
+	return Math.min(Math.max(Math.floor(parallel), 1), MAX_WORKERS);
+}
+/** Strip the callbacks from TransformOptions; what remains is cloneable. */
+function poolTransformOptions(options) {
+	return {
+		mode: options.mode,
+		runtimeId: options.runtimeId,
+		zodCompat: options.zodCompat,
+		compact: options.compact,
+		verbose: options.verbose,
+		autoDiscover: options.autoDiscover,
+		hoist: options.hoist
+	};
+}
+/**
+* Locate the worker entry next to this module.
+*
+* Published, that is `dist/unplugin/pool-worker.js` and a plain dynamic import
+* loads it. Running from source — this repository's own test suite resolves
+* `#src/**` through Vite — only the `.ts` sibling exists, and a worker starts
+* outside Vite's pipeline, in bare Node. Node's native type stripping is not
+* enough there: it erases types but does not remap the `./transform.js`
+* specifiers TypeScript requires onto the `.ts` files that actually exist. So
+* the bootstrap hands `.ts` entries to jiti, which resolves them the same way
+* the loader already resolves user schema files.
+*
+* Returns null when neither exists — the plugin's own code has been bundled
+* into a single file by a consumer, so `import.meta.url` no longer points at a
+* directory containing it. The caller falls back to in-process transforms.
+*/
+function resolveWorkerEntry() {
+	for (const [specifier, isTypeScript] of [["./pool-worker.js", false], ["./pool-worker.ts", true]]) {
+		const url = new URL(specifier, import.meta.url);
+		if (url.protocol !== "file:") continue;
+		try {
+			if (fs$1.statSync(url, { throwIfNoEntry: false })?.isFile()) return {
+				href: url.href,
+				isTypeScript
+			};
+		} catch {}
+	}
+	return null;
+}
+/**
+* CommonJS bootstrap evaluated inside each worker (`eval: true`). A string
+* rather than a file because it has to work identically from `dist/` and from
+* `src/`, where no `.js` sibling exists to point a Worker at.
+*/
+const WORKER_BOOTSTRAP = `
+const { workerData } = require("node:worker_threads");
+(async () => {
+  if (workerData.isTypeScript) {
+    const { createJiti } = await import(workerData.jitiSpecifier);
+    await createJiti(workerData.entry).import(workerData.entry);
+  } else {
+    await import(workerData.entry);
+  }
+})().catch((error) => {
+  // Reaching the parent as an 'error' event is the whole point: a worker that
+  // cannot load its entry must fail loudly enough for the pool to fall back,
+  // not sit idle holding a task.
+  setTimeout(() => { throw error; });
+});
+`;
+/** Resolve jiti's URL for the bootstrap; bare specifier if resolution is unavailable. */
+function jitiSpecifier() {
+	try {
+		return import.meta.resolve("jiti");
+	} catch {
+		return "jiti";
+	}
+}
+/**
+* Live pools, so a host that outlives its bundler can shut them all down.
+*
+* Nothing in the plugin lifecycle disposes a pool on its own: workers are kept
+* warm ACROSS watch rebuilds on purpose — invalidation drops first-party
+* modules but leaves node_modules (zod itself, the expensive bulk) executed,
+* and discarding that per rebuild would re-pay boot plus a cold zod on every
+* keystroke. Idle workers are unref'd, so they never hold a process open and a
+* one-shot build exits normally. This registry exists for hosts that need
+* determinism instead — chiefly this package's own test suite, which builds
+* many plugin instances in one process.
+*/
+const livePools = /* @__PURE__ */ new Set();
+/** Terminate every live transform pool. */
+async function disposeAllPools() {
+	await Promise.all([...livePools].map((pool) => pool.dispose()));
+}
+/**
+* A lazily grown pool of transform workers.
+*
+* Not a general-purpose executor: it knows the transform protocol, and it
+* knows that a broadcast invalidation has to be ordered ahead of every
+* subsequent transform on every worker (per-worker message delivery is FIFO,
+* so posting the broadcast before any later task is sufficient — and the only
+* ordering guarantee available, since a worker mid-transform cannot be
+* interrupted).
+*/
+var TransformPool = class TransformPool {
+	size;
+	entry;
+	workers = [];
+	queue = [];
+	/** In-flight requests by seq, so a worker exit can reject exactly its own. */
+	inflight = /* @__PURE__ */ new Map();
+	executedModules = /* @__PURE__ */ new Set();
+	/** A worker reported it cannot track executed modules — the union is unusable. */
+	moduleTrackingUnavailable = false;
+	seq = 0;
+	disposed = false;
+	/** Worker deaths since the last successful result; trips MAX_CONSECUTIVE_FAILURES. */
+	consecutiveFailures = 0;
+	/** Set once the breaker trips: every later run() rejects without spawning. */
+	brokenPool = false;
+	constructor(size, entry) {
+		this.size = size;
+		this.entry = entry;
+	}
+	/**
+	* Build a pool of `size` workers, or return null when workers are
+	* unavailable in this installation (the entry could not be located). Callers
+	* treat null as "run in-process".
+	*/
+	static create(size) {
+		if (size <= 0) return null;
+		const entry = resolveWorkerEntry();
+		if (entry === null) return null;
+		const pool = new TransformPool(size, entry);
+		livePools.add(pool);
+		return pool;
+	}
+	/** Transform one file on a worker. Rejects with the transform's own error, or PoolUnavailableError. */
+	run(code, id, options) {
+		if (this.disposed) return Promise.reject(new PoolUnavailableError("Transform pool is disposed"));
+		if (this.brokenPool) return Promise.reject(new PoolUnavailableError(`Transform workers failed ${MAX_CONSECUTIVE_FAILURES} times in a row; this build is running in-process`));
+		return new Promise((resolve, reject) => {
+			const request = {
+				type: "transform",
+				seq: this.seq++,
+				code,
+				id,
+				options
+			};
+			this.dispatch({
+				request,
+				resolve,
+				reject
+			});
+		});
+	}
+	/**
+	* Drop every worker's executed-module cache, so the next discovery re-runs
+	* changed schema graphs. Mirrors the loader's invalidateModuleCache() for
+	* the in-process path; called from watchChange.
+	*
+	* Fire-and-forget: the broadcast is posted to every live worker before any
+	* later transform can be, and per-worker FIFO delivery does the rest. A
+	* transform ALREADY executing in a worker keeps its pre-change module cache
+	* — the same window the in-process path has, where invalidation lands
+	* between awaits — and the main thread's own result cache is cleared
+	* alongside, so the file is recomputed either way.
+	*/
+	invalidate() {
+		if (this.disposed) return;
+		this.executedModules.clear();
+		this.moduleTrackingUnavailable = false;
+		for (const entry of this.workers) entry.worker.postMessage({
+			type: "invalidate",
+			seq: this.seq++
+		});
+	}
+	/**
+	* Union of the first-party modules every worker has executed, or null when
+	* any worker cannot track them. Synchronous, because DiskCache.flushDeferred
+	* runs from `buildEnd` and from a process 'exit' hook, where only
+	* synchronous work is allowed — which is why workers push deltas rather than
+	* answering a query.
+	*/
+	firstPartyModulePaths() {
+		if (this.moduleTrackingUnavailable) return null;
+		return [...this.executedModules];
+	}
+	/** Terminate every worker. Pending and queued tasks reject. */
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		livePools.delete(this);
+		const error = new PoolUnavailableError("Transform pool was disposed");
+		for (const task of this.queue.splice(0)) task.reject(error);
+		for (const task of this.inflight.values()) task.reject(error);
+		this.inflight.clear();
+		await Promise.all(this.workers.splice(0).map((entry) => entry.worker.terminate()));
+	}
+	/** Hand a task to an idle worker, grow the pool, or queue it. */
+	dispatch(task) {
+		const idle = this.workers.find((entry) => entry.busy === null);
+		if (idle !== void 0) {
+			this.send(idle, task);
+			return;
+		}
+		if (this.workers.length < this.size) {
+			let created;
+			try {
+				created = this.spawn();
+			} catch (error) {
+				task.reject(new PoolUnavailableError(`Could not start a zod-compiler transform worker: ${error instanceof Error ? error.message : String(error)}`, { cause: error }));
+				return;
+			}
+			this.workers.push(created);
+			this.send(created, task);
+			return;
+		}
+		this.queue.push(task);
+	}
+	send(entry, task) {
+		entry.busy = task.request.seq;
+		this.inflight.set(task.request.seq, task);
+		entry.worker.ref();
+		entry.worker.postMessage(task.request);
+	}
+	spawn() {
+		const worker = new Worker(WORKER_BOOTSTRAP, {
+			eval: true,
+			workerData: {
+				entry: this.entry.href,
+				isTypeScript: this.entry.isTypeScript,
+				jitiSpecifier: jitiSpecifier()
+			}
+		});
+		const entry = {
+			worker,
+			busy: null
+		};
+		worker.unref();
+		worker.on("message", (message) => {
+			this.onMessage(entry, message);
+		});
+		worker.on("error", (error) => {
+			this.onWorkerGone(entry, error);
+		});
+		worker.on("exit", (code) => {
+			if (this.disposed) return;
+			this.onWorkerGone(entry, /* @__PURE__ */ new Error(`worker exited with code ${code}`));
+		});
+		return entry;
+	}
+	onMessage(entry, message) {
+		if (message.type === "invalidated") return;
+		const task = this.inflight.get(message.seq);
+		this.inflight.delete(message.seq);
+		if (entry.busy === message.seq) {
+			entry.busy = null;
+			entry.worker.unref();
+		}
+		if (task !== void 0) if (message.type === "result") {
+			this.consecutiveFailures = 0;
+			this.recordModulePaths(message.result.newModulePaths);
+			task.resolve(message.result);
+		} else {
+			const error = new Error(message.message);
+			error.name = message.name;
+			if (message.stack !== void 0) error.stack = message.stack;
+			task.reject(error);
+		}
+		this.drain();
+	}
+	/**
+	* A worker died — OOM while holding a large module graph is the realistic
+	* cause. Its task fails with PoolUnavailableError so the caller can retry
+	* in-process, and the worker is dropped from the pool; the next dispatch
+	* spawns a replacement.
+	*/
+	onWorkerGone(entry, cause) {
+		const index = this.workers.indexOf(entry);
+		if (index === -1) return;
+		this.workers.splice(index, 1);
+		if (++this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) this.brokenPool = true;
+		const seq = entry.busy;
+		entry.busy = null;
+		if (seq !== null) {
+			const task = this.inflight.get(seq);
+			this.inflight.delete(seq);
+			task?.reject(new PoolUnavailableError(`zod-compiler transform worker failed: ${cause.message}`, { cause }));
+		}
+		this.drain();
+	}
+	drain() {
+		if (this.brokenPool) {
+			const error = new PoolUnavailableError(`Transform workers failed ${MAX_CONSECUTIVE_FAILURES} times in a row; this build is running in-process`);
+			for (const task of this.queue.splice(0)) task.reject(error);
+			return;
+		}
+		while (this.queue.length > 0) {
+			const idle = this.workers.find((e) => e.busy === null);
+			if (idle === void 0) {
+				if (this.workers.length >= this.size) return;
+				const task = this.queue.shift();
+				if (task === void 0) return;
+				this.dispatch(task);
+				continue;
+			}
+			const task = this.queue.shift();
+			if (task === void 0) return;
+			this.send(idle, task);
+		}
+	}
+	recordModulePaths(paths) {
+		if (paths === null) {
+			this.moduleTrackingUnavailable = true;
+			return;
+		}
+		for (const p of paths) this.executedModules.add(p);
+	}
+};
+//#endregion
+export { PoolUnavailableError, TransformPool, disposeAllPools, poolTransformOptions, resolvePoolSize };
+
+//# sourceMappingURL=pool.js.map

package/dist/unplugin/pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.js","names":["fs"],"sources":["../../src/unplugin/pool.ts"],"sourcesContent":["/**\n * Worker-thread pool for the unplugin transform.\n *\n * Discovery — executing a schema file and its whole first-party import graph\n * so Zod's constructors run and produce the objects extract walks — is the\n * single most expensive phase of a cold build, and today it runs strictly one\n * file at a time: `loadQueue` in ../loader.ts serializes every jiti import so\n * concurrent transforms cannot double-execute a shared dependency, and the\n * bundler itself is one process. Nothing about the work requires that. Each\n * file's transform reads only `(code, id, options)` and returns\n * `{ code, map }` plus a few flags — the shape of a task, not of a stage.\n *\n * So the pool moves whole transforms off the bundler thread. Each worker owns\n * its own loader, its own jiti instance and its own copy of zod; nothing is\n * shared, which is exactly why the serialization inside a worker is harmless.\n * Measured on 120 files of deeply nested schemas: 3,633 ms sequential →\n * 1,508 ms at four workers. The pool is spawned LAZILY — a project with three\n * schema files starts three workers, not one per core.\n *\n * ## When it does NOT pay\n *\n * Independence is the whole bet, and it is a bet about the user's import\n * graph, not about their machine. In-process, the loader executes a shared\n * dependency ONCE for the whole build; N workers execute it N times. So the\n * win tracks how disjoint the schema files' graphs are, and it can invert: on\n * a fixture of the same size whose files form a 120-deep chain, four workers\n * measured 1,045 ms against 945 ms in-process — a small loss — and twelve\n * measured 3,332 ms, because each worker was re-executing most of the project\n * to compile its share of it. The same files with the chain removed went\n * 636 ms → 341 ms.\n *\n * That, plus N copies of the graph in memory, is why this is opt-in rather\n * than the default — see ZodCompilerPluginOptions.\n *\n * ## What still runs on the bundler thread\n *\n * Everything that touches shared state: the disk cache (one directory, one GC,\n * atomic writes), the static dependency crawl (pure over the filesystem, and\n * memoized across files — sharding it would multiply the memo instead of the\n * throughput), and the in-memory result cache. Workers do the executing and\n * the generating; the main thread does the bookkeeping.\n *\n * ## Executed-module reporting\n *\n * The disk cache needs `getFirstPartyModulePaths()` — the superset of modules\n * the loader has executed — to persist entries whose static dep crawl came\n * back incomplete (the common outcome on large graphs: one non-literal dynamic\n * import anywhere poisons the closure). With discovery in workers, the main\n * thread's loader executes nothing, so that superset would be empty and every\n * deferred entry would be silently dropped — no stale results, but a large\n * chunk of the cache quietly stops working.\n *\n * Workers therefore report the paths they have executed back with every\n * result, as a DELTA against what they have already reported (the full list\n * grows into the thousands and would be re-sent per file). The pool unions\n * those deltas into {@link TransformPool.firstPartyModulePaths}, which the\n * DiskCache reads synchronously at flush time exactly as it reads the loader's\n * own. A worker that cannot track modules at all — Bun/Deno, where native\n * import has no evictable cache — reports `null`, and the union degrades to\n * `null` so the cache declines to persist rather than guessing.\n */\n\nimport * as fs from \"node:fs\";\nimport { availableParallelism } from \"node:os\";\nimport { Worker } from \"node:worker_threads\";\nimport type { CodegenMode } from \"../core/codegen/context.js\";\nimport type { HoistOptions } from \"./hoist.js\";\nimport type { TransformSourceMap } from \"./transform.js\";\nimport type { BuildStats, TransformOptions } from \"./types.js\";\n\n/**\n * Upper bound on pool size for `parallel: true`.\n *\n * Four, and not \"one per core\", because throughput peaks there and then goes\n * BACKWARDS. Measured on 120 files of deeply nested schemas (960 schemas), on\n * a machine with 12 performance cores:\n *\n *   in-process 3,633 ms · n=2 2,263 · n=4 1,508 · n=6 1,568 · n=8 1,786 · n=12 2,119\n *\n * Past four the bottleneck stops being CPU. Every worker re-executes whatever\n * of the project graph its files reach, holds its own copy of it, and ships\n * megabytes of generated source back through structured cloning that the ONE\n * receiving thread has to deserialize. More workers multiply the first two\n * costs and contend on the third.\n *\n * The same effect makes the cap protective rather than merely tidy: on a\n * fixture whose files form a 120-deep import chain — where the in-process\n * loader executes the shared graph once and every worker re-executes most of\n * it — n=4 costs 1,045 ms against 945 ms in-process, while n=12 costs 3,332 ms.\n * Overshooting turns a small loss into a rout. An explicit `parallel: <n>`\n * overrides this for anyone who has measured their own graph.\n */\nconst MAX_AUTO_WORKERS = 4;\n\n/** Hard ceiling on an explicit `parallel: <n>`, guarding a typo'd 400. */\nconst MAX_WORKERS = 32;\n\n/**\n * Consecutive worker deaths before the pool gives up for the rest of the build.\n *\n * Falling back per file is the right response to ONE unlucky worker (an OOM\n * under a particularly large graph). It is the wrong response to a pool that\n * cannot work at all — a partial install, a Node build without worker support\n * — where every file would spawn a worker, wait for it to die, warn, and then\n * do the transform in-process anyway. Tripping the breaker converts that into\n * a normal serial build after the first few files.\n */\nconst MAX_CONSECUTIVE_FAILURES = 3;\n\n/** The subset of TransformOptions that survives structured cloning. */\nexport interface PoolTransformOptions {\n  mode: CodegenMode;\n  runtimeId?: string | undefined;\n  zodCompat?: boolean | undefined;\n  compact?: boolean | undefined;\n  verbose?: boolean | undefined;\n  autoDiscover?: boolean | undefined;\n  hoist?: boolean | HoistOptions | undefined;\n}\n\n/** Main → worker. */\nexport type PoolRequest =\n  | { type: \"transform\"; seq: number; code: string; id: string; options: PoolTransformOptions }\n  | { type: \"invalidate\"; seq: number };\n\n/**\n * What a worker observed while transforming one file: the output plus the\n * signals the main thread's disk-cache bookkeeping needs, which arrive as\n * callbacks in the in-process path and cannot cross a thread boundary.\n */\nexport interface PoolTransformResult {\n  output: { code: string; map: TransformSourceMap | null } | null;\n  discoveryRan: boolean;\n  substantialWork: boolean;\n  uncacheable: boolean;\n  stats: BuildStats | null;\n  /**\n   * First-party modules this worker executed since its last report, or `null`\n   * when the worker cannot track them (Bun/Deno native import).\n   */\n  newModulePaths: string[] | null;\n}\n\n/** Worker → main. */\nexport type PoolResponse =\n  | { type: \"result\"; seq: number; result: PoolTransformResult }\n  | { type: \"error\"; seq: number; name: string; message: string; stack?: string | undefined }\n  | { type: \"invalidated\"; seq: number };\n\n/**\n * Raised when the pool itself failed — a worker that would not spawn, or one\n * that died mid-task (OOM is the realistic case; each worker holds a full\n * module graph). Distinct from a transform's own error, which is rethrown with\n * its original identity, because the caller's response differs: an\n * infrastructure failure is worth retrying on the bundler thread, a schema\n * that cannot compile is not.\n */\nexport class PoolUnavailableError extends Error {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super(message, options);\n    this.name = \"PoolUnavailableError\";\n  }\n}\n\n/**\n * Resolve `parallel` to a worker count. `false`/`undefined` disable the pool.\n *\n * `true` leaves one core for the bundler itself — it is still parsing,\n * resolving and generating chunks while transforms run — and then caps at\n * {@link MAX_AUTO_WORKERS}.\n */\nexport function resolvePoolSize(parallel: boolean | number | undefined): number {\n  if (parallel === undefined || parallel === false) return 0;\n  if (parallel === true) {\n    return Math.min(Math.max(availableParallelism() - 1, 1), MAX_AUTO_WORKERS);\n  }\n  if (!Number.isFinite(parallel)) return 0;\n  return Math.min(Math.max(Math.floor(parallel), 1), MAX_WORKERS);\n}\n\n/** Strip the callbacks from TransformOptions; what remains is cloneable. */\nexport function poolTransformOptions(options: TransformOptions): PoolTransformOptions {\n  return {\n    mode: options.mode,\n    runtimeId: options.runtimeId,\n    zodCompat: options.zodCompat,\n    compact: options.compact,\n    verbose: options.verbose,\n    autoDiscover: options.autoDiscover,\n    hoist: options.hoist,\n  };\n}\n\n/**\n * Locate the worker entry next to this module.\n *\n * Published, that is `dist/unplugin/pool-worker.js` and a plain dynamic import\n * loads it. Running from source — this repository's own test suite resolves\n * `#src/**` through Vite — only the `.ts` sibling exists, and a worker starts\n * outside Vite's pipeline, in bare Node. Node's native type stripping is not\n * enough there: it erases types but does not remap the `./transform.js`\n * specifiers TypeScript requires onto the `.ts` files that actually exist. So\n * the bootstrap hands `.ts` entries to jiti, which resolves them the same way\n * the loader already resolves user schema files.\n *\n * Returns null when neither exists — the plugin's own code has been bundled\n * into a single file by a consumer, so `import.meta.url` no longer points at a\n * directory containing it. The caller falls back to in-process transforms.\n */\nfunction resolveWorkerEntry(): { href: string; isTypeScript: boolean } | null {\n  for (const [specifier, isTypeScript] of [\n    [\"./pool-worker.js\", false],\n    [\"./pool-worker.ts\", true],\n  ] as const) {\n    const url = new URL(specifier, import.meta.url);\n    if (url.protocol !== \"file:\") continue;\n    try {\n      if (fs.statSync(url, { throwIfNoEntry: false })?.isFile()) {\n        return { href: url.href, isTypeScript };\n      }\n    } catch {\n      // Unreadable path — try the next candidate.\n    }\n  }\n  return null;\n}\n\n/**\n * CommonJS bootstrap evaluated inside each worker (`eval: true`). A string\n * rather than a file because it has to work identically from `dist/` and from\n * `src/`, where no `.js` sibling exists to point a Worker at.\n */\nconst WORKER_BOOTSTRAP = `\nconst { workerData } = require(\"node:worker_threads\");\n(async () => {\n  if (workerData.isTypeScript) {\n    const { createJiti } = await import(workerData.jitiSpecifier);\n    await createJiti(workerData.entry).import(workerData.entry);\n  } else {\n    await import(workerData.entry);\n  }\n})().catch((error) => {\n  // Reaching the parent as an 'error' event is the whole point: a worker that\n  // cannot load its entry must fail loudly enough for the pool to fall back,\n  // not sit idle holding a task.\n  setTimeout(() => { throw error; });\n});\n`;\n\n/** Resolve jiti's URL for the bootstrap; bare specifier if resolution is unavailable. */\nfunction jitiSpecifier(): string {\n  try {\n    return import.meta.resolve(\"jiti\");\n  } catch {\n    return \"jiti\";\n  }\n}\n\n/**\n * Live pools, so a host that outlives its bundler can shut them all down.\n *\n * Nothing in the plugin lifecycle disposes a pool on its own: workers are kept\n * warm ACROSS watch rebuilds on purpose — invalidation drops first-party\n * modules but leaves node_modules (zod itself, the expensive bulk) executed,\n * and discarding that per rebuild would re-pay boot plus a cold zod on every\n * keystroke. Idle workers are unref'd, so they never hold a process open and a\n * one-shot build exits normally. This registry exists for hosts that need\n * determinism instead — chiefly this package's own test suite, which builds\n * many plugin instances in one process.\n */\nconst livePools = new Set<TransformPool>();\n\n/** Terminate every live transform pool. */\nexport async function disposeAllPools(): Promise<void> {\n  await Promise.all([...livePools].map((pool) => pool.dispose()));\n}\n\ninterface PoolWorker {\n  worker: Worker;\n  /** Seq of the request this worker is handling, or null when idle. */\n  busy: number | null;\n}\n\ninterface PendingTask {\n  request: PoolRequest;\n  resolve: (result: PoolTransformResult) => void;\n  reject: (error: Error) => void;\n}\n\n/**\n * A lazily grown pool of transform workers.\n *\n * Not a general-purpose executor: it knows the transform protocol, and it\n * knows that a broadcast invalidation has to be ordered ahead of every\n * subsequent transform on every worker (per-worker message delivery is FIFO,\n * so posting the broadcast before any later task is sufficient — and the only\n * ordering guarantee available, since a worker mid-transform cannot be\n * interrupted).\n */\nexport class TransformPool {\n  private readonly size: number;\n  private readonly entry: { href: string; isTypeScript: boolean };\n  private readonly workers: PoolWorker[] = [];\n  private readonly queue: PendingTask[] = [];\n  /** In-flight requests by seq, so a worker exit can reject exactly its own. */\n  private readonly inflight = new Map<number, PendingTask>();\n  private readonly executedModules = new Set<string>();\n  /** A worker reported it cannot track executed modules — the union is unusable. */\n  private moduleTrackingUnavailable = false;\n  private seq = 0;\n  private disposed = false;\n  /** Worker deaths since the last successful result; trips MAX_CONSECUTIVE_FAILURES. */\n  private consecutiveFailures = 0;\n  /** Set once the breaker trips: every later run() rejects without spawning. */\n  private brokenPool = false;\n\n  private constructor(size: number, entry: { href: string; isTypeScript: boolean }) {\n    this.size = size;\n    this.entry = entry;\n  }\n\n  /**\n   * Build a pool of `size` workers, or return null when workers are\n   * unavailable in this installation (the entry could not be located). Callers\n   * treat null as \"run in-process\".\n   */\n  static create(size: number): TransformPool | null {\n    if (size <= 0) return null;\n    const entry = resolveWorkerEntry();\n    if (entry === null) return null;\n    const pool = new TransformPool(size, entry);\n    livePools.add(pool);\n    return pool;\n  }\n\n  /** Transform one file on a worker. Rejects with the transform's own error, or PoolUnavailableError. */\n  run(code: string, id: string, options: PoolTransformOptions): Promise<PoolTransformResult> {\n    if (this.disposed) {\n      return Promise.reject(new PoolUnavailableError(\"Transform pool is disposed\"));\n    }\n    if (this.brokenPool) {\n      return Promise.reject(\n        new PoolUnavailableError(\n          `Transform workers failed ${MAX_CONSECUTIVE_FAILURES} times in a row; this build is running in-process`,\n        ),\n      );\n    }\n    return new Promise<PoolTransformResult>((resolve, reject) => {\n      const request: PoolRequest = { type: \"transform\", seq: this.seq++, code, id, options };\n      this.dispatch({ request, resolve, reject });\n    });\n  }\n\n  /**\n   * Drop every worker's executed-module cache, so the next discovery re-runs\n   * changed schema graphs. Mirrors the loader's invalidateModuleCache() for\n   * the in-process path; called from watchChange.\n   *\n   * Fire-and-forget: the broadcast is posted to every live worker before any\n   * later transform can be, and per-worker FIFO delivery does the rest. A\n   * transform ALREADY executing in a worker keeps its pre-change module cache\n   * — the same window the in-process path has, where invalidation lands\n   * between awaits — and the main thread's own result cache is cleared\n   * alongside, so the file is recomputed either way.\n   */\n  invalidate(): void {\n    if (this.disposed) return;\n    this.executedModules.clear();\n    this.moduleTrackingUnavailable = false;\n    for (const entry of this.workers) {\n      entry.worker.postMessage({ type: \"invalidate\", seq: this.seq++ } satisfies PoolRequest);\n    }\n  }\n\n  /**\n   * Union of the first-party modules every worker has executed, or null when\n   * any worker cannot track them. Synchronous, because DiskCache.flushDeferred\n   * runs from `buildEnd` and from a process 'exit' hook, where only\n   * synchronous work is allowed — which is why workers push deltas rather than\n   * answering a query.\n   */\n  firstPartyModulePaths(): string[] | null {\n    if (this.moduleTrackingUnavailable) return null;\n    // An empty array is a real answer — no worker has executed anything yet\n    // (every file hit the disk cache). It is the CALLER's job not to pair an\n    // empty superset with an entry that ran discovery; DiskCache.flushDeferred\n    // refuses that combination outright.\n    return [...this.executedModules];\n  }\n\n  /** Terminate every worker. Pending and queued tasks reject. */\n  async dispose(): Promise<void> {\n    if (this.disposed) return;\n    this.disposed = true;\n    livePools.delete(this);\n    const error = new PoolUnavailableError(\"Transform pool was disposed\");\n    for (const task of this.queue.splice(0)) task.reject(error);\n    for (const task of this.inflight.values()) task.reject(error);\n    this.inflight.clear();\n    await Promise.all(this.workers.splice(0).map((entry) => entry.worker.terminate()));\n  }\n\n  /** Hand a task to an idle worker, grow the pool, or queue it. */\n  private dispatch(task: PendingTask): void {\n    const idle = this.workers.find((entry) => entry.busy === null);\n    if (idle !== undefined) {\n      this.send(idle, task);\n      return;\n    }\n    if (this.workers.length < this.size) {\n      let created: PoolWorker;\n      try {\n        created = this.spawn();\n      } catch (error) {\n        task.reject(\n          new PoolUnavailableError(\n            `Could not start a zod-compiler transform worker: ${error instanceof Error ? error.message : String(error)}`,\n            { cause: error },\n          ),\n        );\n        return;\n      }\n      this.workers.push(created);\n      this.send(created, task);\n      return;\n    }\n    this.queue.push(task);\n  }\n\n  private send(entry: PoolWorker, task: PendingTask): void {\n    entry.busy = task.request.seq;\n    this.inflight.set(task.request.seq, task);\n    // A worker is unref'd while idle so it never holds the process open, and\n    // ref'd while it owns a task so the process cannot exit out from under the\n    // promise the caller is awaiting.\n    entry.worker.ref();\n    entry.worker.postMessage(task.request);\n  }\n\n  private spawn(): PoolWorker {\n    const worker = new Worker(WORKER_BOOTSTRAP, {\n      eval: true,\n      workerData: {\n        entry: this.entry.href,\n        isTypeScript: this.entry.isTypeScript,\n        jitiSpecifier: jitiSpecifier(),\n      },\n    });\n    const entry: PoolWorker = { worker, busy: null };\n    worker.unref();\n    worker.on(\"message\", (message: PoolResponse) => {\n      this.onMessage(entry, message);\n    });\n    worker.on(\"error\", (error: Error) => {\n      this.onWorkerGone(entry, error);\n    });\n    worker.on(\"exit\", (code) => {\n      if (this.disposed) return;\n      this.onWorkerGone(entry, new Error(`worker exited with code ${code}`));\n    });\n    return entry;\n  }\n\n  private onMessage(entry: PoolWorker, message: PoolResponse): void {\n    if (message.type === \"invalidated\") return;\n    const task = this.inflight.get(message.seq);\n    this.inflight.delete(message.seq);\n    if (entry.busy === message.seq) {\n      entry.busy = null;\n      entry.worker.unref();\n    }\n    if (task !== undefined) {\n      if (message.type === \"result\") {\n        // A worker that answered is a working worker: an earlier death was\n        // this file's bad luck, not a pool that cannot run.\n        this.consecutiveFailures = 0;\n        this.recordModulePaths(message.result.newModulePaths);\n        task.resolve(message.result);\n      } else {\n        // Rebuild the transform's own error on this side of the boundary. The\n        // message is what surfaces in the bundler's output, so it has to\n        // survive verbatim — this is the path a genuine \"Failed to load\n        // schemas from …\" travels.\n        const error = new Error(message.message);\n        error.name = message.name;\n        if (message.stack !== undefined) error.stack = message.stack;\n        task.reject(error);\n      }\n    }\n    this.drain();\n  }\n\n  /**\n   * A worker died — OOM while holding a large module graph is the realistic\n   * cause. Its task fails with PoolUnavailableError so the caller can retry\n   * in-process, and the worker is dropped from the pool; the next dispatch\n   * spawns a replacement.\n   */\n  private onWorkerGone(entry: PoolWorker, cause: Error): void {\n    const index = this.workers.indexOf(entry);\n    // Node emits 'error' and then 'exit' for the same death; only the first\n    // one still finds the worker in the pool, so only it counts as a failure.\n    if (index === -1) return;\n    this.workers.splice(index, 1);\n    if (++this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) this.brokenPool = true;\n    const seq = entry.busy;\n    entry.busy = null;\n    if (seq !== null) {\n      const task = this.inflight.get(seq);\n      this.inflight.delete(seq);\n      task?.reject(\n        new PoolUnavailableError(`zod-compiler transform worker failed: ${cause.message}`, {\n          cause,\n        }),\n      );\n    }\n    // Executed-module reports from a dead worker describe a module cache that\n    // no longer exists, but the union is a SUPERSET — keeping stale paths can\n    // only over-invalidate cache entries, never validate a stale one.\n    this.drain();\n  }\n\n  private drain(): void {\n    if (this.brokenPool) {\n      // The breaker tripped while these waited. Spawning for them would repeat\n      // the failure per file; hand them back so the caller runs them itself.\n      const error = new PoolUnavailableError(\n        `Transform workers failed ${MAX_CONSECUTIVE_FAILURES} times in a row; this build is running in-process`,\n      );\n      for (const task of this.queue.splice(0)) task.reject(error);\n      return;\n    }\n    while (this.queue.length > 0) {\n      const idle = this.workers.find((e) => e.busy === null);\n      if (idle === undefined) {\n        // No idle worker; grow if the pool is under size (a death may have\n        // freed a slot), otherwise wait for the next completion.\n        if (this.workers.length >= this.size) return;\n        const task = this.queue.shift();\n        if (task === undefined) return;\n        this.dispatch(task);\n        continue;\n      }\n      const task = this.queue.shift();\n      if (task === undefined) return;\n      this.send(idle, task);\n    }\n  }\n\n  private recordModulePaths(paths: string[] | null): void {\n    if (paths === null) {\n      this.moduleTrackingUnavailable = true;\n      return;\n    }\n    for (const p of paths) this.executedModules.add(p);\n  }\n}\n"],"mappings":"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"}