zod-compiler 1.27.0 → 1.28.0

package/dist/unplugin/pool-worker.js

@@ -0,0 +1,116 @@
+import { getFirstPartyModulePaths, invalidateModuleCache } from "../loader.js";
+import { transformCodeWithMap } from "./transform.js";
+import { parentPort } from "node:worker_threads";
+//#region src/unplugin/pool-worker.ts
+/**
+* Worker entry for the transform pool (see ./pool.ts).
+*
+* One transform at a time, on its own module graph. The worker owns a private
+* loader — its own jiti instance, its own zod, its own execution cache — which
+* is what makes running several of these concurrently sound: the serialization
+* inside ../loader.ts exists to stop concurrent transforms from double-
+* executing a SHARED dependency, and nothing is shared across threads.
+*
+* The protocol deliberately carries no callbacks. In-process, the transform
+* reports progress through `onDiscovery`/`onSubstantialWork`/
+* `onUncacheableResult`/`onBuildStats`, all of which the disk cache reads to
+* decide whether and how to persist. Functions do not survive structured
+* cloning, so they are collapsed here into flags on a single reply — the main
+* thread reconstructs exactly the decisions it would have made.
+*/
+const port = parentPort;
+if (port === null) throw new Error("zod-compiler pool worker was started outside a worker thread");
+/**
+* Paths already reported to the pool. The executed-module list grows into the
+* thousands on a real project and the main thread only needs the union, so
+* each reply carries the delta since the last one rather than the whole set.
+*/
+let reported = /* @__PURE__ */ new Set();
+/**
+* Modules executed since the previous report, or null when this runtime cannot
+* track them at all (Bun/Deno use native import, whose cache cannot be
+* enumerated or evicted). Null propagates: the pool stops offering a superset
+* and the disk cache declines to persist deferred entries, which is what the
+* in-process path already does on those runtimes.
+*/
+function moduleDelta() {
+	const all = getFirstPartyModulePaths();
+	if (all === null) return null;
+	const delta = [];
+	for (const p of all) if (!reported.has(p)) {
+		reported.add(p);
+		delta.push(p);
+	}
+	return delta;
+}
+async function handleTransform(request) {
+	let discoveryRan = false;
+	let substantialWork = false;
+	let uncacheable = false;
+	let stats = null;
+	try {
+		const result = {
+			output: await transformCodeWithMap(request.code, request.id, {
+				...request.options,
+				onDiscovery() {
+					discoveryRan = true;
+				},
+				onSubstantialWork() {
+					substantialWork = true;
+				},
+				onUncacheableResult() {
+					uncacheable = true;
+				},
+				onBuildStats(s) {
+					stats = s;
+				}
+			}),
+			discoveryRan,
+			substantialWork,
+			uncacheable,
+			stats,
+			newModulePaths: moduleDelta()
+		};
+		return {
+			type: "result",
+			seq: request.seq,
+			result
+		};
+	} catch (error) {
+		const e = error instanceof Error ? error : new Error(String(error));
+		return {
+			type: "error",
+			seq: request.seq,
+			name: e.name,
+			message: e.message,
+			stack: e.stack
+		};
+	}
+}
+port.on("message", (request) => {
+	if (request.type === "invalidate") {
+		invalidateModuleCache();
+		reported = /* @__PURE__ */ new Set();
+		port.postMessage({
+			type: "invalidated",
+			seq: request.seq
+		});
+		return;
+	}
+	handleTransform(request).then((response) => {
+		port.postMessage(response);
+	}, (error) => {
+		const e = error instanceof Error ? error : new Error(String(error));
+		port.postMessage({
+			type: "error",
+			seq: request.seq,
+			name: e.name,
+			message: e.message,
+			stack: e.stack
+		});
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=pool-worker.js.map

package/dist/unplugin/pool-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-worker.js","names":[],"sources":["../../src/unplugin/pool-worker.ts"],"sourcesContent":["/**\n * Worker entry for the transform pool (see ./pool.ts).\n *\n * One transform at a time, on its own module graph. The worker owns a private\n * loader — its own jiti instance, its own zod, its own execution cache — which\n * is what makes running several of these concurrently sound: the serialization\n * inside ../loader.ts exists to stop concurrent transforms from double-\n * executing a SHARED dependency, and nothing is shared across threads.\n *\n * The protocol deliberately carries no callbacks. In-process, the transform\n * reports progress through `onDiscovery`/`onSubstantialWork`/\n * `onUncacheableResult`/`onBuildStats`, all of which the disk cache reads to\n * decide whether and how to persist. Functions do not survive structured\n * cloning, so they are collapsed here into flags on a single reply — the main\n * thread reconstructs exactly the decisions it would have made.\n */\n\nimport { parentPort } from \"node:worker_threads\";\nimport { getFirstPartyModulePaths, invalidateModuleCache } from \"../loader.js\";\nimport type { PoolRequest, PoolResponse, PoolTransformResult } from \"./pool.js\";\nimport { transformCodeWithMap } from \"./transform.js\";\nimport type { BuildStats } from \"./types.js\";\n\nconst port = parentPort;\nif (port === null) {\n  throw new Error(\"zod-compiler pool worker was started outside a worker thread\");\n}\n\n/**\n * Paths already reported to the pool. The executed-module list grows into the\n * thousands on a real project and the main thread only needs the union, so\n * each reply carries the delta since the last one rather than the whole set.\n */\nlet reported = new Set<string>();\n\n/**\n * Modules executed since the previous report, or null when this runtime cannot\n * track them at all (Bun/Deno use native import, whose cache cannot be\n * enumerated or evicted). Null propagates: the pool stops offering a superset\n * and the disk cache declines to persist deferred entries, which is what the\n * in-process path already does on those runtimes.\n */\nfunction moduleDelta(): string[] | null {\n  const all = getFirstPartyModulePaths();\n  if (all === null) return null;\n  const delta: string[] = [];\n  for (const p of all) {\n    if (!reported.has(p)) {\n      reported.add(p);\n      delta.push(p);\n    }\n  }\n  return delta;\n}\n\nasync function handleTransform(\n  request: Extract<PoolRequest, { type: \"transform\" }>,\n): Promise<PoolResponse> {\n  let discoveryRan = false;\n  let substantialWork = false;\n  let uncacheable = false;\n  let stats: BuildStats | null = null;\n\n  try {\n    const output = await transformCodeWithMap(request.code, request.id, {\n      ...request.options,\n      onDiscovery() {\n        discoveryRan = true;\n      },\n      onSubstantialWork() {\n        substantialWork = true;\n      },\n      onUncacheableResult() {\n        uncacheable = true;\n      },\n      onBuildStats(s) {\n        stats = s;\n      },\n    });\n    const result: PoolTransformResult = {\n      output,\n      discoveryRan,\n      substantialWork,\n      uncacheable,\n      // TS cannot see the assignment inside the callback above.\n      stats: stats as BuildStats | null,\n      newModulePaths: moduleDelta(),\n    };\n    return { type: \"result\", seq: request.seq, result };\n  } catch (error) {\n    // The transform's own failures — a schema file that will not load in\n    // `schemas: \"explicit\"` mode — must reach the bundler with their original\n    // message, so they are forwarded rather than swallowed. The pool rebuilds\n    // the Error on the other side; only these three fields survive cloning.\n    const e = error instanceof Error ? error : new Error(String(error));\n    return { type: \"error\", seq: request.seq, name: e.name, message: e.message, stack: e.stack };\n  }\n}\n\nport.on(\"message\", (request: PoolRequest) => {\n  if (request.type === \"invalidate\") {\n    invalidateModuleCache();\n    // The loader just dropped every first-party module, so the next discovery\n    // re-executes and must re-report them: a delta against the pre-change set\n    // would report nothing and the pool's union would keep paths whose entries\n    // are gone. Harmless for cache soundness (a superset only over-\n    // invalidates) but it would grow without bound across a long watch session.\n    reported = new Set<string>();\n    port.postMessage({ type: \"invalidated\", seq: request.seq } satisfies PoolResponse);\n    return;\n  }\n\n  void handleTransform(request).then(\n    (response) => {\n      port.postMessage(response);\n    },\n    (error: unknown) => {\n      // handleTransform catches its own failures; this is the last resort for\n      // a fault in the reply path itself (an output that will not clone).\n      const e = error instanceof Error ? error : new Error(String(error));\n      port.postMessage({\n        type: \"error\",\n        seq: request.seq,\n        name: e.name,\n        message: e.message,\n        stack: e.stack,\n      } satisfies PoolResponse);\n    },\n  );\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,OAAO;AACb,IAAI,SAAS,MACX,MAAM,IAAI,MAAM,8DAA8D;;;;;;AAQhF,IAAI,2BAAW,IAAI,IAAY;;;;;;;;AAS/B,SAAS,cAA+B;CACtC,MAAM,MAAM,yBAAyB;CACrC,IAAI,QAAQ,MAAM,OAAO;CACzB,MAAM,QAAkB,CAAC;CACzB,KAAK,MAAM,KAAK,KACd,IAAI,CAAC,SAAS,IAAI,CAAC,GAAG;EACpB,SAAS,IAAI,CAAC;EACd,MAAM,KAAK,CAAC;CACd;CAEF,OAAO;AACT;AAEA,eAAe,gBACb,SACuB;CACvB,IAAI,eAAe;CACnB,IAAI,kBAAkB;CACtB,IAAI,cAAc;CAClB,IAAI,QAA2B;CAE/B,IAAI;EAgBF,MAAM,SAA8B;GAClC,QAAA,MAhBmB,qBAAqB,QAAQ,MAAM,QAAQ,IAAI;IAClE,GAAG,QAAQ;IACX,cAAc;KACZ,eAAe;IACjB;IACA,oBAAoB;KAClB,kBAAkB;IACpB;IACA,sBAAsB;KACpB,cAAc;IAChB;IACA,aAAa,GAAG;KACd,QAAQ;IACV;GACF,CAAC;GAGC;GACA;GACA;GAEO;GACP,gBAAgB,YAAY;EAC9B;EACA,OAAO;GAAE,MAAM;GAAU,KAAK,QAAQ;GAAK;EAAO;CACpD,SAAS,OAAO;EAKd,MAAM,IAAI,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;EAClE,OAAO;GAAE,MAAM;GAAS,KAAK,QAAQ;GAAK,MAAM,EAAE;GAAM,SAAS,EAAE;GAAS,OAAO,EAAE;EAAM;CAC7F;AACF;AAEA,KAAK,GAAG,YAAY,YAAyB;CAC3C,IAAI,QAAQ,SAAS,cAAc;EACjC,sBAAsB;EAMtB,2BAAW,IAAI,IAAY;EAC3B,KAAK,YAAY;GAAE,MAAM;GAAe,KAAK,QAAQ;EAAI,CAAwB;EACjF;CACF;CAEA,gBAAqB,OAAO,CAAC,CAAC,MAC3B,aAAa;EACZ,KAAK,YAAY,QAAQ;CAC3B,IACC,UAAmB;EAGlB,MAAM,IAAI,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;EAClE,KAAK,YAAY;GACf,MAAM;GACN,KAAK,QAAQ;GACb,MAAM,EAAE;GACR,SAAS,EAAE;GACX,OAAO,EAAE;EACX,CAAwB;CAC1B,CACF;AACF,CAAC"}

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"}