gofront 1.1.0 → 1.2.1

package/README.md

@@ -395,6 +395,7 @@ gofront <input> --minify                   minify output (built-in minifier)
 gofront <input> --minify --mangle          minify and rename local identifiers
 gofront <file.go> --ast                    dump AST (debug)
 gofront <file.go> --tokens                 dump tokens (debug)
+gofront test [dir] [--dom]                 run unit tests (-v verbose, -run <regex>)
 gofront prep [dir]                         copy static assets and bundle vendor dependencies
 gofront init [dir]                         scaffold a new project
 gofront --version / -v                     print version
@@ -403,6 +404,64 @@ gofront --help / -h                        print this help
 
 ---
 
+## Unit testing (`gofront test`)
+
+GoFront provides native, Go-idiomatic unit testing out of the box:
+
+- Files ending in `*_test.go` are automatically excluded from production builds (`gofront .`, `gofront -o app.js`) and compiled only when running tests.
+- Built-in `testing` standard library package with `*testing.T`.
+- Discover and execute `func TestXxx(t *testing.T)` functions with standard Go-style output.
+
+### Writing a test
+
+```go
+package store
+
+import "testing"
+
+func TestAddTodo(t *testing.T) {
+    store := NewTodoStore()
+    store.Add("Buy milk")
+
+    if store.Count() != 1 {
+        t.Errorf("expected 1 item, got %d", store.Count())
+    }
+}
+```
+
+Subtests and skips are fully supported:
+
+```go
+func TestFilter(t *testing.T) {
+    t.Run("active", func(t *testing.T) {
+        // subtest logic
+    })
+    t.Run("completed", func(t *testing.T) {
+        if testing.Short() {
+            t.Skip("skipping in short mode")
+        }
+    })
+}
+```
+
+### Running tests
+
+```sh
+gofront test                  # run tests in current directory
+gofront test ./src            # run tests in specific directory
+gofront test -v               # verbose output (RUN, PASS/FAIL, logs)
+gofront test -run "Todo"      # run only tests matching regex pattern
+gofront test --dom            # initialize JSDOM for DOM/gom/templ tests
+```
+
+`--dom` requires `jsdom`. It is resolved from the project directory first and
+then from GoFront's own installation, so a globally installed `gofront` works
+without a project-local copy.
+
+Only `TestXxx` functions declared in `*_test.go` files are discovered, matching Go.
+
+---
+
 ## Static assets & vendor bundling
 
 GoFront includes native tooling to manage static assets and package external npm dependencies for the browser without requiring external wrappers or complex build tools.
@@ -432,6 +491,27 @@ gofront prep
 
 GoFront inspects your `dependencies`, dynamically uses `rolldown` or `esbuild` from your `devDependencies`, and bundles them into an ES module (defaulting to `app/vendor.js` or `vendor.js`).
 
+Each bundled package is exposed on `window` under its full name, its unscoped name,
+and a sanitised identifier (e.g. `fuse.js` → `window["fuse.js"]`, `window.fuse_js`).
+To expose additional global names, add a `vendor.globals` mapping:
+
+```json
+{
+  "vendor": {
+    "dest": ["app/vendor.js", "public/vendor.js"],
+    "minify": true,
+    "globals": {
+      "fuse.js": ["Fuse"],
+      "prismjs": ["Prism"],
+      "@emailjs/browser": ["emailjs"]
+    }
+  }
+}
+```
+
+`dest` accepts a string or an array (the bundle is written once and copied to each
+extra destination). `gofront prep --minify` overrides `minify` from the command line.
+
 ---
 
 ## Multi-file packages

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.1.0",
+	"version": "1.2.1",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -36,8 +36,11 @@
 		"build:gom": "node src/index.js example/gom/src -o example/gom/app.js",
 		"build:templ": "node src/index.js example/templ/src -o example/templ/app.js",
 		"build:all": "npm run build:simple && npm run build:reactive && npm run build:gom && npm run build:templ",
-		"test:all": "npm run test:unit && npm run test:e2e",
+		"test": "npm run test:unit",
+		"test:all": "npm run test:unit && npm run test:examples && npm run test:examples:dom && npm run test:e2e",
 		"test:unit": "node test/unit/run.js",
+		"test:examples": "node src/index.js test example/simple/src && node src/index.js test example/simple/src/utils && node src/index.js test example/reactive/src && node src/index.js test example/reactive/src/utils && node src/index.js test example/gom/src && node src/index.js test example/gom/src/utils && node src/index.js test example/templ/src && node src/index.js test example/templ/src/utils",
+		"test:examples:dom": "node src/index.js test --dom example/simple/src && node src/index.js test --dom example/gom/src && node src/index.js test --dom example/templ/src",
 		"test:coverage": "c8 --include='src/**' --reporter=text --reporter=lcov node test/unit/run.js",
 		"test:e2e": "npm run build:all && playwright test",
 		"format": "biome format --write .",

package/src/asset-manager.js

@@ -16,6 +16,7 @@ import {
 	join,
 	relative,
 	resolve,
+	sep,
 } from "node:path";
 
 export function loadAssetConfig(projectDir) {
@@ -58,7 +59,11 @@ function copyAssetEntry(entry, projectRoot) {
 
 	const destPath = resolve(projectRoot, dest);
 	const relDest = relative(projectRoot, destPath);
-	if (relDest.startsWith("..") || isAbsolute(relDest)) {
+	if (
+		relDest === ".." ||
+		relDest.startsWith(`..${sep}`) ||
+		isAbsolute(relDest)
+	) {
 		throw new Error(
 			`gofront: asset destination '${dest}' is outside project directory`,
 		);

package/src/cli-core.js

@@ -6,6 +6,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { copyAssets } from "./asset-manager.js";
 import { compileDir, compileSingleFile } from "./compiler.js";
 import { minify } from "./minifier.js";
+import { runTests } from "./test-runner.js";
 import { bundleVendor } from "./vendor.js";
 
 export function runCompile(inputPath, isDir, options) {
@@ -72,3 +73,53 @@ export async function handlePrep(targetDir, options = {}) {
 	const vendor = await bundleVendor(resolvedTarget, options.vendorConfig);
 	return { assets, vendor };
 }
+
+export function parsePrepArgs(argv) {
+	const positional = argv.filter((a) => !a.startsWith("-"));
+	return {
+		targetDir: positional[0] ?? ".",
+		vendorConfig: argv.includes("--minify") ? { minify: true } : {},
+	};
+}
+
+export function formatPrepSummary({ assets, vendor }) {
+	const lines = [];
+	if (assets.copied > 0 || assets.skipped > 0) {
+		lines.push(`copied ${assets.copied} assets (${assets.skipped} skipped)`);
+	}
+	if (vendor.bundled?.length > 0) {
+		const dest = Array.isArray(vendor.dest)
+			? vendor.dest.join(", ")
+			: vendor.dest;
+		const min = vendor.minify ? " (minified)" : "";
+		lines.push(
+			`bundled ${vendor.bundled.length} vendor dependencies → ${dest}${min}`,
+		);
+	}
+	return lines;
+}
+
+export function parseTestArgs(argv) {
+	let run = null;
+	const positional = [];
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "-run" || arg === "--run") {
+			run = argv[++i] ?? null;
+		} else if (arg.startsWith("-run=") || arg.startsWith("--run=")) {
+			run = arg.slice(arg.indexOf("=") + 1);
+		} else if (!arg.startsWith("-")) {
+			positional.push(arg);
+		}
+	}
+	return {
+		targetDir: positional[0] ?? ".",
+		verbose: argv.includes("-v"),
+		dom: argv.includes("--dom"),
+		run,
+	};
+}
+
+export function handleTest(targetDir, options = {}) {
+	return runTests(targetDir, options);
+}

package/src/codegen/expressions.js

@@ -345,6 +345,8 @@ export const expressionGenMethods = {
 			return this._genRegexpMethodCall(expr.func.field, expr);
 		if (recvName === "time.Time")
 			return this._genTimeMethodCall(expr.func.field, expr);
+		if (recvName === "testing.T")
+			return this._genTestingMethodCall(expr.func.field, expr);
 		return undefined;
 	},
 
@@ -752,6 +754,10 @@ export const expressionGenMethods = {
 				const cmp = `__equal(${l}, ${r})`;
 				return expr.op === "==" ? cmp : `!${cmp}`;
 			}
+			if (l === "null" || r === "null") {
+				const op = expr.op === "==" ? "==" : "!=";
+				return `${l} ${op} ${r}`;
+			}
 		}
 		const op = expr.op === "==" ? "===" : expr.op === "!=" ? "!==" : expr.op;
 		return `${l} ${op} ${r}`;

package/src/codegen/index.js

@@ -30,6 +30,7 @@ import {
 	HELPER_PATH_CLEAN,
 	HELPER_S,
 	HELPER_SPRINTF,
+	HELPER_TESTING,
 	HELPER_TIME_FMT,
 	HELPER_TIME_PARSE,
 } from "./runtime.js";
@@ -71,6 +72,7 @@ export class CodeGen {
 		this._usesPathClean = false;
 		this._usesTimeFmt = false;
 		this._usesTimeParse = false;
+		this._usesTesting = false;
 		// Iterator (range-over-func) context
 		this._inIteratorBody = false;
 		this._iterDepth = 0;
@@ -137,20 +139,24 @@ export class CodeGen {
 		}
 	}
 
-	_callInitAndMain(initNames, program) {
+	_callInitAndMain(initNames, program, isTest = false) {
 		for (const name of initNames) this.line(`${name}();`);
-		if (program.decls.some((d) => d.kind === "FuncDecl" && d.name === "main"))
+		if (
+			!isTest &&
+			program.decls.some((d) => d.kind === "FuncDecl" && d.name === "main")
+		)
 			this.line("main();");
 	}
 
-	generate(program) {
+	generate(program, options = {}) {
+		const isTest = options.isTest ?? false;
 		const methods = this._collectDecls(program);
 		this._emitJsImports();
 		this._emitTypeDecls(program, methods);
 		this._emitVarConstDecls(program);
 		const initNames = this._emitFuncDecls(program);
-		this._callInitAndMain(initNames, program);
-		this._prependHelpers();
+		this._callInitAndMain(initNames, program, isTest);
+		this._prependHelpers(isTest);
 		while (this.out[0] === "") this.out.shift();
 		return this.out.join("\n");
 	}
@@ -221,7 +227,8 @@ export class CodeGen {
 		return methods;
 	}
 
-	_prependHelpers() {
+	_prependHelpers(isTest = false) {
+		const needsTesting = isTest || this._usesTesting;
 		const HELPER_MAP = [
 			[this._usesLen, HELPER_LEN],
 			[this._usesAppend, HELPER_APPEND],
@@ -229,12 +236,13 @@ export class CodeGen {
 			[this._usesEqual, HELPER_EQUAL],
 			[this._usesCmul, HELPER_CMUL],
 			[this._usesCdiv, HELPER_CDIV],
-			[this._usesSprintf, HELPER_SPRINTF],
+			[this._usesSprintf || needsTesting, HELPER_SPRINTF],
 			[this._usesError, HELPER_ERROR],
 			[this._usesErrorIs, HELPER_ERROR_IS],
 			[this._usesPathClean, HELPER_PATH_CLEAN],
 			[this._usesTimeFmt, HELPER_TIME_FMT],
 			[this._usesTimeParse, HELPER_TIME_PARSE],
+			[needsTesting, HELPER_TESTING],
 		];
 		const helpers = HELPER_MAP.filter(([flag]) => flag).map(([, h]) => h);
 		if (helpers.length > 0) this.out.unshift(...helpers, "");
@@ -242,14 +250,14 @@ export class CodeGen {
 
 	// Generate a single bundle from multiple programs (same-package multi-file).
 	// Annotates each decl with its source file index before merging.
-	generateAll(programs) {
+	generateAll(programs, options = {}) {
 		for (let i = 0; i < programs.length; i++) {
 			for (const decl of programs[i].decls) {
 				decl._srcFileIdx = i;
 			}
 		}
 		const merged = { decls: programs.flatMap((p) => p.decls) };
-		return this.generate(merged);
+		return this.generate(merged, options);
 	}
 
 	// Returns a source map JSON string for the last generate() call.

package/src/codegen/runtime.js

@@ -56,9 +56,19 @@ export const HELPER_SPRINTF = `var __sprintf = __sprintf || function(f, ...a) {
       case "s": return pad(String(v == null ? "<nil>" : v), width, false);
       case "d": return pad(String(Math.trunc(Number(v))), width, zero);
       case "v": {
-        if (typeof v === "object" && v !== null && "re" in v && "im" in v) {
-          const sign = v.im >= 0 ? "+" : "";
-          return pad("(" + v.re + sign + v.im + "i)", width, false);
+        if (typeof v === "object" && v !== null) {
+          if ("re" in v && "im" in v) {
+            const sign = v.im >= 0 ? "+" : "";
+            return pad("(" + v.re + sign + v.im + "i)", width, false);
+          }
+          if (typeof v.Error === "function") {
+            return pad(String(v.Error()), width, false);
+          }
+          try {
+            return pad(JSON.stringify(v), width, false);
+          } catch {
+            return pad(String(v), width, false);
+          }
         }
         return pad(String(v == null ? "<nil>" : v), width, false);
       }
@@ -149,3 +159,108 @@ export const HELPER_TIME_PARSE = `var __timeParse = __timeParse || function(layo
     return [{ _d: new Date(0) }, "parsing time: cannot parse"];
   }
 };`;
+
+export const HELPER_TESTING = `var __GoFront_FailNow = __GoFront_FailNow || class extends Error {
+  constructor() { super("FailNow"); this.name = "__GoFront_FailNow"; }
+};
+var __GoFront_SkipNow = __GoFront_SkipNow || class extends Error {
+  constructor() { super("SkipNow"); this.name = "__GoFront_SkipNow"; }
+};
+var __GoFront_T = __GoFront_T || class {
+  constructor(name = "", parent = null) {
+    this._name = name;
+    this._parent = parent;
+    this.failed = false;
+    this.skipped = false;
+    this._logs = [];
+    this._start = typeof performance !== "undefined" ? performance.now() : Date.now();
+  }
+  Name() { return this._name; }
+  Fail() {
+    this.failed = true;
+    if (this._parent) this._parent.Fail();
+  }
+  Failed() { return this.failed; }
+  FailNow() {
+    this.Fail();
+    throw new __GoFront_FailNow();
+  }
+  Log(...args) {
+    const msg = args.map(a => {
+      if (typeof a === "object" && a !== null) {
+        try { return JSON.stringify(a); } catch { return String(a); }
+      }
+      return String(a);
+    }).join(" ");
+    this._logs.push(msg);
+  }
+  Logf(format, ...args) {
+    const msg = typeof __sprintf === "function" ? __sprintf(format, ...args) : format;
+    this._logs.push(msg);
+  }
+  Error(...args) {
+    this.Fail();
+    this.Log(...args);
+  }
+  Errorf(format, ...args) {
+    this.Fail();
+    this.Logf(format, ...args);
+  }
+  Fatal(...args) {
+    this.Log(...args);
+    this.FailNow();
+  }
+  Fatalf(format, ...args) {
+    this.Logf(format, ...args);
+    this.FailNow();
+  }
+  Skip(...args) {
+    this.skipped = true;
+    if (args.length > 0) this.Log(...args);
+    throw new __GoFront_SkipNow();
+  }
+  Skipf(format, ...args) {
+    this.skipped = true;
+    this.Logf(format, ...args);
+    throw new __GoFront_SkipNow();
+  }
+  Skipped() { return this.skipped; }
+  Helper() {}
+  Run(name, fn) {
+    const subName = this._name ? \`\${this._name}/\${name}\` : name;
+    const subT = new __GoFront_T(subName, this);
+    if (typeof globalThis.__onSubtestStart === "function") globalThis.__onSubtestStart(subName);
+    try {
+      const res = fn(subT);
+      if (res && typeof res.then === "function") {
+        return res.then(() => {
+          if (typeof globalThis.__onSubtestEnd === "function") globalThis.__onSubtestEnd(subT);
+          return !subT.failed;
+        }).catch(e => {
+          if (e instanceof __GoFront_FailNow) {
+            // expected
+          } else if (e instanceof __GoFront_SkipNow) {
+            // expected
+          } else {
+            subT.Fail();
+            subT.Log("panic: " + (e?.message ?? String(e)));
+          }
+          if (typeof globalThis.__onSubtestEnd === "function") globalThis.__onSubtestEnd(subT);
+          return false;
+        });
+      }
+    } catch (e) {
+      if (e instanceof __GoFront_FailNow) {
+        // expected on FailNow
+      } else if (e instanceof __GoFront_SkipNow) {
+        // expected on Skip
+      } else {
+        subT.Fail();
+        subT.Log("panic: " + (e?.message ?? String(e)));
+      }
+    }
+    if (typeof globalThis.__onSubtestEnd === "function") globalThis.__onSubtestEnd(subT);
+    return !subT.failed;
+  }
+};
+var __testing_T = __GoFront_T;`;

package/src/codegen/stdlib/index.js

@@ -18,6 +18,7 @@ import { slicesMethods } from "./slices.js";
 import { sortMethods } from "./sort.js";
 import { strconvMethods } from "./strconv.js";
 import { stringsMethods } from "./strings.js";
+import { testingMethods } from "./testing.js";
 import { timeMethods } from "./time.js";
 import { unicodeMethods } from "./unicode.js";
 import { utf8Methods } from "./utf8.js";
@@ -45,6 +46,7 @@ const STDLIB_METHOD_MAP = {
 	rand: "_genRand",
 	utf8: "_genUtf8",
 	path: "_genPath",
+	testing: "_genTesting",
 };
 
 const dispatchMethods = {
@@ -94,5 +96,6 @@ export const stdlibGenMethods = {
 	...timeMethods,
 	...unicodeMethods,
 	...utf8Methods,
+	...testingMethods,
 	...dispatchMethods,
 };

package/src/codegen/stdlib/testing.js

@@ -0,0 +1,34 @@
+// CodeGen for Go `testing` package and `*testing.T` methods.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
+export const testingMethods = {
+	_genTesting(fn, _a) {
+		switch (fn) {
+			case "Short":
+				return "false";
+			case "Verbose":
+				return "Boolean(globalThis.__gofront_verbose)";
+		}
+		return undefined;
+	},
+
+	_genTestingMethodCall(method, expr) {
+		this._usesTesting = true;
+		const recv = expr.func.expr;
+		const t = this.genExpr(recv);
+		const args = expr.args
+			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
+			.join(", ");
+		if (
+			method === "Errorf" ||
+			method === "Fatalf" ||
+			method === "Logf" ||
+			method === "Skipf"
+		) {
+			this._usesSprintf = true;
+		}
+		return `${t}.${method}(${args})`;
+	},
+};

package/src/compiler.js

@@ -62,9 +62,13 @@ function parseGoFrontFile(filePath) {
 	return ast;
 }
 
-function gwFilesIn(dir) {
+export function gwFilesIn(dir, { includeTests = false } = {}) {
 	return readdirSync(dir)
-		.filter((f) => f.endsWith(".go") || f.endsWith(".templ"))
+		.filter((f) => {
+			if (!f.endsWith(".go") && !f.endsWith(".templ")) return false;
+			if (!includeTests && f.endsWith("_test.go")) return false;
+			return true;
+		})
 		.sort() // deterministic order
 		.map((f) => join(dir, f));
 }
@@ -206,11 +210,17 @@ export function compileSingleFile(inputPath, options = {}) {
 }
 
 export function compileDir(dir, options = {}) {
-	const files = gwFilesIn(dir);
+	const files = gwFilesIn(dir, { includeTests: options.includeTests ?? false });
 	if (files.length === 0) throw new Error(`No .go files found in ${dir}`);
 	return compileFiles(files, { ...options, fromDir: dir });
 }
 
+export function compilePackageTests(dir, options = {}) {
+	const files = gwFilesIn(dir, { includeTests: true });
+	if (files.length === 0) throw new Error(`No .go files found in ${dir}`);
+	return compileFiles(files, { ...options, fromDir: dir, isTest: true });
+}
+
 export function compileFiles(files, options = {}) {
 	const fromDir = options.fromDir ?? dirname(resolve(files[0]));
 
@@ -262,7 +272,9 @@ export function compileFiles(files, options = {}) {
 
 	// ── 4. Code generation ────────────────────────────────────────
 	const codegen = new CodeGen(checker, jsImports, bundledPackages);
-	const mainJs = codegen.generateAll(programs);
+	const mainJs = codegen.generateAll(programs, {
+		isTest: options.isTest ?? false,
+	});
 
 	let js = preambles.length > 0 ? `${preambles.join("\n")}\n${mainJs}` : mainJs;
 
@@ -278,6 +290,7 @@ export function compileFiles(files, options = {}) {
 	return {
 		pkgName,
 		js,
+		programs,
 		exportedSymbols: checker.getExportedSymbols(),
 		exportedTypes: checker.getExportedTypes(),
 	};

package/src/dev-server.js

@@ -3,7 +3,7 @@
 
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer } from "node:http";
-import { extname, join, resolve } from "node:path";
+import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
 export const MIME = {
 	".html": "text/html; charset=utf-8",
@@ -22,6 +22,12 @@ export const MIME = {
 // Injected at the bottom of compiled JS in serve mode.
 export const liveReloadClient = `(function(){var es=new EventSource('/_gofront/events');es.addEventListener('reload',function(){location.reload();});})();`;
 
+// True when `target` is `root` itself or a path inside it (no `..` escape).
+function isInsideDir(root, target) {
+	const rel = relative(root, target);
+	return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+
 export function handleDevRequest(req, res, serveDir, clients = new Set()) {
 	// SSE endpoint — browser connects here to receive reload events
 	if (req.url === "/_gofront/events") {
@@ -45,9 +51,8 @@ export function handleDevRequest(req, res, serveDir, clients = new Set()) {
 
 	if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
 
-	const resolvedServe = resolve(serveDir);
 	const filePath = resolve(serveDir, `.${urlPath}`);
-	if (!filePath.startsWith(resolvedServe)) {
+	if (!isInsideDir(resolve(serveDir), filePath)) {
 		res.writeHead(403, { "Content-Type": "text/plain" });
 		res.end("Forbidden");
 		return;

package/src/index.js

@@ -21,7 +21,16 @@ const { version } = _require("../package.json");
 import { mkdirSync, statSync, watch, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { copyAssets } from "./asset-manager.js";
-import { handleInit, handlePrep, maybeMinify, runCompile } from "./cli-core.js";
+import {
+	formatPrepSummary,
+	handleInit,
+	handlePrep,
+	handleTest,
+	maybeMinify,
+	parsePrepArgs,
+	parseTestArgs,
+	runCompile,
+} from "./cli-core.js";
 import { createDevServer, liveReloadClient } from "./dev-server.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
@@ -51,7 +60,8 @@ Usage:
   gofront <input> --minify --mangle  Minify and mangle identifiers
   gofront <file.go> --ast        Dump AST (debug)
   gofront <file.go> --tokens     Dump tokens (debug)
-  gofront prep [dir]             Copy static assets and bundle vendor dependencies
+  gofront test [dir] [--dom]     Run unit tests (-v verbose, -run <regex>)
+  gofront prep [dir] [--minify]  Copy static assets and bundle vendor dependencies
   gofront init [dir]             Scaffold a new GoFront project
   gofront --version              Print version
 `.trim(),
@@ -62,20 +72,11 @@ Usage:
 // ── prep / vendor subcommand ──────────────────────────────────
 
 if (args[0] === "prep" || args[0] === "vendor") {
-	const targetArg = args[1] ?? ".";
-	const targetDir = resolve(targetArg);
+	const { targetDir, vendorConfig } = parsePrepArgs(args.slice(1));
 	try {
-		const { assets, vendor } = await handlePrep(targetDir);
-		if (assets.copied > 0 || assets.skipped > 0) {
-			console.error(
-				`gofront: copied ${assets.copied} assets (${assets.skipped} skipped)`,
-			);
-		}
-		if (vendor.bundled?.length > 0) {
-			console.error(
-				`gofront: bundled ${vendor.bundled.length} vendor dependencies → ${vendor.dest}`,
-			);
-		}
+		const result = await handlePrep(resolve(targetDir), { vendorConfig });
+		for (const line of formatPrepSummary(result))
+			console.error(`gofront: ${line}`);
 	} catch (e) {
 		console.error(`gofront: ${e.message}`);
 		process.exit(1);
@@ -102,6 +103,19 @@ if (args[0] === "init") {
 	process.exit(0);
 }
 
+// ── test subcommand ───────────────────────────────────────────
+
+if (args[0] === "test") {
+	const { targetDir, ...testOptions } = parseTestArgs(args.slice(1));
+	try {
+		const result = await handleTest(targetDir, testOptions);
+		process.exit(result.exitCode);
+	} catch (e) {
+		console.error(`gofront: ${e.message}`);
+		process.exit(1);
+	}
+}
+
 const inputArg = args[0];
 const outputFlag = args.indexOf("-o");
 const outputFile = outputFlag !== -1 ? args[outputFlag + 1] : null;

package/src/resolver.js

@@ -47,6 +47,7 @@ const BUILTIN_PACKAGES = new Set([
 	"regexp",
 	"path",
 	"path/filepath",
+	"testing",
 ]);
 
 // Returns true for local relative paths (start with ./ or ../)

package/src/test-runner.js

@@ -0,0 +1,309 @@
+// GoFront native test runner and harness generator.
+// Handles test function discovery, test harness emission, and subprocess execution.
+
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { basename, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { compilePackageTests, gwFilesIn } from "./compiler.js";
+
+export function isTestFunc(decl) {
+	if (decl.kind !== "FuncDecl") return false;
+	if (!decl.name.startsWith("Test")) return false;
+	if (decl.params?.length !== 1) return false;
+	const pType = decl.params[0].type;
+	if (pType?.kind === "PointerType" && pType.base?.name === "testing.T")
+		return true;
+	if (pType?.kind === "TypeName" && pType.name === "testing.T") return true;
+	return false;
+}
+
+// Only programs from *_test.go files are scanned, matching Go. Programs
+// without a `_filename` (constructed by hand) are treated as test files.
+export function discoverTests(programs) {
+	const testNames = [];
+	for (const p of programs) {
+		if (p._filename && !p._filename.endsWith("_test.go")) continue;
+		for (const d of p.decls) {
+			if (isTestFunc(d) && !testNames.includes(d.name)) {
+				testNames.push(d.name);
+			}
+		}
+	}
+	return testNames;
+}
+
+export function generateTestHarness(bundleJs, testNames, options = {}) {
+	const runRegex = options.run ? options.run : null;
+	const verbose = Boolean(options.verbose);
+	const dom = Boolean(options.dom);
+	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.
+	const jsdomSpec = options.jsdomPath
+		? pathToFileURL(options.jsdomPath).href
+		: "jsdom";
+
+	return `
+${
+	dom
+		? `import { JSDOM } from ${JSON.stringify(jsdomSpec)};
+const __dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+  url: "http://localhost/",
+  pretendToBeVisual: true,
+});
+globalThis.window = __dom.window;
+globalThis.document = __dom.window.document;
+try {
+  Object.defineProperty(globalThis, "navigator", {
+    value: __dom.window.navigator,
+    configurable: true,
+    writable: true,
+  });
+} catch {
+  try { globalThis.navigator = __dom.window.navigator; } catch {}
+}
+globalThis.location = __dom.window.location;
+globalThis.history = __dom.window.history;
+globalThis.HTMLElement = __dom.window.HTMLElement;
+globalThis.Element = __dom.window.Element;
+globalThis.Node = __dom.window.Node;
+globalThis.customElements = __dom.window.customElements;
+`
+		: `globalThis.window = globalThis.window ?? null;
+globalThis.document = globalThis.document ?? null;
+`
+}
+globalThis.__gofront_verbose = ${verbose};
+
+// ── Compiled Package Bundle ──
+${bundleJs}
+// ─────────────────────────────
+
+async function __runGoFrontSuite() {
+  const allTests = ${JSON.stringify(testNames)};
+  const runFilter = ${runRegex ? `new RegExp(${JSON.stringify(runRegex)})` : "null"};
+  const verbose = ${verbose};
+  const pkgName = ${JSON.stringify(pkgName)};
+
+  const testsToRun = runFilter
+    ? allTests.filter((name) => runFilter.test(name))
+    : allTests;
+
+  if (testsToRun.length === 0) {
+    if (allTests.length > 0 && runFilter) {
+      console.log("testing: warning: no tests to run matching " + ${JSON.stringify(runRegex)});
+    }
+    console.log("PASS");
+    console.log("ok  \\t" + pkgName + "\\t0.000s");
+    process.exit(0);
+  }
+
+  let totalFailures = 0;
+  let totalSkipped = 0;
+  const now = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
+  const suiteStart = now();
+
+  // 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);
+    if (t.skipped) {
+      console.log("--- SKIP: " + t._name + " (" + elapsed + "s)");
+      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)");
+    } else if (verbose) {
+      for (const log of t._logs) console.log("    " + log);
+      console.log("--- PASS: " + t._name + " (" + elapsed + "s)");
+    }
+  };
+
+  // FailNow/SkipNow are control flow; anything else is a panic → failure.
+  const recordTestError = (t, e) => {
+    if (e instanceof __GoFront_FailNow || e instanceof __GoFront_SkipNow) return;
+    t.Fail();
+    t.Log("panic: " + (e?.message ?? String(e)));
+  };
+
+  globalThis.__onSubtestStart = (name) => {
+    if (verbose) console.log("=== RUN   " + name);
+  };
+  globalThis.__onSubtestEnd = report;
+
+  const __testRegistry = {
+${testNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ? ${n} : null`).join(",\n")}
+  };
+
+  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);
+      totalFailures++;
+      continue;
+    }
+
+    const t = new __GoFront_T(name);
+    if (verbose) console.log("=== RUN   " + name);
+
+    try {
+      const res = fn(t);
+      if (res && typeof res.then === "function") await res;
+    } catch (e) {
+      recordTestError(t, e);
+    }
+
+    if (t.skipped) totalSkipped++;
+    else if (t.failed) totalFailures++;
+    report(t);
+  }
+
+  const suiteElapsed = ((now() - suiteStart) / 1000).toFixed(3);
+
+  if (totalFailures > 0) {
+    console.log("FAIL");
+    console.log("FAIL\\t" + pkgName + "\\t" + suiteElapsed + "s");
+    process.exit(1);
+  } else {
+    console.log("PASS");
+    console.log("ok  \\t" + pkgName + "\\t" + suiteElapsed + "s");
+    process.exit(0);
+  }
+}
+
+__runGoFrontSuite();
+`;
+}
+
+// Project-local jsdom wins; fall back to the one next to GoFront (global/npx installs).
+export function resolveJsdomPath(projectDir) {
+	for (const from of [join(projectDir, "dummy.js"), import.meta.url]) {
+		try {
+			return createRequire(from).resolve("jsdom");
+		} catch {}
+	}
+	return null;
+}
+
+function validateTestOptions(options, resolvedDir) {
+	if (options.run) {
+		try {
+			new RegExp(options.run);
+		} catch (e) {
+			throw new Error(`gofront: invalid regex for -run: ${e.message}`);
+		}
+	}
+
+	let jsdomPath = null;
+	if (options.dom) {
+		jsdomPath = resolveJsdomPath(resolvedDir);
+		if (!jsdomPath) {
+			throw new Error(
+				"gofront: --dom requires 'jsdom' to be installed. Run 'npm install --save-dev jsdom' to enable DOM testing.",
+			);
+		}
+	}
+	return { jsdomPath };
+}
+
+function reportEmptyTests(label, reason, options) {
+	const out = `?   \t${label}\t[${reason}]\n`;
+	if (options.captureOutput) {
+		return { exitCode: 0, stdout: out, stderr: "", noTests: true };
+	}
+	const dest = options.stdout ?? process.stdout;
+	dest.write(out);
+	return { exitCode: 0, noTests: true };
+}
+
+function spawnTestRunner(resolvedDir, harnessJs, testCount, options) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(process.execPath, ["--input-type=module", "-"], {
+			cwd: resolvedDir,
+			env: process.env,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+
+		let stdout = "";
+		let stderr = "";
+
+		child.stdout.on("data", (chunk) => {
+			const str = chunk.toString();
+			if (options.captureOutput) {
+				stdout += str;
+			} else {
+				(options.stdout ?? process.stdout).write(str);
+			}
+		});
+
+		child.stderr.on("data", (chunk) => {
+			const str = chunk.toString();
+			if (options.captureOutput) {
+				stderr += str;
+			} else {
+				(options.stderr ?? process.stderr).write(str);
+			}
+		});
+
+		child.on("error", (err) => {
+			rejectPromise(err);
+		});
+
+		child.on("close", (exitCode) => {
+			resolvePromise({
+				exitCode: exitCode ?? 0,
+				stdout,
+				stderr,
+				testCount,
+			});
+		});
+
+		child.stdin.on("error", () => {});
+		child.stdin.end(harnessJs);
+	});
+}
+
+export async function runTests(targetDir, options = {}) {
+	const resolvedDir = resolve(targetDir);
+	const { jsdomPath } = validateTestOptions(options, resolvedDir);
+
+	const allFiles = gwFilesIn(resolvedDir, { includeTests: true });
+	if (allFiles.length === 0) {
+		throw new Error(`No .go files found in ${targetDir}`);
+	}
+
+	const testFiles = allFiles.filter((f) => f.endsWith("_test.go"));
+	if (testFiles.length === 0) {
+		return reportEmptyTests(basename(resolvedDir), "no test files", options);
+	}
+
+	let compiled;
+	try {
+		compiled = compilePackageTests(resolvedDir, options);
+	} catch (err) {
+		const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${err?.message ?? String(err)}\n`;
+		if (options.captureOutput) {
+			return { exitCode: 1, stdout: "", stderr: out };
+		}
+		const dest = options.stderr ?? process.stderr;
+		dest.write(out);
+		return { exitCode: 1 };
+	}
+
+	const { pkgName, js, programs } = compiled;
+	const testNames = discoverTests(programs);
+
+	if (testNames.length === 0) {
+		return reportEmptyTests(pkgName, "no tests to run", options);
+	}
+
+	const harnessJs = generateTestHarness(js, testNames, {
+		...options,
+		pkgName,
+		jsdomPath,
+	});
+
+	return spawnTestRunner(resolvedDir, harnessJs, testNames.length, options);
+}

package/src/typechecker/index.js

@@ -225,7 +225,19 @@ export class TypeChecker {
 	_checkTopDeclsPass(programs) {
 		for (const p of programs) {
 			this._setCurrentFile(p);
-			for (const d of p.decls) this.checkTopDecl(d, this.globals);
+			for (const d of p.decls) {
+				if (d.kind === "VarDecl" || d.kind === "ConstDecl") {
+					this.checkTopDecl(d, this.globals);
+				}
+			}
+		}
+		for (const p of programs) {
+			this._setCurrentFile(p);
+			for (const d of p.decls) {
+				if (d.kind === "FuncDecl" || d.kind === "MethodDecl") {
+					this.checkTopDecl(d, this.globals);
+				}
+			}
 		}
 	}
 

package/src/typechecker/stdlib/extended.js

@@ -308,6 +308,64 @@ export function setupExtendedGlobals(globals, types) {
 		},
 	});
 
+	const TESTING_T = {
+		kind: "named",
+		name: "testing.T",
+		underlying: { kind: "struct", fields: new Map(), methods: new Map() },
+	};
+	const TESTING_PTR = { kind: "pointer", base: TESTING_T };
+
+	TESTING_T.underlying.methods = new Map([
+		["Error", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Errorf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Fatal", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Fatalf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Fail", { kind: "func", params: [], returns: [VOID] }],
+		["Failed", { kind: "func", params: [], returns: [BOOL] }],
+		["FailNow", { kind: "func", params: [], returns: [VOID] }],
+		["Log", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Logf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Skip", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Skipf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Skipped", { kind: "func", params: [], returns: [BOOL] }],
+		["Helper", { kind: "func", params: [], returns: [VOID] }],
+		[
+			"Run",
+			{
+				kind: "func",
+				params: [
+					STRING,
+					{ kind: "func", params: [TESTING_PTR], returns: [VOID] },
+				],
+				returns: [BOOL],
+			},
+		],
+		["Name", { kind: "func", params: [], returns: [STRING] }],
+	]);
+
+	globals.define("testing", {
+		kind: "namespace",
+		name: "testing",
+		members: {
+			T: TESTING_T,
+			Short: { kind: "func", params: [], returns: [BOOL] },
+			Verbose: { kind: "func", params: [], returns: [BOOL] },
+		},
+	});
+	types.set("testing.T", TESTING_T);
+
 	for (const name of [
 		"append",
 		"len",

package/src/vendor.js

@@ -2,6 +2,7 @@
 // Dynamically loads a bundler (rolldown or esbuild) from consumer devDependencies.
 
 import {
+	copyFileSync,
 	existsSync,
 	mkdirSync,
 	readFileSync,
@@ -12,28 +13,17 @@ import { createRequire } from "node:module";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
-export function getExportNames(pkgName) {
+export function getExportNames(pkgName, globals = {}) {
 	const base = pkgName.replace(/^@[^/]+\//, "");
 	const clean = base.replace(/[^a-zA-Z0-9_]/g, "_");
 	const names = new Set([pkgName, base, clean]);
-
-	if (pkgName === "@emailjs/browser") names.add("emailjs");
-	if (pkgName === "fuse.js") {
-		names.add("Fuse");
-		names.add("fuse");
-	}
-	if (pkgName === "prismjs") {
-		names.add("Prism");
-		names.add("prism");
-	}
-	if (pkgName === "marked") {
-		names.add("marked");
-	}
-
+	const extra = globals[pkgName];
+	for (const name of Array.isArray(extra) ? extra : extra ? [extra] : [])
+		names.add(name);
 	return [...names];
 }
 
-export function generateVendorEntry(packages) {
+export function generateVendorEntry(packages, globals = {}) {
 	const imports = [];
 	const assignments = [];
 	const exports = [];
@@ -42,7 +32,7 @@ export function generateVendorEntry(packages) {
 		const id = `_dep_${idx}`;
 		imports.push(`import * as ${id} from ${JSON.stringify(pkg)};`);
 
-		const names = getExportNames(pkg);
+		const names = getExportNames(pkg, globals);
 		for (const name of names) {
 			assignments.push(
 				`    window[${JSON.stringify(name)}] = ${id}.default || ${id};`,
@@ -90,6 +80,27 @@ export function findBundler(projectDir) {
 	return null;
 }
 
+// Normalises `vendor.globals` ({ pkg: string | string[] }) to { pkg: string[] }.
+function normalizeGlobals(raw) {
+	if (raw === undefined || raw === null) return {};
+	if (typeof raw !== "object" || Array.isArray(raw)) {
+		throw new Error(
+			"gofront: vendor.globals must be an object mapping package names to global names",
+		);
+	}
+	const out = {};
+	for (const [pkg, value] of Object.entries(raw)) {
+		const list = Array.isArray(value) ? value : [value];
+		if (list.some((v) => typeof v !== "string")) {
+			throw new Error(
+				`gofront: vendor.globals[${JSON.stringify(pkg)}] must be a string or array of strings`,
+			);
+		}
+		out[pkg] = list;
+	}
+	return out;
+}
+
 export function loadVendorConfig(projectDir) {
 	const pkgPath = join(projectDir, "package.json");
 	let pkg = {};
@@ -112,19 +123,87 @@ export function loadVendorConfig(projectDir) {
 
 	let dest = null;
 	let packages = dependencies;
+	let minify = false;
+	let globals = {};
 
 	if (typeof vendorConfig === "string") {
 		dest = vendorConfig;
 	} else if (vendorConfig && typeof vendorConfig === "object") {
 		if (vendorConfig.dest) dest = vendorConfig.dest;
 		if (Array.isArray(vendorConfig.packages)) packages = vendorConfig.packages;
+		if (typeof vendorConfig.minify === "boolean") minify = vendorConfig.minify;
+		globals = normalizeGlobals(vendorConfig.globals);
 	}
 
 	if (!dest) {
 		dest = existsSync(join(projectDir, "app")) ? "app/vendor.js" : "vendor.js";
 	}
 
-	return { dest, packages };
+	return { dest, packages, minify, globals };
+}
+
+export function resolveDestinationPaths(projectRoot, dest) {
+	const destList = Array.isArray(dest) ? dest : [dest];
+	if (destList.length === 0) {
+		throw new Error(
+			"gofront: at least one vendor destination must be specified",
+		);
+	}
+
+	return destList.map((d) => {
+		const fullPath = resolve(projectRoot, d);
+		const relDest = relative(projectRoot, fullPath);
+		if (relDest.startsWith("..") || isAbsolute(relDest)) {
+			throw new Error(
+				`gofront: vendor destination '${d}' is outside project directory`,
+			);
+		}
+		return fullPath;
+	});
+}
+
+async function runBundler(
+	bundlerInfo,
+	{ projectRoot, entryFile, destPath, minify },
+) {
+	if (bundlerInfo.name === "rolldown") {
+		const rolldownModule =
+			bundlerInfo.instance ??
+			(await import(pathToFileURL(bundlerInfo.path).href));
+		const rolldownFn =
+			rolldownModule.rolldown ||
+			rolldownModule.default?.rolldown ||
+			rolldownModule.default;
+
+		const bundle = await rolldownFn({
+			input: entryFile,
+			cwd: projectRoot,
+		});
+		await bundle.write({
+			file: destPath,
+			format: "esm",
+			minify: Boolean(minify),
+		});
+		await bundle.close();
+		return;
+	}
+
+	if (bundlerInfo.name === "esbuild") {
+		const esbuildModule =
+			bundlerInfo.instance ??
+			(await import(pathToFileURL(bundlerInfo.path).href));
+		const buildFn =
+			esbuildModule.build || esbuildModule.default?.build || esbuildModule;
+
+		await buildFn({
+			entryPoints: [entryFile],
+			bundle: true,
+			format: "esm",
+			outfile: destPath,
+			absWorkingDir: projectRoot,
+			minify: Boolean(minify),
+		});
+	}
 }
 
 export async function bundleVendor(projectDir = ".", options = {}) {
@@ -133,24 +212,20 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 
 	const packages = options.packages ?? config.packages;
 	const dest = options.dest ?? config.dest;
+	const minify = options.minify ?? config.minify ?? false;
+	const globals = { ...config.globals, ...normalizeGlobals(options.globals) };
 
 	if (!packages || packages.length === 0) {
 		return {
 			bundled: [],
 			skipped: 0,
 			dest,
+			minify: Boolean(minify),
 			message: "no external dependencies found",
 		};
 	}
 
-	const destPath = resolve(projectRoot, dest);
-	const relDest = relative(projectRoot, destPath);
-	if (relDest.startsWith("..") || isAbsolute(relDest)) {
-		throw new Error(
-			`gofront: vendor destination '${dest}' is outside project directory`,
-		);
-	}
-
+	const destPaths = resolveDestinationPaths(projectRoot, dest);
 	const bundlerInfo = options.bundler ?? findBundler(projectRoot);
 	if (!bundlerInfo) {
 		console.warn(
@@ -161,23 +236,31 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 			skipped: packages.length,
 			dest,
 			bundler: null,
+			minify: Boolean(minify),
 			reason: "no bundler installed",
 		};
 	}
 
-	mkdirSync(dirname(destPath), { recursive: true });
+	for (const p of destPaths) {
+		mkdirSync(dirname(p), { recursive: true });
+	}
 
-	// Allow custom bundler execution function (useful for tests and plugins)
 	if (typeof bundlerInfo.bundle === "function") {
 		await bundlerInfo.bundle({
 			projectRoot,
 			packages,
-			dest: destPath,
+			dest: destPaths.length === 1 ? destPaths[0] : destPaths,
+			minify: Boolean(minify),
 		});
-		return { bundled: packages, bundler: bundlerInfo.name ?? "custom", dest };
+		return {
+			bundled: packages,
+			bundler: bundlerInfo.name ?? "custom",
+			dest,
+			minify: Boolean(minify),
+		};
 	}
 
-	const entryCode = generateVendorEntry(packages);
+	const entryCode = generateVendorEntry(packages, globals);
 	const entryFile = join(
 		projectRoot,
 		`.gofront-vendor-entry-${Date.now()}.mjs`,
@@ -185,38 +268,15 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 	writeFileSync(entryFile, entryCode);
 
 	try {
-		if (bundlerInfo.name === "rolldown") {
-			const rolldownModule =
-				bundlerInfo.instance ??
-				(await import(pathToFileURL(bundlerInfo.path).href));
-			const rolldownFn =
-				rolldownModule.rolldown ||
-				rolldownModule.default?.rolldown ||
-				rolldownModule.default;
-
-			const bundle = await rolldownFn({
-				input: entryFile,
-				cwd: projectRoot,
-			});
-			await bundle.write({
-				file: destPath,
-				format: "esm",
-			});
-			await bundle.close();
-		} else if (bundlerInfo.name === "esbuild") {
-			const esbuildModule =
-				bundlerInfo.instance ??
-				(await import(pathToFileURL(bundlerInfo.path).href));
-			const buildFn =
-				esbuildModule.build || esbuildModule.default?.build || esbuildModule;
-
-			await buildFn({
-				entryPoints: [entryFile],
-				bundle: true,
-				format: "esm",
-				outfile: destPath,
-				absWorkingDir: projectRoot,
-			});
+		await runBundler(bundlerInfo, {
+			projectRoot,
+			entryFile,
+			destPath: destPaths[0],
+			minify,
+		});
+
+		for (let i = 1; i < destPaths.length; i++) {
+			copyFileSync(destPaths[0], destPaths[i]);
 		}
 	} finally {
 		if (existsSync(entryFile)) {
@@ -224,5 +284,10 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 		}
 	}
 
-	return { bundled: packages, bundler: bundlerInfo.name, dest };
+	return {
+		bundled: packages,
+		bundler: bundlerInfo.name,
+		dest,
+		minify: Boolean(minify),
+	};
 }