bosia 0.8.8 → 0.8.10

package/package.json

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

package/src/cli/create.ts

@@ -20,16 +20,21 @@ const TEMPLATE_DESCRIPTIONS: Record<string, string> = {
 };
 
 export async function runCreate(name: string | undefined, args: string[] = []) {
-	if (!name) {
-		console.error("❌ Please provide a project name.\n   Usage: bun x bosia@latest create my-app");
-		process.exit(1);
-	}
-
-	const targetDir = resolve(process.cwd(), name);
-
+	// "." or omitted → scaffold into the current directory
+	const inCurrentDir = !name || name === ".";
+	const targetDir = inCurrentDir ? process.cwd() : resolve(process.cwd(), name);
+	// package.json / placeholder name: cwd basename when scaffolding in place
+	const projectName = inCurrentDir ? basename(targetDir) : name!;
+
+	// allowlist covers the two files that routinely sit in an otherwise empty
+	// scaffold target (git init'd, macOS). Widen if users hit others.
+	const IGNORE = new Set([".git", ".DS_Store"]);
 	if (existsSync(targetDir)) {
-		console.error(`❌ Directory already exists: ${targetDir}`);
-		process.exit(1);
+		const entries = readdirSync(targetDir).filter((e) => !IGNORE.has(e));
+		if (entries.length > 0) {
+			console.error(`❌ Directory is not empty: ${targetDir}`);
+			process.exit(1);
+		}
 	}
 
 	// Parse --template flag (supports `--template foo` and `--template=foo`)
@@ -77,15 +82,15 @@ export async function runCreate(name: string | undefined, args: string[] = []) {
 	// `BOSIA_BUILDING_PREBUILT` is set by the artifact generator so it scaffolds
 	// via the registry instead of trying to download the asset it's producing.
 	if (config?.prebuilt === true && !isLocal && !process.env.BOSIA_BUILDING_PREBUILT) {
-		const ok = await scaffoldFromPrebuilt(template, targetDir, name);
+		const ok = await scaffoldFromPrebuilt(template, targetDir, projectName);
 		if (ok) {
-			await finishCreate(targetDir, name, templateDir, skipInstall);
+			await finishCreate(targetDir, projectName, templateDir, skipInstall, inCurrentDir);
 			return;
 		}
 		console.log("⚠️  Prebuilt artifact unavailable — installing from registry instead.\n");
 	}
 
-	copyDir(templateDir, targetDir, name, isLocal);
+	copyDir(templateDir, targetDir, projectName, isLocal);
 
 	if (existsSync(join(targetDir, ".env.example"))) {
 		writeFileSync(join(targetDir, ".env"), readFileSync(join(targetDir, ".env.example"), "utf-8"));
@@ -116,7 +121,7 @@ export async function runCreate(name: string | undefined, args: string[] = []) {
 		}
 	}
 
-	await finishCreate(targetDir, name, templateDir, skipInstall);
+	await finishCreate(targetDir, projectName, templateDir, skipInstall, inCurrentDir);
 }
 
 // ─── Shared finish: optional `bun install` + printed instructions ──────────
@@ -125,7 +130,10 @@ async function finishCreate(
 	name: string,
 	templateDir: string,
 	skipInstall: boolean,
+	inCurrentDir = false,
 ) {
+	// Already inside the project dir → no `cd` step to show
+	const cd = inCurrentDir ? "" : `cd ${name} && `;
 	const printInstructions = () => {
 		const instPath = join(templateDir, "instructions.txt");
 		if (existsSync(instPath)) {
@@ -137,7 +145,7 @@ async function finishCreate(
 	console.log(`\n✅ Project created at ${targetDir}\n`);
 
 	if (skipInstall) {
-		console.log(`Skipped \`bun install\` (--no-install).\n\ncd ${name} && bun install\n`);
+		console.log(`Skipped \`bun install\` (--no-install).\n\n${cd}bun install\n`);
 		printInstructions();
 		return;
 	}
@@ -152,7 +160,8 @@ async function finishCreate(
 	if (exitCode !== 0) {
 		console.warn("⚠️  bun install failed — run it manually.");
 	} else {
-		console.log(`\n🎉 Ready!\n\ncd ${name}`);
+		console.log(`\n🎉 Ready!\n`);
+		if (!inCurrentDir) console.log(`cd ${name}`);
 		printInstructions();
 		console.log(`bun x bosia dev\n`);
 	}

package/src/core/build.ts

@@ -1,5 +1,6 @@
-import { writeFileSync, rmSync, mkdirSync, existsSync } from "fs";
+import { writeFileSync, readFileSync, rmSync, mkdirSync, existsSync } from "fs";
 import { join, relative } from "path";
+import type { RouteManifest } from "./types.ts";
 
 import { scanRoutes } from "./scanner.ts";
 import { generateRoutesFile } from "./routeFile.ts";
@@ -50,6 +51,17 @@ const envMode = isProduction ? "production" : "development";
 const envVars = loadEnv(envMode);
 const classifiedEnv = classifyEnvVars(envVars);
 
+// 0b-pre. Dev fast path: when the dev watcher knows no route file changed
+// (BOSIA_SKIP_ROUTE_SCAN=1), reuse the previous build's route manifest instead
+// of re-walking src/routes. Read before the cleanup below deletes it. Missing
+// or corrupt (e.g. the previous build failed before writing it) → real scan.
+let cachedManifest: RouteManifest | null = null;
+if (process.env.BOSIA_SKIP_ROUTE_SCAN === "1") {
+	try {
+		cachedManifest = JSON.parse(readFileSync(join(OUT_DIR, "route-manifest.json"), "utf-8"));
+	} catch {}
+}
+
 // 0b. Clean generated output. Only OUT_DIR (this build's artifacts) and the
 // codegen files inside .bosia/ that this build owns. A blanket wipe of .bosia/
 // would clobber a concurrently-running `bosia dev` whose compiled server lives
@@ -70,10 +82,12 @@ for (const p of [
 	} catch {}
 }
 
-// 1. Scan routes
-const manifest = scanRoutes();
+// 1. Scan routes (or reuse the cached manifest — see 0b-pre)
+const manifest = cachedManifest ?? scanRoutes();
 buildCtx.manifest = manifest;
-console.log(`📂 Found ${manifest.pages.length} page route(s):`);
+console.log(
+	`📂 Found ${manifest.pages.length} page route(s)${cachedManifest ? " (cached scan)" : ""}:`,
+);
 for (const r of manifest.pages) {
 	console.log(`   ${r.pattern} → ${r.page}${r.pageServer ? " (server)" : ""}`);
 }

package/src/core/dev.ts

@@ -3,6 +3,7 @@ import { readdirSync, statSync, watch, type Dirent } from "fs";
 import { join } from "path";
 import { loadEnv, resetDeclaredKeys } from "./env.ts";
 import { BOSIA_NODE_PATH } from "./paths.ts";
+import { affectsRouteManifest, shouldIgnoreForRebuild } from "./devWatch.ts";
 
 // Dev always writes to .bosia/dev so a parallel `bun run build` (writing to ./dist)
 // can't clobber the live preview. Hardcoded — BOSIA_OUT_DIR is a build-mode knob,
@@ -122,13 +123,26 @@ const STARTING_PAGE = `<!doctype html>
 
 const BUILD_SCRIPT = join(import.meta.dir, "build.ts");
 
+// True when a change since the last build may have altered the route manifest
+// (any `+` file or directory under src/routes — see devWatch.ts). While false,
+// build.ts reuses the previous route-manifest.json instead of re-walking
+// src/routes. Starts true so the first build always scans.
+let routesDirty = true;
+
 async function runBuild(): Promise<boolean> {
 	console.log("🏗️  Building...");
+	// Managed mode has no watcher, so we never know what changed — always scan.
+	const skipScan = !MANAGED && !routesDirty;
+	routesDirty = false;
 	const proc = spawn(["bun", "run", BUILD_SCRIPT], {
 		stdout: "inherit",
 		stderr: "inherit",
 		cwd: process.cwd(),
-		env: { ...process.env, BOSIA_OUT_DIR: DEV_OUT_DIR },
+		env: {
+			...process.env,
+			BOSIA_OUT_DIR: DEV_OUT_DIR,
+			BOSIA_SKIP_ROUTE_SCAN: skipScan ? "1" : "0",
+		},
 	});
 	return (await proc.exited) === 0;
 }
@@ -281,8 +295,10 @@ async function buildAndRestart(): Promise<boolean> {
 				return false;
 			}
 			await startAppServer();
-			// Give the app server a moment to bind its port
-			await Bun.sleep(200);
+			// Wait until the app server actually answers before telling browsers
+			// to reload — a fixed sleep was too slow for fast binds and too short
+			// for slow ones.
+			await waitForAppHealthy();
 			broadcastReload();
 		} while (buildPending);
 		return ok;
@@ -291,6 +307,20 @@ async function buildAndRestart(): Promise<boolean> {
 	}
 }
 
+// Poll /_health until the freshly-spawned app server answers. 127.0.0.1, not
+// "localhost" — same IPv6-vs-IPv4 pin as the proxy below. On timeout we give
+// up and broadcast anyway; the STARTING_PAGE retry loop covers stragglers.
+async function waitForAppHealthy(timeoutMs = 10_000): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		try {
+			const res = await fetch(`http://127.0.0.1:${APP_PORT}/_health`);
+			if (res.ok) return;
+		} catch {}
+		await Bun.sleep(50);
+	}
+}
+
 function scheduleBuild() {
 	if (buildTimer) clearTimeout(buildTimer);
 	buildTimer = setTimeout(buildAndRestart, 300);
@@ -488,6 +518,7 @@ function isGenerated(path: string): boolean {
 // scheduleBuild() for an edit that was already handled.
 
 const SRC_DIR = join(process.cwd(), "src");
+const ROUTES_DIR = join(SRC_DIR, "routes");
 const MTIME_POLL_MS = 5_000;
 const mtimes = new Map<string, number>();
 
@@ -503,6 +534,8 @@ if (!MANAGED) {
 		if (!filename) return;
 		const abs = join(process.cwd(), "src", filename);
 		if (isGenerated(abs)) return;
+		if (shouldIgnoreForRebuild(abs)) return;
+		if (affectsRouteManifest(abs, ROUTES_DIR)) routesDirty = true;
 		console.log(`[watch] changed: ${filename}`);
 		try {
 			mtimes.set(abs, statSync(abs).mtimeMs);
@@ -533,6 +566,9 @@ function walkSrc(out: Map<string, number>): void {
 				continue;
 			}
 			if (!ent.isFile()) continue;
+			// Keep ignored files out of the mtime map entirely, mirroring the
+			// fs.watch filter — the poll then can't fire on them either.
+			if (shouldIgnoreForRebuild(abs)) continue;
 			try {
 				out.set(abs, statSync(abs).mtimeMs);
 			} catch {
@@ -552,19 +588,20 @@ if (!MANAGED) {
 
 		let changed: string | null = null;
 
+		// One sweep can absorb several files (agents write in batches) and the
+		// whole map is replaced below, so every diff — not just the first —
+		// must be checked against the route manifest.
 		for (const [path, ts] of fresh) {
 			const prev = mtimes.get(path);
 			if (prev === undefined || prev !== ts) {
-				changed = path;
-				break;
+				changed ??= path;
+				if (affectsRouteManifest(path, ROUTES_DIR)) routesDirty = true;
 			}
 		}
-		if (!changed) {
-			for (const path of mtimes.keys()) {
-				if (!fresh.has(path)) {
-					changed = path;
-					break;
-				}
+		for (const path of mtimes.keys()) {
+			if (!fresh.has(path)) {
+				changed ??= path;
+				if (affectsRouteManifest(path, ROUTES_DIR)) routesDirty = true;
 			}
 		}
 

package/src/core/devWatch.ts

@@ -0,0 +1,28 @@
+import { basename, sep } from "path";
+
+// ─── Dev Watcher Classification ──────────────────────────
+// Pure helpers for dev.ts (kept separate so they're testable — dev.ts is a
+// side-effecting script that starts servers on import).
+
+// Changes that can never affect the built app: docs, tests, editor droppings.
+const IGNORED_RE = /\.(md|markdown)$|\.(test|spec)\.[jt]sx?$|(~|\.swp|\.swo|\.tmp)$/i;
+
+export function shouldIgnoreForRebuild(absPath: string): boolean {
+	const name = basename(absPath);
+	return name === ".DS_Store" || IGNORED_RE.test(name);
+}
+
+/**
+ * True when a change at `absPath` can alter the route manifest. The scanner
+ * only reads `+`-prefixed files and directory structure under src/routes, so
+ * everything else (colocated components, lib files) can reuse the cached
+ * manifest. A basename without a dot is treated as a directory — group/param
+ * folder renames must rescan, and the path may already be gone so we can't
+ * stat. False negatives are impossible by construction; false positives just
+ * cost one extra scan.
+ */
+export function affectsRouteManifest(absPath: string, routesDir: string): boolean {
+	if (absPath !== routesDir && !absPath.startsWith(routesDir + sep)) return false;
+	const name = basename(absPath);
+	return name.startsWith("+") || !name.includes(".");
+}