@nestjs-ssr/react 0.1.1

package/dist/render/index.mjs

@@ -0,0 +1,1102 @@
+import { Injectable, Logger, Optional, Inject, Global, Module } from '@nestjs/common';
+import { HttpAdapterHost, APP_INTERCEPTOR, Reflector } from '@nestjs/core';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import serialize from 'serialize-javascript';
+import escapeHtml from 'escape-html';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { createElement } from 'react';
+import { switchMap } from 'rxjs/operators';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var TemplateParserService = class {
+  static {
+    __name(this, "TemplateParserService");
+  }
+  // Mapping of HeadData fields to their HTML tag renderers
+  // Order matters: title and description first for SEO best practices
+  headTagRenderers = [
+    {
+      key: "title",
+      render: /* @__PURE__ */ __name((v) => `<title>${escapeHtml(v)}</title>`, "render")
+    },
+    {
+      key: "description",
+      render: /* @__PURE__ */ __name((v) => `<meta name="description" content="${escapeHtml(v)}" />`, "render")
+    },
+    {
+      key: "keywords",
+      render: /* @__PURE__ */ __name((v) => `<meta name="keywords" content="${escapeHtml(v)}" />`, "render")
+    },
+    {
+      key: "canonical",
+      render: /* @__PURE__ */ __name((v) => `<link rel="canonical" href="${escapeHtml(v)}" />`, "render")
+    },
+    {
+      key: "ogTitle",
+      render: /* @__PURE__ */ __name((v) => `<meta property="og:title" content="${escapeHtml(v)}" />`, "render")
+    },
+    {
+      key: "ogDescription",
+      render: /* @__PURE__ */ __name((v) => `<meta property="og:description" content="${escapeHtml(v)}" />`, "render")
+    },
+    {
+      key: "ogImage",
+      render: /* @__PURE__ */ __name((v) => `<meta property="og:image" content="${escapeHtml(v)}" />`, "render")
+    }
+  ];
+  /**
+  * Parse HTML template into parts for streaming SSR
+  *
+  * Splits the template at strategic injection points:
+  * - Before root div: Shell HTML (head, body start)
+  * - Root div start
+  * - Root div end
+  * - After root: Scripts and closing tags
+  */
+  parseTemplate(html) {
+    const rootStartMarker = '<div id="root">';
+    const rootStartIndex = html.indexOf(rootStartMarker);
+    if (rootStartIndex === -1) {
+      throw new Error('Template must contain <div id="root">');
+    }
+    const commentMarker = "<!--app-html-->";
+    const commentIndex = html.indexOf(commentMarker, rootStartIndex);
+    if (commentIndex === -1) {
+      throw new Error("Template must contain <!--app-html--> placeholder");
+    }
+    const rootEndMarker = "</div>";
+    const rootEndIndex = html.indexOf(rootEndMarker, commentIndex);
+    if (rootEndIndex === -1) {
+      throw new Error("Template must have closing </div> for root");
+    }
+    const htmlStart = html.substring(0, rootStartIndex);
+    const rootStart = rootStartMarker;
+    const rootEnd = rootEndMarker;
+    const htmlEnd = html.substring(rootEndIndex + rootEndMarker.length);
+    return {
+      htmlStart,
+      rootStart,
+      rootEnd,
+      htmlEnd
+    };
+  }
+  /**
+  * Build inline script that provides initial state to the client
+  *
+  * Safely serializes data using serialize-javascript to avoid XSS vulnerabilities.
+  * This library handles all edge cases including escaping dangerous characters,
+  * functions, dates, regexes, and prevents prototype pollution.
+  */
+  buildInlineScripts(data, context, componentPath) {
+    return `<script>
+window.__INITIAL_STATE__ = ${serialize(data, {
+      isJSON: true
+    })};
+window.__CONTEXT__ = ${serialize(context, {
+      isJSON: true
+    })};
+window.__COMPONENT_PATH__ = ${serialize(componentPath, {
+      isJSON: true
+    })};
+</script>`;
+  }
+  /**
+  * Get client script tag for hydration
+  *
+  * In development: Direct module import with Vite HMR
+  * In production: Hashed filename from manifest
+  */
+  getClientScriptTag(isDevelopment, manifest) {
+    if (isDevelopment) {
+      return '<script type="module" src="/src/entry-client.tsx"></script>';
+    }
+    if (!manifest || !manifest["src/entry-client.tsx"]) {
+      throw new Error("Manifest missing entry for src/entry-client.tsx");
+    }
+    const entryFile = manifest["src/entry-client.tsx"].file;
+    return `<script type="module" src="/${entryFile}"></script>`;
+  }
+  /**
+  * Get stylesheet link tags
+  *
+  * In development: Direct link to source CSS file
+  * In production: Hashed CSS files from manifest
+  */
+  getStylesheetTags(isDevelopment, manifest) {
+    if (isDevelopment) {
+      return "";
+    }
+    if (!manifest || !manifest["src/entry-client.tsx"]) {
+      return "";
+    }
+    const entry = manifest["src/entry-client.tsx"];
+    if (!entry.css || entry.css.length === 0) {
+      return "";
+    }
+    return entry.css.map((css) => `<link rel="stylesheet" href="/${css}" />`).join("\n    ");
+  }
+  /**
+  * Build HTML head tags from HeadData
+  *
+  * Generates title, meta tags, and link tags for SEO and page metadata.
+  * Safely escapes content using escape-html to prevent XSS.
+  */
+  buildHeadTags(head) {
+    if (!head) {
+      return "";
+    }
+    const tags = [];
+    for (const { key, render } of this.headTagRenderers) {
+      const value = head[key];
+      if (value && typeof value === "string") {
+        tags.push(render(value));
+      }
+    }
+    if (head.links?.length) {
+      tags.push(...head.links.map((link) => this.buildTag("link", link)));
+    }
+    if (head.meta?.length) {
+      tags.push(...head.meta.map((meta) => this.buildTag("meta", meta)));
+    }
+    return tags.join("\n    ");
+  }
+  /**
+  * Build an HTML tag from an object of attributes
+  */
+  buildTag(tagName, attrs) {
+    const attrString = Object.entries(attrs).map(([key, value]) => `${key}="${escapeHtml(String(value))}"`).join(" ");
+    return `<${tagName} ${attrString} />`;
+  }
+};
+TemplateParserService = _ts_decorate([
+  Injectable()
+], TemplateParserService);
+
+// src/render/error-pages/error-page-development.tsx
+function ErrorPageDevelopment({ error, viewPath, phase }) {
+  const stackLines = error.stack ? error.stack.split("\n").slice(1) : [];
+  return /* @__PURE__ */ React.createElement("html", {
+    lang: "en"
+  }, /* @__PURE__ */ React.createElement("head", null, /* @__PURE__ */ React.createElement("meta", {
+    charSet: "UTF-8"
+  }), /* @__PURE__ */ React.createElement("meta", {
+    name: "viewport",
+    content: "width=device-width, initial-scale=1.0"
+  }), /* @__PURE__ */ React.createElement("title", null, `SSR Error - ${error.name}`), /* @__PURE__ */ React.createElement("style", {
+    dangerouslySetInnerHTML: {
+      __html: `
+              body {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+                line-height: 1.6;
+                padding: 2rem;
+                background: #1a1a1a;
+                color: #e0e0e0;
+              }
+              .error-container {
+                max-width: 900px;
+                margin: 0 auto;
+              }
+              h1 {
+                color: #ff6b6b;
+                font-size: 2rem;
+                margin-bottom: 0.5rem;
+              }
+              .error-type {
+                color: #ffa502;
+                font-size: 1.2rem;
+                margin-bottom: 1rem;
+              }
+              .error-message {
+                background: #2d2d2d;
+                padding: 1rem;
+                border-left: 4px solid #ff6b6b;
+                margin: 1rem 0;
+                font-family: 'Courier New', Courier, monospace;
+              }
+              .stack-trace {
+                background: #2d2d2d;
+                padding: 1rem;
+                border-radius: 4px;
+                overflow-x: auto;
+                margin: 1rem 0;
+              }
+              .stack-trace pre {
+                margin: 0;
+                font-family: 'Courier New', Courier, monospace;
+                font-size: 0.9rem;
+                color: #a0a0a0;
+              }
+              .meta {
+                color: #888;
+                font-size: 0.9rem;
+                margin-top: 2rem;
+              }
+            `
+    }
+  })), /* @__PURE__ */ React.createElement("body", null, /* @__PURE__ */ React.createElement("div", {
+    className: "error-container"
+  }, /* @__PURE__ */ React.createElement("h1", null, "Server-Side Rendering Error"), /* @__PURE__ */ React.createElement("div", {
+    className: "error-type"
+  }, error.name), /* @__PURE__ */ React.createElement("div", {
+    className: "error-message"
+  }, error.message), /* @__PURE__ */ React.createElement("h2", null, "Stack Trace"), /* @__PURE__ */ React.createElement("div", {
+    className: "stack-trace"
+  }, /* @__PURE__ */ React.createElement("pre", null, stackLines.join("\n"))), /* @__PURE__ */ React.createElement("div", {
+    className: "meta"
+  }, /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("strong", null, "View Path:"), " ", viewPath), /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("strong", null, "Error Phase:"), " ", phase === "shell" ? "Shell (before streaming started)" : "Streaming (during content delivery)"), /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("strong", null, "Environment:"), " Development")))));
+}
+__name(ErrorPageDevelopment, "ErrorPageDevelopment");
+
+// src/render/error-pages/error-page-production.tsx
+function ErrorPageProduction() {
+  return /* @__PURE__ */ React.createElement("html", {
+    lang: "en"
+  }, /* @__PURE__ */ React.createElement("head", null, /* @__PURE__ */ React.createElement("meta", {
+    charSet: "UTF-8"
+  }), /* @__PURE__ */ React.createElement("meta", {
+    name: "viewport",
+    content: "width=device-width, initial-scale=1.0"
+  }), /* @__PURE__ */ React.createElement("title", null, "Error"), /* @__PURE__ */ React.createElement("style", {
+    dangerouslySetInnerHTML: {
+      __html: `
+              body {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                min-height: 100vh;
+                margin: 0;
+                background: #f5f5f5;
+              }
+              .error-container {
+                text-align: center;
+                padding: 2rem;
+              }
+              h1 {
+                font-size: 3rem;
+                color: #333;
+                margin: 0 0 1rem 0;
+              }
+              p {
+                font-size: 1.2rem;
+                color: #666;
+              }
+            `
+    }
+  })), /* @__PURE__ */ React.createElement("body", null, /* @__PURE__ */ React.createElement("div", {
+    className: "error-container"
+  }, /* @__PURE__ */ React.createElement("h1", null, "500"), /* @__PURE__ */ React.createElement("p", null, "Internal Server Error"), /* @__PURE__ */ React.createElement("p", null, "Something went wrong while rendering this page."))));
+}
+__name(ErrorPageProduction, "ErrorPageProduction");
+
+// src/render/streaming-error-handler.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var StreamingErrorHandler = class _StreamingErrorHandler {
+  static {
+    __name(this, "StreamingErrorHandler");
+  }
+  errorPageDevelopment;
+  errorPageProduction;
+  logger = new Logger(_StreamingErrorHandler.name);
+  constructor(errorPageDevelopment, errorPageProduction) {
+    this.errorPageDevelopment = errorPageDevelopment;
+    this.errorPageProduction = errorPageProduction;
+  }
+  /**
+  * Handle error that occurred before shell was ready
+  * Can still set HTTP status code and send error page
+  */
+  handleShellError(error, res, viewPath, isDevelopment) {
+    this.logger.error(`Shell error rendering ${viewPath}: ${error.message}`, error.stack);
+    res.statusCode = 500;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    if (isDevelopment) {
+      res.send(this.renderDevelopmentErrorPage(error, viewPath, "shell"));
+    } else {
+      res.send(this.renderProductionErrorPage());
+    }
+  }
+  /**
+  * Handle error that occurred during streaming
+  * Headers already sent, can only log the error
+  */
+  handleStreamError(error, viewPath) {
+    this.logger.error(`Streaming error rendering ${viewPath}: ${error.message}`, error.stack);
+  }
+  /**
+  * Render development error page using React component
+  */
+  renderDevelopmentErrorPage(error, viewPath, phase) {
+    const ErrorComponent = this.errorPageDevelopment || ErrorPageDevelopment;
+    const element = createElement(ErrorComponent, {
+      error,
+      viewPath,
+      phase
+    });
+    return "<!DOCTYPE html>\n" + renderToStaticMarkup(element);
+  }
+  /**
+  * Render production error page using React component
+  */
+  renderProductionErrorPage() {
+    const ErrorComponent = this.errorPageProduction || ErrorPageProduction;
+    const element = createElement(ErrorComponent);
+    return "<!DOCTYPE html>\n" + renderToStaticMarkup(element);
+  }
+};
+StreamingErrorHandler = _ts_decorate2([
+  Injectable(),
+  _ts_param(0, Optional()),
+  _ts_param(0, Inject("ERROR_PAGE_DEVELOPMENT")),
+  _ts_param(1, Optional()),
+  _ts_param(1, Inject("ERROR_PAGE_PRODUCTION")),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ComponentType === "undefined" ? Object : ComponentType,
+    typeof ComponentType === "undefined" ? Object : ComponentType
+  ])
+], StreamingErrorHandler);
+
+// src/render/render.service.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var RenderService = class _RenderService {
+  static {
+    __name(this, "RenderService");
+  }
+  templateParser;
+  streamingErrorHandler;
+  defaultHead;
+  logger = new Logger(_RenderService.name);
+  vite = null;
+  template;
+  manifest = null;
+  serverManifest = null;
+  isDevelopment;
+  ssrMode;
+  constructor(templateParser, streamingErrorHandler, ssrMode, defaultHead) {
+    this.templateParser = templateParser;
+    this.streamingErrorHandler = streamingErrorHandler;
+    this.defaultHead = defaultHead;
+    this.isDevelopment = process.env.NODE_ENV !== "production";
+    this.ssrMode = ssrMode || process.env.SSR_MODE || "string";
+    let templatePath;
+    if (this.isDevelopment) {
+      const packageTemplatePaths = [
+        join(__dirname, "../templates/index.html"),
+        join(__dirname, "../src/templates/index.html"),
+        join(__dirname, "../../src/templates/index.html")
+      ];
+      const localTemplatePath = join(process.cwd(), "src/views/index.html");
+      const foundPackageTemplate = packageTemplatePaths.find((p) => existsSync(p));
+      if (foundPackageTemplate) {
+        templatePath = foundPackageTemplate;
+      } else if (existsSync(localTemplatePath)) {
+        templatePath = localTemplatePath;
+      } else {
+        throw new Error(`Template file not found. Tried:
+` + packageTemplatePaths.map((p) => `  - ${p} (package template)`).join("\n") + `
+  - ${localTemplatePath} (local template)`);
+      }
+    } else {
+      templatePath = join(process.cwd(), "dist/client/index.html");
+      if (!existsSync(templatePath)) {
+        throw new Error(`Template file not found at ${templatePath}. Make sure to run the build process first.`);
+      }
+    }
+    try {
+      this.template = readFileSync(templatePath, "utf-8");
+      this.logger.log(`\u2713 Loaded template from ${templatePath}`);
+    } catch (error) {
+      throw new Error(`Failed to read template file at ${templatePath}: ${error.message}`);
+    }
+    if (!this.isDevelopment) {
+      const manifestPath = join(process.cwd(), "dist/client/.vite/manifest.json");
+      if (existsSync(manifestPath)) {
+        this.manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      } else {
+        this.logger.warn("\u26A0\uFE0F  Client manifest not found. Run `pnpm build:client` first.");
+      }
+      const serverManifestPath = join(process.cwd(), "dist/server/.vite/manifest.json");
+      if (existsSync(serverManifestPath)) {
+        this.serverManifest = JSON.parse(readFileSync(serverManifestPath, "utf-8"));
+      } else {
+        this.logger.warn("\u26A0\uFE0F  Server manifest not found. Run `pnpm build:server` first.");
+      }
+    }
+  }
+  setViteServer(vite) {
+    this.vite = vite;
+  }
+  /**
+  * Main render method that routes to string or stream mode
+  */
+  async render(viewPath, data = {}, res, head) {
+    const mergedHead = this.mergeHead(this.defaultHead, head);
+    if (this.ssrMode === "stream") {
+      if (!res) {
+        throw new Error("Response object is required for streaming SSR mode. Pass res as third parameter.");
+      }
+      return this.renderToStream(viewPath, data, res, mergedHead);
+    }
+    return this.renderToString(viewPath, data, mergedHead);
+  }
+  /**
+  * Merge default head with page-specific head
+  * Page-specific head values override defaults
+  */
+  mergeHead(defaultHead, pageHead) {
+    if (!defaultHead && !pageHead) {
+      return void 0;
+    }
+    return {
+      ...defaultHead,
+      ...pageHead,
+      // Merge arrays (links and meta) instead of replacing
+      links: [
+        ...defaultHead?.links || [],
+        ...pageHead?.links || []
+      ],
+      meta: [
+        ...defaultHead?.meta || [],
+        ...pageHead?.meta || []
+      ]
+    };
+  }
+  /**
+  * Traditional string-based SSR using renderToString
+  */
+  async renderToString(viewPath, data = {}, head) {
+    const startTime = Date.now();
+    try {
+      let template = this.template;
+      if (this.vite) {
+        template = await this.vite.transformIndexHtml("/", template);
+      }
+      let renderModule;
+      if (this.vite) {
+        renderModule = await this.vite.ssrLoadModule("/src/entry-server.tsx");
+      } else {
+        if (this.serverManifest) {
+          const manifestEntry = Object.entries(this.serverManifest).find(([key, value]) => value.isEntry && key.includes("entry-server"));
+          if (manifestEntry) {
+            const [, entry] = manifestEntry;
+            const serverPath = join(process.cwd(), "dist/server", entry.file);
+            renderModule = await import(serverPath);
+          } else {
+            throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
+          }
+        } else {
+          throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
+        }
+      }
+      const { data: pageData, __context: context } = data;
+      const appHtml = await renderModule.renderComponent(viewPath, data);
+      const initialStateScript = `
+        <script>
+          window.__INITIAL_STATE__ = ${serialize(pageData, {
+        isJSON: true
+      })};
+          window.__CONTEXT__ = ${serialize(context, {
+        isJSON: true
+      })};
+          window.__COMPONENT_PATH__ = ${serialize(viewPath, {
+        isJSON: true
+      })};
+        </script>
+      `;
+      let clientScript = "";
+      let styles = "";
+      if (this.vite) {
+        clientScript = `<script type="module" src="/src/entry-client.tsx"></script>`;
+        styles = "";
+      } else {
+        if (this.manifest) {
+          const manifestEntry = Object.entries(this.manifest).find(([key, value]) => value.isEntry && key.includes("entry-client"));
+          if (manifestEntry) {
+            const [, entry] = manifestEntry;
+            const entryFile = entry.file;
+            clientScript = `<script type="module" src="/${entryFile}"></script>`;
+            if (entry.css) {
+              const cssFiles = entry.css;
+              styles = cssFiles.map((css) => `<link rel="stylesheet" href="/${css}" />`).join("\n    ");
+            }
+          } else {
+            this.logger.error("\u26A0\uFE0F  Client entry not found in manifest");
+            clientScript = `<script type="module" src="/assets/client.js"></script>`;
+          }
+        } else {
+          this.logger.error("\u26A0\uFE0F  Client manifest not found");
+          clientScript = `<script type="module" src="/assets/client.js"></script>`;
+        }
+      }
+      const headTags = this.templateParser.buildHeadTags(head);
+      let html = template.replace("<!--app-html-->", appHtml);
+      html = html.replace("<!--initial-state-->", initialStateScript);
+      html = html.replace("<!--client-scripts-->", clientScript);
+      html = html.replace("<!--styles-->", styles);
+      html = html.replace("<!--head-meta-->", headTags);
+      if (this.isDevelopment) {
+        const duration = Date.now() - startTime;
+        this.logger.log(`[SSR] ${viewPath} rendered in ${duration}ms (string mode)`);
+      }
+      return html;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+  * Modern streaming SSR using renderToPipeableStream
+  */
+  async renderToStream(viewPath, data = {}, res, head) {
+    const startTime = Date.now();
+    let shellReadyTime = 0;
+    try {
+      let template = this.template;
+      if (this.vite) {
+        template = await this.vite.transformIndexHtml("/", template);
+      }
+      const templateParts = this.templateParser.parseTemplate(template);
+      let renderModule;
+      if (this.vite) {
+        renderModule = await this.vite.ssrLoadModule("/src/entry-server.tsx");
+      } else {
+        if (this.serverManifest) {
+          const manifestEntry = Object.entries(this.serverManifest).find(([key, value]) => value.isEntry && key.includes("entry-server"));
+          if (manifestEntry) {
+            const [, entry] = manifestEntry;
+            const serverPath = join(process.cwd(), "dist/server", entry.file);
+            renderModule = await import(serverPath);
+          } else {
+            throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
+          }
+        } else {
+          throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
+        }
+      }
+      const { data: pageData, __context: context } = data;
+      const inlineScripts = this.templateParser.buildInlineScripts(pageData, context, viewPath);
+      const clientScript = this.templateParser.getClientScriptTag(this.isDevelopment, this.manifest);
+      const stylesheetTags = this.templateParser.getStylesheetTags(this.isDevelopment, this.manifest);
+      const headTags = this.templateParser.buildHeadTags(head);
+      let didError = false;
+      const { pipe, abort } = renderModule.renderComponentStream(viewPath, data, {
+        onShellReady: /* @__PURE__ */ __name(() => {
+          shellReadyTime = Date.now();
+          res.statusCode = didError ? 500 : 200;
+          res.setHeader("Content-Type", "text/html; charset=utf-8");
+          let htmlStart = templateParts.htmlStart;
+          htmlStart = htmlStart.replace("<!--styles-->", stylesheetTags);
+          htmlStart = htmlStart.replace("<!--head-meta-->", headTags);
+          res.write(htmlStart);
+          res.write(templateParts.rootStart);
+          pipe(res);
+          if (this.isDevelopment) {
+            const ttfb = shellReadyTime - startTime;
+            this.logger.log(`[SSR] ${viewPath} shell ready in ${ttfb}ms (stream mode - TTFB)`);
+          }
+        }, "onShellReady"),
+        onShellError: /* @__PURE__ */ __name((error) => {
+          this.streamingErrorHandler.handleShellError(error, res, viewPath, this.isDevelopment);
+        }, "onShellError"),
+        onError: /* @__PURE__ */ __name((error) => {
+          didError = true;
+          this.streamingErrorHandler.handleStreamError(error, viewPath);
+        }, "onError"),
+        onAllReady: /* @__PURE__ */ __name(() => {
+          res.write(inlineScripts);
+          res.write(clientScript);
+          res.write(templateParts.rootEnd);
+          res.write(templateParts.htmlEnd);
+          res.end();
+          if (this.isDevelopment) {
+            const totalTime = Date.now() - startTime;
+            const streamTime = Date.now() - shellReadyTime;
+            this.logger.log(`[SSR] ${viewPath} streaming complete in ${totalTime}ms total (${streamTime}ms streaming)`);
+          }
+        }, "onAllReady")
+      });
+      res.on("close", () => {
+        abort();
+      });
+    } catch (error) {
+      this.streamingErrorHandler.handleShellError(error, res, viewPath, this.isDevelopment);
+    }
+  }
+};
+RenderService = _ts_decorate3([
+  Injectable(),
+  _ts_param2(2, Optional()),
+  _ts_param2(2, Inject("SSR_MODE")),
+  _ts_param2(3, Optional()),
+  _ts_param2(3, Inject("DEFAULT_HEAD")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof TemplateParserService === "undefined" ? Object : TemplateParserService,
+    typeof StreamingErrorHandler === "undefined" ? Object : StreamingErrorHandler,
+    typeof SSRMode === "undefined" ? Object : SSRMode,
+    typeof HeadData === "undefined" ? Object : HeadData
+  ])
+], RenderService);
+var RENDER_KEY = "render";
+
+// src/render/render.interceptor.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function isRenderResponse(data) {
+  return data && typeof data === "object" && "props" in data;
+}
+__name(isRenderResponse, "isRenderResponse");
+var RenderInterceptor = class {
+  static {
+    __name(this, "RenderInterceptor");
+  }
+  reflector;
+  renderService;
+  constructor(reflector, renderService) {
+    this.reflector = reflector;
+    this.renderService = renderService;
+  }
+  intercept(context, next) {
+    const viewPath = this.reflector.get(RENDER_KEY, context.getHandler());
+    if (!viewPath) {
+      return next.handle();
+    }
+    return next.handle().pipe(switchMap(async (data) => {
+      const httpContext = context.switchToHttp();
+      const request = httpContext.getRequest();
+      const response = httpContext.getResponse();
+      const renderContext = {
+        url: request.url,
+        path: request.path,
+        query: request.query,
+        params: request.params,
+        userAgent: request.headers["user-agent"],
+        acceptLanguage: request.headers["accept-language"],
+        referer: request.headers.referer
+      };
+      const renderResponse = isRenderResponse(data) ? data : {
+        props: data
+      };
+      const fullData = {
+        data: renderResponse.props,
+        __context: renderContext
+      };
+      try {
+        const html = await this.renderService.render(viewPath, fullData, response, renderResponse.head);
+        if (html !== void 0) {
+          response.type("text/html");
+          return html;
+        }
+        return;
+      } catch (error) {
+        throw error;
+      }
+    }));
+  }
+};
+RenderInterceptor = _ts_decorate4([
+  Injectable(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector,
+    typeof RenderService === "undefined" ? Object : RenderService
+  ])
+], RenderInterceptor);
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var ViteInitializerService = class _ViteInitializerService {
+  static {
+    __name(this, "ViteInitializerService");
+  }
+  renderService;
+  httpAdapterHost;
+  logger = new Logger(_ViteInitializerService.name);
+  viteMode;
+  vitePort;
+  constructor(renderService, httpAdapterHost, viteConfig) {
+    this.renderService = renderService;
+    this.httpAdapterHost = httpAdapterHost;
+    this.viteMode = viteConfig?.mode || "embedded";
+    this.vitePort = viteConfig?.port || 5173;
+  }
+  async onModuleInit() {
+    const isDevelopment = process.env.NODE_ENV !== "production";
+    if (isDevelopment) {
+      await this.setupDevelopmentMode();
+    } else {
+      this.setupProductionMode();
+    }
+  }
+  async setupDevelopmentMode() {
+    try {
+      const { createServer: createViteServer } = await import('vite');
+      const vite = await createViteServer({
+        server: {
+          middlewareMode: true
+        },
+        appType: "custom"
+      });
+      this.renderService.setViteServer(vite);
+      if (this.viteMode === "embedded") {
+        await this.mountViteMiddleware(vite);
+      } else if (this.viteMode === "proxy") {
+        await this.setupViteProxy();
+      }
+      this.logger.log(`\u2713 Vite initialized for SSR (mode: ${this.viteMode})`);
+    } catch (error) {
+      this.logger.warn(`Failed to initialize Vite: ${error.message}. Make sure vite is installed.`);
+    }
+  }
+  async mountViteMiddleware(vite) {
+    try {
+      const httpAdapter = this.httpAdapterHost.httpAdapter;
+      if (!httpAdapter) {
+        this.logger.warn("HTTP adapter not available, skipping Vite middleware setup");
+        return;
+      }
+      const app = httpAdapter.getInstance();
+      app.use(vite.middlewares);
+      this.logger.log(`\u2713 Vite middleware mounted (embedded mode with HMR)`);
+    } catch (error) {
+      this.logger.warn(`Failed to mount Vite middleware: ${error.message}`);
+    }
+  }
+  async setupViteProxy() {
+    try {
+      const httpAdapter = this.httpAdapterHost.httpAdapter;
+      if (!httpAdapter) {
+        this.logger.warn("HTTP adapter not available, skipping Vite proxy setup");
+        return;
+      }
+      const app = httpAdapter.getInstance();
+      const { createProxyMiddleware } = await import('http-proxy-middleware');
+      const viteProxy = createProxyMiddleware({
+        target: `http://localhost:${this.vitePort}`,
+        changeOrigin: true,
+        ws: true,
+        pathFilter: /* @__PURE__ */ __name((pathname) => {
+          return pathname.startsWith("/src/") || pathname.startsWith("/@") || pathname.startsWith("/node_modules/");
+        }, "pathFilter")
+      });
+      app.use(viteProxy);
+      this.logger.log(`\u2713 Vite HMR proxy configured (external Vite on port ${this.vitePort})`);
+    } catch (error) {
+      this.logger.warn(`Failed to setup Vite proxy: ${error.message}. Make sure http-proxy-middleware is installed.`);
+    }
+  }
+  setupProductionMode() {
+    try {
+      const httpAdapter = this.httpAdapterHost.httpAdapter;
+      if (httpAdapter) {
+        const app = httpAdapter.getInstance();
+        const { join: join2 } = __require("path");
+        const express = __require("express");
+        app.use(express.static(join2(process.cwd(), "dist/client"), {
+          index: false,
+          maxAge: "1y"
+        }));
+        this.logger.log("\u2713 Static assets configured (dist/client)");
+      }
+    } catch (error) {
+      this.logger.warn(`Failed to setup static assets: ${error.message}`);
+    }
+  }
+};
+ViteInitializerService = _ts_decorate5([
+  Injectable(),
+  _ts_param3(2, Optional()),
+  _ts_param3(2, Inject("VITE_CONFIG")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof RenderService === "undefined" ? Object : RenderService,
+    typeof HttpAdapterHost === "undefined" ? Object : HttpAdapterHost,
+    typeof ViteConfig === "undefined" ? Object : ViteConfig
+  ])
+], ViteInitializerService);
+
+// src/render/render.module.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+var RenderModule = class _RenderModule {
+  static {
+    __name(this, "RenderModule");
+  }
+  /**
+  * Register the render module with optional configuration
+  *
+  * @param config - Optional render configuration
+  * @returns Dynamic module
+  *
+  * @example
+  * ```ts
+  * // Zero config - embedded mode by default (simplest)
+  * @Module({
+  *   imports: [RenderModule],
+  * })
+  *
+  * // Enable HMR with proxy mode
+  * @Module({
+  *   imports: [
+  *     RenderModule.register({
+  *       vite: { mode: 'proxy', port: 5173 }
+  *     })
+  *   ],
+  * })
+  *
+  * // Enable streaming SSR
+  * RenderModule.register({ mode: 'stream' })
+  *
+  * // Custom error pages
+  * RenderModule.register({
+  *   mode: 'stream',
+  *   errorPageDevelopment: MyCustomDevErrorPage,
+  *   errorPageProduction: MyCustomProdErrorPage,
+  * })
+  * ```
+  */
+  static register(config) {
+    const providers = [
+      RenderService,
+      TemplateParserService,
+      StreamingErrorHandler,
+      ViteInitializerService,
+      {
+        provide: APP_INTERCEPTOR,
+        useClass: RenderInterceptor
+      }
+    ];
+    providers.push({
+      provide: "VITE_CONFIG",
+      useValue: config?.vite || {}
+    });
+    if (config?.mode) {
+      providers.push({
+        provide: "SSR_MODE",
+        useValue: config.mode
+      });
+    }
+    if (config?.errorPageDevelopment) {
+      providers.push({
+        provide: "ERROR_PAGE_DEVELOPMENT",
+        useValue: config.errorPageDevelopment
+      });
+    }
+    if (config?.errorPageProduction) {
+      providers.push({
+        provide: "ERROR_PAGE_PRODUCTION",
+        useValue: config.errorPageProduction
+      });
+    }
+    if (config?.defaultHead) {
+      providers.push({
+        provide: "DEFAULT_HEAD",
+        useValue: config.defaultHead
+      });
+    }
+    return {
+      global: true,
+      module: _RenderModule,
+      providers,
+      exports: [
+        RenderService
+      ]
+    };
+  }
+  /**
+  * Register the render module asynchronously with dynamic configuration
+  *
+  * Use this when you need to inject services (e.g., load config from database)
+  *
+  * @param options - Async configuration options
+  * @returns Dynamic module
+  *
+  * @example
+  * ```ts
+  * // Load default head from database
+  * RenderModule.registerAsync({
+  *   imports: [TenantModule],
+  *   inject: [TenantRepository],
+  *   useFactory: async (tenantRepo: TenantRepository) => {
+  *     const tenant = await tenantRepo.findDefaultTenant();
+  *     return {
+  *       defaultHead: {
+  *         title: tenant.appName,
+  *         description: tenant.description,
+  *         links: [
+  *           { rel: 'icon', href: tenant.favicon }
+  *         ]
+  *       }
+  *     };
+  *   }
+  * })
+  * ```
+  */
+  static registerAsync(options) {
+    const configProvider = {
+      provide: "RENDER_CONFIG",
+      useFactory: options.useFactory,
+      inject: options.inject || []
+    };
+    const providers = [
+      configProvider,
+      RenderService,
+      TemplateParserService,
+      StreamingErrorHandler,
+      ViteInitializerService,
+      {
+        provide: APP_INTERCEPTOR,
+        useClass: RenderInterceptor
+      },
+      // Vite configuration provider - reads from config
+      {
+        provide: "VITE_CONFIG",
+        useFactory: /* @__PURE__ */ __name((config) => config?.vite || {}, "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      // SSR mode provider - reads from config
+      {
+        provide: "SSR_MODE",
+        useFactory: /* @__PURE__ */ __name((config) => config?.mode, "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      // Error page providers - read from config
+      {
+        provide: "ERROR_PAGE_DEVELOPMENT",
+        useFactory: /* @__PURE__ */ __name((config) => config?.errorPageDevelopment, "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      {
+        provide: "ERROR_PAGE_PRODUCTION",
+        useFactory: /* @__PURE__ */ __name((config) => config?.errorPageProduction, "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      // Default head provider - reads from config
+      {
+        provide: "DEFAULT_HEAD",
+        useFactory: /* @__PURE__ */ __name((config) => config?.defaultHead, "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      }
+    ];
+    return {
+      global: true,
+      module: _RenderModule,
+      imports: options.imports || [],
+      providers,
+      exports: [
+        RenderService
+      ]
+    };
+  }
+};
+RenderModule = _ts_decorate6([
+  Global(),
+  Module({
+    providers: [
+      RenderService,
+      TemplateParserService,
+      StreamingErrorHandler,
+      ViteInitializerService,
+      {
+        provide: APP_INTERCEPTOR,
+        useClass: RenderInterceptor
+      },
+      {
+        provide: "VITE_CONFIG",
+        useValue: {}
+      }
+    ],
+    exports: [
+      RenderService
+    ]
+  })
+], RenderModule);
+
+export { ErrorPageDevelopment, ErrorPageProduction, RenderInterceptor, RenderModule, RenderService, StreamingErrorHandler, TemplateParserService };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map