next-yak 9.2.0 → 9.3.0

package/dist/isolated-source-eval/index.js

@@ -0,0 +1,329 @@
+// isolated-source-eval/evaluator.ts
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
+import { isAbsolute } from "path";
+import { existsSync } from "fs";
+
+// isolated-source-eval/loader-hooks.ts
+var LOADER_HOOK_SOURCE = `
+import { fileURLToPath } from "node:url";
+
+let port;
+const deps = new Set();
+
+export function initialize(data) {
+  port = data.port;
+  port.on("message", (msg) => {
+    if (msg === "getDeps") {
+      port.postMessage([...deps]);
+      deps.clear();
+    }
+  });
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  const result = await nextResolve(specifier);
+  if (result.url.startsWith("file://") && !result.url.includes("/node_modules/")) {
+    deps.add(fileURLToPath(result.url));
+  }
+  return result;
+}
+`;
+var LOADER_DATA_URL = `data:text/javascript;base64,${Buffer.from(LOADER_HOOK_SOURCE).toString("base64")}`;
+function createLoaderDataUrl() {
+  return LOADER_DATA_URL;
+}
+
+// isolated-source-eval/evaluator.ts
+function resolveWorkerPath() {
+  const jsPath = fileURLToPath(new URL("./worker.js", import.meta.url));
+  if (existsSync(jsPath)) {
+    return jsPath;
+  }
+  return fileURLToPath(new URL("./worker.ts", import.meta.url));
+}
+function bootWorker() {
+  const workerPath = resolveWorkerPath();
+  const loaderDataUrl = createLoaderDataUrl();
+  const worker = new Worker(workerPath, {
+    workerData: { loaderDataUrl }
+  });
+  const ready = new Promise((resolve) => {
+    const onMessage = (msg) => {
+      if (msg.type === "ready") {
+        worker.off("message", onMessage);
+        resolve();
+      }
+    };
+    worker.on("message", onMessage);
+  });
+  return { worker, ready };
+}
+var DEFAULT_EVAL_TIMEOUT_MS = 3e4;
+var MAX_STALENESS_RETRIES = 3;
+async function createEvaluator() {
+  const resultCache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  const reverseDeps = /* @__PURE__ */ new Map();
+  const forwardDeps = /* @__PURE__ */ new Map();
+  let nextId = 0;
+  let currentEval = null;
+  let currentTimeout = null;
+  const queue = [];
+  const invalidatedDuringEval = /* @__PURE__ */ new Set();
+  let disposed = false;
+  let primary = bootWorker();
+  let shadow = bootWorker();
+  await Promise.all([primary.ready, shadow.ready]);
+  function setupMessageHandler(workerObj) {
+    workerObj.worker.on("message", (msg) => {
+      if (msg.type !== "result") return;
+      handleResult(msg);
+    });
+    workerObj.worker.on("error", (err) => {
+      if (currentEval) {
+        clearEvalTimeout();
+        const pending = currentEval;
+        currentEval = null;
+        const result = {
+          ok: false,
+          error: { message: err.message, stack: err.stack ?? "" }
+        };
+        updateDeps(pending.absolutePath, [pending.absolutePath]);
+        resultCache.set(pending.absolutePath, result);
+        inflight.delete(pending.absolutePath);
+        pending.resolve(result);
+        processQueue();
+      }
+    });
+  }
+  setupMessageHandler(primary);
+  function clearEvalTimeout() {
+    if (currentTimeout !== null) {
+      clearTimeout(currentTimeout);
+      currentTimeout = null;
+    }
+  }
+  function handleResult(msg) {
+    if (!currentEval) return;
+    if (msg.id !== currentEval.id) return;
+    clearEvalTimeout();
+    const pending = currentEval;
+    currentEval = null;
+    if (msg.ok && invalidatedDuringEval.size > 0) {
+      const isStale = msg.dependencies.some(
+        (dep) => invalidatedDuringEval.has(dep)
+      );
+      if (isStale) {
+        if (pending.retryCount >= MAX_STALENESS_RETRIES) {
+          pending.resolve({
+            ok: false,
+            error: {
+              message: `Evaluation of ${pending.absolutePath} exceeded maximum staleness retries (${MAX_STALENESS_RETRIES})`,
+              stack: ""
+            }
+          });
+          processQueue();
+          return;
+        }
+        pending.retryCount++;
+        swapWorkers();
+        queue.unshift(pending);
+        processQueue();
+        return;
+      }
+    }
+    let result;
+    if (msg.ok) {
+      result = { ok: true, value: msg.value, dependencies: msg.dependencies };
+      updateDeps(pending.absolutePath, msg.dependencies);
+    } else {
+      result = { ok: false, error: msg.error };
+      updateDeps(pending.absolutePath, msg.dependencies);
+    }
+    resultCache.set(pending.absolutePath, result);
+    inflight.delete(pending.absolutePath);
+    pending.resolve(result);
+    processQueue();
+  }
+  function updateDeps(entryPoint, deps) {
+    const oldDeps = forwardDeps.get(entryPoint);
+    if (oldDeps) {
+      for (const dep of oldDeps) {
+        const entries = reverseDeps.get(dep);
+        if (entries) {
+          entries.delete(entryPoint);
+          if (entries.size === 0) {
+            reverseDeps.delete(dep);
+          }
+        }
+      }
+    }
+    const depSet = new Set(deps);
+    forwardDeps.set(entryPoint, depSet);
+    for (const dep of depSet) {
+      let entries = reverseDeps.get(dep);
+      if (!entries) {
+        entries = /* @__PURE__ */ new Set();
+        reverseDeps.set(dep, entries);
+      }
+      entries.add(entryPoint);
+    }
+  }
+  function processQueue() {
+    if (currentEval || queue.length === 0 || disposed) return;
+    const next = queue.shift();
+    const alreadyCached = resultCache.get(next.absolutePath);
+    if (alreadyCached) {
+      inflight.delete(next.absolutePath);
+      next.resolve(alreadyCached);
+      processQueue();
+      return;
+    }
+    currentEval = next;
+    primary.ready.then(() => {
+      if (disposed || currentEval !== next) return;
+      primary.worker.postMessage({
+        type: "evaluate",
+        id: next.id,
+        absolutePath: next.absolutePath
+      });
+      currentTimeout = setTimeout(() => {
+        if (currentEval !== next) return;
+        currentEval = null;
+        currentTimeout = null;
+        const result = {
+          ok: false,
+          error: {
+            message: `Evaluation of ${next.absolutePath} timed out after ${DEFAULT_EVAL_TIMEOUT_MS}ms`,
+            stack: ""
+          }
+        };
+        updateDeps(next.absolutePath, [next.absolutePath]);
+        resultCache.set(next.absolutePath, result);
+        inflight.delete(next.absolutePath);
+        next.resolve(result);
+        swapWorkers();
+        processQueue();
+      }, DEFAULT_EVAL_TIMEOUT_MS);
+    });
+  }
+  function swapWorkers() {
+    primary.worker.removeAllListeners();
+    primary.worker.terminate();
+    primary = shadow;
+    setupMessageHandler(primary);
+    shadow = bootWorker();
+    invalidatedDuringEval.clear();
+  }
+  function evaluate(absolutePath) {
+    if (disposed) {
+      return Promise.reject(new Error("Evaluator has been disposed"));
+    }
+    if (!isAbsolute(absolutePath)) {
+      return Promise.reject(
+        new Error(`evaluate() requires an absolute path, got: ${absolutePath}`)
+      );
+    }
+    const cached = resultCache.get(absolutePath);
+    if (cached) {
+      return Promise.resolve(cached);
+    }
+    const pending = inflight.get(absolutePath);
+    if (pending) return pending;
+    const promise = new Promise((resolve, reject) => {
+      const id = nextId++;
+      queue.push({ id, absolutePath, resolve, reject, retryCount: 0 });
+      processQueue();
+    });
+    inflight.set(absolutePath, promise);
+    return promise;
+  }
+  function invalidate(...absolutePaths) {
+    if (absolutePaths.length === 0) return;
+    for (const path of absolutePaths) {
+      invalidatedDuringEval.add(path);
+    }
+    const allEntryPoints = /* @__PURE__ */ new Set();
+    for (const path of absolutePaths) {
+      const entryPoints = reverseDeps.get(path);
+      if (entryPoints) {
+        for (const entry of entryPoints) {
+          allEntryPoints.add(entry);
+        }
+      }
+    }
+    if (allEntryPoints.size === 0) return;
+    for (const entry of allEntryPoints) {
+      resultCache.delete(entry);
+      inflight.delete(entry);
+      const deps = forwardDeps.get(entry);
+      if (deps) {
+        for (const dep of deps) {
+          const entries = reverseDeps.get(dep);
+          if (entries) {
+            entries.delete(entry);
+            if (entries.size === 0) {
+              reverseDeps.delete(dep);
+            }
+          }
+        }
+        forwardDeps.delete(entry);
+      }
+    }
+    clearEvalTimeout();
+    const inflightEval = currentEval;
+    currentEval = null;
+    swapWorkers();
+    if (inflightEval) {
+      queue.unshift(inflightEval);
+    }
+    processQueue();
+  }
+  function invalidateAll() {
+    resultCache.clear();
+    inflight.clear();
+    forwardDeps.clear();
+    reverseDeps.clear();
+    clearEvalTimeout();
+    const inflightEval = currentEval;
+    currentEval = null;
+    swapWorkers();
+    if (inflightEval) {
+      queue.unshift(inflightEval);
+    }
+    processQueue();
+  }
+  function getDependentsOf(absolutePath) {
+    const entryPoints = reverseDeps.get(absolutePath);
+    if (!entryPoints) return [];
+    return [...entryPoints];
+  }
+  async function dispose() {
+    if (disposed) return;
+    disposed = true;
+    clearEvalTimeout();
+    if (currentEval) {
+      currentEval.reject(new Error("Evaluator has been disposed"));
+      currentEval = null;
+    }
+    for (const pending of queue) {
+      pending.reject(new Error("Evaluator has been disposed"));
+    }
+    queue.length = 0;
+    inflight.clear();
+    await Promise.all([primary.worker.terminate(), shadow.worker.terminate()]);
+  }
+  return {
+    evaluate,
+    invalidate,
+    invalidateAll,
+    getDependentsOf,
+    dispose,
+    [Symbol.asyncDispose]: dispose
+  };
+}
+export {
+  createEvaluator
+};
+//# sourceMappingURL=index.js.map

package/dist/isolated-source-eval/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../isolated-source-eval/evaluator.ts","../../isolated-source-eval/loader-hooks.ts"],"sourcesContent":["import { Worker } from \"node:worker_threads\";\nimport { fileURLToPath } from \"node:url\";\nimport { isAbsolute } from \"node:path\";\nimport { existsSync } from \"node:fs\";\nimport { createLoaderDataUrl } from \"./loader-hooks.ts\";\n\nexport type EvaluateResult =\n  | { ok: true; value: Record<string, unknown>; dependencies: string[] }\n  | { ok: false; error: { message: string; stack: string } };\n\nexport interface Evaluator {\n  /** Evaluate a module and return its exports plus the full transitive dependency list. */\n  evaluate(absolutePath: string): Promise<EvaluateResult>;\n  /** Clear cached results for every entry point that transitively depends on the given file(s). */\n  invalidate(...absolutePaths: string[]): void;\n  /** Clear the entire result cache and swap workers. */\n  invalidateAll(): void;\n  /** Return entry point paths that would be affected by invalidate(absolutePath). */\n  getDependentsOf(absolutePath: string): string[];\n  /** Terminate both workers and reject any pending evaluations. */\n  dispose(): Promise<void>;\n  [Symbol.asyncDispose](): Promise<void>;\n}\n\n/** Wire format for messages from the worker back to the main thread. */\ntype WorkerResult =\n  | {\n      type: \"result\";\n      id: number;\n      ok: true;\n      value: Record<string, unknown>;\n      dependencies: string[];\n    }\n  | {\n      type: \"result\";\n      id: number;\n      ok: false;\n      error: { message: string; stack: string };\n      dependencies: string[];\n    };\n\ninterface PendingEvaluation {\n  id: number;\n  absolutePath: string;\n  resolve: (result: EvaluateResult) => void;\n  reject: (error: Error) => void;\n  /** Number of times this evaluation has been retried due to staleness detection. */\n  retryCount: number;\n}\n\n/**\n * Resolves the worker entry point path.\n *\n * In production the compiled `.js` file exists in `dist/` — we prefer that.\n * During development (vitest runs against source), only the `.ts` file exists.\n * Node 22.18.0+ handles `.ts` natively via strip-types, so the fallback works\n * without any flags or loaders.\n */\nfunction resolveWorkerPath(): string {\n  const jsPath = fileURLToPath(new URL(\"./worker.js\", import.meta.url));\n  if (existsSync(jsPath)) {\n    return jsPath;\n  }\n  return fileURLToPath(new URL(\"./worker.ts\", import.meta.url));\n}\n\n/**\n * Boots a worker and returns a handle with a ready promise.\n *\n * The loader hook data URL is passed via `workerData` rather than having\n * the worker import it from a sibling module. This avoids a module\n * resolution mismatch: source files use `.ts` extensions (required by\n * Node strip-types) while compiled output uses `.js` (rewritten by tsc\n * via `rewriteRelativeImportExtensions`). Since the worker file would need\n * to import loader-hooks with the right extension for its context, passing\n * the data URL through workerData eliminates the problem entirely.\n */\nfunction bootWorker(): { worker: Worker; ready: Promise<void> } {\n  const workerPath = resolveWorkerPath();\n  const loaderDataUrl = createLoaderDataUrl();\n  const worker = new Worker(workerPath, {\n    workerData: { loaderDataUrl },\n  });\n  const ready = new Promise<void>((resolve) => {\n    const onMessage = (msg: { type: string }) => {\n      if (msg.type === \"ready\") {\n        worker.off(\"message\", onMessage);\n        resolve();\n      }\n    };\n    worker.on(\"message\", onMessage);\n  });\n  return { worker, ready };\n}\n\n/** Default timeout for a single evaluation in milliseconds. */\nconst DEFAULT_EVAL_TIMEOUT_MS = 30_000;\n\n/** Maximum number of staleness retries before giving up with an error. */\nconst MAX_STALENESS_RETRIES = 3;\n\n/** Creates an evaluator that runs modules in isolated worker threads with dependency tracking. */\nexport async function createEvaluator(): Promise<Evaluator> {\n  const resultCache = new Map<string, EvaluateResult>();\n  /**\n   * Tracks in-flight evaluation promises by path. When `evaluate()` is called\n   * for a path that's already queued or being evaluated, the same promise is\n   * returned instead of queuing a duplicate. This prevents a second worker\n   * evaluation from producing incomplete dependencies (the ESM resolve hook\n   * only fires on cache misses — a second import on the same worker would\n   * miss transitive deps that are already in the ESM cache).\n   */\n  const inflight = new Map<string, Promise<EvaluateResult>>();\n\n  /**\n   * Two dependency maps provide O(1) lookups in both directions:\n   *\n   * - `reverseDeps`: file path → set of entry points that depend on it.\n   *   Consulted during `invalidate()` to find which cached results to clear.\n   *\n   * - `forwardDeps`: entry point → set of all its transitive dependencies.\n   *   Needed to clean up stale reverse entries when an entry point is\n   *   re-evaluated and its dependency tree has changed (e.g. an import\n   *   was removed). Without this, removed dependencies would accumulate\n   *   phantom reverse entries that never get cleaned up.\n   */\n  const reverseDeps = new Map<string, Set<string>>();\n  const forwardDeps = new Map<string, Set<string>>();\n\n  let nextId = 0;\n  let currentEval: PendingEvaluation | null = null;\n  let currentTimeout: ReturnType<typeof setTimeout> | null = null;\n  const queue: PendingEvaluation[] = [];\n  /**\n   * Tracks files passed to `invalidate()` while an evaluation is in-flight.\n   * When an evaluation completes, `handleResult()` checks whether any reported\n   * dependency intersects this set. If so, the result is stale — it's discarded,\n   * workers are swapped, and the evaluation is retried on a clean worker.\n   *\n   * This closes the \"cold start\" gap: if `evaluate(\"A\")` is dispatched before\n   * `invalidate(\"B\")` is called, and A depends on B, the dependency graph\n   * doesn't know about A→B yet. Without this set, the invalidation would be\n   * silently missed.\n   *\n   * Cleared in `swapWorkers()` because the new primary has a clean ESM cache.\n   */\n  const invalidatedDuringEval = new Set<string>();\n  let disposed = false;\n\n  /**\n   * Two workers are maintained at all times:\n   *\n   * - **primary**: handles all evaluate() calls. Accumulates Node's ESM\n   *   module cache over time, making repeated evaluations fast (~1-3ms).\n   *\n   * - **shadow**: pre-booted but completely idle. Never evaluates anything,\n   *   so its module cache stays empty. On invalidation, the primary is\n   *   terminated (stale cache) and the shadow is promoted to primary\n   *   instantly (no boot latency). A new shadow is booted in the background.\n   *\n   * This pattern trades ~30ms of background boot time for instant\n   * invalidation. The alternative — reusing a single worker and clearing\n   * its ESM cache — isn't possible because Node doesn't expose an API\n   * to clear the module cache.\n   */\n  let primary = bootWorker();\n  let shadow = bootWorker();\n\n  await Promise.all([primary.ready, shadow.ready]);\n\n  function setupMessageHandler(workerObj: { worker: Worker }) {\n    workerObj.worker.on(\"message\", (msg: WorkerResult) => {\n      if (msg.type !== \"result\") return;\n      handleResult(msg);\n    });\n\n    workerObj.worker.on(\"error\", (err: Error) => {\n      if (currentEval) {\n        clearEvalTimeout();\n        const pending = currentEval;\n        currentEval = null;\n        const result: EvaluateResult = {\n          ok: false,\n          error: { message: err.message, stack: err.stack ?? \"\" },\n        };\n        updateDeps(pending.absolutePath, [pending.absolutePath]);\n        resultCache.set(pending.absolutePath, result);\n        inflight.delete(pending.absolutePath);\n        pending.resolve(result);\n        processQueue();\n      }\n    });\n  }\n\n  setupMessageHandler(primary);\n\n  function clearEvalTimeout() {\n    if (currentTimeout !== null) {\n      clearTimeout(currentTimeout);\n      currentTimeout = null;\n    }\n  }\n\n  function handleResult(msg: WorkerResult) {\n    if (!currentEval) return;\n    if (msg.id !== currentEval.id) return;\n\n    clearEvalTimeout();\n\n    const pending = currentEval;\n    currentEval = null;\n\n    // Staleness check: if a file was invalidated while this evaluation was\n    // in-flight and the result depends on it, discard the result and retry\n    // on a clean worker. Only checked for successes — errors don't report\n    // deps, and the file watcher will trigger another invalidation when the\n    // source is fixed.\n    if (msg.ok && invalidatedDuringEval.size > 0) {\n      const isStale = msg.dependencies.some((dep) =>\n        invalidatedDuringEval.has(dep),\n      );\n      if (isStale) {\n        if (pending.retryCount >= MAX_STALENESS_RETRIES) {\n          pending.resolve({\n            ok: false,\n            error: {\n              message: `Evaluation of ${pending.absolutePath} exceeded maximum staleness retries (${MAX_STALENESS_RETRIES})`,\n              stack: \"\",\n            },\n          });\n          processQueue();\n          return;\n        }\n        pending.retryCount++;\n        swapWorkers();\n        queue.unshift(pending);\n        processQueue();\n        return;\n      }\n    }\n\n    let result: EvaluateResult;\n    if (msg.ok) {\n      result = { ok: true, value: msg.value, dependencies: msg.dependencies };\n      updateDeps(pending.absolutePath, msg.dependencies);\n    } else {\n      result = { ok: false, error: msg.error };\n      // Use the partial dependencies reported by the worker (files resolved\n      // before the error). This ensures transitive deps are registered in\n      // reverseDeps so that fixing a broken file triggers re-evaluation.\n      updateDeps(pending.absolutePath, msg.dependencies);\n    }\n\n    resultCache.set(pending.absolutePath, result);\n    inflight.delete(pending.absolutePath);\n    pending.resolve(result);\n    processQueue();\n  }\n\n  /**\n   * Reconciles the dependency graph after an evaluation.\n   *\n   * First removes all old reverse entries for this entry point (using\n   * forwardDeps as the source of truth), then writes the new forward\n   * and reverse mappings. This ensures that if a dependency was removed\n   * between evaluations, it no longer points back to this entry point.\n   */\n  function updateDeps(entryPoint: string, deps: string[]) {\n    const oldDeps = forwardDeps.get(entryPoint);\n    if (oldDeps) {\n      for (const dep of oldDeps) {\n        const entries = reverseDeps.get(dep);\n        if (entries) {\n          entries.delete(entryPoint);\n          if (entries.size === 0) {\n            reverseDeps.delete(dep);\n          }\n        }\n      }\n    }\n\n    const depSet = new Set(deps);\n    forwardDeps.set(entryPoint, depSet);\n\n    for (const dep of depSet) {\n      let entries = reverseDeps.get(dep);\n      if (!entries) {\n        entries = new Set();\n        reverseDeps.set(dep, entries);\n      }\n      entries.add(entryPoint);\n    }\n  }\n\n  /**\n   * Evaluations are serialized — one at a time per worker. This prevents\n   * interleaved dependency tracking: the loader hook accumulates deps in\n   * a single Set and flushes it after each evaluation. Concurrent imports\n   * would mix dependencies from different entry points.\n   *\n   * Waits for the primary worker to be ready before sending work. This\n   * matters after a swap: the promoted shadow may still be booting.\n   */\n  function processQueue() {\n    if (currentEval || queue.length === 0 || disposed) return;\n\n    const next = queue.shift()!;\n\n    // A prior evaluation for the same path may have completed and cached\n    // while this item was queued (e.g. after invalidation + re-queue).\n    // Resolving from cache avoids dispatching to a worker where the module\n    // is already in the ESM cache (which would produce incomplete deps).\n    const alreadyCached = resultCache.get(next.absolutePath);\n    if (alreadyCached) {\n      inflight.delete(next.absolutePath);\n      next.resolve(alreadyCached);\n      processQueue();\n      return;\n    }\n\n    currentEval = next;\n\n    primary.ready.then(() => {\n      if (disposed || currentEval !== next) return;\n      primary.worker.postMessage({\n        type: \"evaluate\",\n        id: next.id,\n        absolutePath: next.absolutePath,\n      });\n\n      currentTimeout = setTimeout(() => {\n        if (currentEval !== next) return;\n        currentEval = null;\n        currentTimeout = null;\n\n        const result: EvaluateResult = {\n          ok: false,\n          error: {\n            message: `Evaluation of ${next.absolutePath} timed out after ${DEFAULT_EVAL_TIMEOUT_MS}ms`,\n            stack: \"\",\n          },\n        };\n        updateDeps(next.absolutePath, [next.absolutePath]);\n        resultCache.set(next.absolutePath, result);\n        inflight.delete(next.absolutePath);\n        next.resolve(result);\n\n        swapWorkers();\n        processQueue();\n      }, DEFAULT_EVAL_TIMEOUT_MS);\n    });\n  }\n\n  /**\n   * Terminates the primary (stale module cache), promotes the shadow\n   * (clean cache, instant), and boots a new shadow in the background.\n   *\n   * `removeAllListeners` prevents the terminated worker from delivering\n   * late messages or error events that would confuse the result handler.\n   */\n  function swapWorkers() {\n    primary.worker.removeAllListeners();\n    primary.worker.terminate();\n\n    primary = shadow;\n    setupMessageHandler(primary);\n\n    shadow = bootWorker();\n\n    // The new primary has a clean ESM cache, so any previously tracked\n    // invalidations are no longer relevant — the fresh worker will\n    // re-import everything from disk.\n    invalidatedDuringEval.clear();\n  }\n\n  function evaluate(absolutePath: string): Promise<EvaluateResult> {\n    if (disposed) {\n      return Promise.reject(new Error(\"Evaluator has been disposed\"));\n    }\n\n    if (!isAbsolute(absolutePath)) {\n      return Promise.reject(\n        new Error(`evaluate() requires an absolute path, got: ${absolutePath}`),\n      );\n    }\n\n    const cached = resultCache.get(absolutePath);\n    if (cached) {\n      return Promise.resolve(cached);\n    }\n\n    // Deduplicate: if an evaluation is already queued or in-flight for this\n    // path, return the same promise. This prevents a second worker evaluation\n    // that would produce incomplete dependencies (the ESM resolve hook only\n    // fires on cache misses).\n    const pending = inflight.get(absolutePath);\n    if (pending) return pending;\n\n    const promise = new Promise<EvaluateResult>((resolve, reject) => {\n      const id = nextId++;\n      queue.push({ id, absolutePath, resolve, reject, retryCount: 0 });\n      processQueue();\n    });\n\n    inflight.set(absolutePath, promise);\n    return promise;\n  }\n\n  function invalidate(...absolutePaths: string[]): void {\n    if (absolutePaths.length === 0) return;\n\n    // Track all invalidations for cold-start detection (in-flight evaluations\n    // whose dependency graph isn't populated yet).\n    for (const path of absolutePaths) {\n      invalidatedDuringEval.add(path);\n    }\n\n    // Collect all affected entry points across all changed files.\n    const allEntryPoints = new Set<string>();\n    for (const path of absolutePaths) {\n      const entryPoints = reverseDeps.get(path);\n      if (entryPoints) {\n        for (const entry of entryPoints) {\n          allEntryPoints.add(entry);\n        }\n      }\n    }\n\n    // If no cached entry points are affected, return early. The cold-start\n    // set (invalidatedDuringEval) will catch in-flight evaluations.\n    if (allEntryPoints.size === 0) return;\n\n    // Clear caches and clean dependency graphs for all affected entry points.\n    for (const entry of allEntryPoints) {\n      resultCache.delete(entry);\n      inflight.delete(entry);\n\n      const deps = forwardDeps.get(entry);\n      if (deps) {\n        for (const dep of deps) {\n          const entries = reverseDeps.get(dep);\n          if (entries) {\n            entries.delete(entry);\n            if (entries.size === 0) {\n              reverseDeps.delete(dep);\n            }\n          }\n        }\n        forwardDeps.delete(entry);\n      }\n    }\n\n    // If an evaluation is in-flight on the worker we're about to terminate,\n    // capture it and re-queue at the front. The caller's promise will\n    // resolve transparently with the result from the promoted shadow worker.\n    clearEvalTimeout();\n    const inflightEval = currentEval;\n    currentEval = null;\n\n    swapWorkers();\n\n    if (inflightEval) {\n      queue.unshift(inflightEval);\n    }\n\n    processQueue();\n  }\n\n  function invalidateAll(): void {\n    resultCache.clear();\n    inflight.clear();\n    forwardDeps.clear();\n    reverseDeps.clear();\n\n    clearEvalTimeout();\n    const inflightEval = currentEval;\n    currentEval = null;\n\n    swapWorkers();\n\n    if (inflightEval) {\n      queue.unshift(inflightEval);\n    }\n\n    processQueue();\n  }\n\n  function getDependentsOf(absolutePath: string): string[] {\n    const entryPoints = reverseDeps.get(absolutePath);\n    if (!entryPoints) return [];\n    return [...entryPoints];\n  }\n\n  async function dispose(): Promise<void> {\n    if (disposed) return;\n    disposed = true;\n\n    clearEvalTimeout();\n\n    if (currentEval) {\n      currentEval.reject(new Error(\"Evaluator has been disposed\"));\n      currentEval = null;\n    }\n    for (const pending of queue) {\n      pending.reject(new Error(\"Evaluator has been disposed\"));\n    }\n    queue.length = 0;\n    inflight.clear();\n\n    await Promise.all([primary.worker.terminate(), shadow.worker.terminate()]);\n  }\n\n  return {\n    evaluate,\n    invalidate,\n    invalidateAll,\n    getDependentsOf,\n    dispose,\n    [Symbol.asyncDispose]: dispose,\n  };\n}\n","/**\n * ESM loader hook source, embedded as a string constant.\n *\n * This MUST be plain JavaScript — not TypeScript. The loader thread receives\n * this code via a `data:` URL passed to `module.register()`. Node's loader\n * thread does not run data: URLs through strip-types, so any TypeScript\n * syntax here would cause a SyntaxError at registration time.\n *\n * The hook uses a MessagePort (received in `initialize`) to communicate\n * collected dependencies back to the worker thread on demand. Dependencies\n * are accumulated in a Set during `resolve()` calls, then flushed as a\n * batch when the worker requests them after an evaluation completes. This\n * batching avoids per-import message overhead and keeps dependency tracking\n * tightly coupled to a single evaluation.\n *\n * Only `file://` URLs outside of `node_modules` are tracked. Node built-ins\n * (`node:*`) and third-party packages are excluded because consumers only\n * need to invalidate on project source file changes.\n *\n * `fileURLToPath` converts `file://` URLs into platform-correct absolute\n * paths (avoids the leading-slash issue `URL.pathname` has on Windows).\n */\nconst LOADER_HOOK_SOURCE = `\nimport { fileURLToPath } from \"node:url\";\n\nlet port;\nconst deps = new Set();\n\nexport function initialize(data) {\n  port = data.port;\n  port.on(\"message\", (msg) => {\n    if (msg === \"getDeps\") {\n      port.postMessage([...deps]);\n      deps.clear();\n    }\n  });\n}\n\nexport async function resolve(specifier, context, nextResolve) {\n  const result = await nextResolve(specifier);\n  if (result.url.startsWith(\"file://\") && !result.url.includes(\"/node_modules/\")) {\n    deps.add(fileURLToPath(result.url));\n  }\n  return result;\n}\n`;\n\n/**\n * Pre-computed data URL for the loader hook source.\n *\n * The same URL is reused across workers — each `module.register()` call\n * creates an independent loader instance with its own dependency Set\n * regardless of URL identity.\n */\nconst LOADER_DATA_URL = `data:text/javascript;base64,${Buffer.from(LOADER_HOOK_SOURCE).toString(\"base64\")}`;\n\n/** Returns the loader hook as a base64 `data:` URL. */\nexport function createLoaderDataUrl(): string {\n  return LOADER_DATA_URL;\n}\n"],"mappings":"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","names":[]}

package/dist/isolated-source-eval/worker.js

@@ -0,0 +1,63 @@
+// isolated-source-eval/worker.ts
+import { parentPort, workerData } from "worker_threads";
+import { MessageChannel } from "worker_threads";
+import { pathToFileURL } from "url";
+import { register } from "module";
+if (!parentPort) {
+  throw new Error("This file must be run as a worker thread");
+}
+var loaderDataUrl = workerData.loaderDataUrl;
+var { port1, port2 } = new MessageChannel();
+register(loaderDataUrl, {
+  parentURL: import.meta.url,
+  data: { port: port2 },
+  transferList: [port2]
+});
+function requestDeps() {
+  return new Promise((resolve) => {
+    port1.once("message", (deps) => {
+      resolve(deps);
+    });
+    port1.postMessage("getDeps");
+  });
+}
+parentPort.on(
+  "message",
+  async (msg) => {
+    if (msg.type !== "evaluate") return;
+    try {
+      const fileUrl = pathToFileURL(msg.absolutePath).href;
+      const ns = await import(fileUrl);
+      const deps = await requestDeps();
+      if (!deps.includes(msg.absolutePath)) {
+        deps.unshift(msg.absolutePath);
+      }
+      const value = {};
+      for (const key of Object.keys(ns)) {
+        value[key] = ns[key];
+      }
+      parentPort.postMessage({
+        type: "result",
+        id: msg.id,
+        ok: true,
+        value,
+        dependencies: deps
+      });
+    } catch (err) {
+      const error = err instanceof Error ? { message: err.message, stack: err.stack ?? "" } : { message: String(err), stack: "" };
+      const deps = await requestDeps();
+      if (!deps.includes(msg.absolutePath)) {
+        deps.unshift(msg.absolutePath);
+      }
+      parentPort.postMessage({
+        type: "result",
+        id: msg.id,
+        ok: false,
+        error,
+        dependencies: deps
+      });
+    }
+  }
+);
+parentPort.postMessage({ type: "ready" });
+//# sourceMappingURL=worker.js.map

package/dist/isolated-source-eval/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../isolated-source-eval/worker.ts"],"sourcesContent":["/**\n * Worker thread entry point for isolated module evaluation.\n *\n * Each worker is a full Node.js environment with its own ESM module cache.\n * Modules are loaded via dynamic `import()` — Node 22.18.0+ strips TypeScript\n * types natively, so no compilation step or flags are needed.\n *\n * The loader hook data URL is received via `workerData` rather than\n * importing it from a sibling module. This avoids a cross-file import\n * resolution problem: Node's strip-types requires `.ts` extensions in\n * source, but compiled output uses `.js`. Passing the URL through\n * `workerData` sidesteps this entirely since the worker file has no\n * local imports beyond node built-ins.\n */\nimport { parentPort, workerData } from \"node:worker_threads\";\nimport { MessageChannel } from \"node:worker_threads\";\nimport { pathToFileURL } from \"node:url\";\n\n/**\n * We import `register` from `node:module` instead of calling `module.register()`\n * directly. Node's strip-types parser sees the bare `module` identifier as a\n * CJS global, and combined with top-level `await` (or other ESM syntax), it\n * throws \"Cannot determine intended module format\". Using the explicit import\n * avoids this ambiguity entirely.\n */\nimport { register } from \"node:module\";\n\nif (!parentPort) {\n  throw new Error(\"This file must be run as a worker thread\");\n}\n\nconst loaderDataUrl: string = workerData.loaderDataUrl;\n\n/**\n * MessageChannel for communicating with the loader hook.\n * port1 stays in this worker thread; port2 is transferred to the loader\n * thread via `register()`'s transferList. This is the only way to get\n * data out of loader hooks, since they run in an isolated loader thread\n * that cannot access worker_threads.parentPort.\n */\nconst { port1, port2 } = new MessageChannel();\n\nregister(loaderDataUrl, {\n  parentURL: import.meta.url,\n  data: { port: port2 },\n  transferList: [port2],\n});\n\n/**\n * Requests the accumulated dependency list from the loader hook.\n *\n * Called after each `import()` completes. The loader hook clears its\n * internal Set on each request, so dependencies are scoped to the\n * most recent evaluation. This is safe because evaluations are\n * serialized — only one runs at a time per worker.\n */\nfunction requestDeps(): Promise<string[]> {\n  return new Promise((resolve) => {\n    port1.once(\"message\", (deps: string[]) => {\n      resolve(deps);\n    });\n    port1.postMessage(\"getDeps\");\n  });\n}\n\nparentPort.on(\n  \"message\",\n  async (msg: { type: string; id: number; absolutePath: string }) => {\n    if (msg.type !== \"evaluate\") return;\n\n    try {\n      const fileUrl = pathToFileURL(msg.absolutePath).href;\n      const ns = await import(fileUrl);\n\n      const deps = await requestDeps();\n\n      // The entry point may not appear in the loader hook's dependency set\n      // if it was already in the ESM cache from a previous evaluation.\n      // The resolve hook only fires on cache misses.\n      if (!deps.includes(msg.absolutePath)) {\n        deps.unshift(msg.absolutePath);\n      }\n\n      // Module namespace objects are exotic objects that fail structured clone\n      // (postMessage would throw). Copying to a plain object is required.\n      const value: Record<string, unknown> = {};\n      for (const key of Object.keys(ns)) {\n        value[key] = ns[key];\n      }\n\n      parentPort!.postMessage({\n        type: \"result\",\n        id: msg.id,\n        ok: true,\n        value,\n        dependencies: deps,\n      });\n    } catch (err: unknown) {\n      // Catches both evaluation errors (syntax errors, runtime exceptions)\n      // and structured clone failures (e.g. when exports contain functions,\n      // Symbols, or other non-cloneable values). Both are returned as\n      // { ok: false } results — the caller does not need to distinguish.\n      const error =\n        err instanceof Error\n          ? { message: err.message, stack: err.stack ?? \"\" }\n          : { message: String(err), stack: \"\" };\n\n      // Flush partial dependencies that the loader hook tracked before the\n      // error. This allows the evaluator to register them in the reverse\n      // dep map so that fixing the broken file triggers re-evaluation.\n      const deps = await requestDeps();\n      if (!deps.includes(msg.absolutePath)) {\n        deps.unshift(msg.absolutePath);\n      }\n\n      parentPort!.postMessage({\n        type: \"result\",\n        id: msg.id,\n        ok: false,\n        error,\n        dependencies: deps,\n      });\n    }\n  },\n);\n\nparentPort.postMessage({ type: \"ready\" });\n"],"mappings":";AAcA,SAAS,YAAY,kBAAkB;AACvC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAS9B,SAAS,gBAAgB;AAEzB,IAAI,CAAC,YAAY;AACf,QAAM,IAAI,MAAM,0CAA0C;AAC5D;AAEA,IAAM,gBAAwB,WAAW;AASzC,IAAM,EAAE,OAAO,MAAM,IAAI,IAAI,eAAe;AAE5C,SAAS,eAAe;AAAA,EACtB,WAAW,YAAY;AAAA,EACvB,MAAM,EAAE,MAAM,MAAM;AAAA,EACpB,cAAc,CAAC,KAAK;AACtB,CAAC;AAUD,SAAS,cAAiC;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,KAAK,WAAW,CAAC,SAAmB;AACxC,cAAQ,IAAI;AAAA,IACd,CAAC;AACD,UAAM,YAAY,SAAS;AAAA,EAC7B,CAAC;AACH;AAEA,WAAW;AAAA,EACT;AAAA,EACA,OAAO,QAA4D;AACjE,QAAI,IAAI,SAAS,WAAY;AAE7B,QAAI;AACF,YAAM,UAAU,cAAc,IAAI,YAAY,EAAE;AAChD,YAAM,KAAK,MAAM,OAAO;AAExB,YAAM,OAAO,MAAM,YAAY;AAK/B,UAAI,CAAC,KAAK,SAAS,IAAI,YAAY,GAAG;AACpC,aAAK,QAAQ,IAAI,YAAY;AAAA,MAC/B;AAIA,YAAM,QAAiC,CAAC;AACxC,iBAAW,OAAO,OAAO,KAAK,EAAE,GAAG;AACjC,cAAM,GAAG,IAAI,GAAG,GAAG;AAAA,MACrB;AAEA,iBAAY,YAAY;AAAA,QACtB,MAAM;AAAA,QACN,IAAI,IAAI;AAAA,QACR,IAAI;AAAA,QACJ;AAAA,QACA,cAAc;AAAA,MAChB,CAAC;AAAA,IACH,SAAS,KAAc;AAKrB,YAAM,QACJ,eAAe,QACX,EAAE,SAAS,IAAI,SAAS,OAAO,IAAI,SAAS,GAAG,IAC/C,EAAE,SAAS,OAAO,GAAG,GAAG,OAAO,GAAG;AAKxC,YAAM,OAAO,MAAM,YAAY;AAC/B,UAAI,CAAC,KAAK,SAAS,IAAI,YAAY,GAAG;AACpC,aAAK,QAAQ,IAAI,YAAY;AAAA,MAC/B;AAEA,iBAAY,YAAY;AAAA,QACtB,MAAM;AAAA,QACN,IAAI,IAAI;AAAA,QACR,IAAI;AAAA,QACJ;AAAA,QACA,cAAc;AAAA,MAChB,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEA,WAAW,YAAY,EAAE,MAAM,QAAQ,CAAC;","names":[]}

package/dist/loaders/vite-plugin.d.ts

@@ -3,6 +3,14 @@ import { Plugin } from 'vite';
 import { YakConfigOptions } from '../withYak/index.ts';
 
 type ViteYakPluginOptions = YakConfigOptions & {
+    /**
+     * Base path for resolving CSS virtual module paths.
+     * Relative paths are resolved from Vite's project root.
+     * In monorepo setups where source files live outside the Vite project root,
+     * set this to the monorepo root to avoid broken CSS imports.
+     * @defaultValue Vite's resolved `root`
+     */
+    basePath?: string;
     swcOptions?: Omit<Options, "filename" | "sourceFileName" | "inputSourceMap" | "sourceMaps" | "sourceRoot">;
 };
 declare function viteYak(userOptions?: ViteYakPluginOptions): Promise<Plugin>;