@taujs/server 0.3.7 → 0.4.0

package/dist/build.js

@@ -1,805 +0,0 @@
-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 path3 from "path";
-import { build } from "vite";
-import { nodePolyfills } from "vite-plugin-node-polyfills";
-
-// src/SSRServer.ts
-var import_fastify_plugin2 = __toESM(require_plugin(), 1);
-var import_picocolors = __toESM(require_picocolors(), 1);
-import { readFile } from "fs/promises";
-import path2 from "path";
-
-// src/utils/Logger.ts
-var createLogger = (debug) => ({
-  log: (...args) => {
-    if (debug) console.log(...args);
-  },
-  warn: (...args) => {
-    if (debug) console.warn(...args);
-  },
-  error: (...args) => {
-    if (debug) console.error(...args);
-  }
-});
-var debugLog = (logger, message, req) => {
-  const prefix = "[\u03C4js]";
-  const method = req?.method ?? "";
-  const url = req?.url ?? "";
-  const tag = method && url ? `${method} ${url}` : "";
-  logger.log(`${prefix} ${tag} ${message}`);
-};
-
-// 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"
-};
-var DEV_CSP_DIRECTIVES = {
-  "default-src": ["'self'"],
-  "connect-src": ["'self'", "ws:", "http:"],
-  "style-src": ["'self'", "'unsafe-inline'"],
-  "img-src": ["'self'", "data:"]
-};
-
-// src/security/auth.ts
-function createAuthHook(routes, isDebug) {
-  const logger = createLogger(Boolean(isDebug));
-  return async function authHook(req, reply) {
-    const url = new URL(req.url, `http://${req.headers.host}`).pathname;
-    const matched = routes.find((r) => r.path === url);
-    const authConfig = matched?.attr?.middleware?.auth;
-    if (!authConfig?.required) {
-      debugLog(logger, "Auth not required for route", req);
-      return;
-    }
-    if (typeof req.server.authenticate !== "function") {
-      req.log.warn('Route requires auth but no "authenticate" decorator is defined on Fastify.');
-      return reply.status(500).send("Server misconfiguration: auth decorator missing.");
-    }
-    try {
-      debugLog(logger, "Invoking authenticate(...)", req);
-      await req.server.authenticate(req, reply);
-      debugLog(logger, "Authentication successful", req);
-    } catch (err) {
-      debugLog(logger, "Authentication failed", req);
-      return reply.send(err);
-    }
-  };
-}
-
-// src/security/csp.ts
-var import_fastify_plugin = __toESM(require_plugin(), 1);
-import crypto from "crypto";
-
-// 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 (registry, serviceName, methodName, params) => {
-  const service = registry[serviceName];
-  if (!service) throw new Error(`Service ${String(serviceName)} does not exist in the registry`);
-  const method = service[methodName];
-  if (typeof method !== "function") throw new Error(`Service method ${String(methodName)} does not exist on ${String(serviceName)}`);
-  const data = await method(params);
-  if (typeof data !== "object" || data === null)
-    throw new Error(`Expected object response from ${String(serviceName)}.${String(methodName)}, but got ${typeof data}`);
-  return data;
-};
-var isServiceDescriptor = (obj) => {
-  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return false;
-  const maybe = obj;
-  return typeof maybe.serviceName === "string" && typeof maybe.serviceMethod === "string";
-};
-var fetchInitialData = async (attr, params, serviceRegistry, ctx = { headers: {} }, callServiceMethodImpl = callServiceMethod) => {
-  const dataHandler = attr?.data;
-  if (!dataHandler || typeof dataHandler !== "function") return Promise.resolve({});
-  return dataHandler(params, ctx).then(async (result) => {
-    if (isServiceDescriptor(result)) {
-      const { serviceName, serviceMethod, args } = result;
-      if (serviceRegistry[serviceName]?.[serviceMethod]) return callServiceMethodImpl(serviceRegistry, serviceName, serviceMethod, args ?? {});
-      throw new Error(`Invalid service: serviceName=${String(serviceName)}, method=${String(serviceMethod)}`);
-    }
-    if (typeof result === "object" && result !== null) return result;
-    throw new Error("Invalid result from attr.data");
-  });
-};
-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/security/csp.ts
-var defaultGenerateCSP = (directives, nonce) => {
-  const merged = { ...directives };
-  merged["script-src"] = merged["script-src"] || ["'self'"];
-  if (!merged["script-src"].some((v) => v.startsWith("'nonce-"))) merged["script-src"].push(`'nonce-${nonce}'`);
-  if (isDevelopment) {
-    const connect = merged["connect-src"] || ["'self'"];
-    if (!connect.includes("ws:")) connect.push("ws:");
-    if (!connect.includes("http:")) connect.push("http:");
-    merged["connect-src"] = connect;
-    const style = merged["style-src"] || ["'self'"];
-    if (!style.includes("'unsafe-inline'")) style.push("'unsafe-inline'");
-    merged["style-src"] = style;
-  }
-  return Object.entries(merged).map(([key, values]) => `${key} ${values.join(" ")}`).join("; ");
-};
-var generateNonce = () => crypto.randomBytes(16).toString("base64");
-var cspPlugin = (0, import_fastify_plugin.default)(
-  async (fastify, opts) => {
-    fastify.addHook("onRequest", (req, reply, done) => {
-      const nonce = generateNonce();
-      req.cspNonce = nonce;
-      const directives = opts.directives ?? DEV_CSP_DIRECTIVES;
-      const generate = opts.generateCSP ?? defaultGenerateCSP;
-      const cspHeader = generate(directives, nonce);
-      reply.header("Content-Security-Policy", cspHeader);
-      done();
-    });
-  },
-  {
-    name: "taujs-csp-plugin"
-  }
-);
-
-// src/security/verifyMiddleware.ts
-var isAuthRequired = (r) => r.attr?.middleware?.auth?.required === true;
-var hasAuthenticate = (app) => typeof app.authenticate === "function";
-var verifyContracts = (app, routes, contracts, isDebug) => {
-  const logger = createLogger(Boolean(isDebug));
-  for (const contract of contracts) {
-    const isUsed = routes.some(contract.required);
-    if (!isUsed) {
-      debugLog(logger, `Middleware "${contract.key}" not used in any routes`);
-      continue;
-    }
-    if (!contract.verify(app)) {
-      const error = new Error(`[\u03C4js] ${contract.errorMessage}`);
-      logger.error(error.message);
-      throw error;
-    }
-    debugLog(logger, `Middleware "${contract.key}" verified \u2713`);
-  }
-};
-
-// 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_plugin2.default)(
-  async (app, opts) => {
-    const logger = createLogger(opts.isDebug ?? false);
-    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;
-    verifyContracts(
-      app,
-      routes,
-      [
-        {
-          key: "auth",
-          required: isAuthRequired,
-          verify: hasAuthenticate,
-          errorMessage: "Routes require auth but Fastify instance is missing `.authenticate` decorator."
-        }
-      ],
-      opts.isDebug
-    );
-    if (opts.registerStaticAssets && typeof opts.registerStaticAssets === "object") {
-      const { plugin, options } = opts.registerStaticAssets;
-      await app.register(plugin, {
-        root: baseClientRoot,
-        prefix: "/",
-        index: false,
-        wildcard: false,
-        ...options ?? {}
-      });
-    }
-    app.register(cspPlugin, {
-      directives: opts.security?.csp?.directives,
-      generateCSP: opts.security?.csp?.generateCSP
-    });
-    app.addHook("onRequest", createAuthHook(routes));
-    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) {
-                logger.log(import_picocolors.default.green("\u03C4js development server debug started."));
-                server.middlewares.use((req, res, next) => {
-                  logger.log(import_picocolors.default.cyan(`\u2190 rx: ${req.url}`));
-                  res.on("finish", () => logger.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);
-        const cspNonce = req.cspNonce;
-        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 nonce="${cspNonce}">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 shouldHydrate = attr?.hydrate !== false;
-          const bootstrapScriptTag = shouldHydrate ? `<script nonce="${cspNonce}" type="module" src="${bootstrapModule}" defer></script>` : "";
-          const fullHtml = template.replace(SSRTAG.ssrHead, aggregateHeadContent).replace(SSRTAG.ssrHtml, `${appHtml}${initialDataScript}${bootstrapScriptTag}`);
-          return reply.status(200).header("Content-Type", "text/html").send(fullHtml);
-        } else {
-          const { renderStream } = renderModule;
-          const cspNonce2 = req.cspNonce;
-          const cspHeader = reply.getHeader("Content-Security-Policy");
-          reply.raw.writeHead(200, {
-            "Content-Security-Policy": cspHeader,
-            "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 nonce="${cspNonce2}">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,
-            cspNonce2
-          );
-        }
-      } 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;
-        const cspNonce = req.cspNonce;
-        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 nonce="${cspNonce}" 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({
-  configs,
-  projectRoot,
-  clientBaseDir,
-  isSSRBuild = process.env.BUILD_MODE === "ssr"
-}) {
-  const deleteDist = async () => {
-    const { rm } = await import("fs/promises");
-    const distPath = path3.resolve(projectRoot, "dist");
-    try {
-      await 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(configs, clientBaseDir, TEMPLATE);
-  if (!isSSRBuild) await deleteDist();
-  for (const config of processedConfigs) {
-    const { appId, entryPoint, clientRoot, entryClient, entryServer, htmlTemplate, plugins = [] } = config;
-    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: [...config.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
-};