gofront 1.3.10 → 1.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.3.10",
+	"version": "1.3.11",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {

package/src/asset-manager.js

@@ -11,6 +11,7 @@ import {
 	resolve,
 	sep,
 } from "node:path";
+import { log } from "./colors.js";
 import { loadProjectConfig } from "./project-config.js";
 
 export function loadAssetConfig(projectDir) {
@@ -50,7 +51,7 @@ function copyAssetEntry(entry, projectRoot) {
 
 	const srcPath = resolve(projectRoot, source);
 	if (!existsSync(srcPath)) {
-		console.warn(`gofront: asset source '${source}' not found — skipping`);
+		log.warn(`asset source '${source}' not found — skipping`);
 		return {
 			status: "skipped",
 			item: { source, dest, status: "skipped", reason: "source not found" },
@@ -73,7 +74,7 @@ function copyAssetEntry(entry, projectRoot) {
 			item: { source, dest: targetFile, type: "file", status: "copied" },
 		};
 	} catch (err) {
-		console.warn(`gofront: failed to copy asset '${source}': ${err.message}`);
+		log.warn(`failed to copy asset '${source}': ${err.message}`);
 		return {
 			status: "failed",
 			item: { source, dest, status: "failed", reason: err.message },

package/src/cli-core.js

@@ -23,6 +23,7 @@ import {
 	sep,
 } from "node:path";
 import { copyAssets } from "./asset-manager.js";
+import { colors, log } from "./colors.js";
 import { compileDir, compileSingleFile } from "./compiler.js";
 import { createDevServer } from "./dev-server.js";
 import { minify } from "./minifier.js";
@@ -685,7 +686,7 @@ export async function handleBuild(targetDir = ".", options = {}) {
 			dest: join(outDir, "vendor.js"),
 		});
 	} catch (e) {
-		console.warn(`gofront: vendor bundle warning: ${e.message}`);
+		log.warn(`vendor bundle: ${e.message}`);
 	}
 
 	const assets = copyReleaseAssets(
@@ -755,11 +756,12 @@ function buildDevOnce(
 		writeFileSync(outputFile, `${result.js}\n`);
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
 		const note = changedFile ? ` — ${changedFile} changed` : "";
-		console.error(`gofront: OK — wrote ${outputFile} (${elapsedMs}ms${note})`);
+		log.ok(
+			`— wrote ${colors.cyan(outputFile)} ${colors.dim(`(${elapsedMs}ms${note})`)}`,
+		);
 		devServer.notify();
 	} catch (e) {
-		console.error("gofront: ERROR");
-		for (const line of e.message.split("\n")) console.error(`  ${line}`);
+		log.error(e.message);
 		devServer.notifyError(e);
 	}
 }

package/src/colors.js

@@ -0,0 +1,81 @@
+// ANSI color helpers for CLI output. Honours NO_COLOR / FORCE_COLOR and
+// otherwise only colors when the target stream is a TTY.
+
+export function colorEnabled(stream = process.stderr) {
+	if ("NO_COLOR" in process.env) return false;
+	const force = process.env.FORCE_COLOR;
+	if (force !== undefined) return force !== "0" && force !== "false";
+	return Boolean(stream?.isTTY);
+}
+
+const CODES = {
+	red: 31,
+	green: 32,
+	yellow: 33,
+	blue: 34,
+	magenta: 35,
+	cyan: 36,
+	gray: 90,
+	bold: 1,
+	dim: 2,
+};
+
+export function createColors(enabled) {
+	const c = {};
+	for (const [name, code] of Object.entries(CODES)) {
+		c[name] = enabled ? (s) => `\x1b[${code}m${s}\x1b[0m` : (s) => `${s}`;
+	}
+	c.enabled = enabled;
+	return c;
+}
+
+export const colors = createColors(colorEnabled(process.stderr));
+
+const DIAG_LABEL = /^(Lex error|Parse error|Type error)(\b.*?)(:\s)/;
+const GUTTER = /^(\s*\d+ \| )(.*)$/;
+const CARET = /^(\s*)(\^+)$/;
+
+// Colorizes a compiler diagnostic: red label, dimmed source gutter, red caret.
+export function formatDiagnostic(message, c = colors) {
+	if (!c.enabled) return message;
+	return message
+		.split("\n")
+		.map((line) => {
+			const label = line.match(DIAG_LABEL);
+			if (label) {
+				return `${c.bold(c.red(label[1]))}${c.dim(label[2])}${label[3]}${line.slice(label[0].length)}`;
+			}
+			const gutter = line.match(GUTTER);
+			if (gutter) return `${c.dim(gutter[1])}${gutter[2]}`;
+			const caret = line.match(CARET);
+			if (caret) return `${caret[1]}${c.bold(c.red(caret[2]))}`;
+			if (/^warning:/i.test(line.trim())) return c.yellow(line);
+			return line;
+		})
+		.join("\n");
+}
+
+// Standard CLI log helpers writing to stderr with a colored `gofront:` prefix.
+const prefix = () => colors.bold("gofront:");
+const isDiagnostic = (msg) => DIAG_LABEL.test(msg) || msg.includes("\n");
+
+export const log = {
+	info: (msg) => console.error(`${prefix()} ${msg}`),
+	ok: (msg) =>
+		console.error(`${prefix()} ${colors.green("OK")}${msg ? ` ${msg}` : ""}`),
+	warn: (msg) =>
+		console.error(`${prefix()} ${colors.yellow(`warning: ${msg}`)}`),
+	error: (msg) => {
+		console.error(`${prefix()} ${colors.bold(colors.red("ERROR"))}`);
+		for (const line of formatDiagnostic(msg).split("\n"))
+			console.error(`  ${line}`);
+	},
+	// Compiler diagnostics get the block form; anything else is one red line.
+	fail: (msg) =>
+		isDiagnostic(msg)
+			? log.error(msg)
+			: console.error(`${prefix()} ${colors.red(msg)}`),
+};
+
+export const stamp = () => colors.dim(`[${new Date().toLocaleTimeString()}]`);
+export const ms = (n) => colors.dim(`(${n}ms)`);

package/src/compiler.js

@@ -20,6 +20,7 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { CodeGen } from "./codegen/index.js";
+import { log } from "./colors.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
 import { Parser } from "./parser/index.js";
@@ -126,8 +127,8 @@ export function resolveImports(
 				seenLocalPaths.add(path);
 				const depDir = resolveGwDir(path, fromFile);
 				if (!depDir) {
-					console.error(
-						`gofront: warning: cannot find local package '${path}' relative to ${fromDir}`,
+					log.warn(
+						`cannot find local package '${path}' relative to ${fromDir}`,
 					);
 					continue;
 				}

package/src/dev-server.js

@@ -4,6 +4,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer } from "node:http";
 import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { colors, log } from "./colors.js";
 
 export const MIME = {
 	".html": "text/html; charset=utf-8",
@@ -275,9 +276,9 @@ function createNotify(clients) {
 
 function handleServerError(err, port) {
 	if (err.code === "EADDRINUSE") {
-		console.error(`gofront: port ${port} already in use — try --port <number>`);
+		log.fail(`port ${port} already in use — try --port <number>`);
 	} else {
-		console.error(`gofront: dev server error: ${err.message}`);
+		log.fail(`dev server error: ${err.message}`);
 	}
 	process.exit(1);
 }
@@ -327,7 +328,7 @@ export function createDevServer(serveDir, port = 3000, options = {}) {
 	server.listen(port, host, () => {
 		const actualPort = server.address()?.port ?? port;
 		if (port !== 0 && !options.silent) {
-			console.error(`gofront: dev server → http://localhost:${actualPort}`);
+			log.info(`dev server → ${colors.cyan(`http://localhost:${actualPort}`)}`);
 		}
 	});
 

package/src/index.js

@@ -38,6 +38,7 @@ import {
 	parseTestArgs,
 	runCompile,
 } from "./cli-core.js";
+import { colors, formatDiagnostic, log, ms, stamp } from "./colors.js";
 import { createDevServer } from "./dev-server.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
@@ -85,10 +86,9 @@ if (args[0] === "prep" || args[0] === "vendor") {
 	const { targetDir, vendorConfig } = parsePrepArgs(args.slice(1));
 	try {
 		const result = await handlePrep(resolve(targetDir), { vendorConfig });
-		for (const line of formatPrepSummary(result))
-			console.error(`gofront: ${line}`);
+		for (const line of formatPrepSummary(result)) log.info(line);
 	} catch (e) {
-		console.error(`gofront: ${e.message}`);
+		log.fail(e.message);
 		process.exit(1);
 	}
 	process.exit(0);
@@ -103,12 +103,12 @@ if (args[0] === "init") {
 	try {
 		({ mainPath } = handleInit(targetDir));
 	} catch (e) {
-		console.error(`gofront: ${e.message}`);
+		log.fail(e.message);
 		process.exit(1);
 	}
-	console.error(`gofront: created ${mainPath}`);
-	console.error(
-		`gofront: run  gofront ${targetArg === "." ? "main.go" : `${targetArg}/main.go`}  to compile`,
+	log.info(`created ${colors.cyan(mainPath)}`);
+	log.info(
+		`run  ${colors.cyan(`gofront ${targetArg === "." ? "main.go" : `${targetArg}/main.go`}`)}  to compile`,
 	);
 	process.exit(0);
 }
@@ -121,7 +121,7 @@ if (args[0] === "test") {
 		const result = await handleTest(targetDir, testOptions);
 		process.exit(result.exitCode);
 	} catch (e) {
-		console.error(`gofront: ${e.message}`);
+		log.fail(e.message);
 		process.exit(1);
 	}
 }
@@ -132,21 +132,21 @@ if (args[0] === "check") {
 	const { targetDir } = parseCheckArgs(args.slice(1));
 	try {
 		const { elapsedMs, packages } = handleCheck(targetDir);
+		const okLine = (label, t) =>
+			log.info(`${colors.cyan(label)} — ${colors.green("OK")} ${ms(t)}`);
 		if (packages) {
 			for (const pkg of packages) {
-				console.error(
-					`gofront: ${relative(process.cwd(), pkg.dir) || "."} — OK (${pkg.elapsedMs}ms)`,
-				);
+				okLine(relative(process.cwd(), pkg.dir) || ".", pkg.elapsedMs);
 			}
-			console.error(
-				`gofront: ${packages.length} packages — OK (${elapsedMs}ms)`,
+			log.info(
+				`${colors.bold(`${packages.length} packages`)} — ${colors.bold(colors.green("OK"))} ${ms(elapsedMs)}`,
 			);
 		} else {
-			console.error(`gofront: ${targetDir} — OK (${elapsedMs}ms)`);
+			okLine(targetDir, elapsedMs);
 		}
 		process.exit(0);
 	} catch (e) {
-		console.error(`gofront: ${e.message}`);
+		log.fail(e.message);
 		process.exit(1);
 	}
 }
@@ -158,11 +158,15 @@ if (args[0] === "build") {
 	try {
 		const result = await handleBuild(buildOptions.targetDir, buildOptions);
 		for (const line of formatBuildSummary(result)) {
-			console.error(`gofront: ${line}`);
+			log.info(
+				line
+					.replace(/^build complete/, colors.green("build complete"))
+					.replace(/\(([\d.]+ kB)\)$/, (_, s) => colors.dim(`(${s})`)),
+			);
 		}
 		process.exit(0);
 	} catch (e) {
-		console.error(`gofront: ${e.message}`);
+		log.fail(e.message);
 		process.exit(1);
 	}
 }
@@ -174,14 +178,14 @@ if (args[0] === "dev") {
 	try {
 		const dev = await handleDev(devOptions.targetDir, devOptions);
 		if (dev.initialError) {
-			console.error("gofront: ERROR");
-			for (const line of dev.initialError.message.split("\n"))
-				console.error(`  ${line}`);
+			log.error(dev.initialError.message);
 		} else {
-			console.error(`gofront: OK — wrote ${dev.outputFile}`);
+			log.ok(`— wrote ${colors.cyan(dev.outputFile)}`);
 		}
-		console.error(`gofront: dev server running → http://localhost:${dev.port}`);
-		console.error(`gofront: watching ${dev.srcDir} for changes...`);
+		log.info(
+			`dev server running → ${colors.cyan(`http://localhost:${dev.port}`)}`,
+		);
+		log.info(`watching ${colors.cyan(dev.srcDir)} for changes...`);
 
 		const shutdown = async () => {
 			await dev.close();
@@ -191,7 +195,7 @@ if (args[0] === "dev") {
 		process.on("SIGTERM", shutdown);
 		await new Promise(() => {});
 	} catch (e) {
-		console.error(`gofront: ${e.message}`);
+		log.fail(e.message);
 		process.exit(1);
 	}
 }
@@ -218,7 +222,7 @@ let isDir = false;
 try {
 	isDir = statSync(inputPath).isDirectory();
 } catch (e) {
-	console.error(`gofront: cannot access '${inputArg}': ${e.message}`);
+	log.fail(`cannot access '${inputArg}': ${e.message}`);
 	process.exit(1);
 }
 
@@ -235,7 +239,7 @@ if (!watchMode) {
 			dumpAst,
 		});
 	} catch (e) {
-		console.error(`gofront: ${e.message}`);
+		log.fail(e.message);
 		process.exit(1);
 	}
 
@@ -250,7 +254,9 @@ if (!watchMode) {
 
 	if (checkOnly) {
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
-		console.error(`gofront: ${inputArg} — OK (${elapsedMs}ms)`);
+		log.info(
+			`${colors.cyan(inputArg)} — ${colors.green("OK")} ${ms(elapsedMs)}`,
+		);
 		process.exit(0);
 	}
 
@@ -262,7 +268,7 @@ if (!watchMode) {
 			sourceMap,
 		});
 	} catch (e) {
-		console.error(`gofront: minify failed: ${e.message}`);
+		log.fail(`minify failed: ${e.message}`);
 		process.exit(1);
 	}
 
@@ -272,9 +278,9 @@ if (!watchMode) {
 		try {
 			mkdirSync(dirname(resolve(outputFile)), { recursive: true });
 			writeFileSync(outputFile, `${js}\n`);
-			console.error(`gofront: wrote ${outputFile} (${elapsedMs}ms)`);
+			log.info(`wrote ${colors.cyan(outputFile)} ${ms(elapsedMs)}`);
 		} catch (e) {
-			console.error(`gofront: cannot write '${outputFile}': ${e.message}`);
+			log.fail(`cannot write '${outputFile}': ${e.message}`);
 			process.exit(1);
 		}
 	} else {
@@ -286,10 +292,10 @@ if (!watchMode) {
 			const projectDir = resolve(".");
 			const { copied, skipped } = copyAssets(projectDir);
 			if (copied > 0 || skipped > 0) {
-				console.error(`gofront: copied ${copied} assets (${skipped} skipped)`);
+				log.info(`copied ${copied} assets (${skipped} skipped)`);
 			}
 		} catch (e) {
-			console.error(`gofront: asset copy failed: ${e.message}`);
+			log.warn(`asset copy failed: ${e.message}`);
 		}
 	}
 
@@ -298,15 +304,11 @@ if (!watchMode) {
 
 // ── Watch mode ───────────────────────────────────────────────
 
-function timestamp() {
-	return new Date().toLocaleTimeString();
-}
-
 // Start dev server before first build so the browser can connect immediately
 let devServer = null;
 if (serveMode) {
 	if (!outputFile) {
-		console.error("gofront: --serve requires -o <output file>");
+		log.fail("--serve requires -o <output file>");
 		process.exit(1);
 	}
 	const serveDir = dirname(resolve(outputFile));
@@ -324,17 +326,18 @@ function buildOnce(changedFile = null) {
 		});
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
 		const changeNote = changedFile ? ` — ${changedFile} changed` : "";
+		const timing = colors.dim(`(${elapsedMs}ms${changeNote})`);
 		if (outputFile) {
 			writeFileSync(outputFile, `${js}\n`);
 			console.error(
-				`[${timestamp()}] gofront: OK — wrote ${outputFile} (${elapsedMs}ms${changeNote})`,
+				`${stamp()} ${colors.bold("gofront:")} ${colors.green("OK")} — wrote ${colors.cyan(outputFile)} ${timing}`,
 			);
 		} else {
 			// Clear screen then print
 			process.stdout.write("\x1Bc");
 			console.log(js);
 			console.error(
-				`[${timestamp()}] gofront: OK (${elapsedMs}ms${changeNote})`,
+				`${stamp()} ${colors.bold("gofront:")} ${colors.green("OK")} ${timing}`,
 			);
 		}
 
@@ -342,14 +345,17 @@ function buildOnce(changedFile = null) {
 			try {
 				copyAssets(resolve("."));
 			} catch (e) {
-				console.error(`gofront: asset copy failed: ${e.message}`);
+				log.warn(`asset copy failed: ${e.message}`);
 			}
 		}
 
 		devServer?.notify();
 	} catch (e) {
-		console.error(`[${timestamp()}] gofront: ERROR`);
-		for (const line of e.message.split("\n")) console.error(`  ${line}`);
+		console.error(
+			`${stamp()} ${colors.bold("gofront:")} ${colors.bold(colors.red("ERROR"))}`,
+		);
+		for (const line of formatDiagnostic(e.message).split("\n"))
+			console.error(`  ${line}`);
 		devServer?.notifyError?.(e);
 	}
 }
@@ -365,7 +371,7 @@ function handleCssWatch(filename) {
 		try {
 			copyAssets(resolve("."));
 		} catch (e) {
-			console.error(`gofront: asset copy failed: ${e.message}`);
+			log.warn(`asset copy failed: ${e.message}`);
 		}
 	}
 	devServer?.notifyCss?.(filename);
@@ -385,4 +391,6 @@ watch(watchTarget, { recursive: true }, (_event, filename) => {
 	debounce = setTimeout(() => buildOnce(filename), 80);
 });
 
-console.error(`[${timestamp()}] gofront: watching ${inputArg} ...`);
+console.error(
+	`${stamp()} ${colors.bold("gofront:")} watching ${colors.cyan(inputArg)} ...`,
+);

package/src/test-runner.js

@@ -6,6 +6,7 @@ import { statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { colorEnabled, createColors, formatDiagnostic } from "./colors.js";
 import { compilePackageTests, gwFilesIn } from "./compiler.js";
 
 export function isTestFunc(decl) {
@@ -38,6 +39,7 @@ export function generateTestHarness(bundleJs, testNames, options = {}) {
 	const runRegex = options.run ? options.run : null;
 	const verbose = Boolean(options.verbose);
 	const dom = Boolean(options.dom);
+	const color = Boolean(options.color);
 	const pkgName = options.pkgName ?? "main";
 	// The harness runs from stdin with cwd = project dir, so a bare "jsdom"
 	// import only works if the project has it locally. Use the resolved path.
@@ -86,6 +88,12 @@ async function __runGoFrontSuite() {
   const runFilter = ${runRegex ? `new RegExp(${JSON.stringify(runRegex)})` : "null"};
   const verbose = ${verbose};
   const pkgName = ${JSON.stringify(pkgName)};
+  const paint = ${color}
+    ? (code) => (s) => "\\x1b[" + code + "m" + s + "\\x1b[0m"
+    : () => (s) => s;
+  const red = paint(31), green = paint(32), yellow = paint(33), dim = paint(2), bold = paint(1);
+  const PASS = green("PASS"), FAIL = bold(red("FAIL")), SKIP = yellow("SKIP");
+  const okLine = (name, t) => console.log(green("ok  ") + "\\t" + name + "\\t" + dim(t + "s"));
 
   const testsToRun = runFilter
     ? allTests.filter((name) => runFilter.test(name))
@@ -93,10 +101,10 @@ async function __runGoFrontSuite() {
 
   if (testsToRun.length === 0) {
     if (allTests.length > 0 && runFilter) {
-      console.log("testing: warning: no tests to run matching " + ${JSON.stringify(runRegex)});
+      console.log(yellow("testing: warning: no tests to run matching " + ${JSON.stringify(runRegex)}));
     }
-    console.log("PASS");
-    console.log("ok  \\t" + pkgName + "\\t0.000s");
+    console.log(PASS);
+    okLine(pkgName, "0.000");
     process.exit(0);
   }
 
@@ -108,17 +116,17 @@ async function __runGoFrontSuite() {
   // Go-style streaming report. In non-verbose mode only failures and skips are
   // shown, so the "=== RUN" header is emitted late for failures.
   const report = (t) => {
-    const elapsed = ((now() - t._start) / 1000).toFixed(2);
+    const elapsed = dim("(" + ((now() - t._start) / 1000).toFixed(2) + "s)");
     if (t.skipped) {
-      console.log("--- SKIP: " + t._name + " (" + elapsed + "s)");
+      console.log("--- " + SKIP + ": " + t._name + " " + elapsed);
       for (const log of t._logs) console.log("    " + log);
     } else if (t.failed) {
-      if (!verbose) console.log("=== RUN   " + t._name);
-      for (const log of t._logs) console.log("    " + log);
-      console.log("--- FAIL: " + t._name + " (" + elapsed + "s)");
+      if (!verbose) console.log(dim("=== RUN   ") + t._name);
+      for (const log of t._logs) console.log("    " + red(log));
+      console.log("--- " + FAIL + ": " + t._name + " " + elapsed);
     } else if (verbose) {
       for (const log of t._logs) console.log("    " + log);
-      console.log("--- PASS: " + t._name + " (" + elapsed + "s)");
+      console.log("--- " + PASS + ": " + t._name + " " + elapsed);
     }
   };
 
@@ -130,7 +138,7 @@ async function __runGoFrontSuite() {
   };
 
   globalThis.__onSubtestStart = (name) => {
-    if (verbose) console.log("=== RUN   " + name);
+    if (verbose) console.log(dim("=== RUN   ") + name);
   };
   globalThis.__onSubtestEnd = report;
 
@@ -141,13 +149,13 @@ ${testNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ?
   for (const name of testsToRun) {
     const fn = __testRegistry[name] ?? (typeof globalThis[name] === "function" ? globalThis[name] : null);
     if (typeof fn !== "function") {
-      console.error("testing: cannot find test function " + name);
+      console.error(red("testing: cannot find test function " + name));
       totalFailures++;
       continue;
     }
 
     const t = new __GoFront_T(name);
-    if (verbose) console.log("=== RUN   " + name);
+    if (verbose) console.log(dim("=== RUN   ") + name);
 
     try {
       const res = fn(t);
@@ -164,12 +172,12 @@ ${testNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ?
   const suiteElapsed = ((now() - suiteStart) / 1000).toFixed(3);
 
   if (totalFailures > 0) {
-    console.log("FAIL");
-    console.log("FAIL\\t" + pkgName + "\\t" + suiteElapsed + "s");
+    console.log(FAIL);
+    console.log(FAIL + "\\t" + pkgName + "\\t" + dim(suiteElapsed + "s"));
     process.exit(1);
   } else {
-    console.log("PASS");
-    console.log("ok  \\t" + pkgName + "\\t" + suiteElapsed + "s");
+    console.log(PASS);
+    okLine(pkgName, suiteElapsed);
     process.exit(0);
   }
 }
@@ -215,10 +223,17 @@ function reportEmptyTests(label, reason, options) {
 		return { exitCode: 0, stdout: out, stderr: "", noTests: true };
 	}
 	const dest = options.stdout ?? process.stdout;
-	dest.write(out);
+	dest.write(colorsFor(options, dest).dim(out));
 	return { exitCode: 0, noTests: true };
 }
 
+// Color is decided here because the harness child writes to a pipe, not a TTY.
+function colorsFor(options, stream) {
+	const enabled =
+		options.color ?? (!options.captureOutput && colorEnabled(stream));
+	return createColors(enabled);
+}
+
 function spawnTestRunner(resolvedDir, harnessJs, testCount, options) {
 	return new Promise((resolvePromise, rejectPromise) => {
 		const child = spawn(process.execPath, ["--input-type=module", "-"], {
@@ -289,12 +304,16 @@ export async function runTests(targetDir, options = {}) {
 	try {
 		compiled = compilePackageTests(resolvedDir, options);
 	} catch (err) {
-		const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${err?.message ?? String(err)}\n`;
+		const msg = err?.message ?? String(err);
 		if (options.captureOutput) {
+			const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${msg}\n`;
 			return { exitCode: 1, stdout: "", stderr: out };
 		}
 		const dest = options.stderr ?? process.stderr;
-		dest.write(out);
+		const c = colorsFor(options, dest);
+		dest.write(
+			`${c.bold(c.red("FAIL"))}\t${basename(resolvedDir)} ${c.red("[build failed]")}\n${formatDiagnostic(msg, c)}\n`,
+		);
 		return { exitCode: 1 };
 	}
 
@@ -309,6 +328,7 @@ export async function runTests(targetDir, options = {}) {
 		...options,
 		pkgName,
 		jsdomPath,
+		color: colorsFor(options, options.stdout ?? process.stdout).enabled,
 	});
 
 	return spawnTestRunner(resolvedDir, harnessJs, testNames.length, options);

package/src/typechecker/assignability.js

@@ -227,7 +227,10 @@ export const assignabilityMethods = {
 
 	_isUntypedAssignable(target, source) {
 		if (isUntyped(target)) return true;
-		if (target.kind !== "basic") return false;
+		// Named types with a basic underlying type (`type Mode string`) accept
+		// untyped constants of that kind, as in Go.
+		if (target.kind === "named") target = this.resolveType(target.underlying);
+		if (target?.kind !== "basic") return false;
 		return (
 			(UNTYPED_COMPAT[source.base]?.has(target.name) ?? false) ||
 			(isComplex(target) &&
@@ -347,6 +350,14 @@ export const assignabilityMethods = {
 		if (srcType?.kind === "pointer") srcType = this.resolveType(srcType.base);
 		let base = srcType.kind === "named" ? srcType.underlying : srcType;
 		base = this.resolveType(base);
+		// Interface → interface: the source's method set must cover the target's.
+		if (base?.kind === "interface") {
+			for (const [name, required] of iface.methods) {
+				if (!this._implementsMethod(required, base.methods.get(name)))
+					return false;
+			}
+			return true;
+		}
 		const methodMap =
 			base?.kind === "struct"
 				? base.methods