vite-ssg-optimized 0.24.2-optimized.5 → 0.24.2-optimized.50

package/dist/shared/build.worker.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'node:module';
 import { parentPort, workerData } from 'node:worker_threads';
-import { g as getBeastiesOrCritters, e as executeTaskFn } from './vite-ssg-optimized.62fed880.mjs';
-import { gray, blue } from 'kolorist';
+import { p as plainify, e as executeTaskFn, a as buildClient, c as buildServer } from './vite-ssg-optimized.65f46348.mjs';
+import { red, gray, blue } from 'kolorist';
 import { resolveConfig } from 'vite';
 import 'node:path';
 import 'node:process';
@@ -10,9 +10,39 @@ import 'fs-extra';
 import './vite-ssg-optimized.579feabb.mjs';
 import 'html5parser';
 
+async function getBeastiesOrCritters(outDir, options = {}) {
+  try {
+    const BeastiesClass = (await import('beasties')).default;
+    return new BeastiesClass({
+      path: outDir,
+      logLevel: "warn",
+      external: true,
+      inlineFonts: true,
+      preloadFonts: true,
+      ...options
+    });
+  } catch {
+  }
+  try {
+    const CrittersClass = (await import('critters')).default;
+    console.warn("`critters` is deprecated. Please use `beasties` instead.");
+    return new CrittersClass({
+      path: outDir,
+      logLevel: "warn",
+      external: true,
+      inlineFonts: true,
+      preloadFonts: true,
+      ...options
+    });
+  } catch {
+    return void 0;
+  }
+}
+
 (async () => {
-  const fnLog = (level = "info", msg) => {
-    parentPort.postMessage({ type: "log", args: [msg], level });
+  const fnLog = (level = "info", ...msg) => {
+    const newMsg = msg.map(plainify);
+    parentPort.postMessage({ type: "log", args: newMsg, level });
   };
   globalThis.console = Object.assign(globalThis.console, {
     info: fnLog.bind(globalThis.console, "info"),
@@ -22,23 +52,53 @@ import 'html5parser';
     trace: fnLog.bind(globalThis.console, "trace"),
     debug: fnLog.bind(globalThis.console, "debug")
   });
-  const { serverEntry, out, beastiesOptions, viteConfig, mode, format, dirStyle, ...extraOpts } = workerData;
+  const noop = () => void 0;
+  const proccessInjections = {
+    clearLine: noop,
+    cursorTo: noop,
+    clearScreenDown: noop,
+    moveCursor: noop,
+    isTTY: false
+  };
+  Object.assign(process.stdout, proccessInjections);
+  Object.assign(process.stderr, proccessInjections);
+  const { format, out, dirStyle, viteConfig, mode, ...extraOpts } = workerData;
   const nodeEnv = process.env.NODE_ENV || "production";
   const config = await resolveConfig(viteConfig, "build", mode, nodeEnv);
   const {
     onPageRendered,
     onBeforePageRender,
-    onDonePageRender
+    // onDonePageRender,
+    onFinished
   } = config.ssgOptions || {};
   const { renderToString } = await import('vue/server-renderer');
   const outDir = out.replace(process.cwd(), "").replace(/^\//g, "");
   const _require = createRequire(import.meta.url);
-  const beasties = beastiesOptions !== false ? await getBeastiesOrCritters(outDir, beastiesOptions) : void 0;
-  if (beasties)
-    console.log(`${gray("[vite-ssg]")} ${blue("Critical CSS generation enabled via `beasties`")}`);
-  const { createApp } = format === "esm" ? await import(serverEntry) : _require(serverEntry);
+  let createAppPromise = void 0;
+  let beastiesPromise = void 0;
+  function cancelablePromise(promise) {
+    let cancel = () => void 0;
+    const newPromise = new Promise((resolve, reject) => {
+      cancel = () => void reject(new Error("Cancelled"));
+      promise.then((result) => {
+        resolve(result);
+      });
+    });
+    return Object.assign(newPromise, { cancel });
+  }
   const execMap = {
     executeTaskFn: async (opts) => {
+      const { serverEntry } = opts;
+      createAppPromise ?? (createAppPromise = Promise.resolve(format === "esm" ? import(serverEntry) : _require(serverEntry)).then(({ createApp: createApp2 }) => createApp2));
+      const createApp = await createAppPromise;
+      const beastiesOptions = opts.beastiesOptions;
+      beastiesPromise ?? (beastiesPromise = Promise.resolve(beastiesOptions !== false ? getBeastiesOrCritters(outDir, beastiesOptions) : void 0).then((beasties2) => {
+        if (!beasties2)
+          return;
+        console.log(`${gray("[vite-ssg]")} ${blue("Critical CSS generation enabled via `beasties`")}`);
+        return beasties2;
+      }));
+      const beasties = await beastiesPromise;
       const newOpts = {
         ...extraOpts,
         out,
@@ -47,14 +107,34 @@ import 'html5parser';
         renderToString,
         onPageRendered,
         onBeforePageRender,
-        onDonePageRender,
+        // onDonePageRender: onDonePageRender,
         beasties,
         config: { logger: { info: (msg) => {
           parentPort.postMessage({ type: "log", args: [msg] });
         } } },
         ...opts
       };
-      return executeTaskFn(newOpts);
+      const resultPromise = cancelablePromise(executeTaskFn(newOpts));
+      const cancel = async () => {
+        resultPromise.cancel();
+      };
+      process.once("beforeExit", cancel);
+      process.once("SIGINT", cancel);
+      process.once("SIGTERM", cancel);
+      return resultPromise;
+    },
+    onFinished,
+    buildClient: async (...args) => {
+      let [_config, _viteConfig] = args;
+      _config = Object.assign({}, config, _config);
+      _viteConfig = Object.assign({}, viteConfig, _viteConfig);
+      return await buildClient(_config, _viteConfig);
+    },
+    buildServer: async (...args) => {
+      let [_config, _viteConfig, _opts] = args;
+      _config = Object.assign({}, config, _config);
+      _viteConfig = Object.assign({}, viteConfig, _viteConfig);
+      return await buildServer(_config, _viteConfig, _opts);
     }
   };
   parentPort?.on("message", async (message) => {
@@ -62,15 +142,16 @@ import 'html5parser';
     if (type in execMap) {
       parentPort.postMessage(`running ${type}`);
       try {
-        const result = await execMap[type](...args ?? []);
-        if (result.appCtx) {
-          Object.assign(result, {
-            appCtx: result.appCtx.router.push(result.route)
-          });
-        }
+        let result = await execMap[type](...args ?? []);
+        result = plainify(result);
         parentPort.postMessage({ type: "result", id, result });
       } catch (e) {
-        parentPort.postMessage({ type: "error", id, error: e.toString() });
+        const message2 = e.message || e.toString();
+        const stack = e.stack || "";
+        const error = { message: message2, stack };
+        process.stderr.write(`${red("[vite-ssg-worker]")} ${message2} ${stack}
+`);
+        parentPort.postMessage({ type: "error", id, error });
       }
     }
   });

package/dist/shared/{vite-ssg-optimized.cf5cb4ee.d.cts → vite-ssg-optimized.341e382e.d.cts}

@@ -113,8 +113,13 @@ interface ViteSSGOptions {
        * It's useful to debug memory leaks
        *
        */
-    onDonePageRender?: (route: string, renderedHTML: string, appCtx: ViteSSGContext<true>) => Promise<void> | void;
     onFinished?: () => Promise<void> | void;
+    /**
+     * The number of workers to use.
+     *
+     * @default 5
+     */
+    numberOfWorkers?: number;
     /**
      * The application's root container `id`.
      *

package/dist/shared/{vite-ssg-optimized.cf5cb4ee.d.mts → vite-ssg-optimized.341e382e.d.mts}

@@ -113,8 +113,13 @@ interface ViteSSGOptions {
        * It's useful to debug memory leaks
        *
        */
-    onDonePageRender?: (route: string, renderedHTML: string, appCtx: ViteSSGContext<true>) => Promise<void> | void;
     onFinished?: () => Promise<void> | void;
+    /**
+     * The number of workers to use.
+     *
+     * @default 5
+     */
+    numberOfWorkers?: number;
     /**
      * The application's root container `id`.
      *

package/dist/shared/{vite-ssg-optimized.cf5cb4ee.d.ts → vite-ssg-optimized.341e382e.d.ts}

@@ -113,8 +113,13 @@ interface ViteSSGOptions {
        * It's useful to debug memory leaks
        *
        */
-    onDonePageRender?: (route: string, renderedHTML: string, appCtx: ViteSSGContext<true>) => Promise<void> | void;
     onFinished?: () => Promise<void> | void;
+    /**
+     * The number of workers to use.
+     *
+     * @default 5
+     */
+    numberOfWorkers?: number;
     /**
      * The application's root container `id`.
      *

package/dist/shared/{vite-ssg-optimized.62fed880.mjs → vite-ssg-optimized.65f46348.mjs}

@@ -3,7 +3,7 @@ import { isAbsolute, join, parse, dirname } from 'node:path';
 import process$1 from 'node:process';
 import { renderSSRHead } from '@unhead/ssr';
 import fs from 'fs-extra';
-import { gray, yellow, blue, green, dim, cyan, red } from 'kolorist';
+import { gray, yellow, blue, reset, green, cyan, dim, red } from 'kolorist';
 import { resolveConfig, build as build$1, mergeConfig } from 'vite';
 import { s as serializeState } from './vite-ssg-optimized.579feabb.mjs';
 import html5Parser, { SyntaxKind } from 'html5parser';
@@ -830,35 +830,6 @@ class PQueue extends EventEmitter {
     }
 }
 
-async function getBeastiesOrCritters(outDir, options = {}) {
-  try {
-    const BeastiesClass = (await import('beasties')).default;
-    return new BeastiesClass({
-      path: outDir,
-      logLevel: "warn",
-      external: true,
-      inlineFonts: true,
-      preloadFonts: true,
-      ...options
-    });
-  } catch {
-  }
-  try {
-    const CrittersClass = (await import('critters')).default;
-    console.warn("`critters` is deprecated. Please use `beasties` instead.");
-    return new CrittersClass({
-      path: outDir,
-      logLevel: "warn",
-      external: true,
-      inlineFonts: true,
-      preloadFonts: true,
-      ...options
-    });
-  } catch {
-    return void 0;
-  }
-}
-
 function isMatchOption(node, opts) {
   if (opts.match.tag && !(node.name === opts.match.tag)) {
     return false;
@@ -1044,15 +1015,16 @@ class BuildWorkerProxy {
   constructor(path, options) {
     __publicField(this, "worker");
     __publicField(this, "pending", /* @__PURE__ */ new Map());
+    __publicField(this, "_id");
     this.worker = new Worker(path, options);
+    this._id = options.workerData.workerId;
     this.worker.on("message", (message) => {
       const { type, level = "info", args = [] } = message;
       if (type !== "log")
         return;
       const fn = console[level]?.bind(console);
-      let msg = args.map((arg) => typeof arg === "object" && !!arg ? "[object]" : arg).join(" ");
       const workerId = options.workerData.workerId;
-      fn?.(`[woker #${workerId}] ${msg}`);
+      fn?.(`[woker #${workerId}] `, ...args, reset(""));
     });
     this.worker.on("message", (message) => {
       const { id, type, result = void 0, error = void 0 } = message;
@@ -1067,12 +1039,18 @@ class BuildWorkerProxy {
       }
     });
   }
+  get id() {
+    return this._id;
+  }
   on(type, listener) {
     this.worker.on(type, listener);
   }
   off(type, listener) {
     this.worker.off(type, listener);
   }
+  once(type, listener) {
+    this.worker.once(type, listener);
+  }
   async send(type, args) {
     const id = crypto.randomUUID();
     const promise = new Promise((resolve, reject) => {
@@ -1085,7 +1063,9 @@ class BuildWorkerProxy {
     return promise;
   }
   terminate() {
-    this.worker.terminate();
+    return this.worker.terminate().finally(() => {
+      this.pending.clear();
+    });
   }
 }
 
@@ -1113,10 +1093,14 @@ async function buildClient(config, viteConfig) {
     mode: config.mode
   }));
 }
-async function buildServer(config, viteConfig, { ssrEntry, ssgOut, format }) {
+async function buildServer(config, viteConfig, { ssrEntry, ssgOut, format, mock }) {
   buildLog("Build for server...");
   process$1.env.VITE_SSG = "true";
   const { base } = config;
+  if (mock) {
+    const { jsdomGlobal } = await import('../chunks/jsdomGlobal.mjs');
+    jsdomGlobal();
+  }
   await build$1(mergeConfig(viteConfig, {
     base,
     build: {
@@ -1137,6 +1121,19 @@ async function buildServer(config, viteConfig, { ssrEntry, ssgOut, format }) {
     mode: config.mode
   }));
 }
+function createProxy(options) {
+  const workerExt = options.format === "esm" ? ".mjs" : ".cjs";
+  const workerProxy = new BuildWorkerProxy(new URL(`./build.worker${workerExt}`, import.meta.url), {
+    env: process$1.env,
+    workerData: options
+  });
+  process$1.once("SIGINT", workerProxy.terminate.bind(workerProxy));
+  process$1.once("SIGTERM", workerProxy.terminate.bind(workerProxy));
+  process$1.once("SIGBREAK", workerProxy.terminate.bind(workerProxy));
+  process$1.once("beforeExit", workerProxy.terminate.bind(workerProxy));
+  process$1.once("exit", workerProxy.terminate.bind(workerProxy));
+  return workerProxy;
+}
 async function build(ssgOptions = {}, viteConfig = {}) {
   const nodeEnv = process$1.env.NODE_ENV || "production";
   const mode = process$1.env.MODE || ssgOptions.mode || nodeEnv;
@@ -1151,12 +1148,13 @@ async function build(ssgOptions = {}, viteConfig = {}) {
     ssgOut: _ssgOutDir = join(root, ".vite-ssg-temp", Math.random().toString(36).substring(2, 12)),
     formatting = "none",
     minifyOptions = {},
-    crittersOptions = {},
+    // crittersOptions = {},
     beastiesOptions = {},
     includedRoutes: configIncludedRoutes = DefaultIncludedRoutes,
-    onBeforePageRender,
-    onPageRendered,
-    onDonePageRender,
+    // onBeforePageRender,
+    // onPageRendered,
+    // onDonePageRender,
+    numberOfWorkers: _numberOfWorkers = 5,
     onFinished,
     dirStyle = "flat",
     includeAllRoutes = false,
@@ -1165,6 +1163,14 @@ async function build(ssgOptions = {}, viteConfig = {}) {
     rootContainerId = "app"
   } = Object.assign({}, config.ssgOptions || {}, ssgOptions);
   const ssgOut = isAbsolute(_ssgOutDir) ? _ssgOutDir : join(root, _ssgOutDir);
+  const createProxyOptions = {
+    format,
+    out,
+    dirStyle,
+    viteConfig: {
+      configFile: config.configFile
+    }
+  };
   let willRunBuild = true;
   if (fs.existsSync(ssgOut)) {
     willRunBuild = !ssgOptions["skip-build"];
@@ -1172,17 +1178,79 @@ async function build(ssgOptions = {}, viteConfig = {}) {
       await fs.remove(ssgOut);
     }
   }
-  if (willRunBuild)
-    await buildClient(config, viteConfig);
-  if (mock) {
-    const { jsdomGlobal } = await import('../chunks/jsdomGlobal.mjs');
-    jsdomGlobal();
+  const buildPromises = [];
+  if (willRunBuild) {
+    const clientWorker = createProxy({
+      ...createProxyOptions,
+      workerId: "client"
+    });
+    clientWorker.on("unhandledRejection", (error) => {
+      console.error(error);
+      clientWorker.terminate();
+    });
+    const cpBuildClient = execInWorker(clientWorker, buildClient, config, viteConfig).finally(() => clientWorker.terminate());
+    buildPromises.push(cpBuildClient);
   }
   const ssrEntry = await resolveAlias(config, entry);
-  if (willRunBuild)
-    await buildServer(config, viteConfig, { ssrEntry, ssgOut, format });
+  if (willRunBuild) {
+    const serverWorker = createProxy({
+      ...createProxyOptions,
+      workerId: "server"
+    });
+    const cpBuildServer = execInWorker(serverWorker, buildServer, config, viteConfig, { ssrEntry, ssgOut, format, mock }).finally(() => serverWorker.terminate());
+    buildPromises.push(cpBuildServer);
+  }
+  await Promise.all(buildPromises);
   const prefix = format === "esm" && process$1.platform === "win32" ? "file://" : "";
   const ext = format === "esm" ? ".mjs" : ".cjs";
+  const numberOfWorkers = Math.max(1, _numberOfWorkers);
+  console.log(`${gray("[vite-ssg]")} ${blue(`Using ${numberOfWorkers} workers`)}`);
+  const workers = Array.from({ length: numberOfWorkers }, (_, index) => createProxy({
+    ...createProxyOptions,
+    workerId: index
+  }));
+  const workersInUse = /* @__PURE__ */ new Map();
+  const terminateWorker = async (worker, onFinished2) => {
+    if (onFinished2) {
+      await execInWorker(worker, onFinished2);
+    }
+    const foundIndex = workers.indexOf(worker);
+    if (foundIndex > -1) {
+      workers.splice(foundIndex, 1);
+    }
+    await worker.terminate().finally(() => {
+      workersInUse.delete(worker);
+    });
+  };
+  const terminateWorkers = async (onFinished2) => {
+    await Promise.all(workers.map((worker) => terminateWorker(worker, onFinished2)));
+  };
+  let workerIndex = 0;
+  const maxTasksPerWorker = Math.ceil(concurrency / numberOfWorkers);
+  const workerTasksRunning = (w) => workersInUse.get(w)?.length || 0;
+  const selectIdleWorker = () => workers.filter((w) => workerTasksRunning(w) < maxTasksPerWorker).sort((a, b) => workerTasksRunning(a) - workerTasksRunning(b))[0];
+  const selectWorker = async (workerIndex2) => {
+    const index = workerIndex2 ?? Math.round(Math.random() * numberOfWorkers);
+    const maybeWorker = workers[index % numberOfWorkers];
+    const worker = maybeWorker && workerTasksRunning(maybeWorker) < maxTasksPerWorker ? maybeWorker : selectIdleWorker();
+    if (!worker) {
+      await Promise.race(Array.from(workersInUse.values()).flat());
+      return selectWorker(workerIndex2);
+    }
+    const workerPromises = workersInUse.get(worker) || [];
+    const delayPromise = new Promise((resolve) => setImmediate(resolve));
+    workerPromises.push(delayPromise);
+    workersInUse.set(worker, workerPromises);
+    delayPromise.finally(() => {
+      const workerPromises2 = workersInUse.get(worker) || [];
+      const foundIndex = workerPromises2.indexOf(delayPromise);
+      if (foundIndex > -1) {
+        workerPromises2.splice(foundIndex, 1);
+      }
+      workersInUse.set(worker, workerPromises2);
+    });
+    return worker;
+  };
   const serverEntry = prefix + join(ssgOut, parse(ssrEntry).name + ext).replace(/\\/g, "/");
   const _require = createRequire(import.meta.url);
   const { createApp, includedRoutes: serverEntryIncludedRoutes } = format === "esm" ? await import(serverEntry) : _require(serverEntry);
@@ -1191,9 +1259,6 @@ async function build(ssgOptions = {}, viteConfig = {}) {
   let routesPaths = includeAllRoutes ? routesToPaths(routes) : await includedRoutes(routesToPaths(routes), routes || []);
   routesPaths = Array.from(new Set(routesPaths));
   buildLog("Rendering Pages...", routesPaths.length);
-  const beasties = beastiesOptions !== false ? await getBeastiesOrCritters(outDir, beastiesOptions) : void 0;
-  if (beasties)
-    console.log(`${gray("[vite-ssg]")} ${blue("Critical CSS generation enabled via `beasties`")}`);
   const {
     path: _ssrManifestPath,
     content: ssrManifestRaw
@@ -1208,46 +1273,76 @@ async function build(ssgOptions = {}, viteConfig = {}) {
   indexHTML = rewriteScripts(indexHTML, script);
   const IS_PROD = nodeEnv === "production";
   indexHTML = await formatHtml(indexHTML, IS_PROD ? "minify" : formatting, minifyOptions);
+  const workerRunCount = /* @__PURE__ */ new WeakMap();
+  const MAX_RUNS_PER_WORKER = 100;
+  let lastWorkerIndex = workers.length - 1;
+  function replaceWorker(workerProxy) {
+    const index = workers.indexOf(workerProxy);
+    if (index === -1) {
+      return workerProxy;
+    }
+    ++lastWorkerIndex;
+    config.logger.info(`${blue("[vite-ssg]")} ${yellow(`Replace worker #${workerProxy.id} => #${lastWorkerIndex}`)}`);
+    const workerPromises = workersInUse.get(workerProxy) || [];
+    const newWorkerProxy = createProxy({
+      ...createProxyOptions,
+      workerId: lastWorkerIndex
+    });
+    workers[index] = newWorkerProxy;
+    Promise.allSettled([...workerPromises, Promise.resolve()]).then(async () => {
+      await terminateWorker(workerProxy, onFinished);
+    });
+    return newWorkerProxy;
+  }
   const queue = new PQueue({ concurrency });
-  const workerExt = format === "esm" ? ".mjs" : ".cjs";
-  const createProxy = (index) => {
-    const workerProxy = new BuildWorkerProxy(new URL(`./build.worker${workerExt}`, import.meta.url), {
-      env: process$1.env,
-      workerData: {
-        workerId: index,
-        serverEntry,
+  for (const route of routesPaths) {
+    await queue.onSizeLessThan(concurrency);
+    queue.add(async () => {
+      let workerProxy = await selectWorker(workerIndex++ % numberOfWorkers);
+      const currentCount = (workerRunCount.get(workerProxy) ?? 0) + 1;
+      workerRunCount.set(workerProxy, currentCount);
+      if (currentCount > MAX_RUNS_PER_WORKER) {
+        workerRunCount.delete(workerProxy);
+        workerProxy = replaceWorker(workerProxy);
+      }
+      let retryCount = 0;
+      const maxRetries = 3;
+      const execOpts = {
+        route,
         ssrManifest,
-        format,
-        out,
-        beastiesOptions,
-        dirStyle,
         indexHTML,
         rootContainerId,
         formatting,
         minifyOptions,
-        viteConfig: {
-          configFile: config.configFile || "vite.config.ts"
+        // out,
+        // dirStyle,
+        beastiesOptions,
+        serverEntry
+      };
+      const taskPromise = executeTaskInWorker(workerProxy, execOpts);
+      const workerPromises = workersInUse.get(workerProxy) || [];
+      workerPromises.push(taskPromise);
+      workersInUse.set(workerProxy, workerPromises);
+      const retryFn = async (e) => {
+        if (retryCount++ < maxRetries) {
+          console.log(`${gray("[vite-ssg]")} ${yellow(`Retrying ${retryCount} of ${maxRetries} for route: ${cyan(route)}`)}`);
+          return await executeTaskInWorker(workerProxy, execOpts).catch(retryFn);
         }
-      }
-    });
-    return workerProxy;
-  };
-  const numberOfWorkers = 5;
-  const workers = Array.from({ length: numberOfWorkers }, (_, index) => createProxy(index));
-  let workerIndex = 0;
-  for (const route of routesPaths) {
-    await queue.onSizeLessThan(concurrency + 5);
-    const workerProxy = workers[workerIndex];
-    workerIndex = (workerIndex + 1) % numberOfWorkers;
-    queue.add(async () => {
-      const taskPromise = executeTaskInWorker(workerProxy, {
-        route
+        throw e;
+      };
+      taskPromise.catch(retryFn).finally(() => {
+        const workerPromises2 = workersInUse.get(workerProxy) || [];
+        const foundIndex = workerPromises2.indexOf(taskPromise);
+        if (foundIndex > -1) {
+          workerPromises2.splice(foundIndex, 1);
+        }
+        workersInUse.set(workerProxy, workerPromises2);
       });
       return taskPromise;
     });
   }
   await queue.start().onIdle();
-  workers.forEach((worker) => worker.terminate());
+  await terminateWorkers(onFinished);
   if (!ssgOptions["skip-build"]) {
     await fs.remove(ssgOut);
   }
@@ -1267,14 +1362,10 @@ ${gray("[vite-ssg]")} ${green("Build finished.")}`);
   timeout.unref();
 }
 function executeTaskInWorker(worker, opts) {
-  opts = Object.entries(opts).reduce((acc, [key, value]) => {
-    if (typeof value === "function")
-      return acc;
-    const newKey = key;
-    acc[newKey] = value;
-    return acc;
-  }, {});
-  return worker.send("executeTaskFn", [opts]);
+  return execInWorker(worker, executeTaskFn, opts);
+}
+async function execInWorker(worker, fn, ...args) {
+  return await worker.send(fn.name, plainify(args ?? []));
 }
 async function executeTaskFn(opts) {
   const {
@@ -1283,7 +1374,7 @@ async function executeTaskFn(opts) {
     renderToString,
     indexHTML,
     onBeforePageRender,
-    onDonePageRender,
+    // onDonePageRender, 
     onPageRendered,
     ssrManifest,
     rootContainerId,
@@ -1343,7 +1434,6 @@ async function executeTaskFn(opts) {
       config.logger.info(
         `${dim(`${outDir}/`)}${cyan(filename.padEnd(15, " "))}  ${dim(getSize(formatted))}`
       );
-      onDonePageRender?.(route, html, appCtx);
       return { route, html };
     });
   } catch (err) {
@@ -1351,6 +1441,27 @@ async function executeTaskFn(opts) {
 ${err.stack}`);
   }
 }
+function plainify(m) {
+  if (m instanceof Function) {
+    return void 0;
+  }
+  if (Array.isArray(m)) {
+    return m.map(plainify);
+  }
+  if (typeof m === "object" && m !== null) {
+    if (m instanceof Error || "stack" in m) {
+      return {
+        message: m.message,
+        stack: m.stack
+      };
+    }
+    return Object.entries(m).reduce((acc, [key, value]) => {
+      acc[key] = plainify(value);
+      return acc;
+    }, {});
+  }
+  return m;
+}
 async function detectEntry(root) {
   const scriptSrcReg = /<script.*?src=["'](.+?)["'](?!<).*>\s*<\/script>/gi;
   const html = await fs.readFile(join(root, "index.html"), "utf-8");
@@ -1449,4 +1560,4 @@ async function readFiles(...paths) {
   throw new Error(`Could not find any of the following files: ${paths.join(", ")}`);
 }
 
-export { build as b, executeTaskFn as e, getBeastiesOrCritters as g };
+export { buildClient as a, build as b, buildServer as c, executeTaskFn as e, plainify as p };