bimba-cli 0.7.19 → 0.7.21

package/index.js

@@ -168,6 +168,7 @@ async function bundle() {
     stats.failed = 0
     stats.compiled = 0
     stats.errors = 0
+    stats.reported = 0
     stats.bundled = 0
 
     const start = Date.now();
@@ -208,8 +209,10 @@ async function bundle() {
             }
         }
 
-        if(stats.failed)
-            console.log(theme.start(theme.failure(" Failure ") + theme.filename(` Imba compiler failed to proceed ${stats.failed} file${stats.failed > 1 ? 's' : ''}`)));
+        if(stats.failed) {
+            if (stats.reported)
+                console.log(theme.start(theme.failure(" Failure ") + theme.filename(` Imba compiler failed to proceed ${stats.failed} file${stats.failed > 1 ? 's' : ''}`)));
+        }
         else
             console.log(theme.start(theme.success("Success") +` It took ${theme.time(Date.now() - start)} ms to bundle ${theme.count(stats.bundled)} file${stats.bundled > 1 ? 's' : ''} to the folder: ${theme.filedir(flags.outdir)}`));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bimba-cli",
-  "version": "0.7.19",
+  "version": "0.7.21",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/HeapVoid/bimba.git"

package/plugin.js

@@ -1,162 +1,214 @@
-import { plugin } from "bun";
-import {theme} from './utils.js';
-import * as compiler from 'imba/compiler'
-import dir from 'path'
-import fs from 'fs'
-import { Glob } from "bun";
-import { unlink } from "node:fs/promises";
-
-export const cache = dir.join(process.cwd(), '.cache')
-if (!fs.existsSync(cache)){ fs.mkdirSync(cache);}
-
-// this should be reset from outside to get results of entrypoint building
-export let stats = {
-  failed: 0,
-  compiled: 0,
-  cached: 0,
-  bundled: 0,
-  errors: 0,
-};
-
-// Target platform for the Imba compiler: 'browser' or 'node'
-// Set via setTarget() from the CLI before building
-export let target = 'browser';
-export function setTarget(t) { target = t; }
-
-export const imbaPlugin = {
-  name: "imba",
-  async setup(build) {
-
-    // when an .imba file is imported...
-    build.onLoad({ filter: /\.imba$/ }, async ({ path }) => {
-
-      const f = dir.parse(path)
-      let contents = '';
-
-      // return the cached version if exists (include target in hash to avoid cross-platform cache hits)
-      const cached = dir.join(cache, Bun.hash(path + ':' + target) + '_' + fs.statSync(path).mtimeMs + '.js');
-      if (fs.existsSync(cached)) {
-        stats.bundled++;
-        stats.cached++;
-        return {
-          contents: await Bun.file(cached).text(),
-          loader: "js",
-        };
-      }
-
-      // clear previous cached version
-      const glob = new Glob(Bun.hash(path + ':' + target) + '_' + "*.js");
-      for await (const file of glob.scan(cache)) if (fs.existsSync(dir.join(cache, file))) unlink(dir.join(cache, file));
-
-      // if no cached version read and compile it with the imba compiler
-      const file = await Bun.file(path).text();
-      const platform = target === 'node' || target === 'bun' ? 'node' : 'browser';
-      const out = compiler.compile(file, {
-          sourcePath: path,
-          platform: platform,
-          comments: false
-      })
-      
-      // the file has been successfully compiled
-      if (!out.errors?.length) {
-        console.log(theme.action("compiling: ") + theme.folder(dir.join(f.dir,'/')) + theme.filename(f.base) + " - " + theme.success("compiled"));
-        stats.bundled++;
-        stats.compiled++;
-        contents = out.js;
-        await Bun.write(cached, contents);
-      }
-      // there were errors during compilation
-      else {
-        console.log(theme.action("compiling: ") + theme.folder(dir.join(f.dir,'/')) + theme.filename(f.base) + " - " + theme.failure(" fail "));
-        stats.failed++;
-        for (let i = 0; i < out.errors.length; i++) {
-          if(out.errors[i]) printerr(out.errors[i]);
-        }
-        stats.errors++;
-      }
-      
-      // and return the compiled source code as "js"
-      return {
-        contents,
-        loader: "js",
-      };
-    });
-  }
-};
-
-plugin(imbaPlugin);
-
-
-// -------------------------------------------------------------------------------
-// print pretty messages produced by the imba compiler 
-// -------------------------------------------------------------------------------
-
-// print an error generated by the imba compiler
-export function printerr(err) {
-
-  // halper function to produce empty strings
-  const fill = (len = 0) => {return new Array(len + 1).join(' ')}
-
-  // gather the needed information from the compiler error
-  const snippet = err.toSnippet().split("\n");
-  const errs = snippet[2] ? snippet[2].indexOf('^') : -1;
-
-  // no source context available — print compact fallback
-  if (!snippet[1] || errs === -1) {
-    console.log('');
-    console.log(fill(10) + theme.error(" " + err.message + " "));
-    console.log('');
-    return;
-  }
-
-  const display = {
-    error: " " + err.message + " ",
-    outdent: fill(10),
-    source: snippet[1] + "  ",
-    margin: " line " + (err.range.start.line + 1) + " ",
-    errs: errs,
-    erre: snippet[2].lastIndexOf('^') + 1,
-  };
-
-  // calculate parameters for priniting a message
-  const center = display.margin.length + display.errs + Math.floor((display.erre - display.errs) / 2);
-  const half = Math.ceil((display.error.length - 1) / 2);
-  const start = Math.max(0, center - half);
-  const end = start + display.error.length;
-  const total = Math.max(display.margin.length + display.source.length, end);
-
-  // print emtpy line
-  console.log('');
-
-  // print line with the error message
-  console.log(
-    display.outdent +
-    theme.margin(fill(Math.min(start, display.margin.length))) + 
-    theme.code(fill(Math.max(0, start - display.margin.length))) + 
-    theme.error(display.error) +
-    theme.margin(fill(Math.max(0, display.margin.length - end))) +
-    theme.code(fill(Math.min(total - display.margin.length, total - end)))
-  );
-
-  // print line with the source code
-  console.log(
-    display.outdent + 
-    theme.margin(display.margin) + 
-    theme.code(display.source.slice(0,display.errs)) + 
-    theme.error(display.source.slice(display.errs,display.erre)) + 
-    theme.code(display.source.slice(display.erre)) +
-    theme.code(fill(total - display.source.length - display.margin.length))
-  );
-
-  // print empty line to balance the view 
-  // later we can put something usefull here
-  // for example a link to online docs about the error
-  console.log(
-    display.outdent + 
-    theme.margin(fill(display.margin.length)) + 
-    theme.code(fill(total - display.margin.length))
-  );
-
-  // print emtpy line
-  console.log('');
-}
+import { plugin } from "bun";
+import {theme} from './utils.js';
+import * as compiler from 'imba/compiler'
+import dir from 'path'
+import fs from 'fs'
+import { Glob } from "bun";
+import { unlink } from "node:fs/promises";
+
+export const cache = dir.join(process.cwd(), '.cache')
+if (!fs.existsSync(cache)){ fs.mkdirSync(cache);}
+
+// this should be reset from outside to get results of entrypoint building
+export let stats = {
+  failed: 0,
+  compiled: 0,
+  cached: 0,
+  bundled: 0,
+  errors: 0,
+  reported: 0,
+};
+
+const _activeCompileErrors = new Map();
+
+function normalizeCompilePath(filepath) {
+  let value = String(filepath || '');
+  if (dir.isAbsolute(value)) {
+    const rel = dir.relative(process.cwd(), value);
+    if (!rel.startsWith('..')) value = rel;
+  }
+  return value.replaceAll('\\', '/');
+}
+
+function compileErrorMessage(error) {
+  return error?.message || String(error);
+}
+
+function compileErrorLine(error) {
+  return error?.range?.start?.line ?? error?.line ?? '';
+}
+
+function compileErrorSnippet(error) {
+  try {
+    return error?.toSnippet?.() || error?.snippet || error?.stack || compileErrorMessage(error);
+  } catch(_) {
+    return error?.snippet || error?.stack || compileErrorMessage(error);
+  }
+}
+
+function compileErrorSignature(errors) {
+  return errors
+    .map(error => [compileErrorMessage(error), compileErrorLine(error)].join('\n'))
+    .join('\n---\n');
+}
+
+function shouldPrintCompileError(filepath, errors) {
+  const key = normalizeCompilePath(filepath);
+  const signature = compileErrorSignature(errors);
+  const previous = _activeCompileErrors.get(key);
+  _activeCompileErrors.set(key, { signature, time: Date.now() });
+  return previous?.signature !== signature;
+}
+
+function clearCompileError(filepath) {
+  _activeCompileErrors.delete(normalizeCompilePath(filepath));
+}
+
+// Target platform for the Imba compiler: 'browser' or 'node'
+// Set via setTarget() from the CLI before building
+export let target = 'browser';
+export function setTarget(t) { target = t; }
+
+export const imbaPlugin = {
+  name: "imba",
+  async setup(build) {
+
+    // when an .imba file is imported...
+    build.onLoad({ filter: /\.imba$/ }, async ({ path }) => {
+
+      const f = dir.parse(path)
+      let contents = '';
+
+      // return the cached version if exists (include target in hash to avoid cross-platform cache hits)
+      const cached = dir.join(cache, Bun.hash(path + ':' + target) + '_' + fs.statSync(path).mtimeMs + '.js');
+      if (fs.existsSync(cached)) {
+        clearCompileError(path);
+        stats.bundled++;
+        stats.cached++;
+        return {
+          contents: await Bun.file(cached).text(),
+          loader: "js",
+        };
+      }
+
+      // clear previous cached version
+      const glob = new Glob(Bun.hash(path + ':' + target) + '_' + "*.js");
+      for await (const file of glob.scan(cache)) if (fs.existsSync(dir.join(cache, file))) unlink(dir.join(cache, file));
+
+      // if no cached version read and compile it with the imba compiler
+      const file = await Bun.file(path).text();
+      const platform = target === 'node' || target === 'bun' ? 'node' : 'browser';
+      const out = compiler.compile(file, {
+          sourcePath: path,
+          platform: platform,
+          comments: false
+      })
+      
+      // the file has been successfully compiled
+      if (!out.errors?.length) {
+        clearCompileError(path);
+        console.log(theme.action("compiling: ") + theme.folder(dir.join(f.dir,'/')) + theme.filename(f.base) + " - " + theme.success("compiled"));
+        stats.bundled++;
+        stats.compiled++;
+        contents = out.js;
+        await Bun.write(cached, contents);
+      }
+      // there were errors during compilation
+      else {
+        const shouldPrint = shouldPrintCompileError(path, out.errors);
+        if (shouldPrint) console.log(theme.action("compiling: ") + theme.folder(dir.join(f.dir,'/')) + theme.filename(f.base) + " - " + theme.failure(" fail "));
+        stats.failed++;
+        if (shouldPrint) {
+          stats.reported++;
+          for (let i = 0; i < out.errors.length; i++) {
+            if(out.errors[i]) printerr(out.errors[i]);
+          }
+        }
+        stats.errors++;
+      }
+      
+      // and return the compiled source code as "js"
+      return {
+        contents,
+        loader: "js",
+      };
+    });
+  }
+};
+
+plugin(imbaPlugin);
+
+
+// -------------------------------------------------------------------------------
+// print pretty messages produced by the imba compiler 
+// -------------------------------------------------------------------------------
+
+// print an error generated by the imba compiler
+export function printerr(err) {
+
+  // halper function to produce empty strings
+  const fill = (len = 0) => {return new Array(len + 1).join(' ')}
+
+  // gather the needed information from the compiler error
+  const snippet = err.toSnippet().split("\n");
+  const errs = snippet[2] ? snippet[2].indexOf('^') : -1;
+
+  // no source context available — print compact fallback
+  if (!snippet[1] || errs === -1) {
+    console.log('');
+    console.log(fill(10) + theme.error(" " + err.message + " "));
+    console.log('');
+    return;
+  }
+
+  const display = {
+    error: " " + err.message + " ",
+    outdent: fill(10),
+    source: snippet[1] + "  ",
+    margin: " line " + (err.range.start.line + 1) + " ",
+    errs: errs,
+    erre: snippet[2].lastIndexOf('^') + 1,
+  };
+
+  // calculate parameters for priniting a message
+  const center = display.margin.length + display.errs + Math.floor((display.erre - display.errs) / 2);
+  const half = Math.ceil((display.error.length - 1) / 2);
+  const start = Math.max(0, center - half);
+  const end = start + display.error.length;
+  const total = Math.max(display.margin.length + display.source.length, end);
+
+  // print emtpy line
+  console.log('');
+
+  // print line with the error message
+  console.log(
+    display.outdent +
+    theme.margin(fill(Math.min(start, display.margin.length))) + 
+    theme.code(fill(Math.max(0, start - display.margin.length))) + 
+    theme.error(display.error) +
+    theme.margin(fill(Math.max(0, display.margin.length - end))) +
+    theme.code(fill(Math.min(total - display.margin.length, total - end)))
+  );
+
+  // print line with the source code
+  console.log(
+    display.outdent + 
+    theme.margin(display.margin) + 
+    theme.code(display.source.slice(0,display.errs)) + 
+    theme.error(display.source.slice(display.errs,display.erre)) + 
+    theme.code(display.source.slice(display.erre)) +
+    theme.code(fill(total - display.source.length - display.margin.length))
+  );
+
+  // print empty line to balance the view 
+  // later we can put something usefull here
+  // for example a link to online docs about the error
+  console.log(
+    display.outdent + 
+    theme.margin(fill(display.margin.length)) + 
+    theme.code(fill(total - display.margin.length))
+  );
+
+  // print emtpy line
+  console.log('');
+}

package/serve.js

@@ -207,7 +207,7 @@ const hmrClient = `
 			const msg = JSON.parse(e.data);
 			if      (msg.type === 'update')      _applyUpdate(msg.file, msg.slots);
 			else if (msg.type === 'reload')      location.reload();
-			else if (msg.type === 'error')       showError(msg.file, msg.errors);
+			else if (msg.type === 'error')       showError(msg.file, msg.errors, msg.time);
 			else if (msg.type === 'clear-error') clearError(msg.file);
 		};
 
@@ -223,8 +223,9 @@ const hmrClient = `
 		return value;
 	}
 
-	function showError(file, errors) {
+	function showError(file, errors, time) {
 		const displayFile = normalizeFile(file);
+		const displayTime = time || new Date().toLocaleTimeString();
 		let overlay = document.getElementById('__bimba_error__');
 		if (!overlay) {
 			overlay = document.createElement('div');
@@ -237,7 +238,7 @@ const hmrClient = `
 		overlay.innerHTML = \`
 			<div style="background:#1a1a1a;border:1px solid #ff4444;border-radius:8px;max-width:860px;width:100%;max-height:90vh;overflow:auto;box-shadow:0 0 40px rgba(255,68,68,.3)">
 				<div style="background:#ff4444;color:#fff;padding:10px 16px;font-size:13px;font-weight:600;display:flex;justify-content:space-between;align-items:center">
-					<span>Compile error — \${displayFile}</span>
+					<span>Compile error — \${displayFile} <span style="opacity:.75;font-weight:400">\${displayTime}</span></span>
 					<span onclick="document.getElementById('__bimba_error__').remove()" style="cursor:pointer;opacity:.7;font-size:16px">✕</span>
 				</div>
 				\${errors.map(err => \`
@@ -353,16 +354,39 @@ function rewriteBareImports(js) {
 	return js
 }
 
+function isMissingFileError(error) {
+	return error?.code === 'ENOENT' || String(error?.message || error).includes('ENOENT: no such file or directory')
+}
+
+function missingCompileResult(filepath) {
+	dropFileState(filepath)
+	return { js: '', errors: [], slots: null, changeType: 'missing', missing: true }
+}
+
 async function compileFile(filepath) {
 	const abs = path.resolve(filepath)
+	if (!existsSync(abs)) return missingCompileResult(abs)
+
 	const file = Bun.file(filepath)
-	const stat = await file.stat()
+	let stat
+	try {
+		stat = await file.stat()
+	} catch (error) {
+		if (isMissingFileError(error)) return missingCompileResult(abs)
+		throw error
+	}
 	const mtime = stat.mtime.getTime()
 
 	const cached = _compileCache.get(abs)
 	if (cached && cached.mtime === mtime) return _normalizeResult(cached.result, { changeType: 'cached' })
 
-	const code = await file.text()
+	let code
+	try {
+		code = await file.text()
+	} catch (error) {
+		if (isMissingFileError(error)) return missingCompileResult(abs)
+		throw error
+	}
 	const result = compiler.compile(code, {
 		sourcePath: filepath,
 		platform: 'browser',
@@ -609,14 +633,108 @@ export function serve(entrypoint, flags) {
 
 	// ── File watcher ───────────────────────────────────────────────────────────
 
+	const _activeErrors = new Map()
+
 	function broadcast(payload) {
 		const msg = JSON.stringify(payload)
 		for (const socket of sockets) socket.send(msg)
 	}
 
+	function normalizeFile(file) {
+		let value = String(file || '')
+		if (path.isAbsolute(value)) {
+			const rel = path.relative(process.cwd(), value)
+			if (!rel.startsWith('..')) value = rel
+		}
+		value = value.replaceAll('\\', '/')
+		while (value.startsWith('./')) value = value.slice(2)
+		while (value.startsWith('/')) value = value.slice(1)
+		return value
+	}
+
+	function errorMessage(error) {
+		return error?.message || String(error)
+	}
+
+	function errorLine(error) {
+		return error?.range?.start?.line ?? error?.line
+	}
+
+	function errorSnippet(error) {
+		try {
+			return error?.toSnippet?.() || error?.snippet || error?.stack || errorMessage(error)
+		} catch(_) {
+			return error?.snippet || error?.stack || errorMessage(error)
+		}
+	}
+
+	function serializeErrors(errors) {
+		return errors.map(error => ({
+			message: errorMessage(error),
+			line: errorLine(error),
+			snippet: errorSnippet(error),
+		}))
+	}
+
+	function errorSignature(errors) {
+		return serializeErrors(errors)
+			.map(error => [error.message, error.line || ''].join('\n'))
+			.join('\n---\n')
+	}
+
+	function showTrackedError(file, item) {
+		printStatus(file, 'fail', item.errors)
+		broadcast({ type: 'error', file, time: item.time, errors: item.payload })
+	}
+
+	function reportError(file, errors) {
+		const key = normalizeFile(file)
+		const list = Array.isArray(errors) ? errors : [errors]
+		const signature = errorSignature(list)
+		const previous = _activeErrors.get(key)
+
+		const item = {
+			signature,
+			errors: list,
+			payload: serializeErrors(list),
+			time: new Date().toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit', second: '2-digit' }),
+		}
+		_activeErrors.set(key, item)
+		if (previous?.signature === signature && !_isTTY) {
+			broadcast({ type: 'error', file: key, time: item.time, errors: item.payload })
+			return
+		}
+
+		showTrackedError(key, item)
+	}
+
+	function errorText(errors) {
+		const list = Array.isArray(errors) ? errors : [errors]
+		return list.map(errorMessage).join('\n')
+	}
+
+	function errorResponse(file, errors, status = 500) {
+		reportError(file, errors)
+		return new Response(errorText(errors), { status })
+	}
+
 	function clearError(file) {
-		clearStatus(file)
-		broadcast({ type: 'clear-error', file })
+		const key = file ? normalizeFile(file) : null
+		const wasStatusFile = key && _statusFile === key
+		const hadError = key ? _activeErrors.has(key) : _activeErrors.size > 0
+
+		if (key) _activeErrors.delete(key)
+		else _activeErrors.clear()
+
+		if (key && !hadError && !wasStatusFile) return
+
+		clearStatus(key)
+		broadcast({ type: 'clear-error', file: key })
+
+		if (wasStatusFile && _activeErrors.size) {
+			const [nextFile, nextItem] = Array.from(_activeErrors.entries()).at(-1)
+			showTrackedError(nextFile, nextItem)
+		}
 	}
 
 	const _debounce = new Map()
@@ -644,7 +762,7 @@ export function serve(entrypoint, flags) {
 
 	async function compileChangedFile(filename, version) {
 		const filepath = path.join(srcDir, filename)
-		const rel = path.join(path.relative('.', srcDir), filename).replaceAll('\\', '/')
+		const rel = normalizeFile(path.join(path.relative('.', srcDir), filename))
 
 		try {
 			if (!existsSync(filepath)) {
@@ -657,14 +775,13 @@ export function serve(entrypoint, flags) {
 			const out = await compileFile(filepath)
 
 			if (!isCurrentChange(filename, version)) return
+			if (out.missing) {
+				clearError(rel)
+				return
+			}
 
 			if (out.errors?.length) {
-				printStatus(rel, 'fail', out.errors)
-				broadcast({ type: 'error', file: rel, errors: out.errors.map(e => ({
-					message: e.message,
-					line: e.range?.start?.line,
-					snippet: e.toSnippet(),
-				})) })
+				reportError(rel, out.errors)
 				return
 			}
 
@@ -677,8 +794,12 @@ export function serve(entrypoint, flags) {
 			broadcast({ type: 'update', file: rel, slots: out.slots || 'shifted' })
 		} catch(e) {
 			if (!isCurrentChange(filename, version)) return
-			printStatus(rel, 'fail', [{ message: e.message }])
-			broadcast({ type: 'error', file: rel, errors: [{ message: e.message, snippet: e.stack || e.message }] })
+			if (isMissingFileError(e)) {
+				dropFileState(filepath)
+				clearError(rel)
+				return
+			}
+			reportError(rel, [{ message: e.message, snippet: e.stack || e.message }])
 		}
 	}
 
@@ -695,6 +816,7 @@ export function serve(entrypoint, flags) {
 		fetch: async (req, server) => {
 			const url = new URL(req.url)
 			const pathname = url.pathname
+			try {
 
 			// WebSocket upgrade for HMR
 			if (pathname === '/__hmr__') {
@@ -703,44 +825,57 @@ export function serve(entrypoint, flags) {
 
 			if (pathname.startsWith('/__bimba_vendor__/')) {
 				const specifier = vendorSpecifierFromPath(pathname)
+				const file = 'vendor:' + (specifier || pathname)
 				const bundled = specifier ? await bundleVendor(specifier) : null
 				if (bundled?.code) {
+					clearError(file)
 					return new Response(bundled.code, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 
-				return new Response((bundled?.errors || [`Could not bundle vendor module: ${specifier}`]).join('\n'), { status: 500 })
+				return errorResponse(file, bundled?.errors || [`Could not bundle vendor module: ${specifier}`])
 			}
 
 			// HTML: index or any .html file
 			if (pathname === '/' || pathname.endsWith('.html')) {
 				const htmlFile = pathname === '/' ? htmlPath : '.' + pathname
-				let html = await Bun.file(htmlFile).text()
-				return new Response(transformHtml(html, entrypoint), {
-					headers: { 'Content-Type': 'text/html' },
-				})
+				const file = 'html:' + normalizeFile(htmlFile)
+				try {
+					let html = await Bun.file(htmlFile).text()
+					clearError(file)
+					return new Response(transformHtml(html, entrypoint), {
+						headers: { 'Content-Type': 'text/html' },
+					})
+				} catch (error) {
+					if (isMissingFileError(error)) {
+						clearError(file)
+						return new Response('Not Found', { status: 404 })
+					}
+					return errorResponse(file, [error])
+				}
 			}
 
 			// Imba files: compile on demand and serve as JS
 			if (pathname.endsWith('.imba')) {
 				const filepath = '.' + pathname
+				const file = normalizeFile(pathname)
 				try {
 					const out = await compileFile(filepath)
+					if (out.missing) {
+						clearError(file)
+						return new Response('Not Found', { status: 404 })
+					}
 					if (out.errors?.length) {
-						const file = pathname.replace(/^\//, '')
-						printStatus(file, 'fail', out.errors)
-						broadcast({ type: 'error', file, errors: out.errors.map(e => ({
-							message: e.message,
-							line: e.range?.start?.line,
-							snippet: e.toSnippet(),
-						})) })
-						return new Response(out.errors.map(e => e.message).join('\n'), { status: 500 })
+						return errorResponse(file, out.errors)
 					}
+					clearError(file)
 					return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				} catch(e) {
-					const file = pathname.replace(/^\//, '')
-					printStatus(file, 'fail', [{ message: e.message }])
-					broadcast({ type: 'error', file, errors: [{ message: e.message, snippet: e.stack || e.message }] })
-					return new Response(e.message, { status: 500 })
+					if (isMissingFileError(e)) {
+						dropFileState(filepath)
+						clearError(file)
+						return new Response('Not Found', { status: 404 })
+					}
+					return errorResponse(file, [{ message: e.message, snippet: e.stack || e.message }])
 				}
 			}
 
@@ -750,26 +885,50 @@ export function serve(entrypoint, flags) {
 			if (pathname.endsWith('.css')) {
 				const cssPath = resolveFileCandidate(path.join(htmlDir, pathname)) || resolveFileCandidate('.' + pathname)
 				const cssFile = cssPath ? Bun.file(cssPath) : null
-				if (cssFile && await cssFile.exists()) {
-					if (req.headers.get('sec-fetch-dest') === 'style') {
-						return new Response(cssFile, { headers: { 'Content-Type': 'text/css' } })
-					}
+				const file = 'css:' + normalizeFile(cssPath || pathname)
+				try {
+					if (cssFile && await cssFile.exists()) {
+						if (req.headers.get('sec-fetch-dest') === 'style') {
+							clearError(file)
+							return new Response(cssFile, { headers: { 'Content-Type': 'text/css' } })
+						}
 
-					const css = await cssFile.text()
-					const id = JSON.stringify(pathname)
-					const js = [
-						`const id = ${id};`,
-						`let el = document.querySelector('style[data-bimba-css=' + JSON.stringify(id) + ']');`,
-						`if (!el) { el = document.createElement('style'); el.setAttribute('data-bimba-css', id); document.head.appendChild(el); }`,
-						`el.textContent = ${JSON.stringify(css)};`,
-					].join('\n')
-					return new Response(js, { headers: { 'Content-Type': 'application/javascript' } })
+						const css = await cssFile.text()
+						const id = JSON.stringify(pathname)
+						const js = [
+							`const id = ${id};`,
+							`let el = document.querySelector('style[data-bimba-css=' + JSON.stringify(id) + ']');`,
+							`if (!el) { el = document.createElement('style'); el.setAttribute('data-bimba-css', id); document.head.appendChild(el); }`,
+							`el.textContent = ${JSON.stringify(css)};`,
+						].join('\n')
+						clearError(file)
+						return new Response(js, { headers: { 'Content-Type': 'application/javascript' } })
+					}
+				} catch (error) {
+					if (isMissingFileError(error)) {
+						clearError(file)
+						return new Response('Not Found', { status: 404 })
+					}
+					return errorResponse(file, [error])
 				}
 			}
 
 			if (!pathname.startsWith('/node_modules/') && (pathname.endsWith('.js') || pathname.endsWith('.mjs'))) {
 				const jsFile = resolveFileCandidate(path.join(htmlDir, pathname)) || resolveFileCandidate('.' + pathname)
-				if (jsFile) return serveJavaScriptFile(jsFile)
+				if (jsFile) {
+					const file = 'js:' + normalizeFile(jsFile)
+					try {
+						const response = await serveJavaScriptFile(jsFile)
+						clearError(file)
+						return response
+					} catch (error) {
+						if (isMissingFileError(error)) {
+							clearError(file)
+							return new Response('Not Found', { status: 404 })
+						}
+						return errorResponse(file, [error])
+					}
+				}
 			}
 
 			// Direct node_modules URLs (from user import maps or explicit imports)
@@ -779,24 +938,46 @@ export function serve(entrypoint, flags) {
 				const resolved = resolveFileCandidate('.' + pathname)
 				if (resolved?.endsWith('.imba')) {
 					const out = await compileFile(resolved)
-					if (out.errors?.length) return new Response(out.errors.map(e => e.message).join('\n'), { status: 500 })
+					const file = normalizeFile(resolved)
+					if (out.missing) {
+						clearError(file)
+						return new Response('Not Found', { status: 404 })
+					}
+					if (out.errors?.length) {
+						return errorResponse(file, out.errors)
+					}
+					clearError(file)
 					return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 
 				if (resolved) {
+					const file = 'vendor:' + normalizeFile(pathname)
 					const bundled = await bundleVendor(path.resolve(resolved))
 					if (bundled?.code) {
+						clearError(file)
 						return new Response(bundled.code, { headers: { 'Content-Type': 'application/javascript' } })
 					}
-					return new Response((bundled?.errors || [`Could not bundle ${pathname}`]).join('\n'), { status: 500 })
+					return errorResponse(file, bundled?.errors || [`Could not bundle ${pathname}`])
 				}
 			}
 
 			// Static files: check htmlDir first (for assets relative to HTML), then root
-			const inHtmlDir = Bun.file(path.join(htmlDir, pathname))
-			if (await inHtmlDir.exists()) return new Response(inHtmlDir)
-			const inRoot = Bun.file('.' + pathname)
-			if (await inRoot.exists()) return new Response(inRoot)
+			try {
+				const inHtmlDirPath = path.join(htmlDir, pathname)
+				const inHtmlDir = Bun.file(inHtmlDirPath)
+				if (await inHtmlDir.exists()) {
+					clearError('static:' + normalizeFile(inHtmlDirPath))
+					return new Response(inHtmlDir)
+				}
+				const inRootPath = '.' + pathname
+				const inRoot = Bun.file(inRootPath)
+				if (await inRoot.exists()) {
+					clearError('static:' + normalizeFile(inRootPath))
+					return new Response(inRoot)
+				}
+			} catch (error) {
+				if (!isMissingFileError(error)) return errorResponse('static:' + normalizeFile(pathname), [error])
+			}
 
 			// Try extensions for extensionless paths (e.g. node_modules imports)
 			const lastSegment = pathname.split('/').pop()
@@ -805,23 +986,63 @@ export function serve(entrypoint, flags) {
 				const imbaPath = '.' + pathname + '.imba'
 				if (existsSync(imbaPath)) {
 					const out = await compileFile(imbaPath)
-					if (!out.errors?.length) return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
+					const file = normalizeFile(imbaPath)
+					if (out.missing) {
+						clearError(file)
+						return new Response('Not Found', { status: 404 })
+					}
+					if (out.errors?.length) {
+						return errorResponse(file, out.errors)
+					}
+					clearError(file)
+					return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 				for (const ext of ['.js', '.mjs']) {
 					const withExt = '.' + pathname + ext
-					if (existsSync(withExt)) return serveJavaScriptFile(withExt)
+					if (existsSync(withExt)) {
+						const file = 'js:' + normalizeFile(withExt)
+						try {
+							const response = await serveJavaScriptFile(withExt)
+							clearError(file)
+							return response
+						} catch (error) {
+							if (isMissingFileError(error)) {
+								clearError(file)
+								return new Response('Not Found', { status: 404 })
+							}
+							return errorResponse(file, [error])
+						}
+					}
 				}
 			}
 
 			// SPA fallback for extension-less paths
-				if (!lastSegment.includes('.')) {
+			if (!lastSegment.includes('.')) {
+				const file = 'html:' + normalizeFile(htmlPath)
+				try {
 					let html = await Bun.file(htmlPath).text()
+					clearError(file)
 					return new Response(transformHtml(html, entrypoint), {
 						headers: { 'Content-Type': 'text/html' },
 					})
+				} catch (error) {
+					if (isMissingFileError(error)) {
+						clearError(file)
+						return new Response('Not Found', { status: 404 })
+					}
+					return errorResponse(file, [error])
 				}
+			}
 
 			return new Response('Not Found', { status: 404 })
+			} catch (error) {
+				const file = 'server:' + normalizeFile(pathname || req.url)
+				if (isMissingFileError(error)) {
+					clearError(file)
+					return new Response('Not Found', { status: 404 })
+				}
+				return errorResponse(file, [error])
+			}
 		},
 
 		websocket: {