gofront 1.0.1 → 1.2.0

package/README.md

@@ -387,13 +387,16 @@ gofront <dir>                    compile all *.go in directory → stdout
 gofront <input> -o out.js        write output to file (prints elapsed compile time e.g. "15ms")
 gofront <input> --check                    type-check only
 gofront <input> --watch                    watch for changes and recompile
-gofront <input> -o out.js --serve          watch + serve with live reload (default port 3000)
+gofront <input> -o out.js --serve          watch + serve with live reload & SPA fallback (default port 3000)
 gofront <input> -o out.js --serve --port 8080  use a custom port
+gofront <input> -o out.js --copy-assets    compile and synchronize static assets from package.json assetCopy
 gofront <input> --source-map               append inline source map (single file or directory; multi-file packages emit per-file mappings)
 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
 gofront --help / -h                        print this help
@@ -401,6 +404,89 @@ 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
+```
+
+---
+
+## 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.
+
+### Asset copying (`assetCopy`)
+
+Specify static assets (fonts, stylesheets, images) in `package.json` (or `gofront.json`):
+
+```json
+{
+  "assetCopy": [
+    { "source": "node_modules/@fontsource/raleway/files", "dest": "app/fonts" },
+    { "source": "node_modules/prismjs/themes", "dest": "app/css/prism-themes" }
+  ]
+}
+```
+
+Run `gofront prep` to copy them, or pass `--copy-assets` to automatically synchronize assets on build.
+
+### Vendor bundling (`gofront prep`)
+
+Package external npm dependencies for the browser:
+
+```sh
+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`).
+
+---
+
 ## Multi-file packages
 
 All `.go` files in a directory share the same namespace and are compiled as one unit.
@@ -625,7 +711,7 @@ you know exactly what to expect.
 
 ## Roadmap
 
-See [`docs/ROADMAP.md`](docs/ROADMAP.md) for the full roadmap and release history.
+See [`docs/roadmap.md`](docs/roadmap.md) for the full roadmap and release history.
 Design documents for planned features are organised by release under `docs/v*/`
 (e.g. [`docs/v0.0.8/`](docs/v0.0.8/), [`docs/v0.0.9/`](docs/v0.0.9/)).
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.0.1",
+	"version": "1.2.0",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -36,20 +36,23 @@
 		"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 .",
 		"check": "biome check . && sentrux check && sentrux gate && node src/index.js example/simple/src --check && node src/index.js example/reactive/src --check && node src/index.js example/gom/src --check && node src/index.js example/templ/src --check",
-		"prepare": "husky"
+		"prepare": "lefthook install"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.12",
-		"@playwright/test": "^1.59.1",
-		"c8": "^11.0.0",
-		"husky": "^9.1.7",
-		"jsdom": "^29.0.2",
+		"@biomejs/biome": "^2.5.14",
+		"@playwright/test": "^1.63.0",
+		"c8": "^12.0.0",
+		"jsdom": "^30.1.0",
+		"lefthook": "^2.1.14",
 		"serve": "^14.2.6"
 	}
 }

package/src/asset-manager.js

@@ -0,0 +1,125 @@
+// Native static asset manager for GoFront projects.
+// Zero-dependency file and directory copier using node:fs.
+
+import {
+	copyFileSync,
+	cpSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	statSync,
+} from "node:fs";
+import {
+	basename,
+	dirname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+} from "node:path";
+
+export function loadAssetConfig(projectDir) {
+	const gofrontJsonPath = join(projectDir, "gofront.json");
+	if (existsSync(gofrontJsonPath)) {
+		try {
+			const parsed = JSON.parse(readFileSync(gofrontJsonPath, "utf8"));
+			if (Array.isArray(parsed.assetCopy)) return parsed.assetCopy;
+		} catch {}
+	}
+
+	const pkgJsonPath = join(projectDir, "package.json");
+	if (existsSync(pkgJsonPath)) {
+		try {
+			const parsed = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+			if (Array.isArray(parsed.assetCopy)) return parsed.assetCopy;
+		} catch {}
+	}
+
+	return [];
+}
+
+function copyFileAsset(srcPath, destPath, dest) {
+	let targetFile = destPath;
+	if (
+		dest.endsWith("/") ||
+		(existsSync(destPath) && statSync(destPath).isDirectory())
+	) {
+		targetFile = join(destPath, basename(srcPath));
+	}
+	mkdirSync(dirname(targetFile), { recursive: true });
+	copyFileSync(srcPath, targetFile);
+	return targetFile;
+}
+
+function copyAssetEntry(entry, projectRoot) {
+	if (!entry || typeof entry !== "object") return null;
+	const { source, dest } = entry;
+	if (!source || !dest) return null;
+
+	const destPath = resolve(projectRoot, dest);
+	const relDest = relative(projectRoot, destPath);
+	if (relDest.startsWith("..") || isAbsolute(relDest)) {
+		throw new Error(
+			`gofront: asset destination '${dest}' is outside project directory`,
+		);
+	}
+
+	const srcPath = resolve(projectRoot, source);
+	if (!existsSync(srcPath)) {
+		console.warn(`gofront: asset source '${source}' not found — skipping`);
+		return {
+			status: "skipped",
+			item: { source, dest, status: "skipped", reason: "source not found" },
+		};
+	}
+
+	try {
+		const stat = statSync(srcPath);
+		if (stat.isDirectory()) {
+			mkdirSync(destPath, { recursive: true });
+			cpSync(srcPath, destPath, { recursive: true, force: true });
+			return {
+				status: "copied",
+				item: { source, dest, type: "directory", status: "copied" },
+			};
+		}
+		const targetFile = copyFileAsset(srcPath, destPath, dest);
+		return {
+			status: "copied",
+			item: { source, dest: targetFile, type: "file", status: "copied" },
+		};
+	} catch (err) {
+		console.warn(`gofront: failed to copy asset '${source}': ${err.message}`);
+		return {
+			status: "failed",
+			item: { source, dest, status: "failed", reason: err.message },
+		};
+	}
+}
+
+export function copyAssets(projectDir = ".", config = null) {
+	const projectRoot = resolve(projectDir);
+	let entries;
+
+	if (Array.isArray(config)) {
+		entries = config;
+	} else if (config && Array.isArray(config.assetCopy)) {
+		entries = config.assetCopy;
+	} else {
+		entries = loadAssetConfig(projectRoot);
+	}
+
+	const items = [];
+	let copied = 0;
+	let skipped = 0;
+
+	for (const entry of entries) {
+		const result = copyAssetEntry(entry, projectRoot);
+		if (!result) continue;
+		if (result.status === "copied") copied++;
+		else skipped++;
+		items.push(result.item);
+	}
+
+	return { copied, skipped, items };
+}

package/src/cli-core.js

@@ -3,8 +3,11 @@
 
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 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) {
 	const {
@@ -63,3 +66,15 @@ export function handleInit(targetDir) {
 
 	return { mainPath };
 }
+
+export async function handlePrep(targetDir, options = {}) {
+	const resolvedTarget = resolve(targetDir);
+	const assets = copyAssets(resolvedTarget, options.assetConfig);
+	const vendor = await bundleVendor(resolvedTarget, options.vendorConfig);
+	return { assets, vendor };
+}
+
+export async function handleTest(targetDir, options = {}) {
+	const resolvedTarget = resolve(targetDir);
+	return runTests(resolvedTarget, 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(),
 	};