bosia 0.5.7 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.5.7",
+	"version": "0.5.8",
 	"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/build.ts

@@ -5,7 +5,7 @@ import { scanRoutes } from "./scanner.ts";
 import { generateRoutesFile } from "./routeFile.ts";
 import { generateRouteTypes, ensureRootDirs } from "./routeTypes.ts";
 import { makeBosiaPlugin } from "./plugin.ts";
-import { makeBosiaSvelteCompiler } from "./svelteCompiler.ts";
+import { makeBosiaSvelteCompiler, svelteMapCache } from "./svelteCompiler.ts";
 import { prerenderStaticRoutes, generateStaticSite } from "./prerender.ts";
 import { loadEnv, classifyEnvVars } from "./env.ts";
 import { generateEnvModules } from "./envCodegen.ts";
@@ -187,6 +187,18 @@ if (!serverResult.success) {
 	process.exit(1);
 }
 
+// Persist the per-file Svelte compile maps so the inspector's runtime stack
+// resolver can chain bundle-map → svelte-map to land on original source. We
+// cannot chain at bundle time because Bun's bundle maps reference intermediate
+// JS positions that are mostly absent from Svelte's sparse compile map —
+// post-build remapping nukes mappings. Instead we keep both maps separate and
+// do a two-stage lookup with `bias` interpolation in the resolver.
+if (!isProduction && svelteMapCache.size > 0) {
+	const entries: Record<string, unknown> = {};
+	for (const [k, v] of svelteMapCache) entries[k] = v;
+	writeFileSync(`${OUT_DIR}/svelte-maps.json`, JSON.stringify(entries));
+}
+
 // 6. Collect output files for dist/manifest.json
 const jsFiles: string[] = [];
 const cssFiles: string[] = [];

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

@@ -2,6 +2,7 @@ import { parse, compile } from "svelte/compiler";
 import MagicString from "magic-string";
 import { basename, relative } from "node:path";
 import type { BunPlugin } from "bun";
+import { svelteMapCache } from "../../svelteCompiler.ts";
 
 const VIRTUAL_NS = "bosia-inspector-css";
 
@@ -87,6 +88,21 @@ export interface InspectorBunPluginOptions {
 	dev: boolean;
 }
 
+// Svelte 5 dev compile emits named `function get()` / `function set($$value)`
+// expressions inside `$.bind_*` calls (for nicer `$inspect` stack traces). Bun's
+// bundler destructures `import * as $ from "svelte/internal/client"` into named
+// imports, so `$.get(search)` becomes plain `get(search)` — which collides with
+// the wrapping function name and recurses into itself → RangeError. Prod compile
+// uses anonymous arrow functions and is unaffected.
+//
+// Rename to `$$g` / `$$s` (3 chars — length-preserving so cached svelte source
+// map columns stay accurate). These names aren't present in svelte/internal/client.
+function fixBindShadow(code: string): string {
+	return code
+		.replace(/\bfunction get\(\)/g, () => "function $$g()")
+		.replace(/\bfunction set\(\$\$value\)/g, () => "function $$s($$value)");
+}
+
 const fnv = (s: string): string => {
 	let h = 2166136261;
 	for (let i = 0; i < s.length; i++) {
@@ -120,7 +136,29 @@ export function createInspectorBunPlugin(opts: InspectorBunPluginOptions): BunPl
 					cssHash: ({ css }) => `svelte-${fnv(css)}`,
 				});
 
-				let js = result.js.code;
+				// Store Svelte's compile-step map. Bun's bundler doesn't chain
+				// onLoad sourcemaps, so the final bundle map resolves stack frames
+				// to the post-svelte-compile JS intermediate (`$.next()` /
+				// `$.append()` calls) using the .svelte filename — line numbers
+				// land past EOF. The inspector's runtime resolver chases bundle
+				// map → this svelte map (with bias-interpolated lookup) to refine
+				// to original source. `injectLocs` only shifts column offsets
+				// inside HTML open tags, never script-block line numbers, so we
+				// accept the small column drift to skip a second map chain.
+				//
+				// Only cache for the client target — server (Bun) and client builds
+				// share `svelteMapCache` keyed by abs path, but their compile output
+				// line numbers differ. The resolver translates browser-side stack
+				// frames (delivered via SSE), which run client code.
+				if (dev && generate === "client" && result.js.map) {
+					const m =
+						typeof result.js.map === "string"
+							? JSON.parse(result.js.map)
+							: result.js.map;
+					svelteMapCache.set(args.path, m);
+				}
+
+				let js = dev ? fixBindShadow(result.js.code) : result.js.code;
 				// 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".

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

@@ -1,10 +1,37 @@
-import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
+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";
 
 const cache = new Map<string, TraceMap | null>();
 
+// Per-`.svelte` (absolute path) compile maps written by the build step. The
+// bundle map only resolves a stack frame to the post-svelte-compile JS
+// position labeled with the .svelte filename; a second lookup against this
+// map (with `bias: GREATEST_LOWER_BOUND` to interpolate sparse mappings)
+// translates that intermediate position to original source line/col.
+let svelteMaps: Map<string, TraceMap> | null = null;
+let svelteMapsLoaded = false;
+
+function loadSvelteMaps(): Map<string, TraceMap> | null {
+	if (svelteMapsLoaded) return svelteMaps;
+	svelteMapsLoaded = true;
+	try {
+		const p = pathResolve(process.cwd(), OUT_DIR, "svelte-maps.json");
+		if (!existsSync(p)) return null;
+		const raw = JSON.parse(readFileSync(p, "utf8")) as Record<string, unknown>;
+		svelteMaps = new Map();
+		for (const [absPath, m] of Object.entries(raw)) {
+			try {
+				svelteMaps.set(absPath, new TraceMap(m as never));
+			} catch {}
+		}
+		return svelteMaps;
+	} catch {
+		return null;
+	}
+}
+
 function loadMap(mapPath: string): TraceMap | null {
 	if (cache.has(mapPath)) return cache.get(mapPath)!;
 	try {
@@ -57,6 +84,39 @@ export function resolveFrame(
 	const pos = originalPositionFor(tm, { line, column: col });
 	if (!pos.source || pos.line == null) return null;
 	const abs = pathResolve(dirname(mp), pos.source);
+
+	// Bundle map points at the post-svelte-compile JS position labeled with the
+	// .svelte filename. Refine by chasing through the cached svelte compile map
+	// to the real source position. Svelte's map is sparse — a given line may
+	// only carry mappings starting at some column. Try the exact column first,
+	// then fall back to the rightmost mapping on the same line, so we never lose
+	// a frame just because the bundle's reported column lands in a gap.
+	if (abs.endsWith(".svelte") || abs.endsWith(".svelte.ts") || abs.endsWith(".svelte.js")) {
+		const maps = loadSvelteMaps();
+		const svelteMap = maps?.get(abs);
+		if (svelteMap) {
+			let refined = originalPositionFor(svelteMap, {
+				line: pos.line,
+				column: pos.column ?? 0,
+				bias: GREATEST_LOWER_BOUND,
+			});
+			if (!refined.source) {
+				refined = originalPositionFor(svelteMap, {
+					line: pos.line,
+					column: Number.MAX_SAFE_INTEGER,
+					bias: GREATEST_LOWER_BOUND,
+				});
+			}
+			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 };
+			}
+		}
+	}
+
 	const rel = abs.startsWith(process.cwd() + "/") ? abs.slice(process.cwd().length + 1) : abs;
 	return { file: rel, line: pos.line, col: pos.column ?? 1 };
 }

package/src/core/svelteCompiler.ts

@@ -3,6 +3,29 @@ import type { BunPlugin } from "bun";
 
 const svelteHash = (s: string) => Bun.hash(s, 5381).toString(36);
 
+// Bun's bundler does not chain sourcemaps from `onLoad` results, so the final
+// bundle map points at the compiled svelte output (e.g. `$.next()`) using the
+// .svelte filename — runtime stacks resolve to nonsense line numbers past EOF.
+// We capture each per-file svelte compile map here, keyed by absolute source
+// path; `remapBundleSourcemaps()` reads these after `Bun.build` and rewrites
+// the output `.map` files to chain back to original source positions.
+export const svelteMapCache = new Map<string, unknown>();
+
+// Svelte 5 dev compile emits named `function get()` / `function set($$value)`
+// expressions inside `$.bind_*` calls (for nicer `$inspect` stack traces). Bun's
+// bundler destructures `import * as $ from "svelte/internal/client"` into named
+// imports, so `$.get(search)` becomes plain `get(search)` — which collides with
+// the wrapping function name and recurses into itself → RangeError. Prod compile
+// uses anonymous arrow functions and is unaffected.
+//
+// Rename to `$$g` / `$$s` (3 chars — length-preserving so cached svelte source
+// map columns stay accurate). These names aren't present in svelte/internal/client.
+function fixBindShadow(code: string): string {
+	return code
+		.replace(/\bfunction get\(\)/g, () => "function $$g()")
+		.replace(/\bfunction set\(\$\$value\)/g, () => "function $$s($$value)");
+}
+
 export function makeBosiaSvelteCompiler(target: "browser" | "bun"): BunPlugin {
 	const generate = target === "browser" ? "client" : "server";
 	const dev = process.env.NODE_ENV !== "production";
@@ -25,7 +48,19 @@ export function makeBosiaSvelteCompiler(target: "browser" | "bun"): BunPlugin {
 					cssHash: ({ css }) => `svelte-${svelteHash(css)}`,
 					filename: args.path,
 				});
-				return { contents: result.js.code, loader: "ts" };
+				// Only the client target's map is useful to the inspector's runtime
+				// resolver — browser-side stack frames are what we need to translate.
+				// Server (Bun) compile output has different line numbers and would
+				// clobber the client entry under the same cache key.
+				if (dev && target === "browser" && result.js.map) {
+					const m =
+						typeof result.js.map === "string"
+							? JSON.parse(result.js.map)
+							: result.js.map;
+					svelteMapCache.set(args.path, m);
+				}
+				const contents = dev ? fixBindShadow(result.js.code) : result.js.code;
+				return { contents, loader: "ts" };
 			});
 
 			build.onLoad({ filter: /\.svelte\.[tj]s$/ }, async (args) => {
@@ -38,6 +73,13 @@ export function makeBosiaSvelteCompiler(target: "browser" | "bun"): BunPlugin {
 					dev,
 					filename: args.path,
 				});
+				if (dev && target === "browser" && result.js.map) {
+					const m =
+						typeof result.js.map === "string"
+							? JSON.parse(result.js.map)
+							: result.js.map;
+					svelteMapCache.set(args.path, m);
+				}
 				return { contents: result.js.code, loader: "js" };
 			});
 		},