npm - bosia - Versions diffs - 0.8.9 → 0.8.10 - Mend

bosia 0.8.9 → 0.8.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.8.9",
+	"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/core/build.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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(".");
+}