bimba-cli 0.7.12 → 0.7.14

package/README.md

@@ -37,9 +37,9 @@ bunx bimba src/index.imba --serve --port 5200 --html public/index.html
 **How it works:**
 - Serves your HTML file and compiles `.imba` files on demand (no bundling step)
 - Watches `src/` for changes and pushes updates over WebSocket
-- Injects an importmap built from your `package.json` dependencies (supports `exports`, `module`, `browser`, and `main` fields)
+- Rewrites bare package imports in served JS modules to `__bimba_vendor__/*` URLs
 - CSS files imported from JS (e.g. `import 'some-lib/styles.css'`) are automatically wrapped as JS modules that inject `<style>` tags
-- npm packages with ESM entry points are served from `node_modules` locally — no esm.sh proxy needed
+- npm packages are bundled on demand by Bun (`target: "browser"`), so Bun owns `exports`, `browser`, CommonJS interop, and nested dependency resolution
 - Injects an HMR client that swaps component prototypes without a full page reload
 
 **HMR internals:**
@@ -58,7 +58,7 @@ Duplicate root elements (caused by `imba.mount()` running again on re-import) ar
 
 For a deep dive into how Imba compiles tags, how the render cache works, and how bimba hooks into it — see [INTERNALS.md](INTERNALS.md).
 
-**HTML setup:** add a `data-entrypoint` attribute to the script tag that loads your bundle. The dev server will replace it with your `.imba` entrypoint and inject the importmap above it:
+**HTML setup:** add a `data-entrypoint` attribute to the script tag that loads your bundle. The dev server will replace it with your `.imba` entrypoint and remove existing import maps, since package imports are rewritten in served modules instead:
 
 ```html
 <script type='module' src="./js/index.js" data-entrypoint></script>
@@ -72,9 +72,9 @@ For a deep dive into how Imba compiles tags, how the render cache works, and how
 
 `--html <path>` — path to your HTML file (auto-detected from `./index.html`, `./public/index.html`, `./src/index.html` if omitted)
 
-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.
+Static files are resolved relative to the HTML file's directory first, then from the project root (for `node_modules`, `src`, etc.). Extensionless imports are resolved by trying `.imba`, `.js`, and `.mjs` extensions automatically.
 
-**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.
+**npm package resolution:** The dev server scans each served JS module and rewrites bare imports such as `imba/runtime`, `@scope/pkg`, and `pkg/subpath` to `__bimba_vendor__/*` URLs. Those vendor URLs are bundled 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.
 
 ---
 
@@ -90,6 +90,21 @@ With watch:
 bunx bimba src/index.imba --outdir public/js --watch --clearcache
 ```
 
+### TypeScript diagnostics for Imba files
+
+To check TypeScript diagnostics reported by the Imba language-service plugin:
+```bash
+bunx bimba --typecheck
+```
+
+By default this scans `src/` when it exists, otherwise the project root. You can also pass a specific file or folder:
+```bash
+bunx bimba src/index.imba --typecheck
+bunx bimba src --typecheck
+```
+
+This mode requires `typescript` in the project and `typescript-imba-plugin` either in `node_modules` or in an installed Imba editor extension.
+
 ---
 
 ### All CLI flags
@@ -106,6 +121,10 @@ bunx bimba src/index.imba --outdir public/js --watch --clearcache
 
 `--target <browser|node>` — platform flag passed to the Imba compiler (default: `browser`). The `node` value does not work under Bun.
 
+`--typecheck` — check TypeScript diagnostics in `.imba` files using `tsserver` and `typescript-imba-plugin`.
+
+`--tscheck` — alias for `--typecheck`.
+
 `--serve` — start dev server with HMR instead of bundling.
 
 `--port <number>` — port for the dev server (default: `5200`). Used with `--serve`.

package/index.js

@@ -7,6 +7,7 @@ import fs from 'fs'
 import path from 'path';
 import { rmSync } from "node:fs";
 import { serve } from './serve.js';
+import { checkImbaTypes } from './typecheck.js';
 
 
 let flags = {}
@@ -28,6 +29,8 @@ try {
             serve: { type: 'boolean' },
             port: { type: 'string' },
             html: { type: 'string' },
+            typecheck: { type: 'boolean' },
+            tscheck: { type: 'boolean' },
         },
         allowNegative: true,
         strict: true,
@@ -74,6 +77,8 @@ if(flags.help) {
     console.log("   "+theme.flags('--external <package>')+"                Exclude package from bundle (repeatable, e.g. --external ws --external node-pty)");
     console.log("   "+theme.flags('--watch')+"                               Watch for changes in the entrypoint folder");
     console.log("   "+theme.flags('--clearcache')+"                          Clear cache on exit, works only when in watch mode");
+    console.log("   "+theme.flags('--typecheck')+"                           Check TypeScript diagnostics in .imba files");
+    console.log("   "+theme.flags('--tscheck')+"                             Alias for --typecheck");
     console.log("");
     console.log("Dev server (HMR):");
     console.log("   "+theme.flags('--serve')+"                               Start dev server with Hot Module Replacement");
@@ -86,8 +91,19 @@ if(flags.help) {
 
 let bundling = false;
 
+// typecheck mode
+if (flags.typecheck || flags.tscheck) {
+    try {
+        const success = await checkImbaTypes(entrypoint);
+        process.exit(success ? 0 : 1);
+    }
+    catch (error) {
+        console.log(theme.failure(' Failure ') + ` ${error.message}`);
+        process.exit(1);
+    }
+}
 // serve mode
-if (flags.serve) {
+else if (flags.serve) {
     if (!entrypoint) {
         console.log("");
         console.log("You should provide entrypoint: "+theme.flags('bimba file.imba --serve'));

package/package.json

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

package/serve.js

@@ -255,6 +255,7 @@ const hmrClient = `
 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
+const _importScanner = new Bun.Transpiler({ loader: 'js' })
 
 // Imba compiles tag render-cache slots as anonymous local Symbols at module top
 // level: `var $4 = Symbol(), $11 = Symbol(), ...; let c$0 = Symbol();`. Each
@@ -299,6 +300,40 @@ function _normalizeResult(result, extras) {
 	}
 }
 
+function isBareSpecifier(specifier) {
+	if (!specifier) return false
+	if (specifier.startsWith('.') || specifier.startsWith('/')) return false
+	if (/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(specifier)) return false
+	if (specifier.startsWith('#')) return false
+	return true
+}
+
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function rewriteBareImports(js) {
+	let imports = []
+	try {
+		imports = _importScanner.scanImports(js)
+	} catch (_) {
+		return js
+	}
+
+	for (const specifier of new Set(imports.map(item => item.path).filter(isBareSpecifier))) {
+		const target = vendorUrl(specifier)
+		const escaped = escapeRegExp(specifier)
+
+		const staticPattern = new RegExp(`((?:import|export)\\s+(?:[^'"]*?\\s+from\\s*)?)(['"])${escaped}\\2`, 'g')
+		js = js.replace(staticPattern, (_match, prefix, quote) => `${prefix}${quote}${target}${quote}`)
+
+		const dynamicPattern = new RegExp(`(\\bimport\\s*\\(\\s*)(['"])${escaped}\\2`, 'g')
+		js = js.replace(dynamicPattern, (_match, prefix, quote) => `${prefix}${quote}${target}${quote}`)
+	}
+
+	return js
+}
+
 async function compileFile(filepath) {
 	const abs = path.resolve(filepath)
 	const file = Bun.file(filepath)
@@ -318,7 +353,7 @@ async function compileFile(filepath) {
 	const errors = result.errors || []
 	if (!errors.length && result.js) {
 		const { js, slotCount } = stabilizeSymbols(result.js, abs)
-		result.js = js
+		result.js = rewriteBareImports(js)
 		const prev = _prevSlots.get(abs)
 		result.slots = (prev === undefined || prev === slotCount) ? 'stable' : 'shifted'
 		_prevSlots.set(abs, slotCount)
@@ -345,11 +380,7 @@ function findHtml(flagHtml) {
 const _vendorCache = new Map() // entrypoint → { mtime, code }
 
 function vendorUrl(specifier) {
-	return '/__bimba_vendor__/' + specifier
-}
-
-function vendorPrefixUrl(specifier) {
-	return vendorUrl(specifier) + '/'
+	return '/__bimba_vendor__/' + encodeURIComponent(specifier)
 }
 
 function resolveFileCandidate(filepath) {
@@ -453,86 +484,22 @@ async function bundleVendor(entrypoint) {
 	}
 }
 
-async function buildGeneratedImportMap() {
-	const imports = {}
-
-	try {
-		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 */ }
-
-	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>`
+async function serveJavaScriptFile(filepath) {
+	const js = rewriteBareImports(await Bun.file(filepath).text())
+	return new Response(js, { headers: { 'Content-Type': 'application/javascript' } })
 }
 
 // Rewrite production HTML for the dev server:
-// strips existing importmap + data-entrypoint script, injects merged importmap +
+// strips existing importmap + data-entrypoint script, then injects the Imba
 // entrypoint module + HMR client before </head>.
-function transformHtml(html, entrypoint, generatedImportMap) {
-	const extracted = extractUserImportMap(html)
-	html = extracted.html
+function transformHtml(html, entrypoint) {
+	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('\\', '/')
-	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>`
+		`\t\t<script type='module' src='${entryUrl}'></script>\n${hmrClient}\n\t</head>`
 	)
 	return html
 }
@@ -545,7 +512,6 @@ export function serve(entrypoint, flags) {
 	const htmlDir  = path.dirname(htmlPath)
 	const srcDir   = path.dirname(entrypoint)
 	const sockets  = new Set()
-	let generatedImportMap = null
 
 	// ── Status line (prints current compile result, fades out on success) ──────
 
@@ -679,8 +645,7 @@ export function serve(entrypoint, flags) {
 			if (pathname === '/' || pathname.endsWith('.html')) {
 				const htmlFile = pathname === '/' ? htmlPath : '.' + pathname
 				let html = await Bun.file(htmlFile).text()
-				if (!generatedImportMap) generatedImportMap = await buildGeneratedImportMap()
-				return new Response(transformHtml(html, entrypoint, generatedImportMap), {
+				return new Response(transformHtml(html, entrypoint), {
 					headers: { 'Content-Type': 'text/html' },
 				})
 			}
@@ -713,8 +678,13 @@ export function serve(entrypoint, flags) {
 			// Without this, `import './styles.css'` inside an ESM package fails because
 			// the browser expects a JS module response, not raw CSS.
 			if (pathname.endsWith('.css')) {
-				const cssFile = Bun.file('.' + pathname)
-				if (await cssFile.exists()) {
+				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 css = await cssFile.text()
 					const id = JSON.stringify(pathname)
 					const js = [
@@ -727,6 +697,11 @@ export function serve(entrypoint, flags) {
 				}
 			}
 
+			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)
+			}
+
 			// 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.
@@ -763,18 +738,15 @@ export function serve(entrypoint, flags) {
 					if (!out.errors?.length) return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 				for (const ext of ['.js', '.mjs']) {
-					const withExt = Bun.file('.' + pathname + ext)
-					if (await withExt.exists()) return new Response(withExt, {
-						headers: { 'Content-Type': 'application/javascript' },
-					})
+					const withExt = '.' + pathname + ext
+					if (existsSync(withExt)) return serveJavaScriptFile(withExt)
 				}
 			}
 
 			// SPA fallback for extension-less paths
 				if (!lastSegment.includes('.')) {
 					let html = await Bun.file(htmlPath).text()
-					if (!generatedImportMap) generatedImportMap = await buildGeneratedImportMap()
-					return new Response(transformHtml(html, entrypoint, generatedImportMap), {
+					return new Response(transformHtml(html, entrypoint), {
 						headers: { 'Content-Type': 'text/html' },
 					})
 				}

package/typecheck.js

@@ -0,0 +1,248 @@
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { theme } from './utils.js';
+
+const require = createRequire(import.meta.url);
+
+const SKIP_DIRS = new Set([
+    '.bimba',
+    '.cache',
+    '.git',
+    'build',
+    'dist',
+    'node_modules',
+    'public',
+]);
+
+function canResolve(request, from) {
+    try {
+        return require.resolve(request, { paths: [from] });
+    }
+    catch {
+        return null;
+    }
+}
+
+function findTypeScript(cwd) {
+    const tsserver = canResolve('typescript/lib/tsserver.js', cwd);
+    if (tsserver) return tsserver;
+
+    throw new Error('Could not find TypeScript. Install it in this project: bun add -d typescript');
+}
+
+function findPluginProbe(cwd) {
+    const localProbe = path.join(cwd, 'node_modules');
+    if (canResolve('typescript-imba-plugin', localProbe)) return localProbe;
+
+    const extensionRoots = [
+        path.join(os.homedir(), '.vscode', 'extensions'),
+        path.join(os.homedir(), '.cursor', 'extensions'),
+        path.join(os.homedir(), '.windsurf', 'extensions'),
+        path.join(os.homedir(), '.kiro', 'extensions'),
+    ];
+
+    for (const root of extensionRoots) {
+        if (!fs.existsSync(root)) continue;
+
+        for (const entry of fs.readdirSync(root)) {
+            const probe = path.join(root, entry, 'node_modules');
+            if (canResolve('typescript-imba-plugin', probe)) return probe;
+        }
+    }
+
+    throw new Error('Could not find typescript-imba-plugin. Install the Imba VSCode extension or add the plugin to node_modules.');
+}
+
+function getScanRoot(entrypoint, cwd) {
+    if (!entrypoint) {
+        const src = path.join(cwd, 'src');
+        return fs.existsSync(src) ? src : cwd;
+    }
+
+    const resolved = path.resolve(cwd, entrypoint);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`The specified typecheck path does not exist: ${entrypoint}`);
+    }
+
+    const stat = fs.statSync(resolved);
+    return stat.isDirectory() ? resolved : path.dirname(resolved);
+}
+
+function collectImbaFiles(root) {
+    const files = [];
+
+    function walk(dir) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name)) walk(path.join(dir, entry.name));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.imba')) {
+                files.push(path.join(dir, entry.name));
+            }
+        }
+    }
+
+    walk(root);
+    files.sort();
+    return files;
+}
+
+function parseMessages(buffer, onMessage) {
+    while (true) {
+        const text = buffer.toString('utf8');
+        const headerEnd = text.indexOf('\r\n\r\n');
+        if (headerEnd < 0) return buffer;
+
+        const match = /Content-Length: (\d+)/i.exec(text.slice(0, headerEnd));
+        if (!match) return buffer;
+
+        const length = Number(match[1]);
+        const bodyStart = Buffer.byteLength(text.slice(0, headerEnd + 4));
+        if (buffer.length < bodyStart + length) return buffer;
+
+        const body = buffer.slice(bodyStart, bodyStart + length).toString('utf8');
+        buffer = buffer.slice(bodyStart + length);
+
+        try {
+            onMessage(JSON.parse(body));
+        }
+        catch {}
+    }
+}
+
+function flattenMessage(text) {
+    if (typeof text == 'string') return text;
+    if (!text) return '';
+    if (text.messageText) {
+        const next = Array.isArray(text.next) ? text.next.map(flattenMessage) : [];
+        return [flattenMessage(text.messageText), ...next].filter(Boolean).join(' ');
+    }
+    return String(text);
+}
+
+function uniqueDiagnostics(diagnostics) {
+    const unique = Array.from(new Map(diagnostics.map(item => [item.key, item])).values());
+    unique.sort((a, b) => {
+        return a.file.localeCompare(b.file)
+            || (a.start?.line || 0) - (b.start?.line || 0)
+            || (a.start?.offset || 0) - (b.start?.offset || 0)
+            || String(a.code).localeCompare(String(b.code));
+    });
+    return unique;
+}
+
+function printDiagnostics(cwd, diagnostics) {
+    for (const item of diagnostics) {
+        const rel = path.relative(cwd, item.file);
+        const line = item.start?.line || 0;
+        const offset = item.start?.offset || 0;
+        const code = item.code ? `TS${item.code}` : 'TS';
+        const category = item.category || 'error';
+        const text = flattenMessage(item.text);
+
+        console.log(`${theme.filedir(rel)}:${line}:${offset} ${theme.action(item.kind)} ${theme.failure(` ${code} `)} ${category}: ${text}`);
+    }
+}
+
+function send(server, seq, command, args) {
+    server.stdin.write(JSON.stringify({ seq: seq.value++, type: 'request', command, arguments: args }) + '\n');
+}
+
+export async function checkImbaTypes(entrypoint, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const timeout = Number(options.timeout || process.env.BIMBA_TYPECHECK_TIMEOUT || process.env.IMBA_TS_CHECK_TIMEOUT || 12000);
+    const scanRoot = getScanRoot(entrypoint, cwd);
+    const files = collectImbaFiles(scanRoot);
+
+    if (!files.length) {
+        console.log(theme.success('Success') + ` No Imba files found in ${theme.filedir(path.relative(cwd, scanRoot) || '.')}`);
+        return true;
+    }
+
+    const tsserver = findTypeScript(cwd);
+    const pluginProbe = findPluginProbe(cwd);
+    const runner = process.env.BIMBA_NODE || process.env.NODE || 'node';
+
+    console.log(theme.folder('──────────────────────────────────────────────────────────────────────'));
+    console.log(theme.start(`Start checking TypeScript diagnostics for ${theme.count(files.length)} Imba file${files.length > 1 ? 's' : ''}`));
+
+    return await new Promise((resolve) => {
+        let settled = false;
+        let buffer = Buffer.alloc(0);
+        const seq = { value: 1 };
+        const diagnostics = [];
+
+        const server = spawn(runner, [
+            tsserver,
+            '--globalPlugins',
+            'typescript-imba-plugin',
+            '--pluginProbeLocations',
+            pluginProbe,
+        ], { cwd });
+
+        function finish(success) {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            server.kill();
+            resolve(success);
+        }
+
+        const timer = setTimeout(() => {
+            const unique = uniqueDiagnostics(diagnostics);
+
+            if (!unique.length) {
+                console.log(theme.success('Success') + ' No Imba TypeScript diagnostics');
+                finish(true);
+                return;
+            }
+
+            printDiagnostics(cwd, unique);
+            console.log(theme.failure(' Failure ') + ` TypeScript found ${theme.count(unique.length)} diagnostic${unique.length > 1 ? 's' : ''}`);
+            finish(false);
+        }, timeout);
+
+        server.on('error', (error) => {
+            console.log(theme.failure(' Failure ') + ` Could not start ${runner}: ${error.message}`);
+            finish(false);
+        });
+
+        server.stderr.on('data', chunk => process.stderr.write(chunk));
+
+        server.stdout.on('data', chunk => {
+            buffer = Buffer.concat([buffer, chunk]);
+            buffer = parseMessages(buffer, msg => {
+                if (msg.type != 'event' || !/Diag$/.test(msg.event)) return;
+                if (!msg.body?.diagnostics?.length) return;
+
+                for (const diagnostic of msg.body.diagnostics) {
+                    const key = [
+                        msg.event,
+                        msg.body.file,
+                        diagnostic.start?.line,
+                        diagnostic.start?.offset,
+                        diagnostic.code,
+                        flattenMessage(diagnostic.text),
+                    ].join('\0');
+
+                    diagnostics.push({
+                        key,
+                        kind: msg.event,
+                        file: msg.body.file,
+                        ...diagnostic,
+                    });
+                }
+            });
+        });
+
+        setTimeout(() => {
+            if (settled) return;
+            send(server, seq, 'configure', { preferences: {}, hostInfo: 'bimba-typecheck' });
+            for (const file of files) send(server, seq, 'open', { file, projectRootPath: cwd });
+            send(server, seq, 'geterr', { files, delay: 0 });
+        }, 100);
+    });
+}