bimba-cli 0.7.9 → 0.7.11

package/README.md

@@ -74,7 +74,7 @@ For a deep dive into how Imba compiles tags, how the render cache works, and how
 
 Static files are resolved relative to the HTML file's directory first, then from the project root (for `node_modules`, `src`, etc.). Extensionless imports (common in `node_modules`) are resolved by trying `.js` and `.mjs` extensions automatically.
 
-**npm package resolution:** The import map is built by reading each dependency's `package.json`. The resolution order is: `exports["."].import` → `exports["."].default` → `module` → `browser` → `main`. Packages with subpath exports (e.g. `"./styles.css"`) get individual import map entries. CJS-only packages (no ESM entry) are proxied through esm.sh.
+**npm package resolution:** The dev server maps package imports to `__bimba_vendor__/*` URLs and bundles those modules on demand with Bun (`target: "browser"`). Imba source files still compile separately for HMR, while Bun owns dependency resolution, `exports`, `browser` fields, nested `node_modules`, and CommonJS interop.
 
 ---
 
@@ -82,7 +82,7 @@ Static files are resolved relative to the HTML file's directory first, then from
 
 To compile and bundle your source code from .imba to .js:
 ```bash
-bunx bimba src/index.imba --outdir public/js --minify
+bunx bimba src/index.imba --outdir public/js
 ```
 
 With watch:
@@ -100,7 +100,7 @@ bunx bimba src/index.imba --outdir public/js --watch --clearcache
 
 `--clearcache` — delete the cache directory on exit (Ctrl+C). Works only in watch mode.
 
-`--minify` — minify the output JS. Enabled by default in bundle mode.
+`--no-minify` — disable minification. Bundle mode minifies by default.
 
 `--sourcemap <inline|external|none>` — how to include source maps in the output (default: `none`).
 

package/index.js

@@ -14,7 +14,7 @@ let entrypoint = ''
 
 try {
     const { values, positionals } = parseArgs({
-        args: Bun.argv,
+        args: Bun.argv.slice(2),
         options: {
             watch: { type: 'boolean' },
             outdir: { type: 'string' },
@@ -29,11 +29,12 @@ try {
             port: { type: 'string' },
             html: { type: 'string' },
         },
+        allowNegative: true,
         strict: true,
         allowPositionals: true,
     });
     flags = values;
-    entrypoint = Bun.argv[2];
+    entrypoint = positionals[0] || '';
 }
 catch (error) {
     if (error instanceof Error)
@@ -43,16 +44,21 @@ catch (error) {
     process.exit(0);
 }
 
-// Ensure bunfig.toml exists and contains the required preload line
-const bunfigPath = path.join(process.cwd(), 'bunfig.toml');
-const preloadLine = 'preload = ["bimba-cli/plugin.js"]';
-if (!fs.existsSync(bunfigPath)) {
-    fs.writeFileSync(bunfigPath, preloadLine + '\n');
-} else {
-    const content = fs.readFileSync(bunfigPath, 'utf8');
-    if (!content.includes(preloadLine)) {
-        fs.appendFileSync(bunfigPath, (content.endsWith('\n') ? '' : '\n') + preloadLine + '\n');
+function ensureBunfigPreload() {
+    const bunfigPath = path.join(process.cwd(), 'bunfig.toml');
+    const preloadLine = 'preload = ["bimba-cli/plugin.js"]';
+
+    if (!fs.existsSync(bunfigPath)) {
+        console.log(theme.action("note: ") + theme.filename("bunfig.toml was not found, so bimba left it unchanged."));
+        console.log(theme.action("      ") + `Add ${theme.flags(preloadLine)} manually if you want Bun to preload the plugin.`);
+        return;
     }
+
+    const content = fs.readFileSync(bunfigPath, 'utf8');
+    if (content.includes(preloadLine)) return;
+
+    console.log(theme.action("note: ") + theme.filename("bunfig.toml already exists, so bimba did not edit it automatically."));
+    console.log(theme.action("      ") + `Add ${theme.flags(preloadLine)} manually if you want Bun to preload the plugin.`);
 }
 
 // help: more on bun building params here: https://bun.sh/docs/bundler
@@ -62,7 +68,7 @@ if(flags.help) {
     console.log("For example like this: "+theme.filedir('bimba file.imba --outdir public'));
     console.log("");
     console.log("   "+theme.flags('--outdir <folder>')+"                     Compile imba files to the specified folder");
-    console.log("   "+theme.flags('--minify')+"                              Minify compiled .js files");
+    console.log("   "+theme.flags('--no-minify')+"                           Disable minification for compiled .js files");
     console.log("   "+theme.flags('--sourcemap <inline|external|none>')+"    How should sourcemap files be included in the .js");
     console.log("   "+theme.flags('--target <browser|node>')+"               Target platform for both Imba compiler and Bun bundler");
     console.log("   "+theme.flags('--external <package>')+"                Exclude package from bundle (repeatable, e.g. --external ws --external node-pty)");
@@ -88,6 +94,7 @@ if (flags.serve) {
         console.log("");
         process.exit(1);
     }
+    ensureBunfigPreload();
     serve(entrypoint, { port: parseInt(flags.port) || 5200, html: flags.html });
 }
 // no entrypoint or outdir
@@ -100,7 +107,9 @@ else if(!entrypoint || !flags.outdir) {
 }
 // build
 else {
-    bundle();
+    ensureBunfigPreload();
+    const success = await bundle();
+    if (!success && !flags.watch) process.exit(1);
     watch(bundle);
 }
 
@@ -126,7 +135,7 @@ async function bundle() {
 
     if (!fs.existsSync(entrypoint)) {
         console.log(theme.failure('Error.') + ` The specified entrypoint does not exist: ${theme.filedir(entrypoint)}`);
-        process.exit(0);
+        return false;
     }
 
     stats.failed = 0
@@ -150,7 +159,7 @@ async function bundle() {
             outdir: flags.outdir,
             target: buildTarget,
             sourcemap: flags.sourcemap || 'none',
-            minify: true,
+            minify: flags.minify ?? true,
             splitting: flags.splitting || false,
             plugins: [imbaPlugin]
         };
@@ -182,6 +191,8 @@ async function bundle() {
                 console.log(log);
             }
         }
+
+        return result.success && !stats.failed && !stats.errors;
     }
     catch(error) {
         console.log(theme.folder("──────────────────────────────────────────────────────────────────────"));
@@ -189,8 +200,9 @@ async function bundle() {
         console.log(error)
         console.log(theme.folder("──────────────────────────────────────────────────────────────────────"));
         console.log(theme.failure(" Failure ") + theme.filename(' Bun found an error in the compiled JS file'))
+        return false;
     }
     finally {
         bundling = false;
     };
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bimba-cli",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/HeapVoid/bimba.git"
@@ -19,4 +19,4 @@
   "devDependencies": {
     "imba": "latest"
   }
-}
+}

package/serve.js

@@ -1,6 +1,6 @@
 import { serve as bunServe } from 'bun'
 import * as compiler from 'imba/compiler'
-import { watch, existsSync } from 'fs'
+import { watch, existsSync, statSync } from 'fs'
 import path from 'path'
 import { theme } from './utils.js'
 import { printerr } from './plugin.js'
@@ -256,57 +256,6 @@ 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)
-}
-
-
 // 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
@@ -373,7 +322,6 @@ async function compileFile(filepath) {
 		const prev = _prevSlots.get(abs)
 		result.slots = (prev === undefined || prev === slotCount) ? 'stable' : 'shifted'
 		_prevSlots.set(abs, slotCount)
-		updateImportGraph(abs, extractImports(js, abs))
 	}
 
 	// Bake errors as an own property so caching/spreading preserves them.
@@ -392,85 +340,181 @@ function findHtml(flagHtml) {
 	return candidates.find(p => existsSync(p)) || './index.html';
 }
 
-// ─── Node modules resolution ─────────────────────────────────────────────────
+// ─── Vendor modules ──────────────────────────────────────────────────────────
 
-const _pkgJsonCache = new Map() // pkg root dir → parsed package.json
+const _vendorCache = new Map() // entrypoint → { mtime, code }
 
-async function readPkgJson(pkgDir) {
-	const cached = _pkgJsonCache.get(pkgDir)
-	if (cached) return cached
-	try {
-		const json = JSON.parse(await Bun.file(path.join(pkgDir, 'package.json')).text())
-		_pkgJsonCache.set(pkgDir, json)
-		return json
-	} catch(_) {
-		return null
+function vendorUrl(specifier) {
+	return '/__bimba_vendor__/' + specifier
+}
+
+function vendorPrefixUrl(specifier) {
+	return vendorUrl(specifier) + '/'
+}
+
+function resolveFileCandidate(filepath) {
+	const candidates = [
+		filepath,
+		filepath + '.js',
+		filepath + '.mjs',
+		filepath + '.cjs',
+		filepath + '.imba',
+		filepath + '.css',
+		path.join(filepath, 'index.js'),
+		path.join(filepath, 'index.mjs'),
+		path.join(filepath, 'index.cjs'),
+		path.join(filepath, 'index.imba'),
+	]
+
+	for (const candidate of candidates) {
+		if (!existsSync(candidate)) continue
+		try {
+			if (statSync(candidate).isFile()) return candidate
+		} catch (_) {
+			// ignore vanished files and continue resolving
+		}
 	}
+
+	return null
 }
 
-// Wrap a CommonJS file as an ESM module so the browser can import it.
-// Detects CJS by checking for `module.exports` or top-level `exports.` usage.
-function wrapCJS(code) {
-	if (!code.includes('module.exports') && !code.includes('exports.')) return null
-	// Already has ESM syntax — don't wrap (dual-format files)
-	if (/^\s*(export\s|import\s)/m.test(code)) return null
-	return `var module = { exports: {} }, exports = module.exports;\n${code}\nexport default module.exports;\nexport { module };`
+function vendorSpecifierFromPath(pathname) {
+	const prefix = '/__bimba_vendor__/'
+	if (!pathname.startsWith(prefix)) return null
+	const specifier = decodeURIComponent(pathname.slice(prefix.length))
+	return specifier || null
 }
 
-// Resolve the ESM entry point for an npm package.
-// Priority: exports["."].import → exports["."].default → module → main
-function resolveEntry(depPkg) {
-	const exp = depPkg.exports;
-	if (exp) {
-		// exports: "./index.js" (string shorthand)
-		if (typeof exp === 'string') return exp;
-		// exports: { ".": { "import": "...", "default": "..." } }
-		const dot = exp['.'];
-		if (dot) {
-			if (typeof dot === 'string') return dot;
-			if (dot.import) return dot.import;
-			if (dot.default) return dot.default;
+async function bundleVendor(entrypoint) {
+	try {
+		const stat = path.isAbsolute(entrypoint) && existsSync(entrypoint) ? statSync(entrypoint) : null
+		const mtime = stat?.mtimeMs || 0
+		const cached = _vendorCache.get(entrypoint)
+		if (cached && cached.mtime === mtime) return cached
+
+		const result = await Bun.build({
+			entrypoints: [entrypoint],
+			target: 'browser',
+			format: 'esm',
+			write: false,
+			minify: false,
+			sourcemap: 'none',
+			packages: 'bundle',
+		})
+
+		if (!result.success) {
+			return { mtime, errors: result.logs.map(log => String(log)) }
+		}
+
+		const output = result.outputs.find(output => output.path.endsWith('.js')) || result.outputs[0]
+		if (!output) return { mtime, errors: ['Bun.build did not return a JavaScript output'] }
+
+		let code = await output.text()
+		const css = (await Promise.all(
+			result.outputs
+				.filter(output => output.path.endsWith('.css'))
+				.map(output => output.text())
+		)).join('\n')
+		if (css) {
+			const id = JSON.stringify('vendor:' + entrypoint)
+			code = [
+				`const __bimba_vendor_css_id = ${id};`,
+				`let __bimba_vendor_css = document.querySelector('style[data-bimba-css=' + JSON.stringify(__bimba_vendor_css_id) + ']');`,
+				`if (!__bimba_vendor_css) { __bimba_vendor_css = document.createElement('style'); __bimba_vendor_css.setAttribute('data-bimba-css', __bimba_vendor_css_id); document.head.appendChild(__bimba_vendor_css); }`,
+				`__bimba_vendor_css.textContent = ${JSON.stringify(css)};`,
+				code,
+			].join('\n')
 		}
-		// exports: { "import": "...", "default": "..." } (no "." wrapper)
-		if (exp.import) return exp.import;
-		if (exp.default) return exp.default;
+		const bundled = { mtime, code }
+		_vendorCache.set(entrypoint, bundled)
+		return bundled
+	} catch (error) {
+		return { mtime: 0, errors: [error?.message || String(error)] }
 	}
-	// Fallback to legacy fields
-	return depPkg.module || depPkg.browser || depPkg.main;
 }
 
-// Build an ES import map from package.json dependencies.
-// The import map is intentionally simple — it just maps bare specifiers
-// to /node_modules/ URLs. All the smart resolution (conditional exports,
-// CJS→ESM, entry points, extensions) happens on the server side.
-async function buildImportMap() {
-	const imports = {
-		'imba/runtime': 'https://esm.sh/imba/runtime',
-		'imba': 'https://esm.sh/imba',
-	};
+async function buildGeneratedImportMap() {
+	const imports = {}
+
 	try {
-		const pkg = JSON.parse(await Bun.file('./package.json').text());
-		for (const [name] of Object.entries(pkg.dependencies || {})) {
-			if (name === 'imba') continue;
-			imports[name] = `/node_modules/${name}/`;
-			imports[name + '/'] = `/node_modules/${name}/`;
+		const pkg = JSON.parse(await Bun.file('./package.json').text())
+		for (const field of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+			for (const name of Object.keys(pkg[field] || {})) {
+				imports[name] ||= vendorUrl(name)
+				imports[name + '/'] ||= vendorPrefixUrl(name)
+			}
 		}
 	} catch(_) { /* no package.json */ }
 
-	return `\t\t<script type="importmap">\n\t\t\t${JSON.stringify({ imports }, null, '\t\t\t\t')}\n\t\t</script>`;
+	imports['imba'] ||= vendorUrl('imba')
+	imports['imba/'] ||= vendorPrefixUrl('imba')
+	imports['imba/runtime'] ||= vendorUrl('imba/runtime')
+
+	return { imports }
+}
+
+function extractUserImportMap(html) {
+	const merged = { imports: {}, scopes: {} }
+
+	html = html.replace(/<script\s+type=["']importmap["'][^>]*>([\s\S]*?)<\/script>/gi, (_match, json) => {
+		try {
+			const parsed = JSON.parse(json)
+			Object.assign(merged.imports, parsed.imports || {})
+			for (const [scope, specifiers] of Object.entries(parsed.scopes || {})) {
+				merged.scopes[scope] = { ...(merged.scopes[scope] || {}), ...specifiers }
+			}
+		} catch (_) {
+			// ignore invalid import maps and keep serving the page
+		}
+		return ''
+	})
+
+	if (!Object.keys(merged.scopes).length) delete merged.scopes
+	return { html, importMap: merged }
+}
+
+function mergeImportMaps(generated, user) {
+	const merged = {
+		imports: { ...(generated.imports || {}), ...(user.imports || {}) },
+	}
+
+	const scopeKeys = new Set([
+		...Object.keys(generated.scopes || {}),
+		...Object.keys(user.scopes || {}),
+	])
+
+	if (scopeKeys.size) {
+		merged.scopes = {}
+		for (const key of scopeKeys) {
+			merged.scopes[key] = {
+				...((generated.scopes || {})[key] || {}),
+				...((user.scopes || {})[key] || {}),
+			}
+		}
+	}
+
+	return merged
+}
+
+function renderImportMapTag(importMap) {
+	return `\t\t<script type="importmap">\n\t\t\t${JSON.stringify(importMap, null, '\t\t\t\t')}\n\t\t</script>`
 }
 
 // Rewrite production HTML for the dev server:
-// strips existing importmap + data-entrypoint script, injects importmap +
+// strips existing importmap + data-entrypoint script, injects merged importmap +
 // entrypoint module + HMR client before </head>.
-function transformHtml(html, entrypoint, importMapTag) {
-	html = html.replace(/<script\s+type=["']importmap["'][^>]*>[\s\S]*?<\/script>/gi, '');
-	html = html.replace(/<script([^>]*)\bdata-entrypoint\b([^>]*)><\/script>/gi, '');
-	const entryUrl = '/' + entrypoint.replace(/^\.\//, '').replaceAll('\\', '/');
+function transformHtml(html, entrypoint, generatedImportMap) {
+	const extracted = extractUserImportMap(html)
+	html = extracted.html
+	html = html.replace(/<script([^>]*)\bdata-entrypoint\b([^>]*)><\/script>/gi, '')
+
+	const entryUrl = '/' + entrypoint.replace(/^\.\//, '').replaceAll('\\', '/')
+	const importMapTag = renderImportMapTag(mergeImportMaps(generatedImportMap, extracted.importMap))
+
 	html = html.replace('</head>',
 		`${importMapTag}\n\t\t<script type='module' src='${entryUrl}'></script>\n${hmrClient}\n\t</head>`
-	);
-	return html;
+	)
+	return html
 }
 
 // ─── Dev server ───────────────────────────────────────────────────────────────
@@ -481,7 +525,7 @@ export function serve(entrypoint, flags) {
 	const htmlDir  = path.dirname(htmlPath)
 	const srcDir   = path.dirname(entrypoint)
 	const sockets  = new Set()
-	let importMapTag = null
+	let generatedImportMap = null
 
 	// ── Status line (prints current compile result, fades out on success) ──────
 
@@ -601,12 +645,22 @@ export function serve(entrypoint, flags) {
 				if (server.upgrade(req)) return undefined
 			}
 
+			if (pathname.startsWith('/__bimba_vendor__/')) {
+				const specifier = vendorSpecifierFromPath(pathname)
+				const bundled = specifier ? await bundleVendor(specifier) : null
+				if (bundled?.code) {
+					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 })
+			}
+
 			// HTML: index or any .html file
 			if (pathname === '/' || pathname.endsWith('.html')) {
 				const htmlFile = pathname === '/' ? htmlPath : '.' + pathname
 				let html = await Bun.file(htmlFile).text()
-				if (!importMapTag) importMapTag = await buildImportMap()
-				return new Response(transformHtml(html, entrypoint, importMapTag), {
+				if (!generatedImportMap) generatedImportMap = await buildGeneratedImportMap()
+				return new Response(transformHtml(html, entrypoint, generatedImportMap), {
 					headers: { 'Content-Type': 'text/html' },
 				})
 			}
@@ -653,57 +707,23 @@ export function serve(entrypoint, flags) {
 				}
 			}
 
-			// node_modules: entry point resolution, .imba compilation, CJS→ESM wrapping.
-			// The import map just maps bare specifiers to /node_modules/pkg/ URLs.
-			// All smart resolution happens here at request time.
+			// Direct node_modules URLs (from user import maps or explicit imports)
+			// are bundled through Bun too, so browser/cjs/exports handling stays
+			// in one place.
 			if (pathname.startsWith('/node_modules/')) {
-				const filepath = '.' + pathname
-
-				// Serve a resolved file: compile .imba, wrap CJS as ESM, pass ESM through
-				const serveResolved = async (filePath) => {
-					if (filePath.endsWith('.imba')) {
-						const f = Bun.file(filePath)
-						if (!(await f.exists())) return null
-						const out = await compileFile(filePath)
-						if (out.errors?.length) return new Response(out.errors.map(e => e.message).join('\n'), { status: 500 })
-						return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
-					}
-					const f = Bun.file(filePath)
-					if (!(await f.exists())) return null
-					const code = await f.text()
-					const wrapped = wrapCJS(code)
-					return new Response(wrapped || code, { headers: { 'Content-Type': 'application/javascript' } })
-				}
-
-				// Resolve entry point for root package requests (/node_modules/pkg/ or /node_modules/pkg)
-				const parts = pathname.slice(1).split('/')  // ['node_modules', 'pkg', ...]
-				const isScoped = parts[1]?.startsWith('@')
-				const pkgParts = isScoped ? 3 : 2  // node_modules/@scope/pkg or node_modules/pkg
-				const subParts = parts.slice(pkgParts)
-				const isRootRequest = subParts.length === 0 || (subParts.length === 1 && subParts[0] === '')
-
-				if (isRootRequest) {
-					const pkgDir = './' + parts.slice(0, pkgParts).join('/')
-					const depPkg = await readPkgJson(pkgDir)
-					if (depPkg) {
-						const entry = resolveEntry(depPkg)
-						if (entry) {
-							const resp = await serveResolved(path.join(pkgDir, entry))
-							if (resp) return resp
-						}
-					}
+				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 })
+					return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 
-				// Subpath: try the exact path, then with extensions
-				const resp = await serveResolved(filepath)
-				if (resp) return resp
-
-				// Extensionless: try .imba, .js, .mjs
-				if (!filepath.includes('.', filepath.lastIndexOf('/') + 1)) {
-					for (const ext of ['.imba', '.js', '.mjs']) {
-						const resp = await serveResolved(filepath + ext)
-						if (resp) return resp
+				if (resolved) {
+					const bundled = await bundleVendor(path.resolve(resolved))
+					if (bundled?.code) {
+						return new Response(bundled.code, { headers: { 'Content-Type': 'application/javascript' } })
 					}
+					return new Response((bundled?.errors || [`Could not bundle ${pathname}`]).join('\n'), { status: 500 })
 				}
 			}
 
@@ -731,13 +751,13 @@ export function serve(entrypoint, flags) {
 			}
 
 			// SPA fallback for extension-less paths
-			if (!lastSegment.includes('.')) {
-				let html = await Bun.file(htmlPath).text()
-				if (!importMapTag) importMapTag = await buildImportMap()
-				return new Response(transformHtml(html, entrypoint, importMapTag), {
-					headers: { 'Content-Type': 'text/html' },
-				})
-			}
+				if (!lastSegment.includes('.')) {
+					let html = await Bun.file(htmlPath).text()
+					if (!generatedImportMap) generatedImportMap = await buildGeneratedImportMap()
+					return new Response(transformHtml(html, entrypoint, generatedImportMap), {
+						headers: { 'Content-Type': 'text/html' },
+					})
+				}
 
 			return new Response('Not Found', { status: 404 })
 		},