bimba-cli 0.7.28 → 0.7.30

package/package.json

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

package/plugin.js

@@ -45,6 +45,16 @@ function compileErrorKey(filepath) {
   return physicalCompileKey(filepath) || `path:${normalizeCompilePath(filepath)}`;
 }
 
+function compileFileStamp(filepath) {
+  try {
+    const stat = fs.statSync(filepath);
+    if (!stat.isFile()) return null;
+    return `${stat.mtimeMs ?? stat.mtime?.getTime?.() ?? 0}_${stat.size ?? 0}`;
+  } catch(_) {
+    return null;
+  }
+}
+
 function compileErrorMessage(error) {
   return error?.message || String(error);
 }
@@ -102,66 +112,82 @@ export const imbaPlugin = {
     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';
-      let out
-      try {
-        out = compiler.compile(file, {
-          sourcePath: path,
-          platform: platform,
-          comments: false
-        })
-      } catch (error) {
-        out = { js: '', errors: [error] }
-      }
-      
-      // 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]) printCompileError(out.errors[i]);
+      while (true) {
+        const stamp = compileFileStamp(path);
+        if (!stamp) {
+          clearCompileError(path);
+          return { contents: '', loader: "js" };
+        }
+
+        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) + '_' + stamp + '.js');
+        if (fs.existsSync(cached)) {
+          const cachedContents = await Bun.file(cached).text();
+          if (compileFileStamp(path) !== stamp) continue;
+          clearCompileError(path);
+          stats.bundled++;
+          stats.cached++;
+          return {
+            contents: cachedContents,
+            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();
+        if (compileFileStamp(path) !== stamp) continue;
+
+        const platform = target === 'node' || target === 'bun' ? 'node' : 'browser';
+        let out
+        try {
+          out = compiler.compile(file, {
+            sourcePath: path,
+            platform: platform,
+            comments: false
+          })
+        } catch (error) {
+          out = { js: '', errors: [error] }
+        }
+
+        // Never report or cache a result from an older source snapshot.
+        if (compileFileStamp(path) !== stamp) continue;
+
+        // 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]) printCompileError(out.errors[i]);
+            }
           }
+          stats.errors++;
         }
-        stats.errors++;
+
+        // and return the compiled source code as "js"
+        return {
+          contents,
+          loader: "js",
+        };
       }
-      
-      // and return the compiled source code as "js"
-      return {
-        contents,
-        loader: "js",
-      };
     });
   }
 };

package/serve.js

@@ -409,6 +409,17 @@ function isMissingFileError(error) {
 	return error?.code === 'ENOENT' || String(error?.message || error).includes('ENOENT: no such file or directory')
 }
 
+function fileStamp(abs) {
+	try {
+		const stat = statSync(abs)
+		if (!stat.isFile()) return null
+		return `${stat.mtimeMs ?? stat.mtime?.getTime?.() ?? 0}:${stat.size ?? 0}`
+	} catch (error) {
+		if (isMissingFileError(error)) return null
+		throw error
+	}
+}
+
 function missingCompileResult(filepath) {
 	dropFileState(filepath)
 	return { js: '', errors: [], slots: null, changeType: 'missing', missing: true }
@@ -416,49 +427,59 @@ function missingCompileResult(filepath) {
 
 async function compileFile(filepath) {
 	const abs = path.resolve(filepath)
-	if (!existsSync(abs)) return missingCompileResult(abs)
 
-	const file = Bun.file(abs)
-	let stat
-	try {
-		stat = await file.stat()
-	} catch (error) {
-		if (isMissingFileError(error)) return missingCompileResult(abs)
-		throw error
-	}
-	const stamp = `${stat.mtimeMs ?? stat.mtime?.getTime?.() ?? 0}:${stat.size ?? 0}`
+	while (true) {
+		const stamp = fileStamp(abs)
+		if (!stamp) return missingCompileResult(abs)
 
-	const cached = _compileCache.get(abs)
-	if (cached && cached.stamp === stamp) return _normalizeResult(cached.result, { changeType: 'cached' })
+		const cached = _compileCache.get(abs)
+		if (cached && cached.stamp === stamp) {
+			if (fileStamp(abs) !== stamp) continue
+			return _normalizeResult(cached.result, { changeType: 'cached' })
+		}
 
-	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',
-		sourcemap: 'inline',
-	})
+		const file = Bun.file(abs)
+		let code
+		try {
+			code = await file.text()
+		} catch (error) {
+			if (isMissingFileError(error)) return missingCompileResult(abs)
+			throw error
+		}
 
-	const errors = result.errors || []
-	if (!errors.length && result.js) {
-		const { js, slotCount } = stabilizeSymbols(result.js, abs)
-		result.js = rewriteBareImports(js)
-		const prev = _prevSlots.get(abs)
-		result.slots = (prev === undefined || prev === slotCount) ? 'stable' : 'shifted'
-		_prevSlots.set(abs, slotCount)
-	}
+		// A save can land while an older request is compiling. Never publish,
+		// cache, or report a result unless it still matches the current file.
+		if (fileStamp(abs) !== stamp) continue
+
+		let result
+		try {
+			result = compiler.compile(code, {
+				sourcePath: filepath,
+				platform: 'browser',
+				sourcemap: 'inline',
+			})
+		} catch (error) {
+			result = { js: '', errors: [error], slots: null }
+		}
 
-	// Bake errors as an own property so caching/spreading preserves them.
-	const baked = { js: result.js, errors, slots: result.slots }
-	const changeType = _prevJs.get(abs) === baked.js ? 'none' : 'full'
-	_prevJs.set(abs, baked.js)
-	_compileCache.set(abs, { stamp, result: baked })
-	return _normalizeResult(baked, { changeType })
+		if (fileStamp(abs) !== stamp) continue
+
+		const errors = result.errors || []
+		if (!errors.length && result.js) {
+			const { js, slotCount } = stabilizeSymbols(result.js, abs)
+			result.js = rewriteBareImports(js)
+			const prev = _prevSlots.get(abs)
+			result.slots = (prev === undefined || prev === slotCount) ? 'stable' : 'shifted'
+			_prevSlots.set(abs, slotCount)
+		}
+
+		// Bake errors as an own property so caching/spreading preserves them.
+		const baked = { js: result.js, errors, slots: result.slots }
+		const changeType = _prevJs.get(abs) === baked.js ? 'none' : 'full'
+		_prevJs.set(abs, baked.js)
+		_compileCache.set(abs, { stamp, result: baked })
+		return _normalizeResult(baked, { changeType })
+	}
 }
 
 // ─── HTML helpers ─────────────────────────────────────────────────────────────
@@ -632,7 +653,7 @@ export function serve(entrypoint, flags) {
 		_statusKind = null
 	}
 
-	function printStatus(file, state, errors) {
+	function printStatus(file, state, errors, options = {}) {
 		// non-TTY (pipes, Claude Code bash, CI): plain newline-terminated output,
 		// no ANSI cursor tricks, no fade-out — so logs stay readable.
 		if (!_isTTY) {
@@ -657,66 +678,45 @@ export function serve(entrypoint, flags) {
 		const now = new Date().toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit', second: '2-digit' })
 		const status = state === 'ok' ? theme.success(' ok ') : theme.failure(' fail ')
 
+		if (errors?.length || options.sticky) {
+			process.stdout.write(`  ${theme.folder(now)}  ${theme.filename(file)}  ${status}\n`)
+			if (errors?.length) {
+				for (const err of errors) {
+					try { printerr(err) } catch(_) { process.stdout.write('  ' + err.message + '\n') }
+				}
+			}
+			_statusFile = null
+			_statusKind = null
+			return
+		}
+
 		process.stdout.write('\x1b[s')
 		_statusSaved = true
 		_statusFile = file
 		_statusKind = state
 
-		if (errors?.length) {
-			process.stdout.write(`  ${theme.folder(now)}  ${theme.filename(file)}  ${status}\n`)
-			for (const err of errors) {
-				try { printerr(err) } catch(_) { process.stdout.write('  ' + err.message + '\n') }
-			}
-		} else {
-			const myId = ++_fadeId
-			const plainLine = `  ${now}  ${file}   ok `
-			const total = plainLine.length
-			process.stdout.write(`  ${theme.folder(now)}  ${theme.filename(file)}  ${status}`)
-			for (let i = 1; i <= total; i++) {
-				_fadeTimers.push(setTimeout(() => {
-					if (_fadeId !== myId) return
-					process.stdout.write('\x1b[1D \x1b[1D')
-					if (i === total) {
-						_statusSaved = false
-						_statusFile = null
-						_statusKind = null
-					}
-				}, 5000 + i * 22))
-			}
+		const myId = ++_fadeId
+		const plainLine = `  ${now}  ${file}   ok `
+		const total = plainLine.length
+		process.stdout.write(`  ${theme.folder(now)}  ${theme.filename(file)}  ${status}`)
+		for (let i = 1; i <= total; i++) {
+			_fadeTimers.push(setTimeout(() => {
+				if (_fadeId !== myId) return
+				process.stdout.write('\x1b[1D \x1b[1D')
+				if (i === total) {
+					_statusSaved = false
+					_statusFile = null
+					_statusKind = null
+				}
+			}, 5000 + i * 22))
 		}
 	}
 
 	// ── File watcher ───────────────────────────────────────────────────────────
 
 	const _activeErrors = new Map()
-
-	function renderErrorPanel() {
-		if (!_isTTY) return false
-
-		cancelFade()
-		if (_statusSaved) {
-			process.stdout.write('\x1b[u\x1b[J')
-			_statusSaved = false
-		}
-		_statusFile = null
-		_statusKind = null
-
-		if (!_activeErrors.size) return false
-
-		process.stdout.write('\x1b[s')
-		_statusSaved = true
-		_statusKind = 'errors'
-
-		for (const item of _activeErrors.values()) {
-			const file = item.file
-			process.stdout.write(`  ${theme.folder(item.time)}  ${theme.filename(file)}  ${theme.failure(' fail ')}\n`)
-			for (const err of item.errors) {
-				try { printerr(err) } catch(_) { process.stdout.write('  ' + err.message + '\n') }
-			}
-		}
-
-		return true
-	}
+	const _terminalErrors = new Map()
+	const TERMINAL_DUPLICATE_MS = 5000
 
 	function broadcast(payload) {
 		const msg = JSON.stringify(payload)
@@ -753,6 +753,12 @@ export function serve(entrypoint, flags) {
 		return Array.from(variants).filter(Boolean)
 	}
 
+	function terminalErrorKey(file) {
+		const variants = fileVariants(file)
+		const rooted = variants.find(variant => srcRel && variant.startsWith(srcRel + '/'))
+		return `path:${rooted || variants[0] || normalizeFile(file)}`
+	}
+
 	function fileCandidates(file) {
 		const candidates = []
 		for (const variant of fileVariants(file)) {
@@ -841,29 +847,42 @@ export function serve(entrypoint, flags) {
 			.join('\n---\n')
 	}
 
+	function terminalErrorSignature(errors) {
+		return serializeErrors(errors)
+			.map(error => error.message)
+			.join('\n---\n')
+	}
+
 	function showTrackedError(item) {
 		const file = item.file
-		if (_isTTY) renderErrorPanel()
-		else printStatus(file, 'fail', item.errors)
+		printStatus(file, 'fail', item.errors)
 		broadcast({ type: 'error', file, time: item.time, errors: item.payload })
 	}
 
 	function reportError(file, errors) {
 		const display = normalizeFile(file)
 		const key = errorKey(display)
+		const terminalKey = terminalErrorKey(display)
 		const list = Array.isArray(errors) ? errors : [errors]
 		const signature = errorSignature(list)
+		const printSignature = terminalErrorSignature(list)
 		const previous = takeError(display)
+		const now = Date.now()
+		const recent = _terminalErrors.get(terminalKey)
 		const duplicate = previous?.signature === signature
+			|| previous?.printSignature === printSignature
+			|| (recent?.signature === printSignature && now - recent.time < TERMINAL_DUPLICATE_MS)
 
 		const item = {
 			file: display,
 			signature,
+			printSignature,
 			errors: list,
 			payload: serializeErrors(list),
 			time: new Date().toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit', second: '2-digit' }),
 		}
 		_activeErrors.set(key, item)
+		_terminalErrors.set(terminalKey, { signature: printSignature, time: now })
 
 		// The terminal is append-only in many real shells. Repeated reports of the
 		// same active error update the browser overlay, but must not print again.
@@ -887,36 +906,27 @@ export function serve(entrypoint, flags) {
 
 	function clearError(file) {
 		const key = file ? normalizeFile(file) : null
-		const hadPanel = _statusKind === 'errors'
 		const wasStatusFile = key && _statusFile && sameFile(_statusFile, key)
 		const hadError = key ? !!takeError(key) : _activeErrors.size > 0
 
 		if (!key) _activeErrors.clear()
 
-		let showedNext = false
-		if (_isTTY && (hadError || wasStatusFile || hadPanel)) {
-			showedNext = renderErrorPanel()
-		} else if (!key || hadError || wasStatusFile) {
-			clearStatus(key)
-		}
+		if (!key || hadError || wasStatusFile) clearStatus(key)
 
 		broadcast({ type: 'clear-error', file: key })
 
-		if (!_isTTY && wasStatusFile && _activeErrors.size) {
-			const nextItem = Array.from(_activeErrors.values()).at(-1)
-			showTrackedError(nextItem)
-			showedNext = true
-		}
-
-		return { cleared: hadError || wasStatusFile, file: key, showedNext }
+		return { cleared: hadError || wasStatusFile, file: key, showedNext: false }
 	}
 
 	function markSuccess(file) {
 		const key = normalizeFile(file)
 		const result = clearError(key)
 		const active = _activeErrors.size
-		const shouldPrint = result?.cleared && !result.showedNext && !active
-		if (shouldPrint) printStatus(key, 'ok')
+		const shouldPrint = result?.cleared && !result.showedNext
+		if (shouldPrint) {
+			_terminalErrors.delete(terminalErrorKey(key))
+			printStatus(key, 'ok', null, { sticky: true })
+		}
 		return { cleared: !!result?.cleared, printed: !!shouldPrint, showedNext: !!result?.showedNext, active }
 	}