gofront 0.0.5 → 0.0.6

package/README.md

@@ -1,13 +1,13 @@
 ## About
 
-I love Go for the backend — simple, type-safe, no nonsense. I like JavaScript for the
-frontend — runs everywhere, no setup. What I don't like is JavaScript's loose typing. And
-I don't like TypeScript either. I know, controversial. It's fine, I just don't enjoy it.
+Go for the backend: simple, type-safe, no nonsense. JavaScript for the frontend: runs
+everywhere, no setup. The problem is JavaScript's loose typing — and TypeScript never
+quite felt like home either.
 
-So I built GoFront. Go syntax, type safety, compiles to plain ES modules. Same language
+So I built GoFront. Go syntax and type safety, compiling to plain ES modules. One language
 front and back, no runtime, no framework, no tsconfig.json.
 
-Is this useful? Probably not, but it was fun to build:D
+Probably not useful. Definitely fun to build.
 
 ```go
 package main
@@ -258,16 +258,18 @@ npm run build:reactive    # → example/reactive/app.js
 gofront <file.go>                compile single file → stdout
 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> --source-map     append inline source map to output
-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 init [dir]               scaffold a new project
-gofront --version / -v           print version
-gofront --help / -h              print this help
+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 --port 8080  use a custom port
+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 init [dir]                         scaffold a new project
+gofront --version / -v                     print version
+gofront --help / -h                        print this help
 ```
 
 ---
@@ -403,14 +405,18 @@ signatures into GoFront's internal type representation.
 
 | Package | Functions |
 |---|---|
-| `fmt` | `Sprintf`, `Printf`, `Println`, `Print`, `Errorf` — format verbs: `%v`, `%d`, `%s`, `%t`, `%x`, `%o`, `%b`, `%q`, `%e`, `%g`, `%w`, width/precision |
-| `strings` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `LastIndex`, `Count`, `Repeat`, `Replace`, `ReplaceAll`, `ToUpper`, `ToLower`, `TrimSpace`, `Trim`, `TrimPrefix`, `TrimSuffix`, `TrimLeft`, `TrimRight`, `Split`, `Join`, `EqualFold` |
-| `bytes` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `Join`, `Split`, `Replace`, `ToUpper`, `ToLower`, `TrimSpace`, `Equal`, `Count`, `Repeat` |
+| `fmt` | `Sprintf`, `Printf`, `Println`, `Print`, `Errorf`, `Fprintf`, `Fprintln`, `Fprint` — format verbs: `%v`, `%d`, `%s`, `%t`, `%x`, `%o`, `%b`, `%q`, `%e`, `%g`, `%w`, width/precision |
+| `strings` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `LastIndex`, `Count`, `Repeat`, `Replace`, `ReplaceAll`, `ToUpper`, `ToLower`, `TrimSpace`, `Trim`, `TrimPrefix`, `TrimSuffix`, `TrimLeft`, `TrimRight`, `Split`, `Join`, `EqualFold`; **`Builder`** type (`WriteString`, `WriteByte`, `WriteRune`, `Write`, `String`, `Len`, `Reset`, `Grow`) |
+| `bytes` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `Join`, `Split`, `Replace`, `ToUpper`, `ToLower`, `TrimSpace`, `Equal`, `Count`, `Repeat`; **`Buffer`** type (`WriteString`, `WriteByte`, `Write`, `String`, `Bytes`, `Len`, `Reset`) |
 | `strconv` | `Itoa`, `Atoi`, `FormatBool`, `FormatInt`, `FormatFloat`, `ParseFloat`, `ParseInt`, `ParseBool` |
 | `sort` | `Ints`, `Float64s`, `Strings`, `Slice`, `SliceStable`, `SliceIsSorted` |
 | `math` | `Abs`, `Floor`, `Ceil`, `Round`, `Sqrt`, `Cbrt`, `Pow`, `Log`, `Log2`, `Log10`, trig functions + `Pi`, `E`, `MaxFloat64`, `MaxInt`, `MinInt` |
 | `errors` | `New`, `Is`, `Unwrap` — custom error types via interface satisfaction |
 | `time` | `Now`, `Since`, `Sleep` + `Millisecond`, `Second`, `Minute`, `Hour` constants |
+| `html` | `EscapeString`, `UnescapeString` |
+| `maps` | `Keys`, `Values`, `Clone`, `Copy`, `Equal`, `EqualFunc`, `Delete`, `DeleteFunc` |
+| `slices` | `Contains`, `Index`, `Equal`, `Compare`, `Sort`, `SortFunc`, `SortStableFunc`, `IsSorted`, `IsSortedFunc`, `Reverse`, `Max`, `Min`, `MaxFunc`, `MinFunc`, `Clone`, `Compact`, `CompactFunc`, `Concat`, `Delete`, `DeleteFunc`, `Insert`, `Replace`, `Grow`, `Clip` |
+| `regexp` | `MustCompile`, `Compile`, `MatchString`, `QuoteMeta`; **`*Regexp`** methods: `MatchString`, `FindString`, `FindStringIndex`, `FindAllString`, `FindStringSubmatch`, `FindAllStringSubmatch`, `ReplaceAllString`, `ReplaceAllLiteralString`, `Split`, `String`. Inline flags (`(?i)`, `(?m)`, `(?s)`) are extracted automatically into the JS `RegExp` constructor. |
 | `unicode` | `IsLetter`, `IsDigit`, `IsSpace`, `IsUpper`, `IsLower`, `IsPunct`, `IsControl`, `IsPrint`, `IsGraphic`, `ToUpper`, `ToLower` |
 | `os` | `Exit`, `Args`, `Getenv` |
 
@@ -494,7 +500,7 @@ Design documents for planned features are organised by release under `docs/v*/`
 npm test
 ```
 
-869 tests covering language features, type errors, edge cases, DOM (jsdom), external
+940 tests covering language features, type errors, edge cases, DOM (jsdom), external
 `.d.ts`, npm resolver, multi-file compilation, embedded structs, string formatting, map
 iteration order, integer overflow semantics, unused variable detection, unused import
 detection, semantic difference verification, stdlib shim packages, generics (type params,

package/package.json

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

package/src/codegen/expressions.js

@@ -443,6 +443,19 @@ export const expressionGenMethods = {
 			if (result !== undefined) return result;
 		}
 
+		// strings.Builder / bytes.Buffer / regexp.Regexp method dispatch
+		if (expr.func.kind === "SelectorExpr") {
+			const recvType = expr.func.expr._type;
+			const recvName = recvType?.name ?? recvType?.base?.name;
+			if (recvName === "strings.Builder" || recvName === "bytes.Buffer") {
+				const typeName = recvType?.name ?? recvType?.base?.name;
+				return this._genBuilderCall(typeName, expr.func.field, expr);
+			}
+			if (recvName === "regexp.Regexp") {
+				return this._genRegexpMethodCall(expr.func.field, expr);
+			}
+		}
+
 		// Mark the callee so SelectorExpr knows it's being called, not used as a value
 		expr.func._callee = true;
 		const rawFn = this.genExpr(expr.func);
@@ -662,6 +675,8 @@ export const expressionGenMethods = {
 			case "TypeName": {
 				const basic = this._zeroForBasicName(typeNode.name);
 				if (basic !== null) return basic;
+				if (typeNode.name === "strings.Builder") return '{ _buf: "" }';
+				if (typeNode.name === "bytes.Buffer") return "{ _buf: [] }";
 				if (this.structNames.has(typeNode.name))
 					return `new ${typeNode.name}()`;
 				return "null";
@@ -706,6 +721,8 @@ export const expressionGenMethods = {
 				return `{ ${fields} }`;
 			}
 			case "named":
+				if (t.name === "strings.Builder") return '{ _buf: "" }';
+				if (t.name === "bytes.Buffer") return "{ _buf: [] }";
 				if (this.structNames.has(t.name)) return `new ${t.name}()`;
 				return "null";
 			default:
@@ -776,6 +793,268 @@ export const expressionGenMethods = {
 		return base?.kind === "struct" || base?.kind === "array";
 	},
 
+	_genBuilderCall(typeName, method, expr) {
+		// Resolve the receiver — may be a direct var or a &var (pointer)
+		const recv = expr.func.expr;
+		const isPtr = recv._type?.kind === "pointer";
+		const base = isPtr ? `${this.genExpr(recv)}.value` : this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+
+		if (typeName === "strings.Builder") {
+			switch (method) {
+				case "WriteString":
+					return `(${base}._buf += ${args[0]}, [${args[0]}.length, null])`;
+				case "WriteByte":
+				case "WriteRune":
+					return `(${base}._buf += String.fromCodePoint(${args[0]}))`;
+				case "Write":
+					return `(${base}._buf += String.fromCharCode(...${args[0]}))`;
+				case "String":
+					return `${base}._buf`;
+				case "Len":
+					return `${base}._buf.length`;
+				case "Reset":
+					return `(${base}._buf = "")`;
+				case "Grow":
+					return "undefined";
+			}
+		}
+
+		if (typeName === "bytes.Buffer") {
+			switch (method) {
+				case "WriteString":
+					return `(${base}._buf.push(...new TextEncoder().encode(${args[0]})), [${args[0]}.length, null])`;
+				case "WriteByte":
+					return `${base}._buf.push(${args[0]})`;
+				case "Write":
+					return `(${base}._buf.push(...${args[0]}), [${args[0]}.length, null])`;
+				case "String":
+					return `new TextDecoder().decode(new Uint8Array(${base}._buf))`;
+				case "Bytes":
+					return `${base}._buf.slice()`;
+				case "Len":
+					return `${base}._buf.length`;
+				case "Reset":
+					return `(${base}._buf = [])`;
+				case "Grow":
+					return "undefined";
+			}
+		}
+
+		return undefined;
+	},
+
+	_genRegexp(fn, a) {
+		// Converts a Go regexp pattern string (which may contain inline flags like (?i))
+		// into a JS RegExp, extracting the flags into the second constructor argument.
+		const makeRegExp = (pat) =>
+			`((p) => { const m = /^\\(\\?([gimsuy]+)\\)/.exec(p); return m ? new RegExp(p.slice(m[0].length), m[1]) : new RegExp(p); })(${pat})`;
+		switch (fn) {
+			case "MustCompile":
+				return makeRegExp(a()[0]);
+			case "Compile":
+				return `[${makeRegExp(a()[0])}, null]`;
+			case "MatchString": {
+				const [pat, s] = a();
+				return `[new RegExp(${pat}).test(${s}), null]`;
+			}
+			case "QuoteMeta":
+				return `${a()[0]}.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&')`;
+		}
+		return undefined;
+	},
+
+	_genRegexpMethodCall(method, expr) {
+		const recv = expr.func.expr;
+		// *Regexp is a plain JS RegExp — no .value boxing needed
+		const re = this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+
+		switch (method) {
+			case "MatchString":
+				return `${re}.test(${args[0]})`;
+			case "FindString":
+				return `(${re}.exec(${args[0]})?.[0] ?? "")`;
+			case "FindStringIndex":
+				return `((m => m ? [m.index, m.index + m[0].length] : null)(${re}.exec(${args[0]})))`;
+			case "FindAllString":
+				return `[...${args[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${args[1]} < 0 ? undefined : ${args[1]}).map(m => m[0])`;
+			case "FindStringSubmatch":
+				return `[...(${re}.exec(${args[0]}) ?? [])]`;
+			case "FindAllStringSubmatch":
+				return `[...${args[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${args[1]} < 0 ? undefined : ${args[1]}).map(m => [...m])`;
+			case "ReplaceAllString":
+				return `${args[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${args[1]})`;
+			case "ReplaceAllLiteralString":
+				return `${args[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${args[1]}.replace(/\\$/g, '$$$$'))`;
+			case "Split":
+				return `${args[0]}.split(${re}).slice(0, ${args[1]} < 0 ? undefined : ${args[1]})`;
+			case "String":
+				return `${re}.source`;
+		}
+		return undefined;
+	},
+
+	_genSlices(fn, a) {
+		switch (fn) {
+			case "Contains": {
+				const [s, v] = a();
+				return `${s}.includes(${v})`;
+			}
+			case "Index": {
+				const [s, v] = a();
+				return `${s}.indexOf(${v})`;
+			}
+			case "Equal": {
+				this._usesEqual = true;
+				const [a1, b1] = a();
+				return `__equal(${a1}, ${b1})`;
+			}
+			case "Compare": {
+				const [a1, b1] = a();
+				return `((a, b) => { for (let i = 0; i < a.length && i < b.length; i++) { if (a[i] < b[i]) return -1; if (a[i] > b[i]) return 1; } return a.length - b.length; })(${a1}, ${b1})`;
+			}
+			case "Sort": {
+				const [s] = a();
+				return `${s}.sort((a, b) => a < b ? -1 : a > b ? 1 : 0)`;
+			}
+			case "SortFunc": {
+				const [s, cmp] = a();
+				return `${s}.sort(${cmp})`;
+			}
+			case "SortStableFunc": {
+				const [s, cmp] = a();
+				return `${s}.sort(${cmp})`;
+			}
+			case "IsSorted": {
+				const [s] = a();
+				return `((s) => { for (let i = 1; i < s.length; i++) { if (s[i] < s[i-1]) return false; } return true; })(${s})`;
+			}
+			case "IsSortedFunc": {
+				const [s, cmp] = a();
+				return `((s, f) => { for (let i = 1; i < s.length; i++) { if (f(s[i], s[i-1]) < 0) return false; } return true; })(${s}, ${cmp})`;
+			}
+			case "Reverse": {
+				const [s] = a();
+				return `${s}.reverse()`;
+			}
+			case "Max": {
+				const [s] = a();
+				return `Math.max(...${s})`;
+			}
+			case "Min": {
+				const [s] = a();
+				return `Math.min(...${s})`;
+			}
+			case "MaxFunc": {
+				const [s, cmp] = a();
+				return `((s, f) => s.reduce((m, x) => f(x, m) > 0 ? x : m))(${s}, ${cmp})`;
+			}
+			case "MinFunc": {
+				const [s, cmp] = a();
+				return `((s, f) => s.reduce((m, x) => f(x, m) < 0 ? x : m))(${s}, ${cmp})`;
+			}
+			case "Clone": {
+				const [s] = a();
+				return `${s}.slice()`;
+			}
+			case "Compact": {
+				const [s] = a();
+				return `((s) => s.filter((v, i) => i === 0 || v !== s[i-1]))(${s})`;
+			}
+			case "CompactFunc": {
+				const [s, eq] = a();
+				return `((s, f) => s.filter((v, i) => i === 0 || !f(v, s[i-1])))(${s}, ${eq})`;
+			}
+			case "Concat": {
+				const args = a();
+				return `[].concat(${args.join(", ")})`;
+			}
+			case "Delete": {
+				const [s, i, j] = a();
+				return `[...${s}.slice(0, ${i}), ...${s}.slice(${j})]`;
+			}
+			case "DeleteFunc": {
+				const [s, fn2] = a();
+				return `${s}.filter((v) => !${fn2}(v))`;
+			}
+			case "Insert": {
+				const args = a();
+				const s = args[0];
+				const i = args[1];
+				const vs = args.slice(2);
+				return `[...${s}.slice(0, ${i}), ${vs.join(", ")}, ...${s}.slice(${i})]`;
+			}
+			case "Replace": {
+				const args = a();
+				const s = args[0];
+				const i = args[1];
+				const j = args[2];
+				const vs = args.slice(3);
+				return `[...${s}.slice(0, ${i}), ${vs.join(", ")}, ...${s}.slice(${j})]`;
+			}
+			case "Grow":
+			case "Clip": {
+				const [s] = a();
+				return `${s}.slice()`;
+			}
+		}
+		return undefined;
+	},
+
+	_genHtml(fn, a) {
+		switch (fn) {
+			case "EscapeString": {
+				const [s] = a();
+				return `${s}.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&#34;").replace(/'/g,"&#39;")`;
+			}
+			case "UnescapeString": {
+				const [s] = a();
+				return `${s}.replace(/&#39;/g,"'").replace(/&#34;/g,'"').replace(/&gt;/g,">").replace(/&lt;/g,"<").replace(/&amp;/g,"&")`;
+			}
+		}
+		return undefined;
+	},
+
+	_genMaps(fn, a) {
+		switch (fn) {
+			case "Keys": {
+				const [m] = a();
+				return `Object.keys(${m})`;
+			}
+			case "Values": {
+				const [m] = a();
+				return `Object.values(${m})`;
+			}
+			case "Clone": {
+				const [m] = a();
+				return `({...${m}})`;
+			}
+			case "Copy": {
+				const [dst, src] = a();
+				return `Object.assign(${dst}, ${src})`;
+			}
+			case "Equal": {
+				this._usesEqual = true;
+				const [a1, b1] = a();
+				return `__equal(${a1}, ${b1})`;
+			}
+			case "EqualFunc": {
+				const [m1, m2, eq] = a();
+				return `((a, b, f) => { const ka = Object.keys(a); if (ka.length !== Object.keys(b).length) return false; return ka.every(k => k in b && f(a[k], b[k])); })(${m1}, ${m2}, ${eq})`;
+			}
+			case "Delete": {
+				const [m, k] = a();
+				return `(delete ${m}[${k}], undefined)`;
+			}
+			case "DeleteFunc": {
+				const [m, fn2] = a();
+				return `Object.keys(${m}).forEach(k => { if (${fn2}(k, ${m}[k])) delete ${m}[k]; })`;
+			}
+		}
+		return undefined;
+	},
+
 	typeComment(typeNode) {
 		if (!typeNode) return "unknown";
 		switch (typeNode.kind) {
@@ -815,6 +1094,14 @@ export const expressionGenMethods = {
 				return this._genErrors(fn, a);
 			case "time":
 				return this._genTime(fn, a);
+			case "regexp":
+				return this._genRegexp(fn, a);
+			case "slices":
+				return this._genSlices(fn, a);
+			case "maps":
+				return this._genMaps(fn, a);
+			case "html":
+				return this._genHtml(fn, a);
 			default:
 				return undefined;
 		}
@@ -843,6 +1130,52 @@ export const expressionGenMethods = {
 			case "Println":
 				this._usesSprintf = true;
 				return `console.log(__sprintf(${fmtArgs}))`;
+			case "Fprintf":
+			case "Fprintln":
+			case "Fprint": {
+				this._usesSprintf = true;
+				const writerArg = expr.args[0];
+				const rest = expr.args.slice(1);
+				const restJs = rest.map((e) => this.genExpr(e)).join(", ");
+				// Resolve the writer to its underlying buffer expression
+				const writerType = writerArg._type;
+				const targetTypeName =
+					writerType?.name ??
+					(writerType?.kind === "pointer" ? writerType.base?.name : null);
+				let buf;
+				if (targetTypeName === "strings.Builder") {
+					const w = this.genExpr(writerArg);
+					buf =
+						writerType?.kind === "pointer" ? `${w}.value._buf` : `${w}._buf`;
+				} else if (targetTypeName === "bytes.Buffer") {
+					const w = this.genExpr(writerArg);
+					const base = writerType?.kind === "pointer" ? `${w}.value` : w;
+					buf = null;
+					if (fn === "Fprintf") {
+						return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, __sprintf(${restJs}))`;
+					}
+					const valJs =
+						fn === "Fprintln"
+							? `__sprintf("%v\\n", ${restJs})`
+							: `__sprintf("%v", ${restJs})`;
+					return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${valJs})`;
+				} else {
+					// Generic io.Writer fallback — call .WriteString if available
+					const w = this.genExpr(writerArg);
+					const formatted =
+						fn === "Fprintf"
+							? `__sprintf(${restJs})`
+							: fn === "Fprintln"
+								? `__sprintf("%v\\n", ${restJs})`
+								: `__sprintf("%v", ${restJs})`;
+					return `${w}.WriteString(${formatted})`;
+				}
+				// strings.Builder path
+				if (fn === "Fprintf") return `(${buf} += __sprintf(${restJs}))`;
+				if (fn === "Fprintln")
+					return `(${buf} += __sprintf("%v\\n", ${restJs}))`;
+				return `(${buf} += __sprintf("%v", ${restJs}))`;
+			}
 			default:
 				return undefined;
 		}
@@ -862,7 +1195,7 @@ export const expressionGenMethods = {
 			case "LastIndex":
 				return `${args[0]}.lastIndexOf(${args[1]})`;
 			case "Count":
-				return `${args[0]}.split(${args[1]}).length - 1`;
+				return `((s, sep) => sep === "" ? s.length + 1 : s.split(sep).length - 1)(${args[0]}, ${args[1]})`;
 			case "Repeat":
 				return `${args[0]}.repeat(${args[1]})`;
 			case "Replace":
@@ -878,9 +1211,9 @@ export const expressionGenMethods = {
 			case "Trim":
 				return `${args[0]}.replace(new RegExp(\`^[\${${args[1]}}]+|[\${${args[1]}}]+$\`, "g"), "")`;
 			case "TrimPrefix":
-				return `(${args[0]}.startsWith(${args[1]}) ? ${args[0]}.slice(${args[1]}.length) : ${args[0]})`;
+				return `((s, pre) => s.startsWith(pre) ? s.slice(pre.length) : s)(${args[0]}, ${args[1]})`;
 			case "TrimSuffix":
-				return `(${args[0]}.endsWith(${args[1]}) ? ${args[0]}.slice(0, -${args[1]}.length) : ${args[0]})`;
+				return `((s, suf) => !suf.length || !s.endsWith(suf) ? s : s.slice(0, -suf.length))(${args[0]}, ${args[1]})`;
 			case "TrimLeft":
 				return `${args[0]}.replace(new RegExp(\`^[\${${args[1]}}]+\`), "")`;
 			case "TrimRight":
@@ -910,7 +1243,7 @@ export const expressionGenMethods = {
 			case "Index":
 				return `${__bs}(${args[0]}).indexOf(${__bs}(${args[1]}))`;
 			case "Count":
-				return `${__bs}(${args[0]}).split(${__bs}(${args[1]})).length - 1`;
+				return `((b, sep) => sep.length === 0 ? b.length + 1 : ${__bs}(b).split(${__bs}(sep)).length - 1)(${args[0]}, ${args[1]})`;
 			case "Repeat":
 				return `${__sb}(${__bs}(${args[0]}).repeat(${args[1]}))`;
 			case "Replace":

package/src/codegen/source-map.js

@@ -16,21 +16,29 @@ function vlqEncode(value) {
 	return result;
 }
 
-export function buildSourceMap(sourceName, mappings) {
-	// mappings: Array<{ genLine: number, srcLine: number }>  (0-based)
+export function buildSourceMap(sources, mappings) {
+	// sources:  string[]
+	// mappings: Array<{ genLine: number, srcLine: number, srcFileIdx?: number }>  (0-based)
 	// Emits one segment per generated line, column 0 → source line (delta-encoded).
 	const lines = [];
 	let prevSrcLine = 0;
+	let prevSrcFile = 0;
 	const maxGen = mappings.reduce((m, e) => Math.max(m, e.genLine), -1);
 	const byLine = new Map(mappings.map((e) => [e.genLine, e]));
 	for (let g = 0; g <= maxGen; g++) {
 		const entry = byLine.get(g);
 		if (entry) {
+			const fileIdx = entry.srcFileIdx ?? 0;
+			const fileDelta = fileIdx - prevSrcFile;
 			const srcDelta = entry.srcLine - prevSrcLine;
-			// Segment: [genCol=0, srcFileIdx=0, srcLineDelta, srcCol=0]
+			// Segment: [genCol=0, srcFileIdxDelta, srcLineDelta, srcCol=0]
 			lines.push(
-				vlqEncode(0) + vlqEncode(0) + vlqEncode(srcDelta) + vlqEncode(0),
+				vlqEncode(0) +
+					vlqEncode(fileDelta) +
+					vlqEncode(srcDelta) +
+					vlqEncode(0),
 			);
+			prevSrcFile = fileIdx;
 			prevSrcLine = entry.srcLine;
 		} else {
 			lines.push(""); // no mapping for this generated line
@@ -38,7 +46,7 @@ export function buildSourceMap(sourceName, mappings) {
 	}
 	return JSON.stringify({
 		version: 3,
-		sources: [sourceName],
+		sources,
 		names: [],
 		mappings: lines.join(";"),
 	});

package/src/codegen.js

@@ -38,7 +38,8 @@ export class CodeGen {
 		this.jsImports = jsImports;
 		this.bundledPackages = bundledPackages;
 		this.namedReturnVars = null; // names of current function's named return vars
-		this._srcMappings = []; // { genLine, srcLine } for source map
+		this._srcMappings = []; // { genLine, srcLine, srcFileIdx } for source map
+		this._currentSrcFileIdx = 0; // updated as each top-level decl is generated
 		this._boxedVars = new Set(); // address-taken scalar variables that need boxing
 		// Runtime helper usage tracking — only emit helpers that are actually used
 		this._usesLen = false;
@@ -67,8 +68,9 @@ export class CodeGen {
 		if (srcLine != null) {
 			this._srcMappings.push({
 				genLine: this.out.length,
-				srcLine: srcLine - 1,
-			}); // 0-based
+				srcLine: srcLine - 1, // 0-based
+				srcFileIdx: this._currentSrcFileIdx,
+			});
 		}
 		this.out.push("  ".repeat(this.indent) + s);
 	}
@@ -109,6 +111,7 @@ export class CodeGen {
 
 		for (const d of program.decls) {
 			if (d.kind === "TypeDecl") {
+				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
 				this.genTypeDeclWithMethods(d, methods.get(d.name) ?? []);
 				this.blank();
 			}
@@ -116,10 +119,12 @@ export class CodeGen {
 
 		for (const d of program.decls) {
 			if (d.kind === "VarDecl") {
+				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
 				this.genVarDecl(d);
 				this.blank();
 			}
 			if (d.kind === "ConstDecl") {
+				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
 				this.genConstDecl(d);
 				this.blank();
 			}
@@ -130,6 +135,7 @@ export class CodeGen {
 		const initNames = [];
 		for (const d of program.decls) {
 			if (d.kind === "FuncDecl") {
+				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
 				if (d.name === "init") {
 					const renamed = initCount === 0 ? "init" : `init$${initCount}`;
 					initNames.push(renamed);
@@ -152,29 +158,31 @@ export class CodeGen {
 		// Prepend runtime helpers that were actually used
 		const helpers = [];
 		if (this._usesLen)
-			helpers.push("function __len(a) { return a?.length ?? 0; }");
+			helpers.push(
+				"var __len = __len || function(a) { if (a && typeof a === 'object' && !Array.isArray(a)) return Object.keys(a).length; return a?.length ?? 0; };",
+			);
 		if (this._usesAppend)
 			helpers.push(
-				"function __append(a, ...b) { return a ? [...a, ...b] : b; }",
+				"var __append = __append || function(a, ...b) { return a ? [...a, ...b] : b; };",
 			);
 		if (this._usesSliceGuard)
-			helpers.push("function __s(a) { return a || []; }");
+			helpers.push("var __s = __s || function(a) { return a || []; };");
 		if (this._usesEqual)
 			helpers.push(
-				'function __equal(a,b){if(a===b)return true;if(a===null||b===null)return false;if(Array.isArray(a)&&Array.isArray(b)){if(a.length!==b.length)return false;for(let i=0;i<a.length;i++)if(!__equal(a[i],b[i]))return false;return true;}if(typeof a==="object"&&typeof b==="object"){const ka=Object.keys(a),kb=Object.keys(b);if(ka.length!==kb.length)return false;for(const k of ka)if(!__equal(a[k],b[k]))return false;return true;}return false;}',
+				'var __equal = __equal || function __equal(a,b){if(a===b)return true;if(a===null||b===null)return false;if(Array.isArray(a)&&Array.isArray(b)){if(a.length!==b.length)return false;for(let i=0;i<a.length;i++)if(!__equal(a[i],b[i]))return false;return true;}if(typeof a==="object"&&typeof b==="object"){const ka=Object.keys(a),kb=Object.keys(b);if(ka.length!==kb.length)return false;for(const k of ka)if(!__equal(a[k],b[k]))return false;return true;}return false;};',
 			);
 		if (this._usesCmul)
 			helpers.push(
-				"function __cmul(a, b) { return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re }; }",
+				"var __cmul = __cmul || function(a, b) { return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re }; };",
 			);
 		if (this._usesCdiv)
 			helpers.push(
-				"function __cdiv(a, b) { const d = b.re * b.re + b.im * b.im; return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d }; }",
+				"var __cdiv = __cdiv || function(a, b) { const d = b.re * b.re + b.im * b.im; return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d }; };",
 			);
 		if (this._usesSprintf)
 			helpers.push(
 				[
-					"function __sprintf(f,...a){let i=0;return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGw%]/g,(m)=>{",
+					"var __sprintf = __sprintf || function(f,...a){let i=0;return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGw%]/g,(m)=>{",
 					"if(m==='%%')return'%';const fl=m.slice(1,-1),verb=m.slice(-1),v=a[i++];",
 					"const pad=(s,w,z)=>{w=parseInt(w)||0;if(!w)return s;const p=(z?'0':' ').repeat(Math.max(0,w-s.length));return fl.includes('-')?s+p:p+s;};",
 					"const [,flags,width,prec]=m.match(/^%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)/)||[];",
@@ -194,16 +202,16 @@ export class CodeGen {
 					"case'g':case'G':{const n=Number(v);return pad(prec!==''?n.toPrecision(parseInt(prec)):String(n),width,zero);}",
 					"case'w':return pad(String(v==null?'<nil>':typeof v==='object'&&v.Error?v.Error():v),width,false);",
 					"default:return m;}});",
-					"}",
+					"};",
 				].join(""),
 			);
 		if (this._usesError)
 			helpers.push(
-				"function __error(msg, cause) { return { Error() { return msg; }, toString() { return msg; }, _msg: msg, _cause: cause ?? null }; }",
+				"var __error = __error || function(msg, cause) { return { Error() { return msg; }, toString() { return msg; }, _msg: msg, _cause: cause ?? null }; };",
 			);
 		if (this._usesErrorIs)
 			helpers.push(
-				'function __errorIs(err, target) { while (err !== null && err !== undefined) { if (err === target) return true; if (typeof err === "object" && typeof target === "object" && err._msg !== undefined && target._msg !== undefined && err._msg === target._msg) return true; err = err?._cause ?? null; } return false; }',
+				'var __errorIs = __errorIs || function(err, target) { while (err !== null && err !== undefined) { if (err === target) return true; if (typeof err === "object" && typeof target === "object" && err._msg !== undefined && target._msg !== undefined && err._msg === target._msg) return true; err = err?._cause ?? null; } return false; };',
 			);
 
 		if (helpers.length > 0) this.out.unshift(...helpers, "");
@@ -214,16 +222,22 @@ export class CodeGen {
 	}
 
 	// Generate a single bundle from multiple programs (same-package multi-file).
-	// Merges all decls and generates as if it were one program.
+	// Annotates each decl with its source file index before merging.
 	generateAll(programs) {
+		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);
 	}
 
 	// Returns a source map JSON string for the last generate() call.
-	// sourceName: the .go filename to reference in the map.
-	getSourceMap(sourceName) {
-		return buildSourceMap(sourceName, this._srcMappings);
+	// sources: string[] of source filenames (relative to the output file).
+	getSourceMap(sources) {
+		const srcArray = Array.isArray(sources) ? sources : [sources];
+		return buildSourceMap(srcArray, this._srcMappings);
 	}
 
 	// ── Type declarations ────────────────────────────────────────

package/src/compiler.js

@@ -16,7 +16,7 @@
 // de-qualifies it because the dependency is inlined.
 
 import { readdirSync, readFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { CodeGen } from "./codegen.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
@@ -165,8 +165,15 @@ export function compileFiles(files, options = {}) {
 	const codegen = new CodeGen(checker, jsImports, bundledPackages);
 	const mainJs = codegen.generateAll(programs);
 
-	const js =
-		preambles.length > 0 ? `${preambles.join("\n")}\n${mainJs}` : mainJs;
+	let js = preambles.length > 0 ? `${preambles.join("\n")}\n${mainJs}` : mainJs;
+
+	if (options.sourceMap) {
+		const outputDir = options.outputDir ?? fromDir;
+		const sourceFiles = files.map((f) => relative(outputDir, f));
+		const map = codegen.getSourceMap(sourceFiles);
+		const b64 = Buffer.from(map).toString("base64");
+		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
+	}
 
 	return {
 		pkgName,

package/src/dev-server.js

@@ -0,0 +1,83 @@
+// Minimal dev server for gofront --serve watch mode.
+// Serves static files and pushes a reload event via SSE after each build.
+
+import { existsSync, readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { extname, join } from "node:path";
+
+const MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2",
+	".woff": "font/woff",
+};
+
+// 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();});})();`;
+
+export function createDevServer(serveDir, port) {
+	const clients = new Set();
+
+	const server = createServer((req, res) => {
+		// SSE endpoint — browser connects here to receive reload events
+		if (req.url === "/_gofront/events") {
+			res.writeHead(200, {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive",
+			});
+			res.write(": connected\n\n");
+			clients.add(res);
+			req.on("close", () => clients.delete(res));
+			return;
+		}
+
+		let urlPath = req.url.split("?")[0];
+		if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
+
+		const filePath = join(serveDir, urlPath);
+		if (!existsSync(filePath)) {
+			res.writeHead(404, { "Content-Type": "text/plain" });
+			res.end("Not found");
+			return;
+		}
+
+		try {
+			const data = readFileSync(filePath);
+			const mime = MIME[extname(filePath)] ?? "application/octet-stream";
+			res.writeHead(200, { "Content-Type": mime });
+			res.end(data);
+		} catch {
+			res.writeHead(500, { "Content-Type": "text/plain" });
+			res.end("Server error");
+		}
+	});
+
+	server.on("error", (err) => {
+		if (err.code === "EADDRINUSE") {
+			console.error(
+				`gofront: port ${port} already in use — try --port <number>`,
+			);
+		} else {
+			console.error(`gofront: dev server error: ${err.message}`);
+		}
+		process.exit(1);
+	});
+	server.listen(port, () => {
+		console.error(`gofront: dev server → http://localhost:${port}`);
+	});
+
+	function notify() {
+		for (const client of clients) {
+			client.write("event: reload\ndata: {}\n\n");
+		}
+	}
+
+	return { notify };
+}

package/src/index.js

@@ -26,9 +26,10 @@ import { createRequire } from "node:module";
 const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { CodeGen } from "./codegen.js";
 import { compileDir } from "./compiler.js";
+import { createDevServer, liveReloadClient } from "./dev-server.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
 import { minify } from "./minifier.js";
@@ -55,6 +56,8 @@ Usage:
   gofront <input> -o out.js      Compile and write to file
   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 --port 8080  Use a custom port
   gofront <input> --source-map   Append inline source map to output
   gofront <input> --minify       Minify output
   gofront <input> --minify --mangle  Minify and mangle identifiers
@@ -120,9 +123,12 @@ const checkOnly = args.includes("--check");
 const dumpAst = args.includes("--ast");
 const dumpTokens = args.includes("--tokens");
 const sourceMap = args.includes("--source-map");
-const watchMode = args.includes("--watch");
+const serveMode = args.includes("--serve");
+const watchMode = args.includes("--watch") || serveMode;
 const minifyOutput = args.includes("--minify");
 const mangleOutput = args.includes("--mangle");
+const portFlag = args.indexOf("--port");
+const servePort = portFlag !== -1 ? parseInt(args[portFlag + 1], 10) : 3000;
 
 // ── Determine input mode ─────────────────────────────────────
 
@@ -139,7 +145,8 @@ try {
 
 function runCompile() {
 	if (isDir) {
-		return compileDir(inputPath);
+		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
+		return compileDir(inputPath, { sourceMap, outputDir });
 	}
 
 	// Single-file mode
@@ -223,7 +230,9 @@ function runCompile() {
 	let js = cg.generate(ast);
 
 	if (sourceMap) {
-		const map = cg.getSourceMap(inputArg);
+		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
+		const srcPath = relative(outputDir, inputPath);
+		const map = cg.getSourceMap(srcPath);
 		const b64 = Buffer.from(map).toString("base64");
 		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 	}
@@ -291,11 +300,31 @@ 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>");
+		process.exit(1);
+	}
+	const serveDir = dirname(resolve(outputFile));
+	devServer = createDevServer(serveDir, servePort);
+}
+
 function buildOnce() {
 	try {
 		const startMs = performance.now();
 		const result = runCompile();
-		const js = maybeMinify(result.js);
+		let js = maybeMinify(result.js);
+		if (serveMode) {
+			// Insert live reload client before the source map comment so it stays last
+			const smIdx = js.lastIndexOf("\n//# sourceMappingURL=");
+			if (smIdx !== -1) {
+				js = `${js.slice(0, smIdx)}\n${liveReloadClient}${js.slice(smIdx)}`;
+			} else {
+				js += `\n${liveReloadClient}`;
+			}
+		}
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
 		if (outputFile) {
 			writeFileSync(outputFile, `${js}\n`);
@@ -308,6 +337,7 @@ function buildOnce() {
 			console.log(js);
 			console.error(`[${timestamp()}] gofront: OK (${elapsedMs}ms)`);
 		}
+		devServer?.notify();
 	} catch (e) {
 		console.error(`[${timestamp()}] gofront: ERROR`);
 		for (const line of e.message.split("\n")) console.error(`  ${line}`);

package/src/typechecker.js

@@ -146,6 +146,24 @@ export class TypeChecker {
 				Printf: fmtVariadic(VOID),
 				Println: fmtVariadic(VOID),
 				Print: fmtVariadic(VOID),
+				Fprintf: {
+					kind: "func",
+					params: [ANY, STRING],
+					returns: [INT, ERROR],
+					variadic: true,
+				},
+				Fprintln: {
+					kind: "func",
+					params: [ANY],
+					returns: [INT, ERROR],
+					variadic: true,
+				},
+				Fprint: {
+					kind: "func",
+					params: [ANY],
+					returns: [INT, ERROR],
+					variadic: true,
+				},
 			},
 		});
 
@@ -431,6 +449,195 @@ export class TypeChecker {
 			},
 		});
 
+		// slices package (Go 1.21)
+		// Functions are generic — use ANY for slice params so any concrete slice type
+		// is accepted without an assignability error (same pattern as sort.Slice).
+		this.globals.define("slices", {
+			kind: "namespace",
+			name: "slices",
+			members: {
+				Contains: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				Index: { kind: "func", params: [ANY, ANY], returns: [INT] },
+				Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				Compare: { kind: "func", params: [ANY, ANY], returns: [INT] },
+				Sort: { kind: "func", params: [ANY], returns: [VOID] },
+				SortFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				SortStableFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				IsSorted: { kind: "func", params: [ANY], returns: [BOOL] },
+				IsSortedFunc: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				Reverse: { kind: "func", params: [ANY], returns: [VOID] },
+				Max: { kind: "func", params: [ANY], returns: [ANY] },
+				Min: { kind: "func", params: [ANY], returns: [ANY] },
+				MaxFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				MinFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				Clone: { kind: "func", params: [ANY], returns: [ANY] },
+				Compact: { kind: "func", params: [ANY], returns: [ANY] },
+				CompactFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				Concat: { kind: "func", params: [ANY], returns: [ANY], variadic: true },
+				Delete: { kind: "func", params: [ANY, INT, INT], returns: [ANY] },
+				DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				Insert: {
+					kind: "func",
+					params: [ANY, INT, ANY],
+					returns: [ANY],
+					variadic: true,
+				},
+				Replace: {
+					kind: "func",
+					params: [ANY, INT, INT, ANY],
+					returns: [ANY],
+					variadic: true,
+				},
+				Grow: { kind: "func", params: [ANY, INT], returns: [ANY] },
+				Clip: { kind: "func", params: [ANY], returns: [ANY] },
+			},
+		});
+
+		// html package
+		this.globals.define("html", {
+			kind: "namespace",
+			name: "html",
+			members: {
+				EscapeString: { kind: "func", params: [STRING], returns: [STRING] },
+				UnescapeString: { kind: "func", params: [STRING], returns: [STRING] },
+			},
+		});
+
+		// maps package (Go 1.21)
+		this.globals.define("maps", {
+			kind: "namespace",
+			name: "maps",
+			members: {
+				Keys: { kind: "func", params: [ANY], returns: [ANY] },
+				Values: { kind: "func", params: [ANY], returns: [ANY] },
+				Clone: { kind: "func", params: [ANY], returns: [ANY] },
+				Copy: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				EqualFunc: { kind: "func", params: [ANY, ANY, ANY], returns: [BOOL] },
+				Delete: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+			},
+		});
+
+		// regexp package
+		const REGEXP_T = {
+			kind: "named",
+			name: "regexp.Regexp",
+			underlying: { kind: "struct", fields: new Map(), methods: new Map() },
+		};
+		const REGEXP_PTR = { kind: "pointer", base: REGEXP_T };
+		const STR_SLICE = { kind: "slice", elem: STRING };
+		const INT_SLICE = { kind: "slice", elem: INT };
+		const regexpMethods = new Map([
+			["MatchString", { kind: "func", params: [STRING], returns: [BOOL] }],
+			["FindString", { kind: "func", params: [STRING], returns: [STRING] }],
+			[
+				"FindStringIndex",
+				{ kind: "func", params: [STRING], returns: [INT_SLICE] },
+			],
+			[
+				"FindAllString",
+				{ kind: "func", params: [STRING, INT], returns: [STR_SLICE] },
+			],
+			[
+				"FindStringSubmatch",
+				{ kind: "func", params: [STRING], returns: [STR_SLICE] },
+			],
+			[
+				"FindAllStringSubmatch",
+				{
+					kind: "func",
+					params: [STRING, INT],
+					returns: [{ kind: "slice", elem: STR_SLICE }],
+				},
+			],
+			[
+				"ReplaceAllString",
+				{ kind: "func", params: [STRING, STRING], returns: [STRING] },
+			],
+			[
+				"ReplaceAllLiteralString",
+				{ kind: "func", params: [STRING, STRING], returns: [STRING] },
+			],
+			["Split", { kind: "func", params: [STRING, INT], returns: [STR_SLICE] }],
+			["String", { kind: "func", params: [], returns: [STRING] }],
+		]);
+		REGEXP_T.underlying.methods = regexpMethods;
+		this.types.set("regexp.Regexp", REGEXP_T);
+		this.globals.define("regexp", {
+			kind: "namespace",
+			name: "regexp",
+			members: {
+				MustCompile: { kind: "func", params: [STRING], returns: [REGEXP_PTR] },
+				Compile: {
+					kind: "func",
+					params: [STRING],
+					returns: [REGEXP_PTR, ERROR],
+				},
+				MatchString: {
+					kind: "func",
+					params: [STRING, STRING],
+					returns: [BOOL, ERROR],
+				},
+				QuoteMeta: { kind: "func", params: [STRING], returns: [STRING] },
+			},
+		});
+
+		// strings.Builder
+		const BYTE_SLICE_T = { kind: "slice", elem: INT };
+		const strBuilderMethods = new Map([
+			[
+				"WriteString",
+				{ kind: "func", params: [STRING], returns: [INT, ERROR] },
+			],
+			["WriteByte", { kind: "func", params: [INT], returns: [ERROR] }],
+			["WriteRune", { kind: "func", params: [INT], returns: [INT, ERROR] }],
+			[
+				"Write",
+				{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
+			],
+			["String", { kind: "func", params: [], returns: [STRING] }],
+			["Len", { kind: "func", params: [], returns: [INT] }],
+			["Reset", { kind: "func", params: [], returns: [VOID] }],
+			["Grow", { kind: "func", params: [INT], returns: [VOID] }],
+		]);
+		this.types.set("strings.Builder", {
+			kind: "named",
+			name: "strings.Builder",
+			underlying: {
+				kind: "struct",
+				fields: new Map(),
+				methods: strBuilderMethods,
+			},
+		});
+
+		// bytes.Buffer
+		const bytesBufferMethods = new Map([
+			[
+				"WriteString",
+				{ kind: "func", params: [STRING], returns: [INT, ERROR] },
+			],
+			["WriteByte", { kind: "func", params: [INT], returns: [ERROR] }],
+			[
+				"Write",
+				{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
+			],
+			["String", { kind: "func", params: [], returns: [STRING] }],
+			["Bytes", { kind: "func", params: [], returns: [BYTE_SLICE_T] }],
+			["Len", { kind: "func", params: [], returns: [INT] }],
+			["Reset", { kind: "func", params: [], returns: [VOID] }],
+			["Grow", { kind: "func", params: [INT], returns: [VOID] }],
+		]);
+		this.types.set("bytes.Buffer", {
+			kind: "named",
+			name: "bytes.Buffer",
+			underlying: {
+				kind: "struct",
+				fields: new Map(),
+				methods: bytesBufferMethods,
+			},
+		});
+
 		this.globals.define("append", { kind: "builtin", name: "append" });
 		this.globals.define("len", { kind: "builtin", name: "len" });
 		this.globals.define("cap", { kind: "builtin", name: "cap" });
@@ -1360,6 +1567,15 @@ export class TypeChecker {
 	fieldType(baseType, field, node) {
 		baseType = this.resolveType(baseType);
 		if (!baseType || isAny(baseType)) return ANY;
+		// Transparent pointer dereference for named-type method calls: (*T).Method works like T.Method
+		// (only unwrap when the pointer's base is a named type that has methods)
+		if (
+			baseType.kind === "pointer" &&
+			field !== "value" &&
+			baseType.base?.kind === "named"
+		) {
+			baseType = this.resolveType(baseType.base);
+		}
 		let base = baseType.kind === "named" ? baseType.underlying : baseType;
 		base = this.resolveType(base);
 		if (base?.kind === "struct") {