bimba-cli 0.5.11 → 0.5.13

package/package.json

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

package/serve.js

@@ -293,6 +293,68 @@ const _compileCache = new Map()  // filepath → { mtime, result }
 const _prevJs = new Map()  // filepath → compiled js — for change detection
 const _prevSlots = new Map()  // filepath → previous symbol slot count
 
+// ─── Import dependency graph ──────────────────────────────────────────────────
+//
+// When a non-tag module (utility functions, constants, shared state) is edited,
+// the existing class-prototype patching does nothing for the modules that
+// imported it — they hold their own captured references. To make those
+// updates flow into the UI, we track who imports whom and, on every change,
+// re-broadcast updates for the transitive importer set. The client's existing
+// HMR queue then re-imports each in turn; their top-level code reruns, picks
+// up the new symbols, and any tag re-registrations patch instances in place.
+//
+// Keys are absolute, normalized paths (path.resolve). Edges are added during
+// compilation by scanning the produced JS for relative .imba imports.
+
+const _imports = new Map()    // absFile → Set<absFile> (what it imports)
+const _importers = new Map()  // absFile → Set<absFile> (who imports it)
+
+function extractImports(js, fromAbs) {
+	const dir = path.dirname(fromAbs)
+	const out = new Set()
+	const re = /(?:^|[\s;])(?:import|from)\s*['"]([^'"]+)['"]/g
+	let m
+	while ((m = re.exec(js))) {
+		const spec = m[1]
+		if (!spec.startsWith('.') && !spec.startsWith('/')) continue
+		if (!spec.endsWith('.imba')) continue
+		const resolved = spec.startsWith('/')
+			? path.resolve('.' + spec)
+			: path.resolve(dir, spec)
+		out.add(resolved)
+	}
+	return out
+}
+
+function updateImportGraph(fromAbs, newDeps) {
+	const old = _imports.get(fromAbs)
+	if (old) {
+		for (const d of old) {
+			if (newDeps.has(d)) continue
+			const set = _importers.get(d)
+			if (set) { set.delete(fromAbs); if (!set.size) _importers.delete(d) }
+		}
+	}
+	for (const d of newDeps) {
+		let set = _importers.get(d)
+		if (!set) { set = new Set(); _importers.set(d, set) }
+		set.add(fromAbs)
+	}
+	_imports.set(fromAbs, newDeps)
+}
+
+function transitiveImporters(absFile) {
+	const out = new Set()
+	const stack = [absFile]
+	while (stack.length) {
+		const cur = stack.pop()
+		const ups = _importers.get(cur)
+		if (!ups) continue
+		for (const u of ups) if (!out.has(u)) { out.add(u); stack.push(u) }
+	}
+	return out
+}
+
 // Imba compiles tag render-cache slots as anonymous local Symbols at module top
 // level: `var $4 = Symbol(), $11 = Symbol(), ...; let c$0 = Symbol();`. Each
 // re-import of the file creates fresh Symbol objects, so old slot data on live
@@ -323,13 +385,27 @@ function stabilizeSymbols(js, filepath) {
 	return { js: bootstrap + out, slotCount: count }
 }
 
+// Imba's compile result puts `errors` on the prototype as a getter, so plain
+// object spread (`{...result}`) silently strips it. We always normalize to a
+// plain shape with `errors` as an own property — otherwise downstream callers
+// see no errors and serve empty 200s for broken files.
+function _normalizeResult(result, extras) {
+	return {
+		js: result.js,
+		errors: result.errors || [],
+		slots: result.slots,
+		...extras,
+	}
+}
+
 async function compileFile(filepath) {
+	const abs = path.resolve(filepath)
 	const file = Bun.file(filepath)
 	const stat = await file.stat()
 	const mtime = stat.mtime.getTime()
 
-	const cached = _compileCache.get(filepath)
-	if (cached && cached.mtime === mtime) return { ...cached.result, changeType: 'cached', slots: cached.slots }
+	const cached = _compileCache.get(abs)
+	if (cached && cached.mtime === mtime) return _normalizeResult(cached.result, { changeType: 'cached' })
 
 	const code = await file.text()
 	const result = compiler.compile(code, {
@@ -338,18 +414,22 @@ async function compileFile(filepath) {
 		sourcemap: 'inline',
 	})
 
-	if (!result.errors?.length && result.js) {
+	const errors = result.errors || []
+	if (!errors.length && result.js) {
 		const { js, slotCount } = stabilizeSymbols(result.js, filepath)
 		result.js = js
-		const prev = _prevSlots.get(filepath)
+		const prev = _prevSlots.get(abs)
 		result.slots = (prev === undefined || prev === slotCount) ? 'stable' : 'shifted'
-		_prevSlots.set(filepath, slotCount)
+		_prevSlots.set(abs, slotCount)
+		updateImportGraph(abs, extractImports(js, abs))
 	}
 
-	const changeType = _prevJs.get(filepath) === result.js ? 'none' : 'full'
-	_prevJs.set(filepath, result.js)
-	_compileCache.set(filepath, { mtime, result, slots: result.slots })
-	return { ...result, changeType }
+	// 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, { mtime, result: baked })
+	return _normalizeResult(baked, { changeType })
 }
 
 // ─── HTML helpers ─────────────────────────────────────────────────────────────
@@ -505,6 +585,20 @@ export function serve(entrypoint, flags) {
 			printStatus(rel, 'ok')
 			broadcast({ type: 'clear-error' })
 			broadcast({ type: 'update', file: rel, slots: out.slots || 'shifted' })
+
+			// Cascade: re-import every module transitively importing this file.
+			// They don't need recompilation (their source didn't change), but
+			// their captured references to the changed module are stale, so we
+			// tell the client to re-import them. The client's HMR queue
+			// processes these in order; tag classes get re-patched, plain
+			// utility modules get fresh top-level state.
+			const ups = transitiveImporters(path.resolve(filepath))
+			for (const upAbs of ups) {
+				const upRel = path.relative('.', upAbs).replaceAll('\\', '/')
+				const cached = _compileCache.get(upAbs)
+				const slots = cached?.result?.slots || 'shifted'
+				broadcast({ type: 'update', file: upRel, slots })
+			}
 		} catch(e) {
 			printStatus(rel, 'fail', [{ message: e.message }])
 			broadcast({ type: 'error', file: rel, errors: [{ message: e.message, snippet: e.stack || e.message }] })