gofront 1.0.0 → 1.1.0

package/README.md

@@ -387,13 +387,15 @@ 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 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 +403,37 @@ gofront --help / -h                        print this help
 
 ---
 
+## 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 +658,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/)).
 
@@ -634,7 +667,7 @@ Design documents for planned features are organised by release under `docs/v*/`
 ## Tests
 
 ```sh
-npm run test:unit   # unit tests only (~1118 tests, no browser required)
+npm run test:unit   # unit tests only (~1100 tests, no browser required)
 npm run test:e2e    # E2E tests (Playwright, headless Chromium)
 npm run test:all    # both
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.0.0",
+	"version": "1.1.0",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -42,14 +42,14 @@
 		"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

@@ -0,0 +1,74 @@
+// CLI compilation core — extracted for direct import in tests.
+// index.js retains only arg parsing, file I/O, watch mode, and process.exit.
+
+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 { bundleVendor } from "./vendor.js";
+
+export function runCompile(inputPath, isDir, options) {
+	const {
+		sourceMap = false,
+		outputFile = null,
+		dumpTokens = false,
+		dumpAst = false,
+	} = options ?? {};
+
+	if (isDir) {
+		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
+		return compileDir(inputPath, { sourceMap, outputDir });
+	}
+
+	return compileSingleFile(inputPath, {
+		sourceMap,
+		outputFile,
+		dumpTokens,
+		dumpAst,
+	});
+}
+
+export function maybeMinify(js, options) {
+	const {
+		minify: doMinify = false,
+		mangle = false,
+		sourceMap = false,
+	} = options ?? {};
+	if (!doMinify) return js;
+	if (sourceMap)
+		throw new Error("--source-map and --minify cannot be used together");
+	return minify(js, { mangle });
+}
+
+export function handleInit(targetDir) {
+	try {
+		mkdirSync(targetDir, { recursive: true });
+	} catch (e) {
+		throw new Error(`cannot create '${targetDir}': ${e.message}`);
+	}
+
+	const mainPath = join(targetDir, "main.go");
+	if (existsSync(mainPath)) {
+		throw new Error(`${mainPath} already exists — nothing written`);
+	}
+
+	const pkgName = basename(targetDir);
+	const safePkg = pkgName.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_");
+	const template = `package ${safePkg}\n\nfunc main() {\n\tconsole.log("Hello from GoFront!")\n}\n`;
+
+	try {
+		writeFileSync(mainPath, template);
+	} catch (e) {
+		throw new Error(`cannot write '${mainPath}': ${e.message}`);
+	}
+
+	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 };
+}

package/src/codegen/expressions.js

@@ -2,6 +2,8 @@
 
 import { ERROR, isComplex } from "../typechecker/types.js";
 
+/** @typedef {import('./index.js').CodeGen} CodeGen */
+
 // Namespace constants: pkg.Field → JS literal
 const NS_CONSTANTS = {
 	math: {
@@ -143,6 +145,7 @@ const EXPR_GEN_DELEGATE = {
 	TypeAssertExpr: "_genTypeAssertExpr",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const expressionGenMethods = {
 	genExpr(expr) {
 		switch (expr.kind) {

package/src/codegen/statements.js

@@ -2,6 +2,8 @@
 
 import { isComplex } from "../typechecker/types.js";
 
+/** @typedef {import('./index.js').CodeGen} CodeGen */
+
 // Method-name dispatch for genStmt — string values add no static call edges.
 const STMT_GEN_DELEGATE = {
 	VarDecl: "genVarDecl",
@@ -15,6 +17,7 @@ const STMT_GEN_DELEGATE = {
 	BranchStmt: "_genBranchStmt",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const statementGenMethods = {
 	genBlock(block) {
 		for (const stmt of block.stmts) this.genStmt(stmt);

package/src/codegen/stdlib/builder.js

@@ -1,5 +1,7 @@
 // CodeGen for `strings.Builder` and `bytes.Buffer` method calls.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const BUILDER_STR = {
 	WriteString: (b, a) => `(${b}._buf += ${a[0]}, [${a[0]}.length, null])`,
 	WriteByte: (b, a) => `(${b}._buf += String.fromCodePoint(${a[0]}))`,
@@ -22,6 +24,7 @@ const BUILDER_COMMON = {
 	Grow: () => "undefined",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const builderMethods = {
 	_genBuilderCall(typeName, method, expr) {
 		const recv = expr.func.expr;

package/src/codegen/stdlib/bytes.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `bytes` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const __bs = `(b => String.fromCharCode(...b))`;
 const __sb = `(s => [...s].map(c => c.charCodeAt(0)))`;
 
@@ -54,6 +56,7 @@ const BYTES_DISPATCH = {
 		`{_src: ${a[0]}, _pos: 0, Read(p) { const n = Math.min(p.length, this._src.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._src[this._pos + i]; this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(b) { this._src = b; this._pos = 0; }}`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const bytesMethods = {
 	_genBytes(fn, a) {
 		const gen = BYTES_DISPATCH[fn];

package/src/codegen/stdlib/errors.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `errors` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const errorsMethods = {
 	_genErrors(fn, a) {
 		const args = a();

package/src/codegen/stdlib/fmt.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `fmt` package — installed onto CodeGen.prototype via stdlibGenMethods.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const _SSCAN_LOOP =
 	`let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { ` +
 	`const t = tokens[i]; const p = ptrs[i]; ` +
@@ -7,6 +9,7 @@ const _SSCAN_LOOP =
 	`else if (typeof p.value === "boolean") p.value = t === "true"; ` +
 	`else p.value = t; n++; }`;
 
+/** @type {ThisType<CodeGen>} */
 export const fmtMethods = {
 	_genFmt(fn, _a, expr) {
 		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");

package/src/codegen/stdlib/gom.js

@@ -1,5 +1,7 @@
 // CodeGen for the GoFront-built-in `gom` DOM-rendering package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const GOM_ELEMENT_TAGS = {
 	Div: "div",
 	Section: "section",
@@ -85,6 +87,7 @@ const GOM_PROP_SETTERS = {
 	Placeholder: "placeholder",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const gomMethods = {
 	_genGom(fn, expr) {
 		const a = () =>

package/src/codegen/stdlib/html.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `html` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const htmlMethods = {
 	_genHtml(fn, a) {
 		switch (fn) {

package/src/codegen/stdlib/index.js

@@ -22,6 +22,8 @@ import { timeMethods } from "./time.js";
 import { unicodeMethods } from "./unicode.js";
 import { utf8Methods } from "./utf8.js";
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 // Stdlib namespace → handler method name. Used by _genStdlibCall to dispatch
 // dynamically without creating static call edges.
 const STDLIB_METHOD_MAP = {
@@ -70,6 +72,7 @@ const dispatchMethods = {
 	},
 };
 
+/** @type {ThisType<CodeGen>} */
 export const stdlibGenMethods = {
 	...builderMethods,
 	...bytesMethods,

package/src/codegen/stdlib/io.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `io` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const ioMethods = {
 	_genIo(fn, _a, expr) {
 		switch (fn) {

package/src/codegen/stdlib/maps.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `maps` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const mapsMethods = {
 	_genMaps(fn, a) {
 		if (fn === "Equal") {

package/src/codegen/stdlib/math.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `math` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const MATH1 = {
 	Abs: "abs",
 	Floor: "floor",
@@ -41,6 +43,7 @@ const MATH_EXTRA = {
 	Remainder: ([x, y]) => `(${x} - Math.round(${x} / ${y}) * ${y})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const mathMethods = {
 	_genMath(fn, a) {
 		const args = a();

package/src/codegen/stdlib/os.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `os` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const osMethods = {
 	_genOs(fn, a) {
 		const args = a();

package/src/codegen/stdlib/path.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `path` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const PATH_DISPATCH = {
 	Base: (a) =>
 		`((p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; })(${a[0]})`,
@@ -14,6 +16,7 @@ const PATH_DISPATCH = {
 		`((pat, name) => { try { const sp=/[.+^$()|[\\]\\\\]/g; const re = new RegExp("^" + pat.replace(sp, "\\\\$&").replace(/\\*/g, "[^/]*").replace(/\\?/g, "[^/]") + "$"); return [re.test(name), null]; } catch(e) { return [false, "syntax error in pattern"]; } })(${a[0]}, ${a[1]})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const pathMethods = {
 	_genPath(fn, a, expr) {
 		if (fn === "Join") {

package/src/codegen/stdlib/rand.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `math/rand` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const RAND_DISPATCH = {
 	Intn: (a) => `Math.floor(Math.random() * ${a[0]})`,
 	Int63n: (a) => `Math.floor(Math.random() * ${a[0]})`,
@@ -16,6 +18,7 @@ const RAND_DISPATCH = {
 		`((n) => { const a = Array.from({length: n}, (_, i) => i); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; })(${a[0]})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const randMethods = {
 	_genRand(fn, a) {
 		const gen = RAND_DISPATCH[fn];

package/src/codegen/stdlib/regexp.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `regexp` package and `*Regexp` methods.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const REGEXP_METHOD = {
 	MatchString: (re, a) => `${re}.test(${a[0]})`,
 	FindString: (re, a) => `(${re}.exec(${a[0]})?.[0] ?? "")`,
@@ -19,6 +21,7 @@ const REGEXP_METHOD = {
 	String: (re) => `${re}.source`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const regexpMethods = {
 	_genRegexp(fn, a) {
 		// Converts a Go regexp pattern string (which may contain inline flags like (?i))

package/src/codegen/stdlib/slices.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `slices` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const SLICES_DISPATCH = {
 	Contains: (a) => `${a[0]}.includes(${a[1]})`,
 	Index: (a) => `${a[0]}.indexOf(${a[1]})`,
@@ -35,6 +37,7 @@ const SLICES_DISPATCH = {
 	Clip: (a) => `${a[0]}.slice()`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const slicesMethods = {
 	_genSlices(fn, a) {
 		if (fn === "Equal") {

package/src/codegen/stdlib/sort.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `sort` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const SORT_DISPATCH = {
 	Ints: (a) => `${a[0]}.sort((a, b) => a - b)`,
 	Float64s: (a) => `${a[0]}.sort((a, b) => a - b)`,
@@ -20,6 +22,7 @@ const SORT_DISPATCH = {
 		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const sortMethods = {
 	_genSort(fn, a) {
 		const gen = SORT_DISPATCH[fn];

package/src/codegen/stdlib/strconv.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `strconv` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const STRCONV_DISPATCH = {
 	Itoa: (a) => `String(${a[0]})`,
 	Atoi: (a) =>
@@ -22,6 +24,7 @@ const STRCONV_DISPATCH = {
 		`[...(${a[0]}), ...new TextEncoder().encode(${a[1]}.toFixed(${a[3]} < 0 ? 6 : ${a[3]}))]`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const strconvMethods = {
 	_genStrconv(fn, a) {
 		const gen = STRCONV_DISPATCH[fn];

package/src/codegen/stdlib/strings.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `strings` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const STRINGS_M1 = {
 	ToUpper: "toUpperCase",
 	ToLower: "toLowerCase",
@@ -71,6 +73,7 @@ const STRINGS_DISPATCH = {
 		`((...pairs) => { const p = []; for (let i = 0; i < pairs.length; i += 2) p.push([pairs[i], pairs[i+1]]); return { _p: p, Replace(s) { let r = s; for (const [o, n] of this._p) r = r.split(o).join(n); return r; } }; })(${args.join(", ")})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const stringsMethods = {
 	_genStrings(fn, a) {
 		const args = a();

package/src/codegen/stdlib/time.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `time` package — `time.Now`, `time.Since`, etc., plus `*Time` methods.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const TIME_METHOD_DISPATCH = {
 	Year: (r) => `${r}._d.getFullYear()`,
 	Month: (r) => `${r}._d.getMonth() + 1`,
@@ -26,6 +28,7 @@ const TIME_DISPATCH = {
 		`{_d: new Date(${a[0]}, ${a[1]} - 1, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]})}`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const timeMethods = {
 	_genTimeMethodCall(method, expr) {
 		const recv = expr.func.expr;

package/src/codegen/stdlib/unicode.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `unicode` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const unicodeMethods = {
 	_genUnicode(fn, a) {
 		const [arg] = a();

package/src/codegen/stdlib/utf8.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `unicode/utf8` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const UTF8_DISPATCH = {
 	RuneCountInString: (a) => `[...(${a[0]})].length`,
 	RuneLen: (a) =>
@@ -15,6 +17,7 @@ const UTF8_DISPATCH = {
 	FullRuneInString: (a) => `(${a[0]}).length > 0`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const utf8Methods = {
 	_genUtf8(fn, a) {
 		const gen = UTF8_DISPATCH[fn];

package/src/codegen/templ.js

@@ -5,6 +5,9 @@
 import { Parser } from "../parser/index.js";
 import { T, Token } from "../tokens.js";
 
+/** @typedef {import('./index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const templGenMethods = {
 	genTemplDecl(decl) {
 		const params = decl.params