bosia 0.9.6 → 0.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.9.6",
+	"version": "0.9.8",
 	"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

@@ -5,6 +5,7 @@ import { spawn } from "bun";
 import * as p from "@clack/prompts";
 import { installFeature, initFeatRegistry, resolveLocalRegistry } from "./feat.ts";
 import { initAddRegistry } from "./add.ts";
+import { toPosix } from "../core/paths.ts";
 
 // ─── bun x bosia@latest create <name> [--template <name>] ─
 
@@ -283,7 +284,7 @@ function copyDir(src: string, dest: string, projectName: string, isLocal: boolea
 
 			if (entry.name === "package.json" && isLocal) {
 				const bosiaPath = resolve(import.meta.dir, "../../");
-				const relPath = relative(dest, bosiaPath);
+				const relPath = toPosix(relative(dest, bosiaPath));
 				content = content.replaceAll('"^{{BOSIA_VERSION}}"', `"file:${relPath}"`);
 			} else {
 				content = content.replaceAll("{{BOSIA_VERSION}}", BOSIA_VERSION);

package/src/cli/registry.ts

@@ -21,7 +21,7 @@ export interface InstallOptions {
 // ─── Local registry resolution ────────────────────────────
 
 export function resolveLocalRegistry(): string {
-	let dir = dirname(new URL(import.meta.url).pathname);
+	let dir = import.meta.dir;
 	for (let i = 0; i < 10; i++) {
 		const candidate = join(dir, "registry");
 		if (existsSync(join(candidate, "index.json"))) return candidate;

package/src/cli/sync.ts

@@ -1,4 +1,4 @@
-import { scanRoutes } from "../core/scanner.ts";
+import { scanRoutes, RouteConflictError } from "../core/scanner.ts";
 import { generateRoutesFile } from "../core/routeFile.ts";
 import { generateRouteTypes, ensureRootDirs } from "../core/routeTypes.ts";
 import { loadEnv, classifyEnvVars } from "../core/env.ts";
@@ -8,7 +8,14 @@ import { findBrandPlaceholders, BRAND_SENTINEL } from "../core/brandGuard.ts";
 export async function runSync() {
 	const envMode = process.env.NODE_ENV === "production" ? "production" : "development";
 	const classifiedEnv = classifyEnvVars(loadEnv(envMode));
-	const manifest = scanRoutes();
+	let manifest;
+	try {
+		manifest = scanRoutes();
+	} catch (err) {
+		if (!(err instanceof RouteConflictError)) throw err;
+		console.error(`❌ ${err.message}`);
+		process.exit(1);
+	}
 	generateRoutesFile(manifest);
 	generateRouteTypes(manifest);
 	ensureRootDirs();

package/src/core/build.ts

@@ -1,8 +1,8 @@
 import { writeFileSync, readFileSync, rmSync, mkdirSync, existsSync } from "fs";
-import { join, relative } from "path";
+import { basename, join, relative } from "path";
 import type { RouteManifest } from "./types.ts";
 
-import { scanRoutes } from "./scanner.ts";
+import { scanRoutes, RouteConflictError } from "./scanner.ts";
 import { generateRoutesFile } from "./routeFile.ts";
 import { generateRouteTypes, ensureRootDirs } from "./routeTypes.ts";
 import { makeBosiaPlugin } from "./plugin.ts";
@@ -11,7 +11,7 @@ import { finalizeComponentCss } from "./componentCss.ts";
 import { prerenderStaticRoutes, generateStaticSite } from "./prerender.ts";
 import { loadEnv, classifyEnvVars } from "./env.ts";
 import { generateEnvModules } from "./envCodegen.ts";
-import { BOSIA_NODE_PATH, OUT_DIR, resolveBosiaBin } from "./paths.ts";
+import { BOSIA_NODE_PATH, OUT_DIR, resolveBosiaBin, toPosix } from "./paths.ts";
 import { currentBase } from "./appBase.ts";
 import { finalizeTailwindCss, TW_TEMP_BASENAME } from "./twHash.ts";
 import { loadPlugins } from "./config.ts";
@@ -85,7 +85,14 @@ for (const p of [
 }
 
 // 1. Scan routes (or reuse the cached manifest — see 0b-pre)
-const manifest = cachedManifest ?? scanRoutes();
+let manifest: RouteManifest;
+try {
+	manifest = cachedManifest ?? scanRoutes();
+} catch (err) {
+	if (!(err instanceof RouteConflictError)) throw err;
+	console.error(`❌ ${err.message}`);
+	process.exit(1);
+}
 buildCtx.manifest = manifest;
 console.log(
 	`📂 Found ${manifest.pages.length} page route(s)${cachedManifest ? " (cached scan)" : ""}:`,
@@ -251,7 +258,7 @@ const cssFiles: string[] = [];
 // `output.kind === "entry-point"` instead so we pin the actual entry.
 let clientEntry: string | null = null;
 for (const output of clientResult.outputs) {
-	const rel = relative(`${OUT_DIR}/client`, output.path);
+	const rel = toPosix(relative(`${OUT_DIR}/client`, output.path)); // URL path, not fs path
 	if (output.path.endsWith(".js")) jsFiles.push(rel);
 	if (output.path.endsWith(".css")) cssFiles.push(rel);
 	if ((output as { kind?: string }).kind === "entry-point" && output.path.endsWith(".js")) {
@@ -271,11 +278,8 @@ if (componentCssFile) {
 }
 
 // Entry is always "index.js" due to naming: { entry: "index.[ext]" }
-const serverEntry =
-	serverResult.outputs
-		.find((o) => o.path.endsWith("index.js"))
-		?.path.split("/")
-		.pop() ?? "index.js";
+const serverEntryOutput = serverResult.outputs.find((o) => o.path.endsWith("index.js"));
+const serverEntry = serverEntryOutput ? basename(serverEntryOutput.path) : "index.js";
 
 // 8. Write dist/manifest.json
 mkdirSync(OUT_DIR, { recursive: true });

package/src/core/paths.ts

@@ -1,4 +1,4 @@
-import { join, dirname } from "path";
+import { join, dirname, delimiter } from "path";
 import { existsSync } from "fs";
 
 // This file lives at src/core/paths.ts → package root is ../..
@@ -26,18 +26,31 @@ const ANCESTOR_NM = collectAncestorNodeModules(dirname(BOSIA_PKG_DIR));
 const ALL_NM = [NESTED_NM, ...ANCESTOR_NM];
 
 /** NODE_PATH value covering nested and every ancestor node_modules */
-export const BOSIA_NODE_PATH = ALL_NM.join(":");
+export const BOSIA_NODE_PATH = ALL_NM.join(delimiter); // ";" on Windows, ":" elsewhere
 
 // On-disk output directory. URL namespace (/dist/client/...) stays stable;
 // only the on-disk location moves so dev (.bosia/dev) and a parallel
 // `bun run build` (./dist) don't clobber each other.
 export const OUT_DIR = process.env.BOSIA_OUT_DIR ?? "./dist";
 
+/** Normalize a filesystem path to forward slashes (for URLs, manifests, imports). */
+export function toPosix(p: string): string {
+	return p.replace(/\\/g, "/");
+}
+
+/** `.bin` file names to try for `name`. Windows shims carry an extension. */
+export function binCandidates(name: string, platform: string = process.platform): string[] {
+	return platform === "win32" ? [`${name}.exe`, `${name}.cmd`, `${name}.bunx`, name] : [name];
+}
+
 /** Find a binary from bosia's dependencies (handles hoisting) */
 export function resolveBosiaBin(name: string): string {
+	const candidates = binCandidates(name);
 	for (const nm of ALL_NM) {
-		const bin = join(nm, ".bin", name);
-		if (existsSync(bin)) return bin;
+		for (const file of candidates) {
+			const bin = join(nm, ".bin", file);
+			if (existsSync(bin)) return bin;
+		}
 	}
-	return join(NESTED_NM, ".bin", name); // fallback — will produce a clear ENOENT
+	return join(NESTED_NM, ".bin", candidates[0]); // fallback — will produce a clear ENOENT
 }

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

@@ -4,6 +4,7 @@ import { relative } from "node:path";
 import type { BunPlugin } from "bun";
 import { svelteMapCache } from "../../svelteCompiler.ts";
 import { lineColFromOffset } from "../../sourceLoc.ts";
+import { toPosix } from "../../paths.ts";
 import { collectComponentCss } from "../../componentCss.ts";
 
 type AnyNode = {
@@ -129,7 +130,7 @@ export function createInspectorBunPlugin(opts: InspectorBunPluginOptions): BunPl
 		setup(build) {
 			build.onLoad({ filter: /\.svelte$/ }, async (args) => {
 				const source = await Bun.file(args.path).text();
-				const rel = relative(cwd, args.path);
+				const rel = toPosix(relative(cwd, args.path));
 				const transformed = injectLocs(source, rel);
 
 				const result = compile(transformed, {

package/src/core/plugins/inspector/sourcemap.ts

@@ -1,7 +1,7 @@
 import { TraceMap, originalPositionFor, GREATEST_LOWER_BOUND } from "@jridgewell/trace-mapping";
 import { readFileSync, existsSync } from "node:fs";
-import { dirname, resolve as pathResolve } from "node:path";
-import { OUT_DIR } from "../../paths.ts";
+import { dirname, isAbsolute, relative, resolve as pathResolve } from "node:path";
+import { OUT_DIR, toPosix } from "../../paths.ts";
 
 const cache = new Map<string, TraceMap | null>();
 
@@ -64,7 +64,7 @@ function mapPathFor(file: string): string | null {
 			? OUT_DIR + pathname.slice("/dist".length)
 			: "." + pathname;
 		fsPath = pathResolve(process.cwd(), relFromCwd);
-	} else if (file.startsWith("/")) {
+	} else if (isAbsolute(file)) {
 		fsPath = file;
 	} else {
 		fsPath = pathResolve(process.cwd(), file);
@@ -109,16 +109,18 @@ export function resolveFrame(
 			}
 			if (refined.source && refined.line != null) {
 				const refinedAbs = pathResolve(dirname(abs), refined.source);
-				const rel = refinedAbs.startsWith(process.cwd() + "/")
-					? refinedAbs.slice(process.cwd().length + 1)
-					: refinedAbs;
-				return { file: rel, line: refined.line, col: refined.column ?? 1 };
+				return { file: relToCwd(refinedAbs), line: refined.line, col: refined.column ?? 1 };
 			}
 		}
 	}
 
-	const rel = abs.startsWith(process.cwd() + "/") ? abs.slice(process.cwd().length + 1) : abs;
-	return { file: rel, line: pos.line, col: pos.column ?? 1 };
+	return { file: relToCwd(abs), line: pos.line, col: pos.column ?? 1 };
+}
+
+// cwd-relative "/"-separated path when `abs` is inside cwd, else `abs` unchanged.
+function relToCwd(abs: string): string {
+	const rel = relative(process.cwd(), abs);
+	return rel && !rel.startsWith("..") && !isAbsolute(rel) ? toPosix(rel) : abs;
 }
 
 // Rewrite frames in stack strings: "(url:L:C)", "at url:L:C", "@url:L:C".

package/src/core/port.ts

@@ -1,16 +1,38 @@
-/** PIDs listening on `port`. Fails open to [] — lsof may be absent. */
+/** PIDs listening on `port`. Fails open to [] — lsof / netstat may be absent. */
 export async function pidsOnPort(port: number): Promise<number[]> {
+	const isWindows = process.platform === "win32";
 	try {
-		const proc = Bun.spawn(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"], {
-			stdout: "pipe",
-			stderr: "ignore",
-		});
+		const cmd = isWindows ? ["netstat", "-ano"] : ["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"];
+		const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "ignore" });
 		const out = await new Response(proc.stdout).text();
 		await proc.exited;
-		return [...new Set(out.split("\n").map((s) => s.trim()))]
-			.map(Number)
-			.filter((pid) => Number.isInteger(pid) && pid > 0);
+		return isWindows ? parseNetstat(out, port) : parseLsof(out);
 	} catch {
 		return [];
 	}
 }
+
+/** `lsof -t` output: one PID per line. */
+export function parseLsof(out: string): number[] {
+	return uniquePids(out.split("\n").map((s) => s.trim()));
+}
+
+/**
+ * `netstat -ano` (Windows) rows: `TCP  0.0.0.0:3000  0.0.0.0:0  LISTENING  1234`.
+ * The state column is localized on non-English Windows, so a listener is
+ * detected by its foreign address ending in `:0` instead of the word LISTENING.
+ */
+export function parseNetstat(out: string, port: number): number[] {
+	const pids: string[] = [];
+	for (const line of out.split(/\r?\n/)) {
+		const cols = line.trim().split(/\s+/);
+		if (cols.length < 5 || cols[0].toUpperCase() !== "TCP") continue;
+		const [, local, foreign] = cols;
+		if (local.endsWith(`:${port}`) && foreign.endsWith(":0")) pids.push(cols[cols.length - 1]);
+	}
+	return uniquePids(pids);
+}
+
+function uniquePids(raw: string[]): number[] {
+	return [...new Set(raw)].map(Number).filter((pid) => Number.isInteger(pid) && pid > 0);
+}

package/src/core/routeFile.ts

@@ -1,6 +1,7 @@
 import { writeFileSync, mkdirSync } from "fs";
 import type { RouteManifest } from "./types.ts";
 import { currentBase } from "./appBase.ts";
+import { toPosix } from "./paths.ts";
 
 /**
  * The pattern the *client* router matches against. It sees real browser URLs, so
@@ -250,5 +251,5 @@ function generateClientRoutesFile(
 
 // Import path from .bosia/routes.ts to src/routes/<routePath>
 function toImportPath(routePath: string): string {
-	return "../src/routes/" + routePath.replace(/\\/g, "/");
+	return "../src/routes/" + toPosix(routePath);
 }

package/src/core/routeTypes.ts

@@ -1,6 +1,7 @@
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import type { RouteManifest } from "./types.ts";
+import { toPosix } from "./paths.ts";
 
 // ─── Route Types Generator ────────────────────────────────
 // Generates .bosia/types/src/routes/**/$types.d.ts for each
@@ -9,7 +10,7 @@ import type { RouteManifest } from "./types.ts";
 // work in +page.svelte files — identical to SvelteKit's API.
 
 function routeDirOf(filePath: string): string {
-	const parts = filePath.replace(/\\/g, "/").split("/");
+	const parts = toPosix(filePath).split("/");
 	parts.pop();
 	return parts.join("/") || ".";
 }

package/src/core/safePath.ts

@@ -1,4 +1,4 @@
-import { join, resolve as resolvePath } from "path";
+import { join, resolve as resolvePath, sep } from "path";
 
 /**
  * Resolve `untrusted` relative to `base` and verify the result stays inside
@@ -10,5 +10,5 @@ import { join, resolve as resolvePath } from "path";
 export function safePath(base: string, untrusted: string): string | null {
 	const root = resolvePath(base);
 	const full = resolvePath(join(base, untrusted));
-	return full.startsWith(root + "/") || full === root ? full : null;
+	return full.startsWith(root + sep) || full === root ? full : null;
 }

package/src/core/scanner.ts

@@ -70,6 +70,10 @@ export function scanRoutes(): RouteManifest {
 		const fullDir = join(ROUTES_DIR, dir);
 		if (!existsSync(fullDir)) return;
 
+		// Manifest paths are always "/"-separated (they become import specifiers),
+		// so build them by hand — path.join would emit "\" on Windows.
+		const rel = (name: string) => (dir ? `${dir}/${name}` : name);
+
 		const items = readdirSync(fullDir, { withFileTypes: true });
 
 		// Accumulate layouts for this level
@@ -81,14 +85,14 @@ export function scanRoutes(): RouteManifest {
 		// as the layout chain. Without this a section with 40 routes needed 40
 		// identical +loading.svelte files to cover its navigations.
 		const currentLoading = items.some((i) => i.isFile() && i.name === "+loading.svelte")
-			? join(dir, "+loading.svelte")
+			? rel("+loading.svelte")
 			: inheritedLoading;
 
 		if (items.some((i) => i.isFile() && i.name === "+layout.svelte")) {
-			currentLayouts.push(join(dir, "+layout.svelte"));
+			currentLayouts.push(rel("+layout.svelte"));
 		}
 		if (items.some((i) => i.isFile() && i.name === "+layout.server.ts")) {
-			const layoutServerPath = join(dir, "+layout.server.ts");
+			const layoutServerPath = rel("+layout.server.ts");
 			currentLayoutServers.push({
 				path: layoutServerPath,
 				depth: currentLayouts.length - 1,
@@ -100,7 +104,7 @@ export function scanRoutes(): RouteManifest {
 			// depth = number of layouts wrapping this dir (this dir's layout included).
 			// An error page at depth K renders inside layouts[0..K-1].
 			currentErrorPages.push({
-				path: join(dir, "+error.svelte"),
+				path: rel("+error.svelte"),
 				depth: currentLayouts.length,
 			});
 		}
@@ -109,20 +113,20 @@ export function scanRoutes(): RouteManifest {
 		if (items.some((i) => i.isFile() && i.name === "+server.ts")) {
 			apis.push({
 				pattern: toUrlPath(urlSegments),
-				server: join(dir, "+server.ts"),
+				server: rel("+server.ts"),
 			});
 		}
 
 		// Page route (+page.svelte)
 		if (items.some((i) => i.isFile() && i.name === "+page.svelte")) {
 			const pageServerFile = items.some((i) => i.isFile() && i.name === "+page.server.ts")
-				? join(dir, "+page.server.ts")
+				? rel("+page.server.ts")
 				: null;
 
 			const pageTs = pageServerFile ? readTrailingSlash(join(ROUTES_DIR, pageServerFile)) : null;
 			const effectiveTs: TrailingSlash = pageTs ?? currentTrailingSlash;
 
-			const pageFile = join(dir, "+page.svelte");
+			const pageFile = rel("+page.svelte");
 			pages.push({
 				pattern: toUrlPath(urlSegments),
 				page: pageFile,
@@ -146,7 +150,7 @@ export function scanRoutes(): RouteManifest {
 			const isGroup = /^\(.*\)$/.test(dirName);
 
 			walk(
-				dir ? join(dir, dirName) : dirName,
+				rel(dirName),
 				isGroup ? [...urlSegments] : [...urlSegments, dirName],
 				currentLayouts,
 				currentLayoutServers,
@@ -177,11 +181,45 @@ export function scanRoutes(): RouteManifest {
 		}
 	}
 
+	preventConflicts(pages, (p) => p.page);
+	preventConflicts(apis, (a) => a.server);
+
 	const errorPage = existsSync(join(ROUTES_DIR, "+error.svelte")) ? "+error.svelte" : null;
 
 	return { pages, apis, errorPage };
 }
 
+/**
+ * Fail when two route files serve the same URL — e.g. `+page.svelte` next to
+ * `(public)/+page.svelte`, or `blog/[id]` next to `(app)/blog/[slug]`. Route
+ * groups vanish from the URL and param names don't affect matching, so one of
+ * the two could never be reached. Same rule as SvelteKit's prevent_conflicts
+ * and Next.js's "two parallel pages that resolve to the same path".
+ */
+function preventConflicts<T extends { pattern: string }>(routes: T[], fileOf: (r: T) => string) {
+	const seen = new Map<string, T>();
+	for (const r of routes) {
+		const key = r.pattern.replace(/\[\.\.\.\w+\]/g, "[...]").replace(/\[\w+\]/g, "[]");
+		const first = seen.get(key);
+		if (!first) {
+			seen.set(key, r);
+			continue;
+		}
+		throw new RouteConflictError(
+			`The "${first.pattern}" and "${r.pattern}" routes conflict with each other:\n` +
+				`   src/routes/${fileOf(first)}\n` +
+				`   src/routes/${fileOf(r)}\n` +
+				`   Route groups like (public) are not part of the URL, and [id] matches the same URLs as [slug].\n` +
+				`   Delete or move one of them.`,
+		);
+	}
+}
+
+/** Two route files resolve to the same URL. Callers print `message` and exit. */
+export class RouteConflictError extends Error {
+	override name = "RouteConflictError";
+}
+
 function toUrlPath(segments: string[]): string {
 	if (segments.length === 0) return "/";
 	return "/" + segments.join("/");