@octanejs/vite-plugin 0.1.1 → 0.1.4

package/src/index.js

@@ -1,8 +1,10 @@
+// @ts-check
 /** @import {Plugin, ResolvedConfig, ViteDevServer, UserConfig} from 'vite' */
 /** @import {OctaneConfigOptions, ResolvedOctaneConfig, RenderRoute} from '@octanejs/vite-plugin' */
 
 import fs from 'node:fs';
-import { Readable } from 'node:stream';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
 import { octane as octaneCompiler } from 'octane/compiler/vite';
@@ -11,6 +13,9 @@ import { createRouter } from './server/router.js';
 import { createContext, runMiddlewareChain } from './server/middleware.js';
 import { handleRenderRoute } from './server/render-route.js';
 import { handleServerRoute } from './server/server-route.js';
+import { generateServerEntry } from './server/virtual-entry.js';
+import { nodeRequestToWebRequest, sendWebResponse } from './server/node-http.js';
+import { ENTRY_FILENAME } from './constants.js';
 import {
 	getOctaneConfigPath,
 	loadOctaneConfig,
@@ -28,6 +33,8 @@ import {
 
 import { patch_global_fetch, is_rpc_request, handle_rpc_request } from '@ripple-ts/adapter/rpc';
 
+import { get_route_entry_path } from './routes.js';
+
 // Re-export route classes + config helpers (public API surface).
 export { RenderRoute, ServerRoute } from './routes.js';
 export {
@@ -49,6 +56,59 @@ function is_octane_module_path(file_name) {
 	return OCTANE_EXTENSIONS.some((extension) => file_name.endsWith(extension));
 }
 
+// Query params that mark a Vite transform request (`/src/x.svg?url`,
+// `/src/worker?worker`, …). `?v=`/`?t=` module URLs always carry an extension,
+// so the extension check below already covers them.
+const VITE_QUERY_MARKERS = ['import', 'direct', 'raw', 'url', 'worker', 'sharedworker', 'inline'];
+
+/**
+ * Is this a request the Vite dev server owns (module/asset/internal), as
+ * opposed to a page navigation? A catch-all RenderRoute ('/*splat') must not
+ * SSR `/@vite/client` or `/src/main.ts` — those must fall through to Vite's
+ * transform middleware. Exported for tests.
+ *
+ * A dot in the last path segment is NOT enough to claim a request: page URLs
+ * like `/docs/v2.0` or `/users/jane.doe` carry one too. So an extension only
+ * marks a Vite-owned request when the path names a REAL file under one of
+ * `fileRoots` (the Vite root + publicDir — what the dev server can actually
+ * serve). With no `fileRoots` the check stays the conservative heuristic
+ * (any extension → Vite-owned).
+ *
+ * @param {URL} url
+ * @param {string[]} [fileRoots]
+ * @returns {boolean}
+ */
+export function isViteOwnedUrl(url, fileRoots) {
+	const pathname = url.pathname;
+	// Vite-internal namespaces: /@vite/client, /@id/…, /@fs/…, /@react-refresh.
+	if (pathname.startsWith('/@')) return true;
+	// Vite/devtools internals: /__open-in-editor, /__inspect, …
+	if (pathname.startsWith('/__')) return true;
+	if (pathname.includes('/node_modules/')) return true;
+	// Vite emits its transform queries as BARE markers (`?url`, `?raw`,
+	// `?worker`, `&import`) — only an EMPTY value counts. A valued param
+	// (`/docs?url=https://example.com`) is an app query string on a page
+	// navigation, not a transform request.
+	for (const marker of VITE_QUERY_MARKERS) {
+		if (url.searchParams.get(marker) === '') return true;
+	}
+	// A file extension marks a module/asset request (/src/main.ts, /favicon.svg)
+	// — but only when a real file backs it (see above). (dot > 0 so a bare
+	// dotfile segment like '/.well-known' doesn't count.)
+	const lastSegment = pathname.slice(pathname.lastIndexOf('/') + 1);
+	if (lastSegment.lastIndexOf('.') > 0) {
+		if (fileRoots === undefined) return true;
+		let relPath;
+		try {
+			relPath = decodeURIComponent(pathname);
+		} catch {
+			relPath = pathname;
+		}
+		return fileRoots.some((root) => fs.existsSync(path.join(root, relPath)));
+	}
+	return false;
+}
+
 /** @type {import('@ripple-ts/adapter/rpc').AsyncContext | null} */
 let devAsyncContext = null;
 
@@ -96,10 +156,15 @@ function has_route_config(config) {
  * server body when pulled via `ssrLoadModule`). The metaPlugin owns config,
  * routing, dev SSR, the client hydrate virtual module, and dev RPC.
  *
- * PHASE 1 = dev SSR + routing + hydrate. Production build (buildStart /
- * closeBundle / transformIndexHtml / server-entry / adapter.serve) is Phase 2.
+ * PRODUCTION (`vite build`, when octane.config.ts has routes): the client
+ * build is redirected to `{outDir}/client` with a manifest, the hydrate entry
+ * is injected into index.html (so Vite bundles + hashes it), and closeBundle
+ * runs a second, `ssr: true` build of a generated server entry to
+ * `{outDir}/server/entry.js` — a self-contained module (app + octane bundled,
+ * node builtins external) exporting `handler`/`nodeHandler` and auto-booting
+ * under `node`. See server/virtual-entry.js and server/production.js.
  *
- * @param {{ hmr?: boolean }} [inlineOptions]
+ * @param {{ hmr?: boolean, exclude?: string[] }} [inlineOptions]
  * @returns {Plugin[]}
  */
 export function octane(inlineOptions = {}) {
@@ -111,6 +176,14 @@ export function octane(inlineOptions = {}) {
 	let octaneConfig = null;
 	/** @type {ReturnType<typeof createRouter> | null} */
 	let router = null;
+	/** @type {boolean} */
+	let isBuild = false;
+	/** @type {boolean} Is this the SSR sub-build closeBundle launches? */
+	let isSSRBuild = false;
+	/** @type {ResolvedOctaneConfig | null} Config loaded for the build (config hook, reused in closeBundle) */
+	let buildOctaneConfig = null;
+	/** @type {string[]} Module paths the generated client entry maps statically (build only) */
+	let staticEntries = [];
 
 	/** @type {Plugin} */
 	const metaPlugin = {
@@ -118,21 +191,30 @@ export function octane(inlineOptions = {}) {
 
 		/**
 		 * @param {UserConfig} userConfig
+		 * @param {import('vite').ConfigEnv} env
 		 */
-		config(userConfig) {
+		async config(userConfig, env) {
+			isBuild = env?.command === 'build';
+			isSSRBuild = !!userConfig.build?.ssr;
+
 			const exclude = userConfig.optimizeDeps?.exclude || [];
-			return {
-				// SSR owns routing; do not let Vite SPA-fallback to index.html.
-				appType: 'custom',
+			const base = {
+				// SSR owns routing, so default appType to 'custom' (no SPA HTML
+				// fallback masking SSR routes). Respect an explicit user appType, and
+				// leave `vite preview` alone — the production SSR build is previewed
+				// with `octane-preview` (it serves dist/server), not `vite preview`.
+				...(userConfig.appType === undefined && !env?.isPreview
+					? { appType: /** @type {const} */ ('custom') }
+					: {}),
 				optimizeDeps: {
 					exclude: [
-						// `@octanejs/query` ships a `.tsrx` provider component, so it must NOT
+						// `@octanejs/tanstack-query` ships a `.tsrx` provider component, so it must NOT
 						// be esbuild-prebundled — the octane transform owns `.tsrx` compilation.
 						...new Set([
 							...exclude,
 							'octane',
 							'octane/compiler',
-							'@octanejs/query',
+							'@octanejs/tanstack-query',
 							...SERVER_ONLY_ADAPTER_IDS,
 						]),
 					],
@@ -140,9 +222,57 @@ export function octane(inlineOptions = {}) {
 				// Workspace packages with TS source must be transformed by Vite's SSR
 				// pipeline (not require()'d raw) so ssrLoadModule gets transpiled code.
 				ssr: {
-					noExternal: ['octane', 'octane/compiler', '@octanejs/query'],
+					noExternal: ['octane', 'octane/compiler', '@octanejs/tanstack-query'],
 				},
 			};
+
+			// Production CLIENT build (the SSR sub-build closeBundle launches passes
+			// build.ssr, so it skips this): route the client bundle to
+			// `{outDir}/client` and emit a manifest for the server's asset map.
+			if (isBuild && !isSSRBuild) {
+				const projectRoot = userConfig.root ? path.resolve(userConfig.root) : process.cwd();
+				if (octaneConfigExists(projectRoot)) {
+					buildOctaneConfig = await loadOctaneConfig(projectRoot);
+					if (has_route_config(buildOctaneConfig)) {
+						if (!fs.existsSync(path.join(projectRoot, 'index.html'))) {
+							throw new Error(
+								'[@octanejs/vite-plugin] index.html not found — required for SSR builds with octane.config.ts routes.',
+							);
+						}
+						/** @type {import('vite').UserConfig['build']} */
+						const buildConfig = {
+							outDir: `${buildOctaneConfig.build.outDir}/client`,
+							emptyOutDir: true,
+							manifest: true,
+						};
+						if (buildOctaneConfig.build.minify !== undefined) {
+							buildConfig.minify = buildOctaneConfig.build.minify;
+						}
+						if (buildOctaneConfig.build.target !== undefined) {
+							buildConfig.target = buildOctaneConfig.build.target;
+						}
+						return { ...base, build: buildConfig };
+					}
+				}
+			}
+
+			return base;
+		},
+
+		/**
+		 * Production client build: collect every module path the server can name
+		 * in #__octane_data (page entries, layouts, the preHydrate hook) so the
+		 * generated hydrate entry maps them as STATIC dynamic imports Rollup can
+		 * chunk and hash.
+		 */
+		buildStart() {
+			if (!isBuild || isSSRBuild || !has_route_config(buildOctaneConfig)) return;
+			const cfg = /** @type {ResolvedOctaneConfig} */ (buildOctaneConfig);
+			const entries = cfg.router.routes
+				.filter((r) => r.type === 'render')
+				.flatMap((r) => [get_route_entry_path(/** @type {RenderRoute} */ (r).entry), r.layout]);
+			if (cfg.router.preHydrate) entries.push(cfg.router.preHydrate);
+			staticEntries = [...new Set(entries.filter((e) => typeof e === 'string'))];
 		},
 
 		async configResolved(resolvedConfig) {
@@ -167,14 +297,15 @@ export function octane(inlineOptions = {}) {
 			}
 			if (id === RESOLVED_VIRTUAL_HYDRATE_ID) {
 				// Dev: dynamic import() of the route entry works through Vite, so the
-				// static import map is left empty (the codegen falls back to a dynamic
-				// import per entry). The production static map is Phase 2.
+				// static import map stays empty (the codegen falls back to a dynamic
+				// import per entry). Production builds pass the routes' module paths
+				// (collected in buildStart) so Rollup bundles them.
 				const file = write_project_generated_file(
 					config,
 					'client-entry.js',
 					create_client_entry_source({
 						configPath: to_vite_root_import(getOctaneConfigPath(root), root),
-						staticEntries: [],
+						staticEntries,
 					}),
 				);
 				return fs.readFileSync(file, 'utf-8');
@@ -273,6 +404,22 @@ export function octane(inlineOptions = {}) {
 						return;
 					}
 
+					// A catch-all RenderRoute ('/*splat') also matches every module /
+					// asset / Vite-internal request. Those belong to Vite's transform
+					// middleware, not SSR — skip them BEFORE the (per-request) config
+					// reload below so module requests stay cheap. ServerRoutes are not
+					// filtered: an explicit '/api/data.json' endpoint is legitimate.
+					// The file roots let extension-bearing PAGE urls (/docs/v2.0,
+					// /users/jane.doe) SSR — only paths naming a real file are Vite's.
+					const fileRoots = [config.root];
+					if (typeof config.publicDir === 'string' && config.publicDir !== '') {
+						fileRoots.push(config.publicDir);
+					}
+					if (match.route.type === 'render' && isViteOwnedUrl(url, fileRoots)) {
+						next();
+						return;
+					}
+
 					try {
 						// Reload config so route edits are picked up (dev HMR for routes).
 						const previousRoutes = octaneConfig.router.routes;
@@ -360,10 +507,206 @@ export function octane(inlineOptions = {}) {
 				return [];
 			},
 		},
+
+		/**
+		 * Production client build: inject the hydrate entry into index.html so
+		 * Vite bundles it into the html chunk graph (the built template then
+		 * carries the hashed script tag — the production server injects nothing
+		 * per-request). `order: 'pre'` is required: Vite's build-html plugin
+		 * collects module scripts BEFORE default-order transforms run, so a
+		 * post-injected script would ship unbundled. Dev never runs this branch:
+		 * the dev middleware injects `/@id/virtual:octane-hydrate` itself.
+		 */
+		transformIndexHtml: {
+			order: 'pre',
+			handler(html) {
+				if (!isBuild || isSSRBuild || !has_route_config(buildOctaneConfig)) return html;
+				const hydrationScript = `<script type="module" src="${VIRTUAL_HYDRATE_ID}"></script>`;
+				return html.replace('</body>', `${hydrationScript}\n</body>`);
+			},
+		},
+
+		/**
+		 * Production: after the client build completes, build the server bundle.
+		 * Reads the client manifest into a per-route asset map, generates the
+		 * server entry (server/virtual-entry.js), and runs a second Vite build
+		 * with `ssr: true` into `{outDir}/server`. The built index.html MOVES
+		 * from dist/client to dist/server — it is the SSR template (with
+		 * unresolved `<!--ssr-*-->` placeholders), and leaving it in the static
+		 * dir would shadow the SSR handler at `/` on filesystem-first platforms.
+		 */
+		async closeBundle() {
+			if (!isBuild || isSSRBuild || !has_route_config(buildOctaneConfig)) return;
+			const cfg = /** @type {ResolvedOctaneConfig} */ (buildOctaneConfig);
+
+			console.log('[@octanejs/vite-plugin] Client build done. Building the server bundle…');
+
+			const outDir = cfg.build.outDir;
+			const clientOutDir = path.join(root, outDir, 'client');
+			const serverOutDir = path.join(root, outDir, 'server');
+
+			// ------------------------------------------------------------------
+			// Client manifest → per-route asset map (stylesheet + modulepreload
+			// tags the production server emits for the matched route).
+			// ------------------------------------------------------------------
+			const manifestPath = path.join(clientOutDir, '.vite', 'manifest.json');
+			/** @type {Record<string, { file: string, css?: string[], imports?: string[] }>} */
+			let clientManifest = {};
+			if (fs.existsSync(manifestPath)) {
+				clientManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+			} else {
+				console.warn(
+					`[@octanejs/vite-plugin] Client manifest not found at ${manifestPath} — per-route asset preloading disabled`,
+				);
+			}
+
+			/**
+			 * All CSS a manifest entry needs, transitively (cycle-safe).
+			 * @param {string} key
+			 * @param {Set<string>} [visited]
+			 * @returns {string[]}
+			 */
+			const collectCss = (key, visited = new Set()) => {
+				if (visited.has(key)) return [];
+				visited.add(key);
+				const entry = clientManifest[key];
+				if (!entry) return [];
+				const css = [...(entry.css || [])];
+				for (const imp of entry.imports || []) css.push(...collectCss(imp, visited));
+				return css;
+			};
+
+			/** @type {Record<string, { js: string, css: string[] }>} */
+			const clientAssetMap = {};
+			for (const moduleId of staticEntries) {
+				// Manifest keys are root-relative without the leading slash.
+				const manifestKey = moduleId.startsWith('/') ? moduleId.slice(1) : moduleId;
+				const manifestEntry = clientManifest[manifestKey];
+				if (manifestEntry) {
+					clientAssetMap[moduleId] = {
+						js: manifestEntry.file,
+						css: [...new Set(collectCss(manifestKey))],
+					};
+				}
+			}
+
+			// The manifest was only needed here; leaving .vite/ in dist/client would
+			// publish source file paths through the static server.
+			fs.rmSync(path.join(clientOutDir, '.vite'), { recursive: true, force: true });
+
+			// ------------------------------------------------------------------
+			// Generate the server entry and build it (ssr: true). The build loads
+			// the app's vite.config from `root`, so the octane compiler instance
+			// there compiles .tsrx in server mode — do NOT add octane() here.
+			// ------------------------------------------------------------------
+			const serverEntryFile = write_project_generated_file(
+				config,
+				'server-entry.js',
+				generateServerEntry({
+					routes: cfg.router.routes,
+					octaneConfigPath: getOctaneConfigPath(root),
+					clientAssetMap,
+				}),
+			);
+
+			const VIRTUAL_SERVER_ENTRY_ID = 'virtual:octane-server-entry';
+			const RESOLVED_VIRTUAL_SERVER_ENTRY_ID = '\0' + VIRTUAL_SERVER_ENTRY_ID;
+			/** @type {Plugin} */
+			const virtualEntryPlugin = {
+				name: 'octane-virtual-server-entry',
+				resolveId(id) {
+					if (id === VIRTUAL_SERVER_ENTRY_ID) return RESOLVED_VIRTUAL_SERVER_ENTRY_ID;
+				},
+				load(id) {
+					if (id === RESOLVED_VIRTUAL_SERVER_ENTRY_ID) {
+						return fs.readFileSync(serverEntryFile, 'utf-8');
+					}
+				},
+			};
+
+			const { build: viteBuild } = await import('vite');
+			await viteBuild({
+				root,
+				appType: 'custom',
+				plugins: [virtualEntryPlugin],
+				resolve: {
+					alias: [
+						// octane.config.ts imports RenderRoute/defineConfig from the BARE
+						// package — alias it to the config-surface facade so the bundle
+						// carries neither the compiler nor the dev middleware. Subpaths
+						// ('/production', '/node') resolve normally and ARE bundled.
+						{
+							find: /^@octanejs\/vite-plugin$/,
+							replacement: fileURLToPath(new URL('./config-entry.js', import.meta.url)),
+						},
+					],
+				},
+				build: {
+					outDir: serverOutDir,
+					emptyOutDir: true,
+					ssr: true,
+					target: cfg.build.target,
+					minify: cfg.build.minify ?? false,
+					rollupOptions: {
+						input: VIRTUAL_SERVER_ENTRY_ID,
+						output: {
+							entryFileNames: ENTRY_FILENAME,
+							format: 'esm',
+						},
+					},
+				},
+				ssr: {
+					// Self-contained server bundle: everything except node builtins is
+					// bundled, so dist/server deploys without node_modules. 'vite'
+					// stays external as a guard — nothing should reach it (the facade
+					// alias keeps load-config's dynamic import out of the graph).
+					noExternal: true,
+					external: ['vite'],
+				},
+			});
+
+			// The built index.html is the SSR template — move it out of the static
+			// client dir (see hook doc above).
+			const clientHtml = path.join(clientOutDir, 'index.html');
+			if (fs.existsSync(clientHtml)) {
+				fs.renameSync(clientHtml, path.join(serverOutDir, 'index.html'));
+			}
+
+			console.log(`[@octanejs/vite-plugin] Server build complete: ${path.join(outDir, 'server')}`);
+			console.log(
+				`[@octanejs/vite-plugin] Start with: node ${outDir}/server/${ENTRY_FILENAME} (or octane-preview)`,
+			);
+
+			// ------------------------------------------------------------------
+			// Deploy adapter (SvelteKit-style): with both bundles on disk, let the
+			// config's adapter restructure them for its platform (e.g.
+			// @octanejs/adapter-vercel emits `.vercel/output`).
+			// ------------------------------------------------------------------
+			if (cfg.adapter?.adapt) {
+				const adapterName = cfg.adapter.name ?? 'adapter';
+				console.log(`[@octanejs/vite-plugin] Running ${adapterName} adapt()…`);
+				await cfg.adapter.adapt({
+					root,
+					outDir,
+					clientDir: clientOutDir,
+					serverDir: serverOutDir,
+					log: (message) => console.log(message),
+				});
+			}
+		},
 	};
 
-	const hmr = inlineOptions.hmr;
-	return [octaneCompiler(hmr === undefined ? {} : { hmr }), metaPlugin];
+	// Forward compiler options. `exclude` lists ad-hoc path fragments the
+	// compiler's `.ts`/`.js` hook-slotting pass must skip. Hand-slot-forwarding
+	// bindings should not need it: they declare
+	// `"octane": { "hookSlots": { "manual": ["src"] } }` in their own package.json and the
+	// compiler plugin skips them via a nearest-manifest lookup (published
+	// bindings live in node_modules and are skipped outright).
+	const compilerOptions = {};
+	if (inlineOptions.hmr !== undefined) compilerOptions.hmr = inlineOptions.hmr;
+	if (inlineOptions.exclude !== undefined) compilerOptions.exclude = inlineOptions.exclude;
+	// The compiler plugin is untyped JS (its `enforce` infers as `string`).
+	return [/** @type {Plugin} */ (octaneCompiler(compilerOptions)), metaPlugin];
 }
 
 // Mainly to enforce types / DX.
@@ -372,64 +715,10 @@ export function defineConfig(/** @type {OctaneConfigOptions} */ options) {
 }
 
 // ============================================================================
-// Dev-server HTTP helpers
+// Dev-server HTTP helpers — nodeRequestToWebRequest / sendWebResponse live in
+// server/node-http.js (shared with the production server + serverless wrapper).
 // ============================================================================
 
-/**
- * Convert a Node.js IncomingMessage to a Web Request.
- * @param {import('node:http').IncomingMessage} nodeRequest
- * @returns {Request}
- */
-function nodeRequestToWebRequest(nodeRequest) {
-	const host = nodeRequest.headers.host || 'localhost';
-	const url = new URL(nodeRequest.url || '/', `http://${host}`);
-
-	const headers = new Headers();
-	for (const [key, value] of Object.entries(nodeRequest.headers)) {
-		if (value == null) continue;
-		if (Array.isArray(value)) {
-			for (const v of value) headers.append(key, v);
-		} else {
-			headers.set(key, value);
-		}
-	}
-
-	const method = (nodeRequest.method || 'GET').toUpperCase();
-	/** @type {RequestInit & { duplex?: 'half' }} */
-	const init = { method, headers };
-	if (method !== 'GET' && method !== 'HEAD') {
-		init.body = Readable.toWeb(nodeRequest);
-		init.duplex = 'half';
-	}
-	return new Request(url, init);
-}
-
-/**
- * Pipe a Web Response to a Node.js ServerResponse.
- * @param {import('node:http').ServerResponse} nodeResponse
- * @param {Response} webResponse
- */
-async function sendWebResponse(nodeResponse, webResponse) {
-	nodeResponse.statusCode = webResponse.status;
-	if (webResponse.statusText) nodeResponse.statusMessage = webResponse.statusText;
-	webResponse.headers.forEach((value, key) => {
-		nodeResponse.setHeader(key, value);
-	});
-	if (webResponse.body) {
-		const reader = webResponse.body.getReader();
-		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				nodeResponse.write(value);
-			}
-		} finally {
-			reader.releaseLock();
-		}
-	}
-	nodeResponse.end();
-}
-
 /**
  * Handle a dev RPC request for `module server` declarations.
  *
@@ -446,7 +735,7 @@ async function handleRpcRequest(req, res, vite, trustProxy, config) {
 
 		const response = await handle_rpc_request(webRequest, {
 			async resolveFunction(hash) {
-				const rpcModules = globalThis.rpc_modules;
+				const rpcModules = /** @type {any} */ (globalThis).rpc_modules;
 				if (!rpcModules) return null;
 				const moduleInfo = rpcModules.get(hash);
 				if (!moduleInfo) return null;

package/src/load-config.js

@@ -1,3 +1,4 @@
+// @ts-check
 /**
  * Shared utility for loading and resolving octane.config.ts.
  *
@@ -20,135 +21,14 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { compile } from 'octane/compiler';
-import { DEFAULT_OUTDIR } from './constants.js';
+import { resolveOctaneConfig } from './resolve-config.js';
 
 const OCTANE_EXTENSION_PATTERN = /\.tsrx$/;
 
-/**
- * @param {unknown} route
- * @returns {void}
- */
-function validate_render_route(route) {
-	if (
-		!route ||
-		typeof route !== 'object' ||
-		/** @type {{ type?: unknown }} */ (route).type !== 'render'
-	) {
-		return;
-	}
-
-	const render_route = /** @type {{ entry?: unknown, layout?: unknown }} */ (route);
-	const has_entry =
-		typeof render_route.entry === 'string' ||
-		(Array.isArray(render_route.entry) &&
-			render_route.entry.length === 2 &&
-			typeof render_route.entry[0] === 'string' &&
-			typeof render_route.entry[1] === 'string');
-
-	if (!has_entry) {
-		throw new Error('[@octanejs/vite-plugin] RenderRoute requires a string/tuple `entry`.');
-	}
-
-	if (render_route.layout !== undefined && typeof render_route.layout !== 'string') {
-		throw new Error('[@octanejs/vite-plugin] RenderRoute `layout` must be a string path.');
-	}
-}
-
-/**
- * @param {unknown} rootBoundary
- * @returns {void}
- */
-function validate_root_boundary(rootBoundary) {
-	if (rootBoundary === undefined) {
-		return;
-	}
-	if (!rootBoundary || typeof rootBoundary !== 'object') {
-		throw new Error('[@octanejs/vite-plugin] rootBoundary must be an object when provided.');
-	}
-
-	const boundary = /** @type {{ pending?: unknown, catch?: unknown }} */ (rootBoundary);
-	if (boundary.pending !== undefined && typeof boundary.pending !== 'function') {
-		throw new Error('[@octanejs/vite-plugin] rootBoundary.pending must be a component function.');
-	}
-	if (boundary.catch !== undefined && typeof boundary.catch !== 'function') {
-		throw new Error('[@octanejs/vite-plugin] rootBoundary.catch must be a component function.');
-	}
-}
-
-/**
- * Validate a raw octane config and apply all defaults.
- *
- * After this function returns every optional field carries its default
- * value so callers never need to use `??` / `||` fallbacks.
- *
- * The function is idempotent — passing an already-resolved config
- * through it again is safe and produces the same result.
- *
- * @param {OctaneConfigOptions} raw - The user-provided config (from octane.config.ts)
- * @param {{ requireAdapter?: boolean }} [options]
- * @returns {ResolvedOctaneConfig}
- */
-export function resolveOctaneConfig(raw, options = {}) {
-	const { requireAdapter = false } = options;
-
-	// ------------------------------------------------------------------
-	// Validate
-	// ------------------------------------------------------------------
-	if (!raw) {
-		throw new Error(
-			'[@octanejs/vite-plugin] octane.config.ts must export a default config object.',
-		);
-	}
-
-	if (requireAdapter) {
-		if (!raw.adapter) {
-			throw new Error(
-				'[@octanejs/vite-plugin] Production builds require an `adapter` in octane.config.ts. ' +
-					'Install an adapter package (e.g. @ripple-ts/adapter-node) and set the `adapter` property.',
-			);
-		}
-
-		if (!raw.adapter.runtime) {
-			throw new Error(
-				'[@octanejs/vite-plugin] The adapter in octane.config.ts is missing the `runtime` property. ' +
-					'Make sure your adapter exports runtime primitives.',
-			);
-		}
-	}
-
-	if (raw.router?.routes !== undefined && !Array.isArray(raw.router.routes)) {
-		throw new Error('[@octanejs/vite-plugin] router.routes must be an array.');
-	}
-
-	for (const route of raw.router?.routes ?? []) {
-		validate_render_route(route);
-	}
-
-	validate_root_boundary(raw.rootBoundary);
-
-	// ------------------------------------------------------------------
-	// Apply defaults
-	// ------------------------------------------------------------------
-	return {
-		build: {
-			outDir: raw.build?.outDir ?? DEFAULT_OUTDIR,
-			minify: raw.build?.minify,
-			target: raw.build?.target,
-		},
-		adapter: raw.adapter,
-		router: {
-			routes: raw.router?.routes ?? [],
-		},
-		rootBoundary: raw.rootBoundary ?? {},
-		middlewares: raw.middlewares ?? [],
-		platform: {
-			env: raw.platform?.env ?? {},
-		},
-		server: {
-			trustProxy: raw.server?.trustProxy ?? false,
-		},
-	};
-}
+// Validation + defaults live in resolve-config.js (a module with no vite /
+// compiler imports) so the production server bundle can include it without
+// dragging the toolchain along. Re-exported here for existing importers.
+export { resolveOctaneConfig } from './resolve-config.js';
 
 /**
  * Return the absolute path to octane.config.ts for the given project root.