bosia 0.5.2 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.5.2",
+	"version": "0.5.4",
 	"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/apiResolver.ts

@@ -0,0 +1,36 @@
+import { findMatch } from "./matcher.ts";
+import type { RouteMatch } from "./types.ts";
+
+interface ApiRouteLike {
+	pattern: string;
+	module: () => Promise<{ prerender?: unknown }>;
+}
+
+/**
+ * Resolve an incoming request path to an API route, applying the `.json` alias.
+ *
+ * When the URL ends in `.json` the bare path is tried first. If the bare-path
+ * route opted into `prerender = true`, the alias wins — this prevents a
+ * catch-all sibling (e.g. `/api/components/[...path]`) from swallowing the
+ * `.json` suffix as part of its rest-segment param and returning a 4xx from
+ * the catch-all handler. Non-prerender bare-path matches fall through to the
+ * literal `.json` path so legitimate `<segment>.json` routes still resolve.
+ */
+export async function resolveApiMatch<T extends ApiRouteLike>(
+	routes: T[],
+	path: string,
+): Promise<RouteMatch<T> | null> {
+	if (path.endsWith(".json")) {
+		const bare = path.slice(0, -".json".length);
+		const aliased = findMatch(routes, bare);
+		if (aliased) {
+			try {
+				const mod = await aliased.route.module();
+				if (mod.prerender === true) return aliased;
+			} catch {
+				/* fall through to literal-path match */
+			}
+		}
+	}
+	return findMatch(routes, path);
+}

package/src/core/plugins/inspector/bun-plugin.ts

@@ -121,8 +121,15 @@ export function createInspectorBunPlugin(opts: InspectorBunPluginOptions): BunPl
 				});
 
 				let js = result.js.code;
-				if (result.css?.code && generate !== "server") {
-					const uid = `${basename(args.path)}-${fnv(args.path)}-style.css`;
+				// Skip empty CSS — multiple +page.svelte routes with no <style> would
+				// otherwise each emit an empty CSS chunk, all hashing to the same
+				// content → Bun fails with "Multiple files share the same output path".
+				// Also strip dots from basename: Bun's `[name]-[hash].[ext]` chunk
+				// naming treats the first `.` as the extension boundary, so
+				// `+page.svelte-…` collapses to `[name]="+page"` for every route.
+				if (result.css?.code?.trim() && generate !== "server") {
+					const safeBase = basename(args.path).replace(/\./g, "_");
+					const uid = `${safeBase}-${fnv(args.path)}-style.css`;
 					const virtualName = `${VIRTUAL_NS}:${uid}`;
 					virtualCss.set(virtualName, result.css.code);
 					js += `\nimport ${JSON.stringify(virtualName)};`;

package/src/core/prerender.ts

@@ -32,6 +32,8 @@ const PRERENDER_TIMEOUT = Number(process.env.PRERENDER_TIMEOUT) || 5_000; // 5s
 
 interface PrerenderTarget {
 	path: string;
+	kind: "page" | "api";
+	/** Page targets only; APIs always write a single `.json` file regardless of slash mode. */
 	trailingSlash: TrailingSlash;
 }
 
@@ -86,6 +88,15 @@ export function prerenderDataPath(routePath: string): string {
 	return routePath === "/" ? "/index.json" : `${routePath.replace(/\/$/, "")}.json`;
 }
 
+/**
+ * Output filename for a prerendered API route. Always emits a single `.json`
+ * file at the route's path (no trailing-slash variants — static hosts serve
+ * `/api/foo.json` regardless of the request URL's slash).
+ */
+export function prerenderApiOutPath(routePath: string): string {
+	return `./dist/prerendered${routePath.replace(/\/$/, "")}.json`;
+}
+
 async function detectPrerenderRoutes(manifest: RouteManifest): Promise<PrerenderTarget[]> {
 	const targets: PrerenderTarget[] = [];
 	for (const route of manifest.pages) {
@@ -116,6 +127,7 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<Prerender
 				for (const entry of entryList) {
 					targets.push({
 						path: substituteParams(route.pattern, entry),
+						kind: "page",
 						trailingSlash: ts,
 					});
 				}
@@ -123,9 +135,40 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<Prerender
 				console.error(`   ❌ Failed to resolve entries() for ${route.pattern}:`, err);
 			}
 		} else {
-			targets.push({ path: route.pattern, trailingSlash: ts });
+			targets.push({ path: route.pattern, kind: "page", trailingSlash: ts });
 		}
 	}
+
+	for (const route of manifest.apis) {
+		const filePath = join("src", "routes", route.server);
+		const content = await Bun.file(filePath).text();
+		if (!/export\s+const\s+prerender\s*=\s*true/.test(content)) continue;
+
+		if (route.pattern.includes("[")) {
+			try {
+				const mod = await import(join(process.cwd(), filePath));
+				if (typeof mod.entries !== "function") {
+					console.warn(
+						`   ⚠️  ${route.pattern} has prerender=true but no entries() export — skipped`,
+					);
+					continue;
+				}
+				const entryList: Record<string, string>[] = await mod.entries();
+				for (const entry of entryList) {
+					targets.push({
+						path: substituteParams(route.pattern, entry),
+						kind: "api",
+						trailingSlash: "never",
+					});
+				}
+			} catch (err) {
+				console.error(`   ❌ Failed to resolve entries() for ${route.pattern}:`, err);
+			}
+		} else {
+			targets.push({ path: route.pattern, kind: "api", trailingSlash: "never" });
+		}
+	}
+
 	return targets;
 }
 
@@ -178,8 +221,21 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 
 		mkdirSync("./dist/prerendered", { recursive: true });
 
-		for (const { path: routePath, trailingSlash: ts } of targets) {
+		for (const { path: routePath, kind, trailingSlash: ts } of targets) {
 			try {
+				if (kind === "api") {
+					// APIs: fetch the bare route URL, write body to `<path>.json`.
+					const res = await fetch(`${base}${routePath.replace(/\/$/, "")}`, {
+						signal: AbortSignal.timeout(PRERENDER_TIMEOUT),
+					});
+					const body = await res.text();
+					const outPath = prerenderApiOutPath(routePath);
+					mkdirSync(outPath.substring(0, outPath.lastIndexOf("/")), { recursive: true });
+					writeFileSync(outPath, body);
+					console.log(`   ✅ ${routePath} → ${outPath}`);
+					continue;
+				}
+
 				// Hit the canonical URL so the server doesn't 308 us mid-prerender
 				const canonicalRoute = canonicalRouteFor(routePath, ts);
 

package/src/core/server.ts

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 
 import { findMatch, compileRoutes, canonicalPathname } from "./matcher.ts";
+import { resolveApiMatch } from "./apiResolver.ts";
 import { apiRoutes, serverRoutes } from "bosia:routes";
 import { loadPlugins } from "./config.ts";
 import type { RouteManifest } from "./types.ts";
@@ -338,8 +339,8 @@ async function resolve(event: RequestEvent): Promise<Response> {
 		}
 	}
 
-	// API routes (+server.ts)
-	const apiMatch = findMatch(apiRoutes, path);
+	// API routes (+server.ts) — resolve with `.json` alias preference.
+	const apiMatch = await resolveApiMatch(apiRoutes, path);
 	if (apiMatch) {
 		try {
 			const mod = await apiMatch.route.module();
@@ -690,6 +691,24 @@ if (BODY_SIZE_LIMIT === 0) {
 	console.log(`📦 Body size limit: ${BODY_SIZE_LIMIT} bytes`);
 }
 
+// ─── Idle Timeout ─────────────────────────────────────────
+// Parsed once at startup from IDLE_TIMEOUT env var.
+// Integer seconds; Bun caps it at 255. Default: 10 (Bun's default).
+// Raise when API routes hold streaming responses with long gaps
+// between chunks (e.g. AI tool calls that shell out and wait).
+
+function parseIdleTimeout(value?: string): number {
+	if (!value) return 10;
+	const n = parseInt(value, 10);
+	if (!Number.isFinite(n) || n < 0) throw new Error(`Invalid IDLE_TIMEOUT: "${value}"`);
+	if (n > 255) throw new Error(`Invalid IDLE_TIMEOUT: "${value}" (max 255)`);
+	return n;
+}
+
+const IDLE_TIMEOUT = parseIdleTimeout(process.env.IDLE_TIMEOUT);
+
+console.log(`⏱  Idle timeout: ${IDLE_TIMEOUT}s`);
+
 // ─── Graceful Shutdown State ──────────────────────────────
 
 let shuttingDown = false;
@@ -736,13 +755,13 @@ const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : isDev ? 9001 :
 
 // Elysia's chained generics drift when plugins add routes — track the app as a
 // loose `Elysia` so plugin-extended types stay assignable.
-let app: Elysia = new Elysia({ serve: { maxRequestBodySize: BODY_SIZE_LIMIT } }).onError(
-	({ error }) => {
-		if (isDev) console.error("Uncaught server error:", error);
-		else console.error("Uncaught server error:", (error as Error)?.message ?? error);
-		return Response.json({ error: "Internal Server Error" }, { status: 500 });
-	},
-) as unknown as Elysia;
+let app: Elysia = new Elysia({
+	serve: { maxRequestBodySize: BODY_SIZE_LIMIT, idleTimeout: IDLE_TIMEOUT },
+}).onError(({ error }) => {
+	if (isDev) console.error("Uncaught server error:", error);
+	else console.error("Uncaught server error:", (error as Error)?.message ?? error);
+	return Response.json({ error: "Internal Server Error" }, { status: 500 });
+}) as unknown as Elysia;
 
 // Plugins.backend.before — runs before framework middleware/routes.
 // Plugin-registered routes here BYPASS the framework (CSRF, hooks, etc.).

package/templates/default/.prettierrc.json

@@ -1,6 +1,6 @@
 {
 	"useTabs": true,
-	"tabWidth": 4,
+	"tabWidth": 2,
 	"singleQuote": false,
 	"trailingComma": "all",
 	"printWidth": 100,

package/templates/demo/.prettierrc.json

@@ -1,6 +1,6 @@
 {
 	"useTabs": true,
-	"tabWidth": 4,
+	"tabWidth": 2,
 	"singleQuote": false,
 	"trailingComma": "all",
 	"printWidth": 100,

package/templates/todo/.prettierrc.json

@@ -1,6 +1,6 @@
 {
 	"useTabs": true,
-	"tabWidth": 4,
+	"tabWidth": 2,
 	"singleQuote": false,
 	"trailingComma": "all",
 	"printWidth": 100,