@taujs/server 0.2.1 → 0.2.3

package/dist/build.d.ts

@@ -0,0 +1,15 @@
+import { PluginOption } from 'vite';
+
+type Config = {
+    appId: string;
+    entryPoint: string;
+    plugins?: PluginOption[];
+};
+declare function taujsBuild({ config, projectRoot, clientBaseDir, isSSRBuild, }: {
+    config: Config[];
+    projectRoot: string;
+    clientBaseDir: string;
+    isSSRBuild?: boolean;
+}): Promise<void>;
+
+export { type Config, taujsBuild };

package/dist/build.js

@@ -0,0 +1,669 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/fastify-plugin/lib/getPluginName.js
+var require_getPluginName = __commonJS({
+  "node_modules/fastify-plugin/lib/getPluginName.js"(exports, module) {
+    "use strict";
+    var fpStackTracePattern = /at\s{1}(?:.*\.)?plugin\s{1}.*\n\s*(.*)/;
+    var fileNamePattern = /(\w*(\.\w*)*)\..*/;
+    module.exports = function getPluginName(fn) {
+      if (fn.name.length > 0) return fn.name;
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 10;
+      try {
+        throw new Error("anonymous function");
+      } catch (e) {
+        Error.stackTraceLimit = stackTraceLimit;
+        return extractPluginName(e.stack);
+      }
+    };
+    function extractPluginName(stack) {
+      const m = stack.match(fpStackTracePattern);
+      return m ? m[1].split(/[/\\]/).slice(-1)[0].match(fileNamePattern)[1] : "anonymous";
+    }
+    module.exports.extractPluginName = extractPluginName;
+  }
+});
+
+// node_modules/fastify-plugin/lib/toCamelCase.js
+var require_toCamelCase = __commonJS({
+  "node_modules/fastify-plugin/lib/toCamelCase.js"(exports, module) {
+    "use strict";
+    module.exports = function toCamelCase(name) {
+      if (name[0] === "@") {
+        name = name.slice(1).replace("/", "-");
+      }
+      return name.replace(/-(.)/g, function(match2, g1) {
+        return g1.toUpperCase();
+      });
+    };
+  }
+});
+
+// node_modules/fastify-plugin/plugin.js
+var require_plugin = __commonJS({
+  "node_modules/fastify-plugin/plugin.js"(exports, module) {
+    "use strict";
+    var getPluginName = require_getPluginName();
+    var toCamelCase = require_toCamelCase();
+    var count = 0;
+    function plugin(fn, options = {}) {
+      let autoName = false;
+      if (fn.default !== void 0) {
+        fn = fn.default;
+      }
+      if (typeof fn !== "function") {
+        throw new TypeError(
+          `fastify-plugin expects a function, instead got a '${typeof fn}'`
+        );
+      }
+      if (typeof options === "string") {
+        options = {
+          fastify: options
+        };
+      }
+      if (typeof options !== "object" || Array.isArray(options) || options === null) {
+        throw new TypeError("The options object should be an object");
+      }
+      if (options.fastify !== void 0 && typeof options.fastify !== "string") {
+        throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof options.fastify}'`);
+      }
+      if (!options.name) {
+        autoName = true;
+        options.name = getPluginName(fn) + "-auto-" + count++;
+      }
+      fn[Symbol.for("skip-override")] = options.encapsulate !== true;
+      fn[Symbol.for("fastify.display-name")] = options.name;
+      fn[Symbol.for("plugin-meta")] = options;
+      if (!fn.default) {
+        fn.default = fn;
+      }
+      const camelCase = toCamelCase(options.name);
+      if (!autoName && !fn[camelCase]) {
+        fn[camelCase] = fn;
+      }
+      return fn;
+    }
+    module.exports = plugin;
+    module.exports.default = plugin;
+    module.exports.fastifyPlugin = plugin;
+  }
+});
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/build.ts
+import fs from "fs/promises";
+import path3 from "path";
+import { build } from "vite";
+import { nodePolyfills } from "vite-plugin-node-polyfills";
+
+// src/SSRServer.ts
+var import_fastify_plugin = __toESM(require_plugin(), 1);
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { readFile } from "fs/promises";
+import path2 from "path";
+
+// src/constants.ts
+var RENDERTYPE = {
+  ssr: "ssr",
+  streaming: "streaming"
+};
+var SSRTAG = {
+  ssrHead: "<!--ssr-head-->",
+  ssrHtml: "<!--ssr-html-->"
+};
+var TEMPLATE = {
+  defaultEntryClient: "entry-client",
+  defaultEntryServer: "entry-server",
+  defaultHtmlTemplate: "index.html"
+};
+
+// src/utils/Utils.ts
+import { dirname, join } from "path";
+import "path";
+import { fileURLToPath } from "url";
+import { match } from "path-to-regexp";
+var isDevelopment = process.env.NODE_ENV === "development";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = join(dirname(__filename), !isDevelopment ? "./" : "..");
+var CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+async function collectStyle(server, entries) {
+  const urls = await collectStyleUrls(server, entries);
+  const codes = await Promise.all(
+    urls.map(async (url) => {
+      const res = await server.transformRequest(url + "?direct");
+      return [`/* [collectStyle] ${url} */`, res?.code];
+    })
+  );
+  return codes.flat().filter(Boolean).join("\n\n");
+}
+async function collectStyleUrls(server, entries) {
+  const visited = /* @__PURE__ */ new Set();
+  async function traverse(url) {
+    const [, id] = await server.moduleGraph.resolveUrl(url);
+    if (visited.has(id)) return;
+    visited.add(id);
+    const mod = server.moduleGraph.getModuleById(id);
+    if (!mod) return;
+    await Promise.all([...mod.importedModules].map((childMod) => traverse(childMod.url)));
+  }
+  await Promise.all(entries.map((e) => server.transformRequest(e)));
+  await Promise.all(entries.map((url) => traverse(url)));
+  return [...visited].filter((url) => url.match(CSS_LANGS_RE));
+}
+function renderPreloadLinks(ssrManifest, basePath = "") {
+  const seen = /* @__PURE__ */ new Set();
+  let links = "";
+  for (const moduleId in ssrManifest) {
+    const files = ssrManifest[moduleId];
+    if (files) {
+      files.forEach((file) => {
+        if (!seen.has(file)) {
+          seen.add(file);
+          links += renderPreloadLink(basePath ? `${basePath}/${file}` : `${file}`);
+        }
+      });
+    }
+  }
+  return links;
+}
+function renderPreloadLink(file) {
+  const fileType = file.match(/\.(js|css|woff2?|gif|jpe?g|png|svg)$/)?.[1];
+  switch (fileType) {
+    case "js":
+      return `<link rel="modulepreload" href="${file}">`;
+    case "css":
+      return `<link rel="stylesheet" href="${file}">`;
+    case "woff":
+    case "woff2":
+      return `<link rel="preload" href="${file}" as="font" type="font/${fileType}" crossorigin>`;
+    case "gif":
+    case "jpeg":
+    case "jpg":
+    case "png":
+      return `<link rel="preload" href="${file}" as="image" type="image/${fileType}">`;
+    case "svg":
+      return `<link rel="preload" href="${file}" as="image" type="image/svg+xml">`;
+    default:
+      return "";
+  }
+}
+var callServiceMethod = async (serviceRegistry, serviceName, serviceMethod, params) => {
+  const service = serviceRegistry[serviceName];
+  if (service && typeof service[serviceMethod] === "function") {
+    const method = service[serviceMethod];
+    const data = await method(params);
+    if (typeof data !== "object" || data === null)
+      throw new Error(`Expected object response from service method ${serviceMethod} on ${serviceName}, but got ${typeof data}`);
+    return data;
+  }
+  throw new Error(`Service method ${serviceMethod} does not exist on ${serviceName}`);
+};
+var fetchData = async ({ url, options }) => {
+  if (url) {
+    const response = await fetch(url, options);
+    if (!response.ok) throw new Error(`Failed to fetch data from ${url}`);
+    const data = await response.json();
+    if (typeof data !== "object" || data === null) throw new Error(`Expected object response from ${url}, but got ${typeof data}`);
+    return data;
+  }
+  throw new Error("URL must be provided to fetch data");
+};
+var fetchInitialData = async (attr, params, serviceRegistry) => {
+  if (attr && typeof attr.fetch === "function") {
+    return attr.fetch(params, {
+      headers: { "Content-Type": "application/json" },
+      params
+    }).then(async (data) => {
+      if (data.serviceName && data.serviceMethod) {
+        return await callServiceMethod(serviceRegistry, data.serviceName, data.serviceMethod, data.options?.params ?? {});
+      }
+      return await fetchData(data);
+    }).catch((error) => {
+      console.error("Error fetching initial data:", error);
+      throw error;
+    });
+  }
+  return Promise.resolve({});
+};
+var matchRoute = (url, renderRoutes) => {
+  for (const route of renderRoutes) {
+    const matcher = match(route.path, {
+      decode: decodeURIComponent
+    });
+    const matched = matcher(url);
+    if (matched) return { route, params: matched.params };
+  }
+  return null;
+};
+function getCssLinks(manifest, basePath = "") {
+  const seen = /* @__PURE__ */ new Set();
+  const styles = [];
+  for (const key in manifest) {
+    const entry = manifest[key];
+    if (entry && entry.css) {
+      for (const cssFile of entry.css) {
+        if (!seen.has(cssFile)) {
+          seen.add(cssFile);
+          styles.push(`<link rel="preload stylesheet" as="style" type="text/css" href="${basePath}/${cssFile}">`);
+        }
+      }
+    }
+  }
+  return styles.join("\n");
+}
+var overrideCSSHMRConsoleError = () => {
+  const originalConsoleError = console.error;
+  console.error = function(message, ...optionalParams) {
+    if (typeof message === "string" && message.includes("css hmr is not supported in runtime mode")) return;
+    originalConsoleError.apply(console, [message, ...optionalParams]);
+  };
+};
+var ensureNonNull = (value, errorMessage) => {
+  if (value === void 0 || value === null) throw new Error(errorMessage);
+  return value;
+};
+
+// src/SSRServer.ts
+var createMaps = () => {
+  return {
+    bootstrapModules: /* @__PURE__ */ new Map(),
+    cssLinks: /* @__PURE__ */ new Map(),
+    manifests: /* @__PURE__ */ new Map(),
+    preloadLinks: /* @__PURE__ */ new Map(),
+    renderModules: /* @__PURE__ */ new Map(),
+    ssrManifests: /* @__PURE__ */ new Map(),
+    templates: /* @__PURE__ */ new Map()
+  };
+};
+var processConfigs = (configs, baseClientRoot, templateDefaults) => {
+  return configs.map((config) => {
+    const clientRoot = path2.resolve(baseClientRoot, config.entryPoint);
+    return {
+      clientRoot,
+      entryPoint: config.entryPoint,
+      entryClient: config.entryClient || templateDefaults.defaultEntryClient,
+      entryServer: config.entryServer || templateDefaults.defaultEntryServer,
+      htmlTemplate: config.htmlTemplate || templateDefaults.defaultHtmlTemplate,
+      appId: config.appId
+    };
+  });
+};
+var SSRServer = (0, import_fastify_plugin.default)(
+  async (app, opts) => {
+    const { alias, configs, routes, serviceRegistry, isDebug, clientRoot: baseClientRoot } = opts;
+    const { bootstrapModules, cssLinks, manifests, preloadLinks, renderModules, ssrManifests, templates } = createMaps();
+    const processedConfigs = processConfigs(configs, baseClientRoot, TEMPLATE);
+    for (const config of processedConfigs) {
+      const { clientRoot, entryClient, htmlTemplate } = config;
+      const templateHtmlPath = path2.join(clientRoot, htmlTemplate);
+      const templateHtml = await readFile(templateHtmlPath, "utf-8");
+      templates.set(clientRoot, templateHtml);
+      const relativeBasePath = path2.relative(baseClientRoot, clientRoot).replace(/\\/g, "/");
+      const adjustedRelativePath = relativeBasePath ? `/${relativeBasePath}` : "";
+      if (!isDevelopment) {
+        const manifestPath = path2.join(clientRoot, ".vite/manifest.json");
+        const manifestContent = await readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(manifestContent);
+        manifests.set(clientRoot, manifest);
+        const ssrManifestPath = path2.join(clientRoot, ".vite/ssr-manifest.json");
+        const ssrManifestContent = await readFile(ssrManifestPath, "utf-8");
+        const ssrManifest = JSON.parse(ssrManifestContent);
+        ssrManifests.set(clientRoot, ssrManifest);
+        const entryClientFile = manifest[`${entryClient}.tsx`]?.file;
+        if (!entryClientFile) throw new Error(`Entry client file not found in manifest for ${entryClient}.tsx`);
+        const bootstrapModule = `/${adjustedRelativePath}/${entryClientFile}`.replace(/\/{2,}/g, "/");
+        bootstrapModules.set(clientRoot, bootstrapModule);
+        const preloadLink = renderPreloadLinks(ssrManifest, adjustedRelativePath);
+        preloadLinks.set(clientRoot, preloadLink);
+        const cssLink = getCssLinks(manifest, adjustedRelativePath);
+        cssLinks.set(clientRoot, cssLink);
+      } else {
+        const bootstrapModule = `/${adjustedRelativePath}/${entryClient}`.replace(/\/{2,}/g, "/");
+        bootstrapModules.set(clientRoot, bootstrapModule);
+      }
+    }
+    let viteDevServer;
+    await app.register(import("@fastify/static"), {
+      index: false,
+      prefix: "/",
+      root: baseClientRoot,
+      wildcard: false
+    });
+    if (isDevelopment) {
+      const { createServer } = await import("vite");
+      viteDevServer = await createServer({
+        appType: "custom",
+        css: {
+          preprocessorOptions: {
+            scss: {
+              api: "modern-compiler"
+            }
+          }
+        },
+        mode: "development",
+        plugins: [
+          ...isDebug ? [
+            {
+              name: "taujs-development-server-debug-logging",
+              configureServer(server) {
+                console.log(import_picocolors.default.green("\u03C4js development server debug started."));
+                server.middlewares.use((req, res, next) => {
+                  console.log(import_picocolors.default.cyan(`\u2190 rx: ${req.url}`));
+                  res.on("finish", () => console.log(import_picocolors.default.yellow(`\u2192 tx: ${req.url}`)));
+                  next();
+                });
+              }
+            }
+          ] : []
+        ],
+        resolve: {
+          alias: {
+            "@client": path2.resolve(baseClientRoot),
+            "@server": path2.resolve(__dirname),
+            "@shared": path2.resolve(__dirname, "../shared"),
+            ...alias
+          }
+        },
+        root: baseClientRoot,
+        server: {
+          middlewareMode: true,
+          hmr: {
+            port: 5174
+          }
+        }
+      });
+      overrideCSSHMRConsoleError();
+      app.addHook("onRequest", async (request, reply) => {
+        await new Promise((resolve) => {
+          viteDevServer.middlewares(request.raw, reply.raw, () => {
+            if (!reply.sent) resolve();
+          });
+        });
+      });
+    }
+    app.get("/*", async (req, reply) => {
+      try {
+        if (/\.\w+$/.test(req.raw.url ?? "")) return reply.callNotFound();
+        const url = req.url ? new URL(req.url, `http://${req.headers.host}`).pathname : "/";
+        const matchedRoute = matchRoute(url, routes);
+        if (!matchedRoute) {
+          reply.callNotFound();
+          return;
+        }
+        const { route, params } = matchedRoute;
+        const { attr, appId } = route;
+        const config = processedConfigs.find((config2) => config2.appId === appId) || processedConfigs[0];
+        if (!config) throw new Error("No configuration found for the request.");
+        const { clientRoot, entryServer } = config;
+        let template = ensureNonNull(templates.get(clientRoot), `Template not found for clientRoot: ${clientRoot}`);
+        const bootstrapModule = bootstrapModules.get(clientRoot);
+        const cssLink = cssLinks.get(clientRoot);
+        const manifest = manifests.get(clientRoot);
+        const preloadLink = preloadLinks.get(clientRoot);
+        const ssrManifest = ssrManifests.get(clientRoot);
+        let renderModule;
+        if (isDevelopment) {
+          template = template.replace(/<script type="module" src="\/@vite\/client"><\/script>/g, "");
+          template = template.replace(/<style type="text\/css">[\s\S]*?<\/style>/g, "");
+          const entryServerPath = path2.join(clientRoot, `${entryServer}.tsx`);
+          const executedModule = await viteDevServer.ssrLoadModule(entryServerPath);
+          renderModule = executedModule;
+          const styles = await collectStyle(viteDevServer, [entryServerPath]);
+          template = template?.replace("</head>", `<style type="text/css">${styles}</style></head>`);
+          template = await viteDevServer.transformIndexHtml(url, template);
+        } else {
+          renderModule = renderModules.get(clientRoot);
+          if (!renderModule) {
+            const renderModulePath = path2.join(clientRoot, `${entryServer}.js`);
+            const importedModule = await import(renderModulePath);
+            renderModule = importedModule;
+            renderModules.set(clientRoot, renderModule);
+          }
+        }
+        const renderType = attr?.render || RENDERTYPE.ssr;
+        const [beforeBody = "", afterBody = ""] = template.split(SSRTAG.ssrHtml);
+        const [beforeHead = "", afterHead = ""] = beforeBody.split(SSRTAG.ssrHead);
+        const initialDataPromise = fetchInitialData(attr, params, serviceRegistry);
+        if (renderType === RENDERTYPE.ssr) {
+          const { renderSSR } = renderModule;
+          const initialDataResolved = await initialDataPromise;
+          const initialDataScript = `<script>window.__INITIAL_DATA__ = ${JSON.stringify(initialDataResolved).replace(/</g, "\\u003c")}</script>`;
+          const { headContent, appHtml } = await renderSSR(initialDataResolved, req.url, attr?.meta);
+          let aggregateHeadContent = headContent;
+          if (ssrManifest && preloadLink) aggregateHeadContent += preloadLink;
+          if (manifest && cssLink) aggregateHeadContent += cssLink;
+          const fullHtml = template.replace(SSRTAG.ssrHead, aggregateHeadContent).replace(SSRTAG.ssrHtml, `${appHtml}${initialDataScript}<script type="module" src="${bootstrapModule}" defer></script>`);
+          return reply.status(200).header("Content-Type", "text/html").send(fullHtml);
+        } else {
+          const { renderStream } = renderModule;
+          reply.raw.writeHead(200, { "Content-Type": "text/html" });
+          renderStream(
+            reply.raw,
+            {
+              onHead: (headContent) => {
+                let aggregateHeadContent = headContent;
+                if (ssrManifest && preloadLink) aggregateHeadContent += preloadLink;
+                if (manifest && cssLink) aggregateHeadContent += cssLink;
+                reply.raw.write(`${beforeHead}${aggregateHeadContent}${afterHead}`);
+              },
+              onFinish: async (initialDataResolved) => {
+                reply.raw.write(`<script>window.__INITIAL_DATA__ = ${JSON.stringify(initialDataResolved).replace(/</g, "\\u003c")}</script>`);
+                reply.raw.write(afterBody);
+                reply.raw.end();
+              },
+              onError: (error) => {
+                console.error("Critical rendering onError:", error);
+                reply.raw.end("Internal Server Error");
+              }
+            },
+            initialDataPromise,
+            req.url,
+            bootstrapModule,
+            attr?.meta
+          );
+        }
+      } catch (error) {
+        console.error("Error setting up SSR stream:", error);
+        if (!reply.raw.headersSent) reply.raw.writeHead(500, { "Content-Type": "text/plain" });
+        reply.raw.end("Internal Server Error");
+      }
+    });
+    app.setNotFoundHandler(async (req, reply) => {
+      if (/\.\w+$/.test(req.raw.url ?? "")) return reply.callNotFound();
+      try {
+        const defaultConfig = processedConfigs[0];
+        if (!defaultConfig) throw new Error("No default configuration found.");
+        const { clientRoot } = defaultConfig;
+        let template = ensureNonNull(templates.get(clientRoot), `Template not found for clientRoot: ${clientRoot}`);
+        const cssLink = cssLinks.get(clientRoot);
+        const bootstrapModule = bootstrapModules.get(clientRoot);
+        template = template.replace(SSRTAG.ssrHead, "").replace(SSRTAG.ssrHtml, "");
+        if (!isDevelopment && cssLink) template = template.replace("</head>", `${cssLink}</head>`);
+        if (bootstrapModule) template = template.replace("</body>", `<script type="module" src="${bootstrapModule}" defer></script></body>`);
+        reply.status(200).type("text/html").send(template);
+      } catch (error) {
+        console.error("Failed to serve clientHtmlTemplate:", error);
+        reply.status(500).send("Internal Server Error");
+      }
+    });
+  },
+  { name: "taujs-ssr-server" }
+);
+
+// src/build.ts
+async function taujsBuild({
+  config,
+  projectRoot,
+  clientBaseDir,
+  isSSRBuild = process.env.BUILD_MODE === "ssr"
+}) {
+  const deleteDist = async () => {
+    const distPath = path3.resolve(projectRoot, "dist");
+    try {
+      await fs.rm(distPath, { recursive: true, force: true });
+      console.log("Deleted the dist directory\n");
+    } catch (err) {
+      console.error("Error deleting dist directory:", err);
+    }
+  };
+  const processedConfigs = processConfigs(config, clientBaseDir, TEMPLATE);
+  if (!isSSRBuild) await deleteDist();
+  for (const config2 of processedConfigs) {
+    const { appId, entryPoint, clientRoot, entryClient, entryServer, htmlTemplate, plugins = [] } = config2;
+    const outDir = path3.resolve(projectRoot, `dist/client/${entryPoint}`);
+    const root = entryPoint ? path3.resolve(clientBaseDir, entryPoint) : clientBaseDir;
+    const server = path3.resolve(clientRoot, `${entryServer}.tsx`);
+    const client = path3.resolve(clientRoot, `${entryClient}.tsx`);
+    const main = path3.resolve(clientRoot, htmlTemplate);
+    const viteConfig = {
+      base: entryPoint ? `/${entryPoint}/` : "/",
+      build: {
+        outDir,
+        manifest: !isSSRBuild,
+        rollupOptions: {
+          input: isSSRBuild ? { server } : { client, main }
+        },
+        ssr: isSSRBuild ? server : void 0,
+        ssrManifest: isSSRBuild,
+        ...isSSRBuild && {
+          format: "esm",
+          target: `node${process.versions.node.split(".").map(Number)[0]}`
+        }
+      },
+      css: {
+        preprocessorOptions: {
+          scss: { api: "modern-compiler" }
+        }
+      },
+      plugins: [...config2.plugins ?? [], nodePolyfills({ include: ["fs", "stream"] })],
+      publicDir: "public",
+      resolve: {
+        alias: {
+          "@client": root,
+          "@server": path3.resolve(projectRoot, "src/server"),
+          "@shared": path3.resolve(projectRoot, "src/shared")
+        }
+      },
+      root,
+      server: {
+        proxy: {
+          "/api": {
+            target: "http://localhost:3000",
+            changeOrigin: true,
+            rewrite: (path4) => path4.replace(/^\/api/, "")
+          }
+        }
+      }
+    };
+    try {
+      console.log(`Building for entryPoint: "${entryPoint}" (${appId})`);
+      await build(viteConfig);
+      console.log(`Build complete for entryPoint: "${entryPoint}"
+`);
+    } catch (error) {
+      console.error(`Error building for entryPoint: "${entryPoint}"
+`, error);
+      process.exit(1);
+    }
+  }
+}
+export {
+  taujsBuild
+};

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { ServerResponse } from 'node:http';
 import { FastifyPluginAsync } from 'fastify';
+import { PluginOption } from 'vite';
 
 declare const RENDERTYPE: {
     ssr: string;
@@ -36,6 +37,7 @@ type ProcessedConfig = {
     entryPoint: string;
     entryServer: string;
     htmlTemplate: string;
+    plugins?: PluginOption[];
 };
 type SSRServerOptions = {
     alias?: Record<string, string>;

package/dist/index.js

@@ -523,7 +523,7 @@ var SSRServer = (0, import_fastify_plugin.default)(
           let aggregateHeadContent = headContent;
           if (ssrManifest && preloadLink) aggregateHeadContent += preloadLink;
           if (manifest && cssLink) aggregateHeadContent += cssLink;
-          const fullHtml = template.replace(SSRTAG.ssrHead, aggregateHeadContent).replace(SSRTAG.ssrHtml, `${appHtml}${initialDataScript}<script type="module" src="${bootstrapModule}" async=""></script>`);
+          const fullHtml = template.replace(SSRTAG.ssrHead, aggregateHeadContent).replace(SSRTAG.ssrHtml, `${appHtml}${initialDataScript}<script type="module" src="${bootstrapModule}" defer></script>`);
           return reply.status(200).header("Content-Type", "text/html").send(fullHtml);
         } else {
           const { renderStream } = renderModule;
@@ -570,7 +570,7 @@ var SSRServer = (0, import_fastify_plugin.default)(
         const bootstrapModule = bootstrapModules.get(clientRoot);
         template = template.replace(SSRTAG.ssrHead, "").replace(SSRTAG.ssrHtml, "");
         if (!isDevelopment && cssLink) template = template.replace("</head>", `${cssLink}</head>`);
-        if (bootstrapModule) template = template.replace("</body>", `<script type="module" src="${bootstrapModule}" async=""></script></body>`);
+        if (bootstrapModule) template = template.replace("</body>", `<script type="module" src="${bootstrapModule}" defer></script></body>`);
         reply.status(200).type("text/html").send(template);
       } catch (error) {
         console.error("Failed to serve clientHtmlTemplate:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taujs/server",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "taujs | τjs",
   "author": "Aoede <taujs@aoede.uk.net> (https://www.aoede.uk.net)",
   "license": "MIT",
@@ -29,9 +29,9 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./data": {
-      "import": "./dist/data.js",
-      "types": "./dist/data.d.ts"
+    "./build": {
+      "import": "./dist/build.js",
+      "types": "./dist/build.d.ts"
     },
     "./package.json": "./package.json"
   },
@@ -40,22 +40,18 @@
   ],
   "dependencies": {
     "@fastify/static": "^8.0.3",
-    "path-to-regexp": "^8.1.0"
+    "path-to-regexp": "^8.1.0",
+    "vite-plugin-node-polyfills": "^0.23.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.15.4",
     "@babel/preset-typescript": "^7.24.7",
     "@changesets/cli": "^2.27.7",
-    "@testing-library/dom": "^10.4.0",
-    "@testing-library/react": "^16.1.0",
     "@types/node": "^20.14.9",
-    "@types/react": "^19.0.2",
-    "@types/react-dom": "^19.0.2",
     "@vitest/coverage-v8": "^2.1.0",
     "fastify": "^5.3.3",
     "jsdom": "^25.0.0",
     "prettier": "^3.3.3",
-    "react-dom": "^19.0.0",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
     "vite": "^6.3.5",
@@ -63,8 +59,6 @@
   },
   "peerDependencies": {
     "fastify": "^5.3.3",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
     "typescript": "^5.5.4",
     "vite": "^6.3.5"
   },