@moostjs/vite 0.6.2 → 0.6.4

package/README.md

@@ -2,13 +2,19 @@
 
 Vite dev plugin for [Moost](https://moost.org). Enables hot module replacement for Moost HTTP applications during development, automatic adapter detection, and production build configuration.
 
+Supports two modes:
+- **Backend mode** (default) — Moost owns the server, Vite provides HMR and TypeScript transforms
+- **Middleware mode** — Vite serves the frontend (Vue, React, etc.), Moost handles API routes as middleware
+
 ## Installation
 
 ```bash
 npm install @moostjs/vite --save-dev
 ```
 
-## Quick Start
+## Backend Mode (default)
+
+For pure API servers where Moost handles all HTTP requests. Vite is used as a dev tool for HMR and decorator transforms.
 
 ```ts
 // vite.config.ts
@@ -19,23 +25,176 @@ export default defineConfig({
   plugins: [
     moostVite({
       entry: './src/main.ts',
-      port: 3000,
     }),
   ],
 })
 ```
 
+```ts
+// src/main.ts
+import { Moost, Param } from 'moost'
+import { MoostHttp, Get } from '@moostjs/event-http'
+
+class App extends Moost {
+  @Get('hello/:name')
+  hello(@Param('name') name: string) {
+    return { message: `Hello ${name}!` }
+  }
+}
+
+const app = new App()
+const http = new MoostHttp()
+app.adapter(http).listen(3000)
+app.init()
+```
+
+Run with `vite dev`. The plugin patches `MoostHttp.listen()` so Moost doesn't bind a port — Vite's dev server handles HTTP instead. Controller changes trigger HMR with automatic DI cleanup.
+
+## Middleware Mode
+
+For fullstack apps where Vite serves the frontend and Moost handles API routes. Unmatched requests fall through to Vite's default handler (static assets, Vue/React pages, HMR client).
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { moostVite } from '@moostjs/vite'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    moostVite({
+      entry: './src/api/main.ts',
+      middleware: true,
+    }),
+  ],
+})
+```
+
+```ts
+// src/api/main.ts
+import { Moost, Param } from 'moost'
+import { MoostHttp, Get } from '@moostjs/event-http'
+
+class ApiController extends Moost {
+  @Get('api/hello/:name')
+  hello(@Param('name') name: string) {
+    return { message: `Hello ${name}!` }
+  }
+}
+
+const app = new ApiController()
+const http = new MoostHttp()
+app.adapter(http).listen(3000)
+app.init()
+```
+
+Requests matching Moost routes (e.g. `/api/hello/world`) are handled by Moost with the full pipeline (interceptors, DI, validation). Everything else (`/`, `/about`, static assets) falls through to Vite.
+
+The optional `prefix` option adds a fast-path check — requests not matching the prefix skip Moost entirely:
+
+```ts
+moostVite({
+  entry: './src/api/main.ts',
+  middleware: true,
+  prefix: '/api',
+})
+```
+
+## SSR Mode
+
+Add `ssrEntry` to enable server-side rendering. The plugin handles everything automatically — SSR rendering in dev, multi-environment builds for production:
+
+```ts
+moostVite({
+  entry: '/src/main.ts',
+  middleware: true,
+  prefix: '/api',
+  ssrEntry: '/src/entry-server.ts',
+})
+```
+
+In dev, the plugin adds an SSR fallback middleware that renders pages on the server using your `entry-server.ts`. In production, `vite build` produces three bundles in a single pass:
+
+- **client** — optimized browser assets (`dist/client/`)
+- **ssr** — server-side render function (`dist/server/ssr/`)
+- **server** — production Node.js server (`dist/server/server.js`)
+
+### SPA Mode
+
+Omit `ssrEntry` and Vite serves the app as a standard SPA. The production build still generates a server that serves static files and API routes — it just skips server-side rendering.
+
+### Custom Server Entry
+
+By default, `vite build` auto-generates a minimal production server. If you need custom middleware (compression, auth, logging), provide your own server file:
+
+```ts
+moostVite({
+  entry: '/src/main.ts',
+  middleware: true,
+  prefix: '/api',
+  ssrEntry: '/src/entry-server.ts',
+  serverEntry: './server.ts',
+})
+```
+
+```ts
+// server.ts
+import { createSSRServer } from '@moostjs/vite/server'
+
+const app = await createSSRServer()
+// app.use(compression())
+await app.listen()
+```
+
+`createSSRServer` handles dev/prod branching — in dev it creates a Vite dev server, in prod it serves built assets with `sirv`.
+
+## SSR Local Fetch
+
+When `ssrFetch` is enabled (default: `true`), the plugin patches `globalThis.fetch` so that local paths are routed in-process through Moost instead of making a real HTTP request. This is useful for SSR where server-side code fetches from its own API:
+
+```ts
+// During SSR rendering:
+const res = await fetch('/api/hello/world')
+// → Routed in-process to Moost, no TCP round-trip
+```
+
+If no Moost route matches, the call falls back to the original `fetch`. External URLs (e.g. `https://api.example.com`) always go through real HTTP.
+
+Disable with `ssrFetch: false` when running behind Nitro or another framework that manages fetch routing itself.
+
+## Hot Module Replacement
+
+Both modes support full HMR for Moost controllers:
+
+1. File change detected → Vite invalidates the module graph
+2. Moost DI container is cleaned up (stale instances ejected, dependants cascade)
+3. The SSR entry is re-imported → Moost re-initializes with updated controllers
+4. New requests use the updated code — no server restart needed
+
+The plugin injects a `__VITE_ID` decorator on `@Injectable` and `@Controller` classes to track which file each class belongs to, enabling precise cleanup during hot reloads.
+
 ## Options
 
-| Option      | Type                | Default       | Description                       |
-| ----------- | ------------------- | ------------- | --------------------------------- |
-| `entry`     | `string`            | —             | Application entry file (required) |
-| `port`      | `number`            | `3000`        | Dev server port                   |
-| `host`      | `string`            | `'localhost'` | Dev server host                   |
-| `outDir`    | `string`            | `'dist'`      | Build output directory            |
-| `format`    | `'cjs' \| 'esm'`    | `'esm'`       | Output module format              |
-| `sourcemap` | `boolean`           | `true`        | Generate source maps              |
-| `externals` | `boolean \| object` | `true`        | Configure external dependencies   |
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `entry` | `string` | — | Application entry file (required) |
+| `port` | `number` | `3000` | Dev server port (backend mode only) |
+| `host` | `string` | `'localhost'` | Dev server host (backend mode only) |
+| `outDir` | `string` | `'dist'` | Build output directory (backend mode only) |
+| `format` | `'cjs' \| 'esm'` | `'esm'` | Output module format (backend mode only) |
+| `sourcemap` | `boolean` | `true` | Generate source maps (backend mode only) |
+| `externals` | `boolean \| object` | `true` | Configure external dependencies (backend mode only) |
+| `onEject` | `function` | — | Hook to control DI instance ejection during HMR |
+| `ssrFetch` | `boolean` | `true` | Enable local fetch interception for SSR |
+| `middleware` | `boolean` | `false` | Run Moost as Connect middleware (Vite serves frontend) |
+| `prefix` | `string` | — | URL prefix filter for middleware mode (e.g. `'/api'`) |
+| `ssrEntry` | `string` | — | Vue/React SSR entry module (e.g. `'/src/entry-server.ts'`) |
+| `ssrOutlet` | `string` | `'<!--ssr-outlet-->'` | HTML placeholder for SSR-rendered content |
+| `ssrState` | `string` | `'<!--ssr-state-->'` | HTML placeholder for SSR state transfer script |
+| `serverEntry` | `string` | — | Custom production server entry file (e.g. `'./server.ts'`) |
+
+Options marked "backend mode only" are ignored when `middleware: true` — the user's `vite.config.ts` controls build/server configuration in middleware mode.
 
 ## License
 

package/dist/index.cjs

@@ -21,13 +21,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const magic_string = __toESM(require("magic-string"));
 const node_fs = __toESM(require("node:fs"));
+const node_path = __toESM(require("node:path"));
+const vite = __toESM(require("vite"));
+const magic_string = __toESM(require("magic-string"));
 const node_module = __toESM(require("node:module"));
 const moost = __toESM(require("moost"));
 
 //#region packages/vite/src/utils.ts
 const PLUGIN_NAME = "moost-vite";
+const DEFAULT_SSR_OUTLET = "<!--ssr-outlet-->";
+const DEFAULT_SSR_STATE = "<!--ssr-state-->";
+function entryBasename(entry) {
+	return entry.split("/").pop().replace(/\.ts$/, ".js");
+}
 /**
 * Recursively gathers all importer modules upstream from a given module.
 *
@@ -45,10 +52,14 @@ const logger = (0, moost.createLogger)({ level: 99 }).createTopic("\x1B[2m\x1B[3
 function getLogger() {
 	return logger;
 }
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function getExternals({ node, workspace }) {
 	const pkg = JSON.parse((0, node_fs.readFileSync)("package.json", "utf8").toString());
-	const externals = workspace ? Object.keys(pkg.dependencies || {}) : Object.entries(pkg.dependencies || {}).filter(([key, ver]) => !ver.startsWith("workspace:")).map((i) => i[0]);
-	if (node) externals.push(...node_module.builtinModules, ...node_module.builtinModules.map((m) => `node:${m}`));
+	const packageNames = workspace ? Object.keys(pkg.dependencies || {}) : Object.entries(pkg.dependencies || {}).filter(([key, ver]) => !ver.startsWith("workspace:")).map((i) => i[0]);
+	const externals = packageNames.map((name) => /* @__PURE__ */ new RegExp(`^${escapeRegex(name)}(/|$)`));
+	if (node) externals.push(...node_module.builtinModules.map((m) => /* @__PURE__ */ new RegExp(`^${escapeRegex(m)}(/|$)`)), ...node_module.builtinModules.map((m) => /* @__PURE__ */ new RegExp(`^node:${escapeRegex(m)}(/|$)`)));
 	return externals;
 }
 
@@ -72,7 +83,7 @@ function getExternals({ node, workspace }) {
 			const constructorName$1 = `Moost${adapter.charAt(0).toUpperCase() + adapter.slice(1)}`;
 			getLogger().log(`🔍 Extracting Adapter "${constructorName$1}"`);
 			this.constructor = module$1[constructorName$1];
-			if (onInit && this.constructor) onInit(this.constructor);
+			if (onInit && this.constructor) onInit(this.constructor, module$1);
 		},
 		compare(c) {
 			if (this.detected && this.constructor) return this.constructor === c || c instanceof this.constructor || c.prototype instanceof this.constructor;
@@ -311,16 +322,44 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 *
 * @param {TMoostViteDevOptions} options - Configuration options for the Moost Vite plugin.
 * @returns {PluginOption} The configured Vite plugin.
-*/ function moostVite(options) {
+*/ const DEFAULT_SERVER_ENTRY_CODE = `import { createSSRServer } from '@moostjs/vite/server'
+const app = await createSSRServer()
+await app.listen()
+`;
+function generatedServerEntry(root) {
+	const dir = (0, node_path.resolve)(root || process.cwd(), "node_modules", ".moost-vite");
+	(0, node_fs.mkdirSync)(dir, { recursive: true });
+	const entryPath = (0, node_path.resolve)(dir, "server-entry.mjs");
+	(0, node_fs.writeFileSync)(entryPath, DEFAULT_SERVER_ENTRY_CODE);
+	return entryPath;
+}
+function moostVite(options) {
 	const isTest = process.env.NODE_ENV === "test";
 	const isProd = process.env.NODE_ENV === "production";
 	const externals = options.externals ?? true;
+	let prefix = options.prefix;
+	if (prefix) {
+		if (!prefix.startsWith("/")) prefix = `/${prefix}`;
+		if (prefix.endsWith("/")) prefix = prefix.slice(0, -1);
+	}
+	const prefixSlash = prefix ? prefix + "/" : void 0;
+	const prefixQuery = prefix ? prefix + "?" : void 0;
 	let moostMiddleware = null;
+	let localFetchTeardown = null;
+	/** In middleware mode: maps req → next() for the onNoMatch callback */ const pendingNextMap = /* @__PURE__ */ new WeakMap();
 	const adapters = isTest ? [] : [
-		createAdapterDetector("http", (MoostHttp) => {
+		createAdapterDetector("http", (MoostHttp, moduleExports) => {
 			MoostHttp.prototype.listen = function(...args) {
 				logger$1.log(`🔌 Overtaking HTTP.listen`);
-				moostMiddleware = this.getServerCb();
+				if (options.middleware) moostMiddleware = this.getServerCb((req) => {
+					pendingNextMap.get(req)?.();
+				});
+				else moostMiddleware = this.getServerCb();
+				if (options.ssrFetch !== false && moduleExports?.enableLocalFetch) {
+					if (localFetchTeardown) localFetchTeardown();
+					localFetchTeardown = moduleExports.enableLocalFetch(this);
+					logger$1.log(`🔀 Local fetch enabled for SSR`);
+				}
 				setTimeout(() => {
 					args.filter((a) => typeof a === "function").forEach((a) => a());
 				}, 1);
@@ -337,17 +376,69 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 		name: PLUGIN_NAME,
 		enforce: "pre",
 		config(cfg) {
+			if (options.middleware) {
+				const defaultExternals = getExternals({
+					node: true,
+					workspace: true
+				});
+				const serverDefines = {
+					"process.env.MOOST_DEFERRED_ENV": "\"production\"",
+					__MOOST_ENTRY__: JSON.stringify(options.entry),
+					__MOOST_PREFIX__: JSON.stringify(prefix || "/api")
+				};
+				const serverEntry = options.serverEntry || generatedServerEntry(cfg.root);
+				const ssrInput = { server: serverEntry };
+				if (options.ssrEntry) {
+					const ssrBasename = entryBasename(options.ssrEntry);
+					ssrInput[`ssr/${ssrBasename.replace(/\.js$/, "")}`] = options.ssrEntry;
+					serverDefines.__MOOST_SSR_ENTRY__ = JSON.stringify(`./ssr/${ssrBasename}`);
+					serverDefines.__MOOST_SSR_OUTLET__ = JSON.stringify(options.ssrOutlet || DEFAULT_SSR_OUTLET);
+					serverDefines.__MOOST_SSR_STATE__ = JSON.stringify(options.ssrState || DEFAULT_SSR_STATE);
+				}
+				const outDir = cfg.build?.outDir || "dist";
+				return {
+					...options.ssrEntry && { appType: "custom" },
+					builder: { async buildApp(builder) {
+						(0, node_fs.rmSync)((0, node_path.resolve)(cfg.root || process.cwd(), outDir), {
+							recursive: true,
+							force: true
+						});
+						for (const env of Object.values(builder.environments)) await builder.build(env);
+					} },
+					environments: {
+						client: { build: {
+							outDir: `${outDir}/client`,
+							emptyOutDir: false,
+							...options.ssrEntry && { ssrManifest: true }
+						} },
+						ssr: {
+							build: {
+								outDir: `${outDir}/server`,
+								emptyOutDir: false,
+								minify: false,
+								sourcemap: !!(options.sourcemap ?? true),
+								rollupOptions: {
+									input: ssrInput,
+									external: (id) => {
+										if (id === "@moostjs/vite/server") return false;
+										return defaultExternals.some((ext) => ext.test(id));
+									},
+									output: { format: "esm" }
+								}
+							},
+							define: serverDefines
+						}
+					}
+				};
+			}
 			const entry = cfg.build?.rollupOptions?.input || options.entry;
-			const outfile = typeof entry === "string" ? entry.split("/").pop().replace(/\.ts$/, ".js") : void 0;
+			const outfile = typeof entry === "string" ? entryBasename(entry) : void 0;
 			return {
 				server: {
 					port: cfg.server?.port || options.port || 3e3,
 					host: cfg.server?.host || options.host
 				},
-				optimizeDeps: {
-					noDiscovery: cfg.optimizeDeps?.noDiscovery === void 0 ? true : cfg.optimizeDeps.noDiscovery,
-					exclude: cfg.optimizeDeps?.exclude || ["@swc/core"]
-				},
+				optimizeDeps: { noDiscovery: cfg.optimizeDeps?.noDiscovery === void 0 ? true : cfg.optimizeDeps.noDiscovery },
 				build: {
 					target: cfg.build?.target || "node",
 					outDir: cfg.build?.outDir || options.outDir || "dist",
@@ -369,6 +460,17 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 				}
 			};
 		},
+		configResolved(config) {
+			config.__moostViteOptions = {
+				entry: options.entry,
+				ssrEntry: options.ssrEntry,
+				serverEntry: options.serverEntry,
+				prefix,
+				port: options.port,
+				ssrOutlet: options.ssrOutlet,
+				ssrState: options.ssrState
+			};
+		},
 		async transform(code, id) {
 			if (!id.endsWith(".ts")) return null;
 			for (const adapter of adapters) if (!adapter.detected && adapter.regex.test(code)) await adapter.init();
@@ -399,19 +501,32 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 			};
 		},
 		async configureServer(server) {
-			for (const adapter of adapters) adapter.ssrLoadModule = (id) => server.ssrLoadModule(id);
+			const runner = (0, vite.createServerModuleRunner)(server.environments.ssr);
+			const ssrImport = (id) => runner.import(id);
+			for (const adapter of adapters) adapter.ssrLoadModule = ssrImport;
 			moostRestartCleanup(adapters, options.onEject);
-			await server.ssrLoadModule(options.entry);
+			await ssrImport(options.entry);
 			server.middlewares.use(async (req, res, next) => {
 				if (reloadRequired) {
 					reloadRequired = false;
 					console.log();
 					logger$1.debug("🚀 Reloading Moost App...");
 					console.log();
-					await server.ssrLoadModule(options.entry);
-					await new Promise((resolve) => setTimeout(resolve, 1));
+					await ssrImport(options.entry);
+					await new Promise((resolve$1) => setTimeout(resolve$1, 1));
+				}
+				if (options.middleware && prefix) {
+					const url = req.url || "";
+					if (url !== prefix && !url.startsWith(prefixSlash) && !url.startsWith(prefixQuery)) return next();
+				}
+				if (moostMiddleware) {
+					if (options.middleware) {
+						pendingNextMap.set(req, next);
+						moostMiddleware(req, res);
+						return;
+					}
+					return moostMiddleware(req, res);
 				}
-				if (moostMiddleware) return moostMiddleware(req, res);
 				next();
 			});
 		},
@@ -427,6 +542,10 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 						this.environment.moduleGraph.invalidateModule(mod);
 					}
 					moostMiddleware = null;
+					if (localFetchTeardown) {
+						localFetchTeardown();
+						localFetchTeardown = null;
+					}
 					moostRestartCleanup(adapters, options.onEject, cleanupInstances);
 					reloadRequired = true;
 				}
@@ -441,7 +560,35 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 		delete pluginConfig.transform;
 		delete pluginConfig.hotUpdate;
 	}
-	return pluginConfig;
+	const ssrFallbackPlugin = !isProd && !isTest && options.middleware && options.ssrEntry ? {
+		name: `${PLUGIN_NAME}:ssr-fallback`,
+		async configureServer(server) {
+			const ssrOutlet = options.ssrOutlet || DEFAULT_SSR_OUTLET;
+			const ssrState = options.ssrState || DEFAULT_SSR_STATE;
+			const fs = await import("node:fs/promises");
+			return () => {
+				server.middlewares.use(async (req, res, next) => {
+					if (req.method !== "GET") return next();
+					const url = req.originalUrl || req.url || "/";
+					try {
+						let template = await fs.readFile((0, node_path.resolve)(process.cwd(), "index.html"), "utf-8");
+						template = await server.transformIndexHtml(url, template);
+						const { render } = await server.ssrLoadModule(options.ssrEntry);
+						const { html: appHtml, state } = await render(url);
+						res.statusCode = 200;
+						res.setHeader("Content-Type", "text/html");
+						res.end(template.replace(ssrOutlet, appHtml).replace(ssrState, state ? `<script>window.__SSR_STATE__=${state}</script>` : ""));
+					} catch (e) {
+						server.ssrFixStacktrace(e);
+						console.error(e);
+						res.statusCode = 500;
+						res.end(e.message);
+					}
+				});
+			};
+		}
+	} : null;
+	return [pluginConfig, ssrFallbackPlugin];
 }
 
 //#endregion

package/dist/index.d.ts

@@ -65,26 +65,62 @@ interface TMoostViteDevOptions {
         workspace?: boolean;
     } | boolean;
     onEject?: (instance: object, dependency: Function) => boolean;
+    /**
+     * Whether to enable local fetch interception for SSR.
+     * When enabled, `fetch('/path')` calls are routed to the Moost HTTP adapter
+     * in-process instead of making a network request.
+     *
+     * Set to `false` when running behind Nitro or another framework that
+     * manages fetch routing itself.
+     *
+     * Default: `true`.
+     */
+    ssrFetch?: boolean;
+    /**
+     * Run Moost as Connect middleware instead of taking over the server.
+     * When enabled, Moost handles only matching routes (guarded by `prefix`),
+     * and unmatched requests fall through to Vite's default handler
+     * (static assets, Vue/React pages, HMR client).
+     *
+     * Use this for fullstack apps where Vite serves the frontend (Vue, React, etc.)
+     * and Moost handles API routes.
+     *
+     * Default: `false`.
+     */
+    middleware?: boolean;
+    /**
+     * URL prefix for Moost API routes in middleware mode.
+     * Only requests starting with this prefix are dispatched to Moost.
+     * Ignored when `middleware` is `false`.
+     *
+     * Example: `'/api'`
+     */
+    prefix?: string;
+    /**
+     * Vue/React SSR entry module path. Used by the SSR server helper
+     * (`@moostjs/vite/server`) for server-side rendering.
+     *
+     * Example: `'/src/entry-server.ts'`
+     */
+    ssrEntry?: string;
+    /**
+     * HTML placeholder for SSR-rendered content.
+     * Default: `'<!--ssr-outlet-->'`
+     */
+    ssrOutlet?: string;
+    /**
+     * HTML placeholder for SSR state transfer script.
+     * Default: `'<!--ssr-state-->'`
+     */
+    ssrState?: string;
+    /**
+     * Path to a custom server entry file (e.g., `'./server.ts'`).
+     * When provided, this file is used as the production server build entry.
+     * When omitted in middleware mode, the plugin auto-generates a minimal
+     * production server that serves static files + Moost API (+ SSR if configured).
+     */
+    serverEntry?: string;
 }
-/**
- * The main Vite plugin for integrating Moost applications.
- *
- * Features:
- * - **Adapter Detection**: Detects Moost adapter usage (`http`, `cli`, `wf`) and applies relevant configurations.
- * - **Dev Mode Middleware**:
- *   - Patches `MoostHttp.prototype.listen` to register a custom middleware for serving the app via Vite's dev server instead of binding to a port.
- *   - Handles Moost state cleanup and hot module replacement (HMR) during development.
- * - **Class Tracking**: Injects a `__VITE_ID()` decorator into exported classes to enable tracking and cleanup during hot reloads.
- * - **Externals Support**:
- *   - Allows marking Node.js built-in modules and dependencies from `package.json` (optionally excluding workspace dependencies) as external during builds.
- *   - Configured via the `externals` option, which helps reduce bundle size and ensures compatibility with runtime environments.
- * - **Build and Test Friendly**:
- *   - Avoids interfering with Vitest runs by skipping dev-specific behaviors during tests.
- *   - Ensures proper SSR entry setup and Rollup configurations for production builds.
- *
- * @param {TMoostViteDevOptions} options - Configuration options for the Moost Vite plugin.
- * @returns {PluginOption} The configured Vite plugin.
- */
 declare function moostVite(options: TMoostViteDevOptions): PluginOption;
 
 export { moostVite };

package/dist/index.mjs

@@ -1,10 +1,17 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createServerModuleRunner } from "vite";
 import MagicString from "magic-string";
-import { readFileSync } from "node:fs";
 import { builtinModules } from "node:module";
 import { Moost, clearGlobalWooks, createLogger, getMoostInfact, getMoostMate } from "moost";
 
 //#region packages/vite/src/utils.ts
 const PLUGIN_NAME = "moost-vite";
+const DEFAULT_SSR_OUTLET = "<!--ssr-outlet-->";
+const DEFAULT_SSR_STATE = "<!--ssr-state-->";
+function entryBasename(entry) {
+	return entry.split("/").pop().replace(/\.ts$/, ".js");
+}
 /**
 * Recursively gathers all importer modules upstream from a given module.
 *
@@ -22,10 +29,14 @@ const logger = createLogger({ level: 99 }).createTopic("\x1B[2m\x1B[36m" + PLUGI
 function getLogger() {
 	return logger;
 }
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function getExternals({ node, workspace }) {
 	const pkg = JSON.parse(readFileSync("package.json", "utf8").toString());
-	const externals = workspace ? Object.keys(pkg.dependencies || {}) : Object.entries(pkg.dependencies || {}).filter(([key, ver]) => !ver.startsWith("workspace:")).map((i) => i[0]);
-	if (node) externals.push(...builtinModules, ...builtinModules.map((m) => `node:${m}`));
+	const packageNames = workspace ? Object.keys(pkg.dependencies || {}) : Object.entries(pkg.dependencies || {}).filter(([key, ver]) => !ver.startsWith("workspace:")).map((i) => i[0]);
+	const externals = packageNames.map((name) => /* @__PURE__ */ new RegExp(`^${escapeRegex(name)}(/|$)`));
+	if (node) externals.push(...builtinModules.map((m) => /* @__PURE__ */ new RegExp(`^${escapeRegex(m)}(/|$)`)), ...builtinModules.map((m) => /* @__PURE__ */ new RegExp(`^node:${escapeRegex(m)}(/|$)`)));
 	return externals;
 }
 
@@ -49,7 +60,7 @@ function getExternals({ node, workspace }) {
 			const constructorName$1 = `Moost${adapter.charAt(0).toUpperCase() + adapter.slice(1)}`;
 			getLogger().log(`🔍 Extracting Adapter "${constructorName$1}"`);
 			this.constructor = module[constructorName$1];
-			if (onInit && this.constructor) onInit(this.constructor);
+			if (onInit && this.constructor) onInit(this.constructor, module);
 		},
 		compare(c) {
 			if (this.detected && this.constructor) return this.constructor === c || c instanceof this.constructor || c.prototype instanceof this.constructor;
@@ -288,16 +299,44 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 *
 * @param {TMoostViteDevOptions} options - Configuration options for the Moost Vite plugin.
 * @returns {PluginOption} The configured Vite plugin.
-*/ function moostVite(options) {
+*/ const DEFAULT_SERVER_ENTRY_CODE = `import { createSSRServer } from '@moostjs/vite/server'
+const app = await createSSRServer()
+await app.listen()
+`;
+function generatedServerEntry(root) {
+	const dir = resolve(root || process.cwd(), "node_modules", ".moost-vite");
+	mkdirSync(dir, { recursive: true });
+	const entryPath = resolve(dir, "server-entry.mjs");
+	writeFileSync(entryPath, DEFAULT_SERVER_ENTRY_CODE);
+	return entryPath;
+}
+function moostVite(options) {
 	const isTest = false;
 	const isProd = false;
 	const externals = options.externals ?? true;
+	let prefix = options.prefix;
+	if (prefix) {
+		if (!prefix.startsWith("/")) prefix = `/${prefix}`;
+		if (prefix.endsWith("/")) prefix = prefix.slice(0, -1);
+	}
+	const prefixSlash = prefix ? prefix + "/" : void 0;
+	const prefixQuery = prefix ? prefix + "?" : void 0;
 	let moostMiddleware = null;
+	let localFetchTeardown = null;
+	/** In middleware mode: maps req → next() for the onNoMatch callback */ const pendingNextMap = /* @__PURE__ */ new WeakMap();
 	const adapters = isTest ? [] : [
-		createAdapterDetector("http", (MoostHttp) => {
+		createAdapterDetector("http", (MoostHttp, moduleExports) => {
 			MoostHttp.prototype.listen = function(...args) {
 				logger$1.log(`🔌 Overtaking HTTP.listen`);
-				moostMiddleware = this.getServerCb();
+				if (options.middleware) moostMiddleware = this.getServerCb((req) => {
+					pendingNextMap.get(req)?.();
+				});
+				else moostMiddleware = this.getServerCb();
+				if (options.ssrFetch !== false && moduleExports?.enableLocalFetch) {
+					if (localFetchTeardown) localFetchTeardown();
+					localFetchTeardown = moduleExports.enableLocalFetch(this);
+					logger$1.log(`🔀 Local fetch enabled for SSR`);
+				}
 				setTimeout(() => {
 					args.filter((a) => typeof a === "function").forEach((a) => a());
 				}, 1);
@@ -314,17 +353,69 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 		name: PLUGIN_NAME,
 		enforce: "pre",
 		config(cfg) {
+			if (options.middleware) {
+				const defaultExternals = getExternals({
+					node: true,
+					workspace: true
+				});
+				const serverDefines = {
+					"process.env.MOOST_DEFERRED_ENV": "\"production\"",
+					__MOOST_ENTRY__: JSON.stringify(options.entry),
+					__MOOST_PREFIX__: JSON.stringify(prefix || "/api")
+				};
+				const serverEntry = options.serverEntry || generatedServerEntry(cfg.root);
+				const ssrInput = { server: serverEntry };
+				if (options.ssrEntry) {
+					const ssrBasename = entryBasename(options.ssrEntry);
+					ssrInput[`ssr/${ssrBasename.replace(/\.js$/, "")}`] = options.ssrEntry;
+					serverDefines.__MOOST_SSR_ENTRY__ = JSON.stringify(`./ssr/${ssrBasename}`);
+					serverDefines.__MOOST_SSR_OUTLET__ = JSON.stringify(options.ssrOutlet || DEFAULT_SSR_OUTLET);
+					serverDefines.__MOOST_SSR_STATE__ = JSON.stringify(options.ssrState || DEFAULT_SSR_STATE);
+				}
+				const outDir = cfg.build?.outDir || "dist";
+				return {
+					...options.ssrEntry && { appType: "custom" },
+					builder: { async buildApp(builder) {
+						rmSync(resolve(cfg.root || process.cwd(), outDir), {
+							recursive: true,
+							force: true
+						});
+						for (const env of Object.values(builder.environments)) await builder.build(env);
+					} },
+					environments: {
+						client: { build: {
+							outDir: `${outDir}/client`,
+							emptyOutDir: false,
+							...options.ssrEntry && { ssrManifest: true }
+						} },
+						ssr: {
+							build: {
+								outDir: `${outDir}/server`,
+								emptyOutDir: false,
+								minify: false,
+								sourcemap: !!(options.sourcemap ?? true),
+								rollupOptions: {
+									input: ssrInput,
+									external: (id) => {
+										if (id === "@moostjs/vite/server") return false;
+										return defaultExternals.some((ext) => ext.test(id));
+									},
+									output: { format: "esm" }
+								}
+							},
+							define: serverDefines
+						}
+					}
+				};
+			}
 			const entry = cfg.build?.rollupOptions?.input || options.entry;
-			const outfile = typeof entry === "string" ? entry.split("/").pop().replace(/\.ts$/, ".js") : void 0;
+			const outfile = typeof entry === "string" ? entryBasename(entry) : void 0;
 			return {
 				server: {
 					port: cfg.server?.port || options.port || 3e3,
 					host: cfg.server?.host || options.host
 				},
-				optimizeDeps: {
-					noDiscovery: cfg.optimizeDeps?.noDiscovery === void 0 ? true : cfg.optimizeDeps.noDiscovery,
-					exclude: cfg.optimizeDeps?.exclude || ["@swc/core"]
-				},
+				optimizeDeps: { noDiscovery: cfg.optimizeDeps?.noDiscovery === void 0 ? true : cfg.optimizeDeps.noDiscovery },
 				build: {
 					target: cfg.build?.target || "node",
 					outDir: cfg.build?.outDir || options.outDir || "dist",
@@ -346,6 +437,17 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 				}
 			};
 		},
+		configResolved(config) {
+			config.__moostViteOptions = {
+				entry: options.entry,
+				ssrEntry: options.ssrEntry,
+				serverEntry: options.serverEntry,
+				prefix,
+				port: options.port,
+				ssrOutlet: options.ssrOutlet,
+				ssrState: options.ssrState
+			};
+		},
 		async transform(code, id) {
 			if (!id.endsWith(".ts")) return null;
 			for (const adapter of adapters) if (!adapter.detected && adapter.regex.test(code)) await adapter.init();
@@ -376,19 +478,32 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 			};
 		},
 		async configureServer(server) {
-			for (const adapter of adapters) adapter.ssrLoadModule = (id) => server.ssrLoadModule(id);
+			const runner = createServerModuleRunner(server.environments.ssr);
+			const ssrImport = (id) => runner.import(id);
+			for (const adapter of adapters) adapter.ssrLoadModule = ssrImport;
 			moostRestartCleanup(adapters, options.onEject);
-			await server.ssrLoadModule(options.entry);
+			await ssrImport(options.entry);
 			server.middlewares.use(async (req, res, next) => {
 				if (reloadRequired) {
 					reloadRequired = false;
 					console.log();
 					logger$1.debug("🚀 Reloading Moost App...");
 					console.log();
-					await server.ssrLoadModule(options.entry);
-					await new Promise((resolve) => setTimeout(resolve, 1));
+					await ssrImport(options.entry);
+					await new Promise((resolve$1) => setTimeout(resolve$1, 1));
+				}
+				if (options.middleware && prefix) {
+					const url = req.url || "";
+					if (url !== prefix && !url.startsWith(prefixSlash) && !url.startsWith(prefixQuery)) return next();
+				}
+				if (moostMiddleware) {
+					if (options.middleware) {
+						pendingNextMap.set(req, next);
+						moostMiddleware(req, res);
+						return;
+					}
+					return moostMiddleware(req, res);
 				}
-				if (moostMiddleware) return moostMiddleware(req, res);
 				next();
 			});
 		},
@@ -404,6 +519,10 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 						this.environment.moduleGraph.invalidateModule(mod);
 					}
 					moostMiddleware = null;
+					if (localFetchTeardown) {
+						localFetchTeardown();
+						localFetchTeardown = null;
+					}
 					moostRestartCleanup(adapters, options.onEject, cleanupInstances);
 					reloadRequired = true;
 				}
@@ -418,7 +537,35 @@ const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
 		delete pluginConfig.transform;
 		delete pluginConfig.hotUpdate;
 	}
-	return pluginConfig;
+	const ssrFallbackPlugin = !isProd && !isTest && options.middleware && options.ssrEntry ? {
+		name: `${PLUGIN_NAME}:ssr-fallback`,
+		async configureServer(server) {
+			const ssrOutlet = options.ssrOutlet || DEFAULT_SSR_OUTLET;
+			const ssrState = options.ssrState || DEFAULT_SSR_STATE;
+			const fs = await import("node:fs/promises");
+			return () => {
+				server.middlewares.use(async (req, res, next) => {
+					if (req.method !== "GET") return next();
+					const url = req.originalUrl || req.url || "/";
+					try {
+						let template = await fs.readFile(resolve(process.cwd(), "index.html"), "utf-8");
+						template = await server.transformIndexHtml(url, template);
+						const { render } = await server.ssrLoadModule(options.ssrEntry);
+						const { html: appHtml, state } = await render(url);
+						res.statusCode = 200;
+						res.setHeader("Content-Type", "text/html");
+						res.end(template.replace(ssrOutlet, appHtml).replace(ssrState, state ? `<script>window.__SSR_STATE__=${state}</script>` : ""));
+					} catch (e) {
+						server.ssrFixStacktrace(e);
+						console.error(e);
+						res.statusCode = 500;
+						res.end(e.message);
+					}
+				});
+			};
+		}
+	} : null;
+	return [pluginConfig, ssrFallbackPlugin];
 }
 
 //#endregion

package/dist/prod-server.cjs

@@ -0,0 +1,179 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+require("node:fs");
+require("node:module");
+const moost = __toESM(require("moost"));
+
+//#region packages/vite/src/utils.ts
+const PLUGIN_NAME = "moost-vite";
+const DEFAULT_SSR_OUTLET = "<!--ssr-outlet-->";
+const DEFAULT_SSR_STATE = "<!--ssr-state-->";
+const logger = (0, moost.createLogger)({ level: 99 }).createTopic("\x1B[2m\x1B[36m" + PLUGIN_NAME);
+
+//#endregion
+//#region packages/vite/src/prod-server.ts
+function stripUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+async function createSSRServer(options) {
+	const userMiddlewares = [];
+	const opts = options ? stripUndefined(options) : {};
+	const isProd = process.env.MOOST_DEFERRED_ENV === "production";
+	if (!isProd) {
+		const { createServer: createViteServer } = await import("vite");
+		const vite = await createViteServer();
+		const pluginOpts = vite.config.__moostViteOptions || {};
+		const config = {
+			...pluginOpts,
+			...opts
+		};
+		const ssrEntry = config.ssrEntry;
+		const ssrOutlet$1 = config.ssrOutlet || DEFAULT_SSR_OUTLET;
+		const ssrState$1 = config.ssrState || DEFAULT_SSR_STATE;
+		let ssrFallback = null;
+		if (ssrEntry) {
+			const fs$1 = await import("node:fs/promises");
+			const path$1 = await import("node:path");
+			ssrFallback = async (req, res, next) => {
+				if (req.method !== "GET") return next();
+				const url = req.originalUrl || req.url || "/";
+				try {
+					let template$1 = await fs$1.readFile(path$1.resolve(process.cwd(), "index.html"), "utf-8");
+					template$1 = await vite.transformIndexHtml(url, template$1);
+					const { render: render$1 } = await vite.ssrLoadModule(ssrEntry);
+					const { html: appHtml, state } = await render$1(url);
+					res.statusCode = 200;
+					res.setHeader("Content-Type", "text/html");
+					res.end(template$1.replace(ssrOutlet$1, appHtml).replace(ssrState$1, state ? `<script>window.__SSR_STATE__=${state}</script>` : ""));
+				} catch (e) {
+					vite.ssrFixStacktrace(e);
+					console.error(e);
+					res.statusCode = 500;
+					res.end(e.message);
+				}
+			};
+		}
+		return {
+			use(mw) {
+				userMiddlewares.push(mw);
+			},
+			async listen(_port) {
+				for (const mw of userMiddlewares) vite.middlewares.use(mw);
+				if (ssrFallback) vite.middlewares.use(ssrFallback);
+				await vite.listen();
+				vite.printUrls();
+			}
+		};
+	}
+	const fs = await import("node:fs/promises");
+	const path = await import("node:path");
+	const { createServer: createHttpServer } = await import("node:http");
+	const clientDir = opts.clientDir || path.resolve(__dirname, "../client");
+	const ssrOutlet = opts.ssrOutlet || (typeof __MOOST_SSR_OUTLET__ !== "undefined" ? __MOOST_SSR_OUTLET__ : "<!--ssr-outlet-->");
+	const ssrState = opts.ssrState || (typeof __MOOST_SSR_STATE__ !== "undefined" ? __MOOST_SSR_STATE__ : "<!--ssr-state-->");
+	let prefix = opts.prefix || __MOOST_PREFIX__;
+	if (!prefix.startsWith("/")) prefix = `/${prefix}`;
+	if (prefix.endsWith("/")) prefix = prefix.slice(0, -1);
+	const prefixSlash = prefix + "/";
+	const defaultPort = opts.port || Number(process.env.PORT) || 3e3;
+	const template = await fs.readFile(path.resolve(clientDir, "index.html"), "utf-8");
+	let render = null;
+	const hasSsr = typeof __MOOST_SSR_ENTRY__ !== "undefined" && !!__MOOST_SSR_ENTRY__;
+	if (hasSsr) {
+		const ssrModule = await import(
+		/* @vite-ignore */
+		__MOOST_SSR_ENTRY__);
+		render = ssrModule.render;
+	}
+	const { MoostHttp, enableLocalFetch } = await import("@moostjs/event-http");
+	let moostHandler = null;
+	let moostHttpInstance = null;
+	const origListen = MoostHttp.prototype.listen;
+	MoostHttp.prototype.listen = function(...args) {
+		moostHandler = this.getServerCb();
+		moostHttpInstance = this;
+		setTimeout(() => args.filter((a) => typeof a === "function").forEach((a) => a()), 1);
+		return Promise.resolve();
+	};
+	if (typeof opts.entry === "function") await opts.entry();
+	else if (typeof opts.entry === "string") await import(
+	/* @vite-ignore */
+	opts.entry);
+	else await import(__MOOST_ENTRY__);
+	MoostHttp.prototype.listen = origListen;
+	if (enableLocalFetch && moostHttpInstance) enableLocalFetch(moostHttpInstance);
+	const sirv = (await import("sirv")).default;
+	const serve = sirv(path.resolve(clientDir), { extensions: [] });
+	return {
+		use(mw) {
+			userMiddlewares.push(mw);
+		},
+		async listen(port) {
+			const p = port || defaultPort;
+			createHttpServer((req, res) => {
+				const url = req.url || "/";
+				let i = 0;
+				const runNext = () => {
+					if (i < userMiddlewares.length) {
+						userMiddlewares[i++](req, res, runNext);
+						return;
+					}
+					if (moostHandler && (url.startsWith(prefixSlash) || url === prefix || url.startsWith(prefix + "?"))) {
+						moostHandler(req, res);
+						return;
+					}
+					serve(req, res, async () => {
+						if (req.method !== "GET") {
+							res.statusCode = 404;
+							res.end();
+							return;
+						}
+						try {
+							if (render) {
+								const { html: appHtml, state } = await render(url);
+								res.statusCode = 200;
+								res.setHeader("Content-Type", "text/html");
+								res.end(template.replace(ssrOutlet, appHtml).replace(ssrState, state ? `<script>window.__SSR_STATE__=${state}</script>` : ""));
+							} else {
+								res.statusCode = 200;
+								res.setHeader("Content-Type", "text/html");
+								res.end(template);
+							}
+						} catch (e) {
+							console.error(e);
+							res.statusCode = 500;
+							res.end(e.message);
+						}
+					});
+				};
+				runNext();
+			}).listen(p, () => {
+				console.log(`Server running at http://localhost:${p}`);
+			});
+		}
+	};
+}
+
+//#endregion
+exports.createSSRServer = createSSRServer;

package/dist/prod-server.d.ts

@@ -0,0 +1,29 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+type TMiddleware = (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+interface TSSRServerOptions {
+    /** Override: lazy import for the Moost app entry. */
+    entry?: (() => Promise<unknown>) | string;
+    /** Override: SSR entry module path (e.g., '/src/entry-server.ts') */
+    ssrEntry?: string;
+    /** Override: URL prefix for API routes (e.g., '/api') */
+    prefix?: string;
+    /** Override: port number (default: process.env.PORT || 3000) */
+    port?: number;
+    /** Override: client build directory (default: 'dist/client') */
+    clientDir?: string;
+    /** Override: HTML placeholder for SSR content */
+    ssrOutlet?: string;
+    /** Override: HTML placeholder for SSR state */
+    ssrState?: string;
+}
+interface TSSRServer {
+    /** Add Connect-compatible middleware (runs in both dev and prod) */
+    use(middleware: TMiddleware): void;
+    /** Start the server */
+    listen(port?: number): Promise<void>;
+}
+declare function createSSRServer(options?: TSSRServerOptions): Promise<TSSRServer>;
+
+export { createSSRServer };
+export type { TSSRServer, TSSRServerOptions };

package/dist/prod-server.mjs

@@ -0,0 +1,156 @@
+import "node:fs";
+import "node:module";
+import { createLogger } from "moost";
+
+//#region packages/vite/src/utils.ts
+const PLUGIN_NAME = "moost-vite";
+const DEFAULT_SSR_OUTLET = "<!--ssr-outlet-->";
+const DEFAULT_SSR_STATE = "<!--ssr-state-->";
+const logger = createLogger({ level: 99 }).createTopic("\x1B[2m\x1B[36m" + PLUGIN_NAME);
+
+//#endregion
+//#region packages/vite/src/prod-server.ts
+function stripUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+async function createSSRServer(options) {
+	const userMiddlewares = [];
+	const opts = options ? stripUndefined(options) : {};
+	const isProd = process.env.MOOST_DEFERRED_ENV === "production";
+	if (!isProd) {
+		const { createServer: createViteServer } = await import("vite");
+		const vite = await createViteServer();
+		const pluginOpts = vite.config.__moostViteOptions || {};
+		const config = {
+			...pluginOpts,
+			...opts
+		};
+		const ssrEntry = config.ssrEntry;
+		const ssrOutlet$1 = config.ssrOutlet || DEFAULT_SSR_OUTLET;
+		const ssrState$1 = config.ssrState || DEFAULT_SSR_STATE;
+		let ssrFallback = null;
+		if (ssrEntry) {
+			const fs$1 = await import("node:fs/promises");
+			const path$1 = await import("node:path");
+			ssrFallback = async (req, res, next) => {
+				if (req.method !== "GET") return next();
+				const url = req.originalUrl || req.url || "/";
+				try {
+					let template$1 = await fs$1.readFile(path$1.resolve(process.cwd(), "index.html"), "utf-8");
+					template$1 = await vite.transformIndexHtml(url, template$1);
+					const { render: render$1 } = await vite.ssrLoadModule(ssrEntry);
+					const { html: appHtml, state } = await render$1(url);
+					res.statusCode = 200;
+					res.setHeader("Content-Type", "text/html");
+					res.end(template$1.replace(ssrOutlet$1, appHtml).replace(ssrState$1, state ? `<script>window.__SSR_STATE__=${state}</script>` : ""));
+				} catch (e) {
+					vite.ssrFixStacktrace(e);
+					console.error(e);
+					res.statusCode = 500;
+					res.end(e.message);
+				}
+			};
+		}
+		return {
+			use(mw) {
+				userMiddlewares.push(mw);
+			},
+			async listen(_port) {
+				for (const mw of userMiddlewares) vite.middlewares.use(mw);
+				if (ssrFallback) vite.middlewares.use(ssrFallback);
+				await vite.listen();
+				vite.printUrls();
+			}
+		};
+	}
+	const fs = await import("node:fs/promises");
+	const path = await import("node:path");
+	const { createServer: createHttpServer } = await import("node:http");
+	const clientDir = opts.clientDir || path.resolve(import.meta.dirname, "../client");
+	const ssrOutlet = opts.ssrOutlet || (typeof __MOOST_SSR_OUTLET__ !== "undefined" ? __MOOST_SSR_OUTLET__ : "<!--ssr-outlet-->");
+	const ssrState = opts.ssrState || (typeof __MOOST_SSR_STATE__ !== "undefined" ? __MOOST_SSR_STATE__ : "<!--ssr-state-->");
+	let prefix = opts.prefix || __MOOST_PREFIX__;
+	if (!prefix.startsWith("/")) prefix = `/${prefix}`;
+	if (prefix.endsWith("/")) prefix = prefix.slice(0, -1);
+	const prefixSlash = prefix + "/";
+	const defaultPort = opts.port || Number(process.env.PORT) || 3e3;
+	const template = await fs.readFile(path.resolve(clientDir, "index.html"), "utf-8");
+	let render = null;
+	const hasSsr = typeof __MOOST_SSR_ENTRY__ !== "undefined" && !!__MOOST_SSR_ENTRY__;
+	if (hasSsr) {
+		const ssrModule = await import(
+		/* @vite-ignore */
+		__MOOST_SSR_ENTRY__);
+		render = ssrModule.render;
+	}
+	const { MoostHttp, enableLocalFetch } = await import("@moostjs/event-http");
+	let moostHandler = null;
+	let moostHttpInstance = null;
+	const origListen = MoostHttp.prototype.listen;
+	MoostHttp.prototype.listen = function(...args) {
+		moostHandler = this.getServerCb();
+		moostHttpInstance = this;
+		setTimeout(() => args.filter((a) => typeof a === "function").forEach((a) => a()), 1);
+		return Promise.resolve();
+	};
+	if (typeof opts.entry === "function") await opts.entry();
+	else if (typeof opts.entry === "string") await import(
+	/* @vite-ignore */
+	opts.entry);
+	else await import(__MOOST_ENTRY__);
+	MoostHttp.prototype.listen = origListen;
+	if (enableLocalFetch && moostHttpInstance) enableLocalFetch(moostHttpInstance);
+	const sirv = (await import("sirv")).default;
+	const serve = sirv(path.resolve(clientDir), { extensions: [] });
+	return {
+		use(mw) {
+			userMiddlewares.push(mw);
+		},
+		async listen(port) {
+			const p = port || defaultPort;
+			createHttpServer((req, res) => {
+				const url = req.url || "/";
+				let i = 0;
+				const runNext = () => {
+					if (i < userMiddlewares.length) {
+						userMiddlewares[i++](req, res, runNext);
+						return;
+					}
+					if (moostHandler && (url.startsWith(prefixSlash) || url === prefix || url.startsWith(prefix + "?"))) {
+						moostHandler(req, res);
+						return;
+					}
+					serve(req, res, async () => {
+						if (req.method !== "GET") {
+							res.statusCode = 404;
+							res.end();
+							return;
+						}
+						try {
+							if (render) {
+								const { html: appHtml, state } = await render(url);
+								res.statusCode = 200;
+								res.setHeader("Content-Type", "text/html");
+								res.end(template.replace(ssrOutlet, appHtml).replace(ssrState, state ? `<script>window.__SSR_STATE__=${state}</script>` : ""));
+							} else {
+								res.statusCode = 200;
+								res.setHeader("Content-Type", "text/html");
+								res.end(template);
+							}
+						} catch (e) {
+							console.error(e);
+							res.statusCode = 500;
+							res.end(e.message);
+						}
+					});
+				};
+				runNext();
+			}).listen(p, () => {
+				console.log(`Server running at http://localhost:${p}`);
+			});
+		}
+	};
+}
+
+//#endregion
+export { createSSRServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moostjs/vite",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Vite Dev plugin for moostjs",
   "keywords": [
     "composables",
@@ -36,8 +36,19 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
+    },
+    "./server": {
+      "types": "./dist/prod-server.d.ts",
+      "import": "./dist/prod-server.mjs",
+      "require": "./dist/prod-server.cjs"
     }
   },
+  "build": {
+    "entries": [
+      "src/index.ts",
+      "src/prod-server.ts"
+    ]
+  },
   "dependencies": {
     "magic-string": "^0.30.21"
   },
@@ -45,9 +56,15 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "vite": "^7.0.0",
-    "@moostjs/event-http": "^0.6.2",
-    "moost": "^0.6.2"
+    "sirv": "^3.0.0",
+    "vite": "^8.0.0",
+    "@moostjs/event-http": "^0.6.4",
+    "moost": "^0.6.4"
+  },
+  "peerDependenciesMeta": {
+    "sirv": {
+      "optional": true
+    }
   },
   "scripts": {
     "pub": "pnpm publish --access public",