@taujs/server 0.4.2 → 0.4.3

package/dist/{Config-BuUuMjmO.d.ts → Config-CEhfq8Mm.d.ts}

@@ -6,7 +6,6 @@ type DebugCategory = (typeof DEBUG_CATEGORIES)[number];
 type DebugConfig = boolean | DebugCategory[] | ({
     all?: boolean;
 } & Partial<Record<DebugCategory, boolean>>);
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 interface BaseLogger {
     debug?(meta?: Record<string, unknown>, message?: string): void;
     info?(meta?: Record<string, unknown>, message?: string): void;
@@ -23,41 +22,8 @@ interface Logs extends BaseLogger {
     child(context: Record<string, unknown>): Logs;
     isDebugEnabled(category: DebugCategory): boolean;
 }
-declare class Logger implements Logs {
-    private config;
-    private debugEnabled;
-    private context;
-    constructor(config?: {
-        custom?: BaseLogger;
-        context?: Record<string, unknown>;
-        minLevel?: LogLevel;
-        includeStack?: boolean | ((level: LogLevel) => boolean);
-        includeContext?: boolean | ((level: LogLevel) => boolean);
-        singleLine?: boolean;
-    });
-    child(context: Record<string, unknown>): Logger;
-    configure(debug?: DebugConfig): void;
-    isDebugEnabled(category: DebugCategory): boolean;
-    private shouldEmit;
-    private shouldIncludeStack;
-    private stripStacks;
-    private formatTimestamp;
-    private emit;
-    info(meta?: unknown, message?: string): void;
-    warn(meta?: unknown, message?: string): void;
-    error(meta?: unknown, message?: string): void;
-    debug(category: DebugCategory, meta?: unknown, message?: string): void;
-}
-declare function createLogger(opts?: {
-    debug?: DebugConfig | string | boolean;
-    custom?: BaseLogger;
-    context?: Record<string, unknown>;
-    minLevel?: LogLevel;
-    includeStack?: boolean | ((level: LogLevel) => boolean);
-    includeContext?: boolean | ((level: LogLevel) => boolean);
-    singleLine?: boolean;
-}): Logger;
 
+type RegistryCaller<R extends ServiceRegistry = ServiceRegistry> = (serviceName: keyof R & string, methodName: string, args?: JsonObject) => Promise<JsonObject>;
 type JsonPrimitive = string | number | boolean | null;
 type JsonValue = JsonPrimitive | JsonValue[] | {
     [k: string]: JsonValue;
@@ -77,7 +43,9 @@ type ServiceContext = {
         id: string;
         roles: string[];
     } | null;
+    call?: (service: string, method: string, args?: JsonObject) => Promise<JsonObject>;
 };
+declare function withDeadline(signal: AbortSignal | undefined, ms?: number): AbortSignal | undefined;
 type ServiceMethod<P, R extends JsonObject = JsonObject> = (params: P, ctx: ServiceContext) => Promise<R>;
 type ServiceDefinition = Readonly<Record<string, ServiceMethod<any, JsonObject>>>;
 type ServiceRegistry = Readonly<Record<string, ServiceDefinition>>;
@@ -94,6 +62,7 @@ declare function defineService<T extends Record<string, ServiceMethod<any, JsonO
     handler: ServiceMethod<infer P, infer R_1>;
 } ? ServiceMethod<P, R_1> : never; };
 declare const defineServiceRegistry: <R extends ServiceRegistry>(registry: R) => R;
+declare function callServiceMethod(registry: ServiceRegistry, serviceName: string, methodName: string, params: JsonObject | undefined, ctx: ServiceContext): Promise<JsonObject>;
 
 type RequestContext<L extends Logs = Logs> = {
     traceId: string;
@@ -122,7 +91,11 @@ type BaseMiddleware = {
     csp?: RouteCSPConfig | false;
 };
 type DataResult = Record<string, unknown> | ServiceDescriptor;
-type DataHandler<Params extends PathToRegExpParams, L extends Logs = Logs> = (params: Params, ctx: RequestContext<L> & {
+type RequestServiceContext<L extends Logs = Logs> = RequestContext<L> & {
+    call: RegistryCaller<ServiceRegistry>;
+    headers?: Record<string, string>;
+};
+type DataHandler<Params extends PathToRegExpParams, L extends Logs = Logs> = (params: Params, ctx: RequestServiceContext<L> & {
     [key: string]: unknown;
 }) => Promise<DataResult>;
 type PathToRegExpParams = Partial<Record<string, string | string[]>>;
@@ -163,6 +136,35 @@ type CSPViolationReport = {
     disposition?: 'enforce' | 'report';
 };
 
+type ErrorKind = 'infra' | 'upstream' | 'domain' | 'validation' | 'auth' | 'canceled' | 'timeout';
+declare class AppError extends Error {
+    readonly kind: ErrorKind;
+    readonly httpStatus: number;
+    readonly details?: unknown;
+    readonly safeMessage: string;
+    readonly code?: string;
+    constructor(message: string, kind: ErrorKind, options?: {
+        httpStatus?: number;
+        details?: unknown;
+        cause?: unknown;
+        safeMessage?: string;
+        code?: string;
+    });
+    private getSafeMessage;
+    private serialiseValue;
+    toJSON(): any;
+    static notFound(message: string, details?: unknown, code?: string): AppError;
+    static forbidden(message: string, details?: unknown, code?: string): AppError;
+    static badRequest(message: string, details?: unknown, code?: string): AppError;
+    static unprocessable(message: string, details?: unknown, code?: string): AppError;
+    static timeout(message: string, details?: unknown, code?: string): AppError;
+    static canceled(message: string, details?: unknown, code?: string): AppError;
+    static internal(message: string, cause?: unknown, details?: unknown, code?: string): AppError;
+    static upstream(message: string, cause?: unknown, details?: unknown, code?: string): AppError;
+    static serviceUnavailable(message: string, cause?: unknown, details?: unknown, code?: string): AppError;
+    static from(err: unknown, fallback?: string): AppError;
+}
+
 /**
  * τjs [ taujs ] Orchestration System
  * (c) 2024-present Aoede Ltd
@@ -195,15 +197,15 @@ type AppConfig = {
     routes?: AppRoute[];
 };
 type TaujsConfig = {
+    apps: AppConfig[];
+    security?: SecurityConfig;
     server?: {
         host?: string;
         port?: number;
         hmrPort?: number;
     };
-    security?: SecurityConfig;
-    apps: AppConfig[];
 };
 
 declare function defineConfig<T extends TaujsConfig>(config: T): T;
 
-export { type AppConfig as A, type BaseLogger as B, type DebugConfig as D, type InitialRouteParams as I, type ServiceRegistry as S, type TaujsConfig as T, type SecurityConfig as a, type AppRoute as b, createLogger as c, defineConfig as d, defineServiceRegistry as e, defineService as f, type ServiceContext as g };
+export { type AppConfig as A, type BaseLogger as B, type DebugConfig as D, type InitialRouteParams as I, type RegistryCaller as R, type ServiceRegistry as S, type TaujsConfig as T, type SecurityConfig as a, type AppRoute as b, callServiceMethod as c, defineConfig as d, defineService as e, defineServiceRegistry as f, type ServiceContext as g, AppError as h, withDeadline as w };

package/dist/Config.d.ts

@@ -1,3 +1,3 @@
 import 'fastify';
 import 'vite';
-export { A as AppConfig, b as AppRoute, a as SecurityConfig, g as ServiceContext, T as TaujsConfig, d as defineConfig, f as defineService, e as defineServiceRegistry } from './Config-BuUuMjmO.js';
+export { A as AppConfig, h as AppError, b as AppRoute, R as RegistryCaller, a as SecurityConfig, g as ServiceContext, T as TaujsConfig, c as callServiceMethod, d as defineConfig, e as defineService, f as defineServiceRegistry, w as withDeadline } from './Config-CEhfq8Mm.js';

package/dist/Config.js

@@ -1,9 +1,137 @@
 // src/utils/DataServices.ts
 import { performance } from "perf_hooks";
+
+// 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);
+  }
+};
+
+// src/utils/DataServices.ts
 var runSchema = (schema, input) => {
   if (!schema) return input;
   return typeof schema.parse === "function" ? schema.parse(input) : schema(input);
 };
+function withDeadline(signal, ms) {
+  if (!ms) return signal;
+  const ctrl = new AbortController();
+  const onAbort = () => ctrl.abort(signal?.reason ?? new Error("Aborted"));
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const t = setTimeout(() => ctrl.abort(new Error("DeadlineExceeded")), ms);
+  ctrl.signal.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(t);
+      signal?.removeEventListener("abort", onAbort);
+    },
+    { once: true }
+  );
+  return ctrl.signal;
+}
 function defineService(spec) {
   const out = {};
   for (const [name, v] of Object.entries(spec)) {
@@ -21,6 +149,38 @@ function defineService(spec) {
   return Object.freeze(out);
 }
 var defineServiceRegistry = (registry) => Object.freeze(Object.fromEntries(Object.entries(registry).map(([k, v]) => [k, Object.freeze(v)])));
+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 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 = performance.now();
+  try {
+    const result = await method(params ?? {}, ctx);
+    if (typeof result !== "object" || result === null) {
+      throw AppError.internal(`Non-object result from ${serviceName}.${methodName}`);
+    }
+    logger?.debug?.({ ms: +(performance.now() - t0).toFixed(1) }, "Service method ok");
+    return result;
+  } catch (err) {
+    logger?.error?.(
+      {
+        params,
+        error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : String(err),
+        ms: +(performance.now() - t0).toFixed(1)
+      },
+      "Service method failed"
+    );
+    throw err instanceof AppError ? err : err instanceof Error ? AppError.internal(err.message, { cause: err }) : AppError.internal("Unknown error", { details: { err } });
+  }
+}
 
 // src/Config.ts
 function defineConfig(config) {
@@ -28,7 +188,10 @@ function defineConfig(config) {
   return config;
 }
 export {
+  AppError,
+  callServiceMethod,
   defineConfig,
   defineService,
-  defineServiceRegistry
+  defineServiceRegistry,
+  withDeadline
 };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { FastifyPluginCallback, FastifyPluginAsync, FastifyInstance } from 'fastify';
-import { T as TaujsConfig, S as ServiceRegistry, D as DebugConfig, B as BaseLogger, A as AppConfig } from './Config-BuUuMjmO.js';
-export { I as InitialRouteParams, c as createLogger } from './Config-BuUuMjmO.js';
-import 'vite';
+import { T as TaujsConfig, S as ServiceRegistry, D as DebugConfig, B as BaseLogger, A as AppConfig } from './Config-CEhfq8Mm.js';
+export { I as InitialRouteParams } from './Config-CEhfq8Mm.js';
+import { InlineConfig } from 'vite';
 
 type StaticMountEntry = {
     plugin: FastifyPluginCallback<any> | FastifyPluginAsync<any>;
@@ -42,13 +42,84 @@ declare const createServer: (opts: CreateServerOptions) => Promise<CreateServerR
  * including CSR, SSR, streaming, and middleware composition.
  */
 
-declare function taujsBuild({ config, projectRoot, clientBaseDir, isSSRBuild, }: {
+type ViteBuildContext = {
+    appId: string;
+    entryPoint: string;
+    isSSRBuild: boolean;
+    clientRoot: string;
+};
+/**
+ * User-supplied vite config override.
+ * Can be a static config object or a function that receives build context.
+ *
+ * **Plugin order**: Framework applies plugins in this sequence:
+ * 1. `appConfig.plugins` (from taujs.config.ts)
+ * 2. `nodePolyfills({ include: ['stream'] })` (client builds only)
+ * 3. `userViteConfig.plugins` (from this option)
+ *
+ * If you need plugins before nodePolyfills, add them to `appConfig.plugins` instead.
+ *
+ * **Allowed customisations:**
+ * - `plugins`: Appended to framework plugin list
+ * - `define`: Shallow-merged with framework defines
+ * - `css.preprocessorOptions`: Deep-merged by preprocessor engine (scss, less, etc.)
+ * - `build.sourcemap`, `minify`, `terserOptions`: Direct overrides
+ * - `build.rollupOptions.external`: Direct override
+ * - `build.rollupOptions.output.manualChunks`: Merged into output config
+ * - `resolve.*` (except `alias`): Merged with framework resolve config
+ * - `esbuild`, `logLevel`, `optimizeDeps`: Direct overrides
+ *
+ * **Protected fields (cannot override):**
+ * - `root`, `base`, `publicDir`: Framework-controlled per-app paths
+ * - `build.outDir`: Framework manages `dist/client` vs `dist/ssr` separation
+ * - `build.ssr`, `ssrManifest`, `format`, `target`: Framework-controlled for SSR integrity
+ * - `build.rollupOptions.input`: Framework manages entry points
+ * - `resolve.alias`: Use top-level `alias` option in taujsBuild() instead
+ * - `server.*`: Ignored in builds (dev-mode only; configure in DevServer.ts)
+ *
+ * @example
+ * ```ts
+ * // Static config
+ * vite: {
+ *   plugins: [visualizer()],
+ *   build: { sourcemap: 'inline' }
+ * }
+ *
+ * // Function-based (conditional per app/mode)
+ * vite: ({ isSSRBuild, entryPoint }) => ({
+ *   plugins: isSSRBuild ? [] : [visualizer()],
+ *   logLevel: entryPoint === 'admin' ? 'info' : 'warn'
+ * })
+ * ```
+ */
+type ViteConfigOverride = Partial<InlineConfig> | ((ctx: ViteBuildContext) => Partial<InlineConfig>);
+declare function taujsBuild({ config, projectRoot, clientBaseDir, isSSRBuild, alias: userAlias, vite: userViteConfig, }: {
     config: {
         apps: AppConfig[];
     };
     projectRoot: string;
     clientBaseDir: string;
     isSSRBuild?: boolean;
+    /**
+     * Top-level alias overrides. Use this instead of `vite.resolve.alias`.
+     * User aliases are merged with framework defaults; user values win on conflicts.
+     *
+     * Framework provides:
+     * - `@client`: Resolves to current app's root
+     * - `@server`: Resolves to `src/server`
+     * - `@shared`: Resolves to `src/shared`
+     *
+     * @example
+     * ```ts
+     * alias: {
+     *   '@utils': './src/utils',
+     *   '@server': './custom-server', // overrides framework default
+     * }
+     * ```
+     */
+    alias?: Record<string, string>;
+    /** User-supplied Vite config overrides (plugins, tuning, etc.) */
+    vite?: ViteConfigOverride;
 }): Promise<void>;
 
 interface MessageMetaLogger {
@@ -60,4 +131,4 @@ interface MessageMetaLogger {
 }
 declare function winstonAdapter(winston: MessageMetaLogger): BaseLogger;
 
-export { createServer, taujsBuild, winstonAdapter };
+export { BaseLogger, createServer, taujsBuild, winstonAdapter };

package/dist/index.js

@@ -189,7 +189,7 @@ var require_plugin = __commonJS({
 
 // src/CreateServer.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
-import path5 from "path";
+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,8 +344,8 @@ 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/logging/AppError.ts
@@ -609,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);
@@ -632,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);
     }
@@ -839,6 +845,7 @@ var verifyContracts = (app, routes, contracts, security) => {
 
 // src/SSRServer.ts
 var import_fastify_plugin3 = __toESM(require_plugin(), 1);
+import path6 from "path";
 
 // src/logging/utils/index.ts
 var httpStatusFrom = (err, fallback = 500) => err instanceof AppError ? err.httpStatus : fallback;
@@ -879,6 +886,12 @@ 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];
@@ -929,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;
@@ -962,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,
@@ -978,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");
@@ -1102,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)(
@@ -1434,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");
@@ -1444,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);
@@ -1468,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);
@@ -1476,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) {
@@ -1687,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);
@@ -1699,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();
@@ -1709,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;
@@ -1728,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 {
@@ -1744,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;
@@ -1787,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");
             }
           }
         },
@@ -1897,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];
 }
@@ -1906,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,
@@ -1939,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,
@@ -1951,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,
@@ -1971,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,
@@ -2026,9 +2131,9 @@ var SSRServer = (0, import_fastify_plugin3.default)(
 // src/CreateServer.ts
 var createServer = async (opts) => {
   const t0 = performance3.now();
-  const clientRoot = opts.clientRoot ?? path5.resolve(process.cwd(), "client");
+  const clientRoot = opts.clientRoot ?? path7.resolve(process.cwd(), "client");
   const app = opts.fastify ?? Fastify({ logger: false });
-  const fastifyLogger = app.log && app.log.level !== "silent" ? app.log : void 0;
+  const fastifyLogger = app.log && app.log.level && app.log.level !== "silent" ? app.log : void 0;
   const logger = createLogger({
     debug: opts.debug,
     custom: opts.logger ?? fastifyLogger,
@@ -2095,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");
@@ -2117,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: {
@@ -2144,33 +2390,28 @@ 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);
     }
@@ -2192,7 +2433,6 @@ function winstonAdapter(winston) {
   return messageMetaAdapter(winston);
 }
 export {
-  createLogger,
   createServer,
   taujsBuild,
   winstonAdapter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taujs/server",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "τjs [ taujs ]",
   "author": "John Smith | Aoede <taujs@aoede.uk.net> (https://www.aoede.uk.net)",
   "license": "MIT",