bosia 0.6.15 → 0.6.17

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.6.15",
+	"version": "0.6.17",
 	"type": "module",
 	"description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing inspired by SvelteKit. No Node.js, no Vite, no adapters.",
 	"keywords": [

package/src/core/appHtml.ts

@@ -1,5 +1,7 @@
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+
+import { OUT_DIR } from "./paths.ts";
 
 // ─── Types ────────────────────────────────────────────────
 
@@ -70,13 +72,37 @@ function replaceStaticPlaceholders(template: string): string {
 	return template;
 }
 
+// ─── Persisted Segments (production runtime) ──────────────
+// At build time we serialize the parsed segments to `${OUT_DIR}/app-html.json`
+// so the production runtime can read them without needing `src/app.html` in
+// the image. This lets minimal Docker images copy only `dist/`.
+
+export function writeAppHtmlSegments(segments: AppHtmlSegments, outDir: string = OUT_DIR): string {
+	const target = join(outDir, "app-html.json");
+	mkdirSync(dirname(target), { recursive: true });
+	writeFileSync(target, JSON.stringify(segments));
+	return target;
+}
+
+function readPersistedSegments(cwd: string): AppHtmlSegments | undefined {
+	const persistedPath = join(cwd, OUT_DIR, "app-html.json");
+	if (!existsSync(persistedPath)) return undefined;
+	try {
+		return JSON.parse(readFileSync(persistedPath, "utf-8")) as AppHtmlSegments;
+	} catch {
+		return undefined;
+	}
+}
+
 // ─── Cached Getter ────────────────────────────────────────
 
 export function getAppHtmlSegments(cwd: string = process.cwd()): AppHtmlSegments {
 	if (cachedSegments !== undefined) {
 		return cachedSegments;
 	}
-	cachedSegments = loadAppHtmlTemplate(cwd);
+	// Prefer persisted dist artifact (production runtime — no `src/` in image).
+	// Fall back to parsing `src/app.html` directly (dev mode, build step).
+	cachedSegments = readPersistedSegments(cwd) ?? loadAppHtmlTemplate(cwd);
 	return cachedSegments;
 }
 

package/src/core/build.ts

@@ -1,4 +1,4 @@
-import { writeFileSync, rmSync, mkdirSync } from "fs";
+import { writeFileSync, rmSync, mkdirSync, existsSync } from "fs";
 import { join, relative } from "path";
 
 import { scanRoutes } from "./scanner.ts";
@@ -12,11 +12,14 @@ import { generateEnvModules } from "./envCodegen.ts";
 import { BOSIA_NODE_PATH, OUT_DIR, resolveBosiaBin } from "./paths.ts";
 import { loadPlugins } from "./config.ts";
 import type { BuildContext } from "./types/plugin.ts";
-import { loadAppHtmlTemplate } from "./appHtml.ts";
+import { loadAppHtmlTemplate, writeAppHtmlSegments } from "./appHtml.ts";
 
 // Resolved from this file's location inside the bosia package
 const CORE_DIR = import.meta.dir;
 
+// Runtime externals: never bundled into dist/hooks.server.js or dist/bosia.config.js
+const BOSIA_RUNTIME_EXTERNALS = ["bosia", "elysia", "bun", "svelte", "svelte/server"];
+
 // ─── Entry Point ─────────────────────────────────────────
 
 const isProduction = process.env.NODE_ENV === "production";
@@ -250,6 +253,18 @@ console.log(`✅ Server entry:  ${OUT_DIR}/server/${serverEntry}`);
 // 8b. Persist route manifest for runtime plugins (backend.after consumers like OpenAPI).
 writeFileSync(`${OUT_DIR}/route-manifest.json`, JSON.stringify(manifest, null, 2));
 
+// 8c. Persist parsed app.html segments so the production runtime doesn't need
+// `src/app.html` in the image. Renderer reads `${OUT_DIR}/app-html.json` first,
+// falls back to parsing `src/app.html` for dev.
+writeAppHtmlSegments(appHtml);
+
+// 8d. Bundle user `src/hooks.server.ts` and `bosia.config.{ts,js,mjs}` into
+// `dist/` so production images can copy only `dist/` + `node_modules/` —
+// `src/` is never required at runtime. The runtime (server.ts, config.ts)
+// prefers these artifacts over the source files. npm packages stay external
+// so they resolve against the app's node_modules at runtime.
+await bundleRuntimeUserFiles(process.cwd());
+
 // 9. Prerender static routes
 await prerenderStaticRoutes(manifest);
 
@@ -263,3 +278,75 @@ for (const p of userPlugins) {
 }
 
 console.log(`\n🎉 Build complete in ${Math.round(performance.now() - buildStart)}ms!`);
+
+// ─── Helpers ─────────────────────────────────────────────
+
+async function readUserDependencyNames(cwd: string): Promise<string[]> {
+	try {
+		const pkg = (await Bun.file(join(cwd, "package.json")).json()) as {
+			dependencies?: Record<string, string>;
+			peerDependencies?: Record<string, string>;
+			optionalDependencies?: Record<string, string>;
+		};
+		return Array.from(
+			new Set([
+				...Object.keys(pkg.dependencies ?? {}),
+				...Object.keys(pkg.peerDependencies ?? {}),
+				...Object.keys(pkg.optionalDependencies ?? {}),
+			]),
+		);
+	} catch {
+		return [];
+	}
+}
+
+async function bundleRuntimeUserFiles(cwd: string): Promise<void> {
+	const userDeps = await readUserDependencyNames(cwd);
+	// Externalize every npm package + every subpath (e.g. `bosia/plugins/inspector`).
+	// Bun.build's `external` accepts globs.
+	const externalNames = Array.from(new Set([...BOSIA_RUNTIME_EXTERNALS, ...userDeps]));
+	const external = externalNames.flatMap((n) => [n, `${n}/*`]);
+
+	// 1) src/hooks.server.ts → dist/hooks.server.js
+	const hooksSrc = join(cwd, "src", "hooks.server.ts");
+	if (existsSync(hooksSrc)) {
+		const result = await Bun.build({
+			entrypoints: [hooksSrc],
+			outdir: OUT_DIR,
+			target: "bun",
+			format: "esm",
+			naming: { entry: "hooks.server.[ext]" },
+			minify: isProduction,
+			sourcemap: isProduction ? "none" : "linked",
+			external,
+		});
+		if (!result.success) {
+			console.error("❌ hooks.server bundle failed:");
+			for (const msg of result.logs) console.error(msg);
+			process.exit(1);
+		}
+		console.log("🪝 Bundled hooks.server → " + OUT_DIR + "/hooks.server.js");
+	}
+
+	// 2) bosia.config.{ts,js,mjs} → dist/bosia.config.js
+	const configCandidates = ["bosia.config.ts", "bosia.config.js", "bosia.config.mjs"];
+	const configSrc = configCandidates.map((n) => join(cwd, n)).find((p) => existsSync(p));
+	if (configSrc) {
+		const result = await Bun.build({
+			entrypoints: [configSrc],
+			outdir: OUT_DIR,
+			target: "bun",
+			format: "esm",
+			naming: { entry: "bosia.config.[ext]" },
+			minify: isProduction,
+			sourcemap: isProduction ? "none" : "linked",
+			external,
+		});
+		if (!result.success) {
+			console.error("❌ bosia.config bundle failed:");
+			for (const msg of result.logs) console.error(msg);
+			process.exit(1);
+		}
+		console.log("⚙️  Bundled bosia.config → " + OUT_DIR + "/bosia.config.js");
+	}
+}

package/src/core/config.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync } from "fs";
 import { join } from "path";
 
+import { OUT_DIR } from "./paths.ts";
 import type { BosiaConfig, BosiaPlugin } from "./types/plugin.ts";
 
 let cached: BosiaConfig | null = null;
@@ -26,6 +27,25 @@ function findConfigPath(cwd: string): string | null {
 export async function loadBosiaConfig(cwd: string = process.cwd()): Promise<BosiaConfig> {
 	if (cached && cachedFromPath === cwd) return cached;
 
+	// Production runtime: prefer the pre-bundled `${OUT_DIR}/bosia.config.js`
+	// produced by the build. Avoids needing `bosia.config.ts` in the image and
+	// skips an on-the-fly Bun.build at server startup.
+	const prebuiltPath = join(cwd, OUT_DIR, "bosia.config.js");
+	if (existsSync(prebuiltPath)) {
+		const mod = (await import(prebuiltPath)) as { default?: BosiaConfig };
+		const config = mod.default;
+		if (!config || typeof config !== "object") {
+			throw new Error(
+				`${prebuiltPath} must export a default object (use \`export default defineConfig({...})\`).`,
+			);
+		}
+		const rawPlugins = Array.isArray(config.plugins) ? config.plugins : [];
+		const plugins = rawPlugins.filter((p): p is BosiaPlugin => Boolean(p));
+		cached = { plugins };
+		cachedFromPath = cwd;
+		return cached;
+	}
+
 	const configPath = findConfigPath(cwd);
 	if (!configPath) {
 		cached = { plugins: [] };

package/src/core/server.ts

@@ -45,21 +45,32 @@ import {
 import { getServerTime } from "../lib/utils.ts";
 
 // ─── User Hooks ──────────────────────────────────────────
-// Load src/hooks.server.ts if present. Uses process.cwd() so
-// Bun can resolve it at runtime without bundling user code.
+// Load user hooks. Production prefers the pre-bundled `${OUT_DIR}/hooks.server.js`
+// emitted by the build (single-file, all relative imports inlined, npm deps left
+// external) so production images can ship only `dist/` + `node_modules/` without
+// the `src/` tree. Dev (and any environment lacking the artifact) falls back to
+// importing `src/hooks.server.ts` directly so edits hot-reload without a build.
 
 let userHandle: Handle | null = null;
 
-const hooksPath = join(process.cwd(), "src", "hooks.server.ts");
-if (existsSync(hooksPath)) {
+const prebuiltHooksPath = join(process.cwd(), OUT_DIR, "hooks.server.js");
+const srcHooksPath = join(process.cwd(), "src", "hooks.server.ts");
+const hooksPath = existsSync(prebuiltHooksPath)
+	? prebuiltHooksPath
+	: existsSync(srcHooksPath)
+		? srcHooksPath
+		: null;
+if (hooksPath) {
 	try {
 		const mod = await import(hooksPath);
 		if (typeof mod.handle === "function") {
 			userHandle = mod.handle as Handle;
-			console.log("🪝 Loaded hooks.server.ts");
+			console.log(
+				`🪝 Loaded ${hooksPath === prebuiltHooksPath ? "dist/hooks.server.js" : "src/hooks.server.ts"}`,
+			);
 		}
 	} catch (err) {
-		console.warn("⚠️  Failed to load hooks.server.ts:", err);
+		console.warn("⚠️  Failed to load hooks.server:", err);
 	}
 }
 

package/src/core/staticManifest.ts

@@ -64,6 +64,16 @@ export function buildStaticManifest(outDir: string): StaticManifest {
 		}
 	}
 
+	// `dist/static/` mirrors `public/` (the build copies it for SSG output).
+	// Walk it too so production images can drop `public/` and ship only `dist/`.
+	// `addOnce` keeps the `public/` source canonical when both exist (dev).
+	const staticRoot = join(outAbs, "static");
+	if (existsSync(staticRoot)) {
+		for (const { abs, rel } of walk(staticRoot)) {
+			addOnce(manifest, `/${rel}`, { absPath: abs });
+		}
+	}
+
 	if (existsSync(outAbs)) {
 		let rootEntries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
 		try {