@taujs/server 0.4.1 → 0.4.3

package/dist/index.js

@@ -189,8 +189,8 @@ var require_plugin = __commonJS({
 
 // src/CreateServer.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
-import path5 from "path";
-import { performance as performance2 } from "perf_hooks";
+import path7 from "path";
+import { performance as performance3 } from "perf_hooks";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
 
@@ -259,8 +259,8 @@ var extractRoutes = (taujsConfig) => {
     apps.push({ appId: app.appId, routeCount: appRoutes.length });
     allRoutes.push(...appRoutes);
   }
-  for (const [path7, appIds] of pathTracker.entries()) {
-    if (appIds.length > 1) warnings.push(`Route path "${path7}" is declared in multiple apps: ${appIds.join(", ")}`);
+  for (const [path9, appIds] of pathTracker.entries()) {
+    if (appIds.length > 1) warnings.push(`Route path "${path9}" is declared in multiple apps: ${appIds.join(", ")}`);
   }
   const sortedRoutes = allRoutes.sort((a, b) => computeScore(b.path) - computeScore(a.path));
   const durationMs = performance.now() - t0;
@@ -344,13 +344,133 @@ function printContractReport(logger, report) {
     }
   }
 }
-var computeScore = (path7) => {
-  return path7.split("/").filter(Boolean).reduce((score, segment) => score + (segment.startsWith(":") ? 1 : 10), 0);
+var computeScore = (path9) => {
+  return path9.split("/").filter(Boolean).reduce((score, segment) => score + (segment.startsWith(":") ? 1 : 10), 0);
 };
 
-// src/network/Network.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
-import { networkInterfaces } from "os";
+// src/logging/AppError.ts
+var HTTP_STATUS = {
+  infra: 500,
+  upstream: 502,
+  domain: 404,
+  validation: 400,
+  auth: 403,
+  canceled: 499,
+  // Client Closed Request (nginx convention)
+  timeout: 504
+};
+var AppError = class _AppError extends Error {
+  kind;
+  httpStatus;
+  details;
+  safeMessage;
+  code;
+  constructor(message, kind, options = {}) {
+    super(message);
+    this.name = "AppError";
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (options.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        enumerable: false,
+        writable: false,
+        configurable: true
+      });
+    }
+    this.kind = kind;
+    this.httpStatus = options.httpStatus ?? HTTP_STATUS[kind];
+    this.details = options.details;
+    this.safeMessage = options.safeMessage ?? this.getSafeMessage(kind, message);
+    this.code = options.code;
+    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+  }
+  getSafeMessage(kind, message) {
+    return kind === "domain" || kind === "validation" || kind === "auth" ? message : "Internal Server Error";
+  }
+  serialiseValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+    if (value === null || value === void 0) return value;
+    if (typeof value !== "object") return value;
+    if (seen.has(value)) return "[circular]";
+    seen.add(value);
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack,
+        ...value instanceof _AppError && {
+          kind: value.kind,
+          httpStatus: value.httpStatus,
+          code: value.code
+        }
+      };
+    }
+    if (Array.isArray(value)) return value.map((item) => this.serialiseValue(item, seen));
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = this.serialiseValue(val, seen);
+    }
+    return result;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      kind: this.kind,
+      message: this.message,
+      safeMessage: this.safeMessage,
+      httpStatus: this.httpStatus,
+      ...this.code && { code: this.code },
+      details: this.serialiseValue(this.details),
+      stack: this.stack,
+      ...this.cause && {
+        cause: this.serialiseValue(this.cause)
+      }
+    };
+  }
+  static notFound(message, details, code) {
+    return new _AppError(message, "domain", { httpStatus: 404, details, code });
+  }
+  static forbidden(message, details, code) {
+    return new _AppError(message, "auth", { httpStatus: 403, details, code });
+  }
+  static badRequest(message, details, code) {
+    return new _AppError(message, "validation", { httpStatus: 400, details, code });
+  }
+  static unprocessable(message, details, code) {
+    return new _AppError(message, "validation", { httpStatus: 422, details, code });
+  }
+  static timeout(message, details, code) {
+    return new _AppError(message, "timeout", { details, code });
+  }
+  static canceled(message, details, code) {
+    return new _AppError(message, "canceled", { details, code });
+  }
+  static internal(message, cause, details, code) {
+    return new _AppError(message, "infra", { cause, details, code });
+  }
+  static upstream(message, cause, details, code) {
+    return new _AppError(message, "upstream", { cause, details, code });
+  }
+  static serviceUnavailable(message, cause, details, code) {
+    return new _AppError(message, "infra", { httpStatus: 503, cause, details, code });
+  }
+  static from(err, fallback = "Internal error") {
+    return err instanceof _AppError ? err : _AppError.internal(err?.message ?? fallback, err);
+  }
+};
+function normaliseError(e) {
+  if (e instanceof Error) return { name: e.name, message: e.message, stack: e.stack };
+  const hasMessageProp = e != null && typeof e.message !== "undefined";
+  const msg = hasMessageProp ? String(e.message) : String(e);
+  return { name: "Error", message: msg };
+}
+function toReason(e) {
+  if (e instanceof Error) return e;
+  if (e === null) return new Error("null");
+  if (typeof e === "undefined") return new Error("Unknown render error");
+  const maybeMsg = e?.message;
+  if (typeof maybeMsg !== "undefined") return new Error(String(maybeMsg));
+  return new Error(String(e));
+}
 
 // src/logging/Logger.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
@@ -489,9 +609,11 @@ var Logger = class _Logger {
     if (!this.shouldEmit(level)) return;
     const timestamp = this.formatTimestamp();
     const wantCtx = this.config.includeContext === void 0 ? false : typeof this.config.includeContext === "function" ? this.config.includeContext(level) : this.config.includeContext;
-    const customSink = this.config.custom?.[level];
+    const owner = this.config.custom;
+    const rawSink = owner && typeof owner[level] === "function" ? owner[level] : void 0;
+    const boundSink = rawSink ? rawSink.bind(owner) : void 0;
     const consoleFallback = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
-    const sink = customSink ?? consoleFallback;
+    const hasCustom = !!boundSink;
     const merged = meta ?? {};
     const withCtx = wantCtx && Object.keys(this.context).length > 0 ? { context: this.context, ...merged } : merged;
     const finalMeta = this.shouldIncludeStack(level) ? withCtx : this.stripStacks(withCtx);
@@ -512,16 +634,20 @@ var Logger = class _Logger {
           return plainTag;
       }
     })();
-    const tagForOutput = customSink ? plainTag : coloredTag;
+    const tagForOutput = hasCustom ? plainTag : coloredTag;
     const formatted = `${timestamp} ${tagForOutput} ${message}`;
-    if (this.config.singleLine && hasMeta && !customSink) {
+    if (this.config.singleLine && hasMeta && !hasCustom) {
       const metaStr = JSON.stringify(finalMeta).replace(/\n/g, "\\n");
       consoleFallback(`${formatted} ${metaStr}`);
       return;
     }
-    if (customSink) {
+    if (hasCustom) {
       const obj = hasMeta ? finalMeta : {};
-      customSink(obj, formatted);
+      try {
+        const result = boundSink(obj, formatted);
+      } catch (err) {
+        hasMeta ? consoleFallback(formatted, finalMeta) : consoleFallback(formatted);
+      }
     } else {
       hasMeta ? consoleFallback(formatted, finalMeta) : consoleFallback(formatted);
     }
@@ -554,7 +680,54 @@ function createLogger(opts) {
   return logger;
 }
 
+// src/network/CLI.ts
+function readFlag(argv, keys, bareValue) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  for (let i = 0; i < limit; i++) {
+    const arg = argv[i];
+    for (const key of keys) {
+      if (arg === key) {
+        const next = argv[i + 1];
+        if (!next || next.startsWith("-")) return bareValue;
+        return next.trim();
+      }
+      const pref = `${key}=`;
+      if (arg && arg.startsWith(pref)) {
+        const v = arg.slice(pref.length).trim();
+        return v || bareValue;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveNet(input) {
+  const env = process.env;
+  const argv = process.argv;
+  let host = "localhost";
+  let port = 5173;
+  let hmrPort = 5174;
+  if (input?.host) host = input.host;
+  if (Number.isFinite(input?.port)) port = Number(input.port);
+  if (Number.isFinite(input?.hmrPort)) hmrPort = Number(input.hmrPort);
+  if (env.HOST?.trim()) host = env.HOST.trim();
+  else if (env.FASTIFY_ADDRESS?.trim()) host = env.FASTIFY_ADDRESS.trim();
+  if (env.PORT) port = Number(env.PORT) || port;
+  if (env.FASTIFY_PORT) port = Number(env.FASTIFY_PORT) || port;
+  if (env.HMR_PORT) hmrPort = Number(env.HMR_PORT) || hmrPort;
+  const cliHost = readFlag(argv, ["--host", "--hostname", "-H"], "0.0.0.0");
+  const cliPort = readFlag(argv, ["--port", "-p"]);
+  const cliHMR = readFlag(argv, ["--hmr-port"]);
+  if (cliHost) host = cliHost;
+  if (cliPort) port = Number(cliPort) || port;
+  if (cliHMR) hmrPort = Number(cliHMR) || hmrPort;
+  if (host === "true" || host === "") host = "0.0.0.0";
+  return { host, port, hmrPort };
+}
+
 // src/network/Network.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+import { networkInterfaces } from "os";
 var isPrivateIPv4 = (addr) => {
   if (!/^\d+\.\d+\.\d+\.\d+$/.test(addr)) return false;
   const [a, b, _c, _d] = addr.split(".").map(Number);
@@ -606,51 +779,6 @@ var bannerPlugin = async (fastify, options) => {
   });
 };
 
-// src/network/CLI.ts
-function readFlag(argv, keys, bareValue) {
-  const end = argv.indexOf("--");
-  const limit = end === -1 ? argv.length : end;
-  for (let i = 0; i < limit; i++) {
-    const arg = argv[i];
-    for (const key of keys) {
-      if (arg === key) {
-        const next = argv[i + 1];
-        if (!next || next.startsWith("-")) return bareValue;
-        return next.trim();
-      }
-      const pref = `${key}=`;
-      if (arg && arg.startsWith(pref)) {
-        const v = arg.slice(pref.length).trim();
-        return v || bareValue;
-      }
-    }
-  }
-  return void 0;
-}
-function resolveNet(input) {
-  const env = process.env;
-  const argv = process.argv;
-  let host = "localhost";
-  let port = 5173;
-  let hmrPort = 5174;
-  if (input?.host) host = input.host;
-  if (Number.isFinite(input?.port)) port = Number(input.port);
-  if (Number.isFinite(input?.hmrPort)) hmrPort = Number(input.hmrPort);
-  if (env.HOST?.trim()) host = env.HOST.trim();
-  else if (env.FASTIFY_ADDRESS?.trim()) host = env.FASTIFY_ADDRESS.trim();
-  if (env.PORT) port = Number(env.PORT) || port;
-  if (env.FASTIFY_PORT) port = Number(env.FASTIFY_PORT) || port;
-  if (env.HMR_PORT) hmrPort = Number(env.HMR_PORT) || hmrPort;
-  const cliHost = readFlag(argv, ["--host", "--hostname", "-H"], "0.0.0.0");
-  const cliPort = readFlag(argv, ["--port", "-p"]);
-  const cliHMR = readFlag(argv, ["--hmr-port"]);
-  if (cliHost) host = cliHost;
-  if (cliPort) port = Number(cliPort) || port;
-  if (cliHMR) hmrPort = Number(cliHMR) || hmrPort;
-  if (host === "true" || host === "") host = "0.0.0.0";
-  return { host, port, hmrPort };
-}
-
 // src/security/VerifyMiddleware.ts
 var isAuthRequired = (route) => Boolean(route.attr?.middleware?.auth);
 var hasAuthenticate = (app) => typeof app.authenticate === "function";
@@ -717,130 +845,7 @@ var verifyContracts = (app, routes, contracts, security) => {
 
 // src/SSRServer.ts
 var import_fastify_plugin3 = __toESM(require_plugin(), 1);
-
-// src/logging/AppError.ts
-var HTTP_STATUS = {
-  infra: 500,
-  upstream: 502,
-  domain: 404,
-  validation: 400,
-  auth: 403,
-  canceled: 499,
-  // Client Closed Request (nginx convention)
-  timeout: 504
-};
-var AppError = class _AppError extends Error {
-  kind;
-  httpStatus;
-  details;
-  safeMessage;
-  code;
-  constructor(message, kind, options = {}) {
-    super(message);
-    this.name = "AppError";
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (options.cause !== void 0) {
-      Object.defineProperty(this, "cause", {
-        value: options.cause,
-        enumerable: false,
-        writable: false,
-        configurable: true
-      });
-    }
-    this.kind = kind;
-    this.httpStatus = options.httpStatus ?? HTTP_STATUS[kind];
-    this.details = options.details;
-    this.safeMessage = options.safeMessage ?? this.getSafeMessage(kind, message);
-    this.code = options.code;
-    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-  }
-  getSafeMessage(kind, message) {
-    return kind === "domain" || kind === "validation" || kind === "auth" ? message : "Internal Server Error";
-  }
-  serialiseValue(value, seen = /* @__PURE__ */ new WeakSet()) {
-    if (value === null || value === void 0) return value;
-    if (typeof value !== "object") return value;
-    if (seen.has(value)) return "[circular]";
-    seen.add(value);
-    if (value instanceof Error) {
-      return {
-        name: value.name,
-        message: value.message,
-        stack: value.stack,
-        ...value instanceof _AppError && {
-          kind: value.kind,
-          httpStatus: value.httpStatus,
-          code: value.code
-        }
-      };
-    }
-    if (Array.isArray(value)) return value.map((item) => this.serialiseValue(item, seen));
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = this.serialiseValue(val, seen);
-    }
-    return result;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      kind: this.kind,
-      message: this.message,
-      safeMessage: this.safeMessage,
-      httpStatus: this.httpStatus,
-      ...this.code && { code: this.code },
-      details: this.serialiseValue(this.details),
-      stack: this.stack,
-      ...this.cause && {
-        cause: this.serialiseValue(this.cause)
-      }
-    };
-  }
-  static notFound(message, details, code) {
-    return new _AppError(message, "domain", { httpStatus: 404, details, code });
-  }
-  static forbidden(message, details, code) {
-    return new _AppError(message, "auth", { httpStatus: 403, details, code });
-  }
-  static badRequest(message, details, code) {
-    return new _AppError(message, "validation", { httpStatus: 400, details, code });
-  }
-  static unprocessable(message, details, code) {
-    return new _AppError(message, "validation", { httpStatus: 422, details, code });
-  }
-  static timeout(message, details, code) {
-    return new _AppError(message, "timeout", { details, code });
-  }
-  static canceled(message, details, code) {
-    return new _AppError(message, "canceled", { details, code });
-  }
-  static internal(message, cause, details, code) {
-    return new _AppError(message, "infra", { cause, details, code });
-  }
-  static upstream(message, cause, details, code) {
-    return new _AppError(message, "upstream", { cause, details, code });
-  }
-  static serviceUnavailable(message, cause, details, code) {
-    return new _AppError(message, "infra", { httpStatus: 503, cause, details, code });
-  }
-  static from(err, fallback = "Internal error") {
-    return err instanceof _AppError ? err : _AppError.internal(err?.message ?? fallback, err);
-  }
-};
-function normaliseError(e) {
-  if (e instanceof Error) return { name: e.name, message: e.message, stack: e.stack };
-  const hasMessageProp = e != null && typeof e.message !== "undefined";
-  const msg = hasMessageProp ? String(e.message) : String(e);
-  return { name: "Error", message: msg };
-}
-function toReason(e) {
-  if (e instanceof Error) return e;
-  if (e === null) return new Error("null");
-  if (typeof e === "undefined") return new Error("Unknown render error");
-  const maybeMsg = e?.message;
-  if (typeof maybeMsg !== "undefined") return new Error(String(maybeMsg));
-  return new Error(String(e));
-}
+import path6 from "path";
 
 // src/logging/utils/index.ts
 var httpStatusFrom = (err, fallback = 500) => err instanceof AppError ? err.httpStatus : fallback;
@@ -880,39 +885,53 @@ var statusText = (status) => {
 import { match } from "path-to-regexp";
 
 // src/utils/DataServices.ts
+import { performance as performance2 } from "perf_hooks";
+function createCaller(registry, ctx) {
+  return (serviceName, methodName, args) => callServiceMethod(registry, serviceName, methodName, args ?? {}, ctx);
+}
+function ensureServiceCaller(registry, ctx) {
+  if (!ctx.call) ctx.call = createCaller(registry, ctx);
+}
 async function callServiceMethod(registry, serviceName, methodName, params, ctx) {
   if (ctx.signal?.aborted) throw AppError.timeout("Request canceled");
   const service = registry[serviceName];
   if (!service) throw AppError.notFound(`Unknown service: ${serviceName}`);
-  const desc = service[methodName];
-  if (!desc) throw AppError.notFound(`Unknown method: ${serviceName}.${methodName}`);
-  const logger = ctx.logger?.child({
+  const method = service[methodName];
+  if (!method) throw AppError.notFound(`Unknown method: ${serviceName}.${methodName}`);
+  const logger = ctx.logger?.child?.({
     component: "service-call",
     service: serviceName,
     method: methodName,
     traceId: ctx.traceId
   });
+  const t0 = performance2.now();
   try {
-    const p = desc.parsers?.params ? desc.parsers.params(params) : params;
-    const data = await desc.handler(p, ctx);
-    const out = desc.parsers?.result ? desc.parsers.result(data) : data;
-    if (typeof out !== "object" || out === null) throw AppError.internal(`Non-object result from ${serviceName}.${methodName}`);
-    return out;
+    const result = await method(params ?? {}, ctx);
+    if (typeof result !== "object" || result === null) {
+      throw AppError.internal(`Non-object result from ${serviceName}.${methodName}`);
+    }
+    logger?.debug?.({ ms: +(performance2.now() - t0).toFixed(1) }, "Service method ok");
+    return result;
   } catch (err) {
-    logger?.error(
+    logger?.error?.(
       {
         params,
-        error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : String(err)
+        error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : String(err),
+        ms: +(performance2.now() - t0).toFixed(1)
       },
       "Service method failed"
     );
-    throw err;
+    throw err instanceof AppError ? err : err instanceof Error ? AppError.internal(err.message, { cause: err }) : AppError.internal("Unknown error", { details: { err } });
   }
 }
 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";
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
+  const o = obj;
+  if (typeof o.serviceName !== "string" || typeof o.serviceMethod !== "string") return false;
+  if ("args" in o) {
+    if (o.args === null || typeof o.args !== "object" || Array.isArray(o.args)) return false;
+  }
+  return true;
 };
 
 // src/utils/DataRoutes.ts
@@ -923,15 +942,15 @@ var safeDecode = (value) => {
     return value;
   }
 };
-var cleanPath = (path7) => {
-  if (!path7) return "/";
-  const basePart = path7.split("?")[0];
+var cleanPath = (path9) => {
+  if (!path9) return "/";
+  const basePart = path9.split("?")[0];
   const base = basePart ? basePart.split("#")[0] : "/";
   return base || "/";
 };
-var calculateSpecificity = (path7) => {
+var calculateSpecificity = (path9) => {
   let score = 0;
-  const segments = path7.split("/").filter(Boolean);
+  const segments = path9.split("/").filter(Boolean);
   for (const segment of segments) {
     if (segment.startsWith(":")) {
       score += 1;
@@ -956,9 +975,9 @@ var createRouteMatchers = (routes) => {
   });
 };
 var matchRoute = (url, routeMatchers) => {
-  const path7 = cleanPath(url);
+  const path9 = cleanPath(url);
   for (const { route, matcher, keys } of routeMatchers) {
-    const match2 = matcher(path7);
+    const match2 = matcher(path9);
     if (match2) {
       return {
         route,
@@ -972,14 +991,16 @@ var matchRoute = (url, routeMatchers) => {
 var fetchInitialData = async (attr, params, serviceRegistry, ctx, callServiceMethodImpl = callServiceMethod) => {
   const dataHandler = attr?.data;
   if (!dataHandler || typeof dataHandler !== "function") return {};
+  const ctxForData = {
+    ...ctx,
+    headers: ctx.headers ?? {}
+  };
+  ensureServiceCaller(serviceRegistry, ctxForData);
   try {
-    const result = await dataHandler(params, {
-      ...ctx,
-      headers: ctx.headers ?? {}
-    });
+    const result = await dataHandler(params, ctxForData);
     if (isServiceDescriptor(result)) {
       const { serviceName, serviceMethod, args } = result;
-      return callServiceMethodImpl(serviceRegistry, serviceName, serviceMethod, args ?? {}, ctx);
+      return callServiceMethodImpl(serviceRegistry, serviceName, serviceMethod, args ?? {}, ctxForData);
     }
     if (isPlainObject(result)) return result;
     throw AppError.badRequest("attr.data must return a plain object or a ServiceDescriptor");
@@ -1019,6 +1040,16 @@ var createAuthHook = (routeMatchers, logger) => {
     if (!match2) return;
     const { route } = match2;
     const authConfig = route.attr?.middleware?.auth;
+    req.routeMeta = {
+      path: route.path,
+      appId: route.appId,
+      attr: {
+        middleware: {
+          auth: route.attr?.middleware?.auth
+        },
+        render: route.attr?.render
+      }
+    };
     if (!authConfig) {
       logger.debug("auth", { method: req.method, url: req.url }, "(none)");
       return;
@@ -1086,9 +1117,9 @@ var mergeDirectives = (base, override) => {
   }
   return merged;
 };
-var findMatchingRoute = (routeMatchers, path7) => {
+var findMatchingRoute = (routeMatchers, path9) => {
   if (!routeMatchers) return null;
-  const match2 = matchRoute(path7, routeMatchers);
+  const match2 = matchRoute(path9, routeMatchers);
   return match2 ? { route: match2.route, params: match2.params } : null;
 };
 var cspPlugin = (0, import_fastify_plugin.default)(
@@ -1103,42 +1134,27 @@ var cspPlugin = (0, import_fastify_plugin.default)(
     fastify.addHook("onRequest", (req, reply, done) => {
       const nonce = generateNonce();
       req.cspNonce = nonce;
+      const headerNameFor = (routeCSP2) => routeCSP2 && typeof routeCSP2 === "object" && routeCSP2.reportOnly || opts.reporting?.reportOnly ? "Content-Security-Policy-Report-Only" : "Content-Security-Policy";
+      let routeCSP;
       try {
         const routeMatch = findMatchingRoute(matchers, req.url);
-        const routeCSP = routeMatch?.route.attr?.middleware?.csp;
+        routeCSP = routeMatch?.route.attr?.middleware?.csp;
         if (routeCSP === false) {
           done();
           return;
         }
         let finalDirectives = globalDirectives;
-        if (routeCSP && typeof routeCSP === "object") {
-          if (!routeCSP.disabled) {
-            let routeDirectives;
-            if (typeof routeCSP.directives === "function") {
-              const params = routeMatch?.params || {};
-              routeDirectives = routeCSP.directives({
-                url: req.url,
-                params,
-                headers: req.headers,
-                req
-              });
-            } else {
-              routeDirectives = routeCSP.directives || {};
-            }
-            if (routeCSP.mode === "replace") {
-              finalDirectives = routeDirectives;
-            } else {
-              finalDirectives = mergeDirectives(globalDirectives, routeDirectives);
-            }
-          }
-        }
-        let cspHeader;
-        if (routeCSP?.generateCSP) {
-          cspHeader = routeCSP.generateCSP(finalDirectives, nonce, req);
-        } else {
-          cspHeader = generateCSP(finalDirectives, nonce, req);
+        if (routeCSP && typeof routeCSP === "object" && !routeCSP.disabled) {
+          const routeDirectives = typeof routeCSP.directives === "function" ? routeCSP.directives({
+            url: req.url,
+            params: routeMatch?.params || {},
+            headers: req.headers,
+            req
+          }) : routeCSP.directives ?? {};
+          finalDirectives = routeCSP.mode === "replace" ? routeDirectives : mergeDirectives(globalDirectives, routeDirectives);
         }
-        reply.header("Content-Security-Policy", cspHeader);
+        const cspHeader = routeCSP?.generateCSP ? routeCSP.generateCSP(finalDirectives, nonce, req) : generateCSP(finalDirectives, nonce, req);
+        reply.header(headerNameFor(routeCSP), cspHeader);
       } catch (error) {
         logger.error(
           {
@@ -1148,7 +1164,7 @@ var cspPlugin = (0, import_fastify_plugin.default)(
           "CSP plugin error"
         );
         const fallbackHeader = generateCSP(globalDirectives, nonce, req);
-        reply.header("Content-Security-Policy", fallbackHeader);
+        reply.header(headerNameFor(routeCSP), fallbackHeader);
       }
       done();
     });
@@ -1433,8 +1449,9 @@ var loadAssets = async (processedConfigs, baseClientRoot, bootstrapModules, cssL
     debug: opts.debug,
     includeContext: true
   });
+  const projectRoot = opts.projectRoot ?? path2.resolve(process.cwd());
   for (const config of processedConfigs) {
-    const { clientRoot, entryClient, entryServer, htmlTemplate } = config;
+    const { clientRoot, entryClient, entryServer, htmlTemplate, entryPoint } = config;
     try {
       const templateHtmlPath = path2.join(clientRoot, htmlTemplate);
       const templateHtml = await readFile(templateHtmlPath, "utf-8");
@@ -1443,11 +1460,13 @@ var loadAssets = async (processedConfigs, baseClientRoot, bootstrapModules, cssL
       const adjustedRelativePath = relativeBasePath ? `/${relativeBasePath}` : "";
       if (!isDevelopment) {
         try {
-          const manifestPath = path2.join(clientRoot, ".vite/manifest.json");
+          const clientDistPath = path2.resolve(projectRoot, "client", entryPoint);
+          const manifestPath = path2.join(clientDistPath, ".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 ssrDistPath = path2.resolve(projectRoot, "ssr", entryPoint);
+          const ssrManifestPath = path2.join(ssrDistPath, ".vite/ssr-manifest.json");
           const ssrManifestContent = await readFile(ssrManifestPath, "utf-8");
           const ssrManifest = JSON.parse(ssrManifestContent);
           ssrManifests.set(clientRoot, ssrManifest);
@@ -1467,7 +1486,7 @@ var loadAssets = async (processedConfigs, baseClientRoot, bootstrapModules, cssL
           preloadLinks.set(clientRoot, preloadLink);
           const cssLink = getCssLinks(manifest, adjustedRelativePath);
           cssLinks.set(clientRoot, cssLink);
-          const renderModulePath = path2.join(clientRoot, `${entryServer}.js`);
+          const renderModulePath = path2.join(ssrDistPath, `${entryServer}.js`);
           const moduleUrl = pathToFileURL(renderModulePath).href;
           try {
             const importedModule = await import(moduleUrl);
@@ -1475,7 +1494,7 @@ var loadAssets = async (processedConfigs, baseClientRoot, bootstrapModules, cssL
           } catch (err) {
             throw AppError.internal(`Failed to load render module ${renderModulePath}`, {
               cause: err,
-              details: { moduleUrl, clientRoot, entryServer }
+              details: { moduleUrl, clientRoot, entryServer, ssrDistPath }
             });
           }
         } catch (err) {
@@ -1686,10 +1705,15 @@ var handleRender = async (req, reply, routeMatchers, processedConfigs, serviceRe
     if (renderType === RENDERTYPE.ssr) {
       const { renderSSR } = renderModule;
       if (!renderSSR) {
-        throw AppError.internal("renderSSR function not found in module", {
-          details: { clientRoot, availableFunctions: Object.keys(renderModule) }
-        });
+        throw AppError.internal(
+          "ssr",
+          {
+            details: { clientRoot, availableFunctions: Object.keys(renderModule) }
+          },
+          "renderSSR function not found in module"
+        );
       }
+      logger.debug?.("ssr", {}, "ssr requested");
       const ac = new AbortController();
       const onAborted = () => ac.abort("client_aborted");
       req.raw.on("aborted", onAborted);
@@ -1698,7 +1722,7 @@ var handleRender = async (req, reply, routeMatchers, processedConfigs, serviceRe
       });
       reply.raw.on("finish", () => req.raw.off("aborted", onAborted));
       if (ac.signal.aborted) {
-        logger.warn("SSR skipped; already aborted", { url: req.url });
+        logger.warn({ url: req.url }, "SSR skipped; already aborted");
         return;
       }
       const initialDataResolved = await initialDataInput();
@@ -1708,14 +1732,31 @@ var handleRender = async (req, reply, routeMatchers, processedConfigs, serviceRe
         const res = await renderSSR(initialDataResolved, req.url, attr?.meta, ac.signal, { logger: reqLogger });
         headContent = res.headContent;
         appHtml = res.appHtml;
+        logger.debug?.("ssr", {}, "ssr data resolved");
+        if (ac.signal.aborted) {
+          logger.warn({}, "SSR completed but client disconnected");
+          return;
+        }
       } catch (err) {
         const msg = String(err?.message ?? err ?? "");
         const benign = REGEX.BENIGN_NET_ERR.test(msg);
         if (ac.signal.aborted || benign) {
-          logger.warn("SSR aborted mid-render (benign)", { url: req.url, reason: msg });
+          logger.warn(
+            {
+              url: req.url,
+              reason: msg
+            },
+            "SSR aborted mid-render (benign)"
+          );
           return;
         }
-        logger.error("SSR render failed", { url: req.url, error: normaliseError(err) });
+        logger.error(
+          {
+            url: req.url,
+            error: normaliseError(err)
+          },
+          "SSR render failed"
+        );
         throw err;
       }
       let aggregateHeadContent = headContent;
@@ -1727,13 +1768,14 @@ var handleRender = async (req, reply, routeMatchers, processedConfigs, serviceRe
       const bootstrapScriptTag = shouldHydrate && bootstrapModule ? `<script${nonceAttr} type="module" src="${bootstrapModule}" defer></script>` : "";
       const safeAppHtml = appHtml.trim();
       const fullHtml = rebuildTemplate(templateParts, aggregateHeadContent, `${safeAppHtml}${initialDataScript}${bootstrapScriptTag}`);
+      logger.debug?.("ssr", {}, "ssr template rebuilt and sending response");
       try {
         return reply.status(200).header("Content-Type", "text/html").send(fullHtml);
       } catch (err) {
         const msg = String(err?.message ?? err ?? "");
         const benign = REGEX.BENIGN_NET_ERR.test(msg);
-        if (!benign) logger.error("SSR send failed", { url: req.url, error: normaliseError(err) });
-        else logger.warn("SSR send aborted (benign)", { url: req.url, reason: msg });
+        if (!benign) logger.error({ url: req.url, error: normaliseError(err) }, "SSR send failed");
+        else logger.warn({ url: req.url, reason: msg }, "SSR send aborted (benign)");
         return;
       }
     } else {
@@ -1743,30 +1785,44 @@ var handleRender = async (req, reply, routeMatchers, processedConfigs, serviceRe
           details: { clientRoot, availableFunctions: Object.keys(renderModule) }
         });
       }
+      const headers2 = reply.getHeaders();
+      headers2["Content-Type"] = "text/html; charset=utf-8";
       const cspHeader = reply.getHeader("Content-Security-Policy");
-      reply.raw.writeHead(200, {
-        "Content-Security-Policy": cspHeader,
-        "Content-Type": "text/html; charset=utf-8"
-      });
+      if (cspHeader) headers2["Content-Security-Policy"] = cspHeader;
+      reply.raw.writeHead(200, headers2);
+      const abortedState = { aborted: false };
       const ac = new AbortController();
-      const onAborted = () => ac.abort();
+      const onAborted = () => {
+        if (!abortedState.aborted) {
+          logger.warn({}, "Client disconnected before stream finished");
+          abortedState.aborted = true;
+        }
+        ac.abort();
+      };
       req.raw.on("aborted", onAborted);
       reply.raw.on("close", () => {
-        if (!reply.raw.writableEnded) ac.abort();
+        if (!reply.raw.writableEnded) {
+          if (!abortedState.aborted) {
+            logger.warn({}, "Client disconnected before stream finished");
+            abortedState.aborted = true;
+          }
+          ac.abort();
+        }
+      });
+      reply.raw.on("finish", () => {
+        req.raw.off("aborted", onAborted);
       });
-      reply.raw.on("finish", () => req.raw.off("aborted", onAborted));
       const shouldHydrate = attr?.hydrate !== false;
-      const abortedState = { aborted: false };
       const isBenignSocketAbort = (e) => {
         const msg = String(e?.message ?? e ?? "");
         return REGEX.BENIGN_NET_ERR.test(msg);
       };
       const writable = new PassThrough();
       writable.on("error", (err) => {
-        if (!isBenignSocketAbort(err)) logger.error("PassThrough error:", { error: err });
+        if (!isBenignSocketAbort(err)) logger.error({ error: err }, "PassThrough error:");
       });
       reply.raw.on("error", (err) => {
-        if (!isBenignSocketAbort(err)) logger.error("HTTP socket error:", { error: err });
+        if (!isBenignSocketAbort(err)) logger.error({ error: err }, "HTTP socket error:");
       });
       writable.pipe(reply.raw, { end: false });
       let finalData = void 0;
@@ -1786,30 +1842,33 @@ var handleRender = async (req, reply, routeMatchers, processedConfigs, serviceRe
           },
           onError: (err) => {
             if (abortedState.aborted || isBenignSocketAbort(err)) {
-              logger.warn("Client disconnected before stream finished");
+              logger.warn({}, "Client disconnected before stream finished");
               try {
                 if (!reply.raw.writableEnded && !reply.raw.destroyed) reply.raw.destroy();
               } catch (e) {
-                logger.debug?.("stream teardown: destroy() failed", { error: normaliseError(e) });
+                logger.debug?.("ssr", { error: normaliseError(e) }, "stream teardown: destroy() failed");
               }
               return;
             }
             abortedState.aborted = true;
-            logger.error("Critical rendering error during stream", {
-              error: normaliseError(err),
-              clientRoot,
-              url: req.url
-            });
+            logger.error(
+              {
+                error: normaliseError(err),
+                clientRoot,
+                url: req.url
+              },
+              "Critical rendering error during stream"
+            );
             try {
               ac?.abort?.();
             } catch (e) {
-              logger.debug?.("stream teardown: abort() failed", { error: normaliseError(e) });
+              logger.debug?.("ssr", { error: normaliseError(e) }, "stream teardown: abort() failed");
             }
             const reason = toReason(err);
             try {
               if (!reply.raw.writableEnded && !reply.raw.destroyed) reply.raw.destroy(reason);
             } catch (e) {
-              logger.debug?.("stream teardown: destroy() failed", { error: normaliseError(e) });
+              logger.debug?.("ssr", { error: normaliseError(e) }, "stream teardown: destroy() failed");
             }
           }
         },
@@ -1896,8 +1955,33 @@ var handleNotFound = async (req, reply, processedConfigs, maps, opts = {}) => {
   }
 };
 
+// src/utils/ResolveRouteData.ts
+async function resolveRouteData(url, opts) {
+  const { req, reply, routeMatchers, serviceRegistry, logger } = opts;
+  const match2 = matchRoute(url, routeMatchers);
+  if (!match2) {
+    throw AppError.notFound("route_not_found", {
+      details: { url }
+    });
+  }
+  const { route, params } = match2;
+  const attr = route.attr;
+  if (!attr?.data) {
+    throw AppError.notFound("no_data_handler", {
+      details: {
+        url,
+        path: route.path,
+        appId: route.appId
+      }
+    });
+  }
+  const ctx = createRequestContext(req, reply, logger);
+  return fetchInitialData(attr, params, serviceRegistry, ctx);
+}
+
 // src/utils/StaticAssets.ts
-function normalizeStaticAssets(reg) {
+import path5 from "path";
+function normaliseStaticAssets(reg) {
   if (!reg) return [];
   return Array.isArray(reg) ? reg : [reg];
 }
@@ -1905,11 +1989,14 @@ function prefixWeight(prefix) {
   if (typeof prefix !== "string" || prefix === "/" || prefix.length === 0) return 0;
   return prefix.split("/").filter(Boolean).length;
 }
-async function registerStaticAssets(app, baseClientRoot, reg, defaults) {
-  const entries = normalizeStaticAssets(reg).map(({ plugin, options }) => ({
+async function registerStaticAssets(app, baseClientRoot, reg, defaults, projectRoot) {
+  const isDevelopment2 = process.env.NODE_ENV === "development";
+  const effectiveProjectRoot = projectRoot ?? path5.resolve(process.cwd());
+  const staticRoot = isDevelopment2 ? baseClientRoot : path5.resolve(effectiveProjectRoot, "client");
+  const entries = normaliseStaticAssets(reg).map(({ plugin, options }) => ({
     plugin,
     options: {
-      root: baseClientRoot,
+      root: staticRoot,
       prefix: "/",
       index: false,
       wildcard: false,
@@ -1938,6 +2025,7 @@ var SSRServer = (0, import_fastify_plugin3.default)(
     const processedConfigs = processConfigs(configs, baseClientRoot, TEMPLATE);
     const routeMatchers = createRouteMatchers(routes);
     let viteDevServer;
+    const projectRoot = path6.resolve(baseClientRoot, "..");
     await loadAssets(
       processedConfigs,
       baseClientRoot,
@@ -1950,10 +2038,11 @@ var SSRServer = (0, import_fastify_plugin3.default)(
       maps.templates,
       {
         debug: opts.debug,
-        logger
+        logger,
+        projectRoot
       }
     );
-    if (opts.staticAssets) await registerStaticAssets(app, baseClientRoot, opts.staticAssets);
+    if (opts.staticAssets) await registerStaticAssets(app, baseClientRoot, opts.staticAssets, void 0, projectRoot);
     if (security?.csp?.reporting) {
       app.register(cspReportPlugin, {
         path: security.csp.reporting.endpoint,
@@ -1970,6 +2059,23 @@ var SSRServer = (0, import_fastify_plugin3.default)(
     });
     if (isDevelopment) viteDevServer = await setupDevServer(app, baseClientRoot, alias, opts.debug, opts.devNet);
     app.addHook("onRequest", createAuthHook(routeMatchers, logger));
+    app.get("/__taujs/data", async (req, reply) => {
+      const query = req.query;
+      const url = typeof query.url === "string" ? query.url : "";
+      if (!url) {
+        throw AppError.badRequest("url query param required", {
+          details: { query }
+        });
+      }
+      const data = await resolveRouteData(url, {
+        req,
+        reply,
+        routeMatchers,
+        serviceRegistry,
+        logger
+      });
+      return reply.status(200).send({ data });
+    });
     app.get("/*", async (req, reply) => {
       await handleRender(req, reply, routeMatchers, processedConfigs, serviceRegistry, maps, {
         debug: opts.debug,
@@ -2024,20 +2130,21 @@ var SSRServer = (0, import_fastify_plugin3.default)(
 
 // src/CreateServer.ts
 var createServer = async (opts) => {
-  const t0 = performance2.now();
-  const clientRoot = opts.clientRoot ?? path5.resolve(process.cwd(), "client");
+  const t0 = performance3.now();
+  const clientRoot = opts.clientRoot ?? path7.resolve(process.cwd(), "client");
   const app = opts.fastify ?? Fastify({ logger: false });
-  const net = resolveNet(opts.config.server);
-  await app.register(bannerPlugin, {
-    debug: opts.debug,
-    hmr: { host: net.host, port: net.hmrPort }
-  });
+  const fastifyLogger = app.log && app.log.level && app.log.level !== "silent" ? app.log : void 0;
   const logger = createLogger({
     debug: opts.debug,
-    custom: opts.logger,
+    custom: opts.logger ?? fastifyLogger,
     minLevel: process.env.NODE_ENV === "production" ? "info" : "debug",
     includeContext: true
   });
+  const net = resolveNet(opts.config.server);
+  await app.register(bannerPlugin, {
+    debug: opts.debug,
+    hmr: { host: net.host, port: net.hmrPort }
+  });
   const configs = extractBuildConfigs(opts.config);
   const { routes, apps, totalRoutes, durationMs, warnings } = extractRoutes(opts.config);
   const { security, durationMs: securityDuration, hasExplicitCSP } = extractSecurity(opts.config);
@@ -2084,7 +2191,7 @@ var createServer = async (opts) => {
       "Failed to register SSRServer"
     );
   }
-  const t1 = performance2.now();
+  const t1 = performance3.now();
   console.log(`
 ${import_picocolors4.default.bgGreen(import_picocolors4.default.black(` ${CONTENT.TAG} `))} configured in ${(t1 - t0).toFixed(0)}ms
 `);
@@ -2093,18 +2200,149 @@ ${import_picocolors4.default.bgGreen(import_picocolors4.default.black(` ${CONTEN
 };
 
 // src/Build.ts
-import path6 from "path";
+import { existsSync } from "fs";
+import path8 from "path";
 import { build } from "vite";
-import { nodePolyfills } from "vite-plugin-node-polyfills";
+function resolveInputs(isSSRBuild, mainExists, paths) {
+  if (isSSRBuild) return { server: paths.server };
+  if (mainExists) return { client: paths.client, main: paths.main };
+  return { client: paths.client };
+}
+function getFrameworkInvariants(config) {
+  return {
+    root: config.root || "",
+    base: config.base || "/",
+    publicDir: config.publicDir === void 0 ? "public" : config.publicDir,
+    build: {
+      outDir: config.build?.outDir || "",
+      manifest: config.build?.manifest ?? false,
+      ssr: config.build?.ssr ?? void 0,
+      // Preserve exact type
+      ssrManifest: config.build?.ssrManifest ?? false,
+      format: config.build?.format,
+      target: config.build?.target,
+      rollupOptions: {
+        input: config.build?.rollupOptions?.input || {}
+      }
+    }
+  };
+}
+function mergeViteConfig(framework, userOverride, context) {
+  if (!userOverride) return framework;
+  const userConfig = typeof userOverride === "function" && context ? userOverride(context) : userOverride;
+  const invariants = getFrameworkInvariants(framework);
+  const merged = {
+    ...framework,
+    build: { ...framework.build ?? {} },
+    css: { ...framework.css ?? {} },
+    resolve: { ...framework.resolve ?? {} },
+    plugins: [...framework.plugins ?? []],
+    define: { ...framework.define ?? {} }
+  };
+  const ignoredKeys = [];
+  if (userConfig.plugins) {
+    const frameworkPlugins = merged.plugins;
+    merged.plugins = [...frameworkPlugins, ...userConfig.plugins];
+  }
+  if (userConfig.define && typeof userConfig.define === "object") {
+    merged.define = {
+      ...merged.define,
+      ...userConfig.define
+    };
+  }
+  if (userConfig.css?.preprocessorOptions && typeof userConfig.css.preprocessorOptions === "object") {
+    const fpp = merged.css.preprocessorOptions ?? {};
+    const upp = userConfig.css.preprocessorOptions;
+    merged.css.preprocessorOptions = Object.keys({ ...fpp, ...upp }).reduce((acc, engine) => {
+      const fppEngine = fpp[engine];
+      const uppEngine = upp[engine];
+      acc[engine] = { ...fppEngine ?? {}, ...uppEngine ?? {} };
+      return acc;
+    }, {});
+  }
+  if (userConfig.build) {
+    const protectedBuildFields = ["outDir", "ssr", "ssrManifest", "format", "target"];
+    for (const field of protectedBuildFields) {
+      if (field in userConfig.build) {
+        ignoredKeys.push(`build.${field}`);
+      }
+    }
+    if ("sourcemap" in userConfig.build) merged.build.sourcemap = userConfig.build.sourcemap;
+    if ("minify" in userConfig.build) merged.build.minify = userConfig.build.minify;
+    if (userConfig.build.terserOptions && typeof userConfig.build.terserOptions === "object") {
+      merged.build.terserOptions = {
+        ...merged.build.terserOptions ?? {},
+        ...userConfig.build.terserOptions
+      };
+    }
+    if (userConfig.build.rollupOptions) {
+      if (!merged.build.rollupOptions) {
+        merged.build.rollupOptions = {};
+      }
+      const userRollup = userConfig.build.rollupOptions;
+      if ("input" in userRollup) ignoredKeys.push("build.rollupOptions.input");
+      if ("external" in userRollup) merged.build.rollupOptions.external = userRollup.external;
+      if (userRollup.output) {
+        const mro = merged.build.rollupOptions ??= {};
+        const uo = Array.isArray(userRollup.output) ? userRollup.output[0] : userRollup.output;
+        const baseOut = Array.isArray(mro.output) ? mro.output[0] ?? {} : mro.output ?? {};
+        mro.output = { ...baseOut, ...uo?.manualChunks ? { manualChunks: uo.manualChunks } : {} };
+      }
+    }
+  }
+  if (userConfig.resolve) {
+    const userResolve = userConfig.resolve;
+    const { alias: _ignore, ...resolveRest } = userResolve;
+    if (_ignore) ignoredKeys.push("resolve.alias");
+    merged.resolve = {
+      ...merged.resolve,
+      ...resolveRest
+    };
+  }
+  if (userConfig.server) ignoredKeys.push("server (ignored in build; dev-only)");
+  if ("root" in userConfig) ignoredKeys.push("root");
+  if ("base" in userConfig) ignoredKeys.push("base");
+  if ("publicDir" in userConfig) ignoredKeys.push("publicDir");
+  const safeTopLevelKeys = /* @__PURE__ */ new Set([
+    "esbuild",
+    "logLevel",
+    "envPrefix",
+    "optimizeDeps",
+    "ssr"
+    // NOTE: NOT 'server' (build-time irrelevant; dev-server only)
+  ]);
+  for (const [key, value] of Object.entries(userConfig)) {
+    if (safeTopLevelKeys.has(key)) merged[key] = value;
+  }
+  merged.root = invariants.root;
+  merged.base = invariants.base;
+  merged.publicDir = invariants.publicDir;
+  merged.build.outDir = invariants.build.outDir;
+  merged.build.manifest = invariants.build.manifest;
+  if (invariants.build.ssr !== void 0) merged.build.ssr = invariants.build.ssr;
+  merged.build.ssrManifest = invariants.build.ssrManifest;
+  if (invariants.build.format) merged.build.format = invariants.build.format;
+  if (invariants.build.target) merged.build.target = invariants.build.target;
+  if (!merged.build.rollupOptions) merged.build.rollupOptions = {};
+  merged.build.rollupOptions.input = invariants.build.rollupOptions.input;
+  if (ignoredKeys.length > 0) {
+    const uniqueKeys = [...new Set(ignoredKeys)];
+    const prefix = context ? `[taujs:build:${context.entryPoint}]` : "[taujs:build]";
+    console.warn(`${prefix} Ignored Vite config overrides: ${uniqueKeys.join(", ")}`);
+  }
+  return merged;
+}
 async function taujsBuild({
   config,
   projectRoot,
   clientBaseDir,
-  isSSRBuild = process.env.BUILD_MODE === "ssr"
+  isSSRBuild = process.env.BUILD_MODE === "ssr",
+  alias: userAlias,
+  vite: userViteConfig
 }) {
   const deleteDist = async () => {
     const { rm } = await import("fs/promises");
-    const distPath = path6.resolve(projectRoot, "dist");
+    const distPath = path8.resolve(projectRoot, "dist");
     try {
       await rm(distPath, { recursive: true, force: true });
       console.log("Deleted the dist directory\n");
@@ -2115,26 +2353,36 @@ async function taujsBuild({
   const extractedConfigs = extractBuildConfigs(config);
   const processedConfigs = processConfigs(extractedConfigs, clientBaseDir, TEMPLATE);
   if (!isSSRBuild) await deleteDist();
-  for (const config2 of processedConfigs) {
-    const { appId, entryPoint, clientRoot, entryClient, entryServer, htmlTemplate, plugins = [] } = config2;
-    const outDir = path6.resolve(projectRoot, `dist/client/${entryPoint}`);
-    const root = entryPoint ? path6.resolve(clientBaseDir, entryPoint) : clientBaseDir;
-    const server = path6.resolve(clientRoot, `${entryServer}.tsx`);
-    const client = path6.resolve(clientRoot, `${entryClient}.tsx`);
-    const main = path6.resolve(clientRoot, htmlTemplate);
-    const viteConfig = {
+  for (const appConfig of processedConfigs) {
+    const { appId, entryPoint, clientRoot, entryClient, entryServer, htmlTemplate, plugins = [] } = appConfig;
+    const outDir = path8.resolve(projectRoot, isSSRBuild ? `dist/ssr/${entryPoint}` : `dist/client/${entryPoint}`);
+    const root = entryPoint ? path8.resolve(clientBaseDir, entryPoint) : clientBaseDir;
+    const defaultAlias = {
+      "@client": root,
+      "@server": path8.resolve(projectRoot, "src/server"),
+      "@shared": path8.resolve(projectRoot, "src/shared")
+    };
+    const resolvedAlias = { ...defaultAlias, ...userAlias ?? {} };
+    const server = path8.resolve(clientRoot, `${entryServer}.tsx`);
+    const client = path8.resolve(clientRoot, `${entryClient}.tsx`);
+    const main = path8.resolve(clientRoot, htmlTemplate);
+    const inputs = resolveInputs(isSSRBuild, !isSSRBuild && existsSync(main), { server, client, main });
+    const nodeVersion = process.versions.node.split(".")[0];
+    const frameworkConfig = {
       base: entryPoint ? `/${entryPoint}/` : "/",
       build: {
         outDir,
+        emptyOutDir: true,
         manifest: !isSSRBuild,
         rollupOptions: {
-          input: isSSRBuild ? { server } : { client, main }
+          input: inputs
         },
         ssr: isSSRBuild ? server : void 0,
         ssrManifest: isSSRBuild,
         ...isSSRBuild && {
           format: "esm",
-          target: `node${process.versions.node.split(".").map(Number)[0]}`
+          target: `node${nodeVersion}`,
+          copyPublicDir: false
         }
       },
       css: {
@@ -2142,39 +2390,50 @@ async function taujsBuild({
           scss: { api: "modern-compiler" }
         }
       },
-      plugins: [...plugins, nodePolyfills({ include: ["fs", "stream"] })],
-      publicDir: "public",
-      resolve: {
-        alias: {
-          "@client": root,
-          "@server": path6.resolve(projectRoot, "src/server"),
-          "@shared": path6.resolve(projectRoot, "src/shared")
-        }
-      },
-      root,
-      server: {
-        proxy: {
-          "/api": {
-            target: "http://localhost:3000",
-            changeOrigin: true,
-            rewrite: (path7) => path7.replace(/^\/api/, "")
-          }
-        }
-      }
+      plugins,
+      publicDir: isSSRBuild ? false : "public",
+      // single shared public
+      // publicDir: isSSRBuild ? false : path.join(root, 'public'), // per-app. no public dir for SSR builds
+      resolve: { alias: resolvedAlias },
+      root
+    };
+    const buildContext = {
+      appId,
+      entryPoint,
+      isSSRBuild,
+      clientRoot
     };
+    const finalConfig = mergeViteConfig(frameworkConfig, userViteConfig, buildContext);
     try {
-      console.log(`Building for entryPoint: "${entryPoint}" (${appId})`);
-      await build(viteConfig);
-      console.log(`Build complete for entryPoint: "${entryPoint}"
+      const mode = isSSRBuild ? "SSR" : "Client";
+      console.log(`[taujs:build:${entryPoint}] Building \u2192 ${mode}`);
+      await build(finalConfig);
+      console.log(`[taujs:build:${entryPoint}] \u2713 Complete
 `);
     } catch (error) {
-      console.error(`Error building for entryPoint: "${entryPoint}"
+      console.error(`[taujs:build:${entryPoint}] \u2717 Failed
 `, error);
       process.exit(1);
     }
   }
 }
+
+// src/logging/Adapters.ts
+var cleanMeta = (m) => m && Object.keys(m).length === 0 ? void 0 : m;
+function messageMetaAdapter(sink) {
+  return {
+    debug: (meta, message) => sink.debug?.(message, cleanMeta(meta)),
+    info: (meta, message) => sink.info?.(message, cleanMeta(meta)),
+    warn: (meta, message) => sink.warn?.(message, cleanMeta(meta)),
+    error: (meta, message) => sink.error?.(message, cleanMeta(meta)),
+    child: (ctx) => messageMetaAdapter(sink.child?.(ctx) ?? sink)
+  };
+}
+function winstonAdapter(winston) {
+  return messageMetaAdapter(winston);
+}
 export {
   createServer,
-  taujsBuild
+  taujsBuild,
+  winstonAdapter
 };