gofront 0.0.5 → 0.0.7

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/statements.js

@@ -7,6 +7,30 @@ export const statementGenMethods = {
 		for (const stmt of block.stmts) this.genStmt(stmt);
 	},
 
+	// Shared helper for comma-ok map index in both DefineStmt and AssignStmt.
+	// isDefine=true  → emit `let v = m[k]; let ok = k in m;`
+	// isDefine=false → emit `v = k in m ? m[k] : zero; ok = k in m;`
+	_genCommaOkMapIndex(stmt, rhsNode, isDefine) {
+		const mapExpr = this.genExpr(rhsNode.expr);
+		const keyExpr = this.genExpr(rhsNode.index);
+		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
+		const decl = isDefine ? "let " : "";
+		if (vName !== "_") {
+			if (isDefine) {
+				this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
+			} else {
+				const zero = rhsNode._mapValueType
+					? this.zeroValueForType(rhsNode._mapValueType)
+					: "undefined";
+				this.line(
+					`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
+				);
+			}
+		}
+		if (okName !== "_")
+			this.line(`${decl}${okName} = (${keyExpr}) in ${mapExpr};`);
+	},
+
 	genStmt(stmt) {
 		// Record source mapping for the first line this statement produces
 		const srcLine = stmt._line ?? null;
@@ -31,15 +55,7 @@ export const statementGenMethods = {
 					rhsNode?.kind === "IndexExpr" &&
 					rhsNode.expr?._type?.kind === "map"
 				) {
-					const mapExpr = this.genExpr(rhsNode.expr);
-					const keyExpr = this.genExpr(rhsNode.index);
-					const [vName, okName] = stmt.lhs.map(
-						(e) => e.name ?? this.genExpr(e),
-					);
-					if (vName !== "_")
-						this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
-					if (okName !== "_")
-						this.line(`let ${okName} = (${keyExpr}) in ${mapExpr};`);
+					this._genCommaOkMapIndex(stmt, rhsNode, true);
 					break;
 				}
 				const rhs = stmt.rhs.map((e) => this.genExpr(e));
@@ -117,22 +133,7 @@ export const statementGenMethods = {
 				}
 				// comma-ok map index: v, ok = m["key"]
 				if (stmt._commaOkMap) {
-					const rhsNode = stmt.rhs[0];
-					const mapExpr = this.genExpr(rhsNode.expr);
-					const keyExpr = this.genExpr(rhsNode.index);
-					const [vName, okName] = stmt.lhs.map(
-						(e) => e.name ?? this.genExpr(e),
-					);
-					if (vName !== "_") {
-						const zero = rhsNode._mapValueType
-							? this.zeroValueForType(rhsNode._mapValueType)
-							: "undefined";
-						this.line(
-							`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
-						);
-					}
-					if (okName !== "_")
-						this.line(`${okName} = (${keyExpr}) in ${mapExpr};`);
+					this._genCommaOkMapIndex(stmt, stmt.rhs[0], false);
 					break;
 				}
 				// comma-ok type assertion: v, ok = x.(T)
@@ -383,8 +384,11 @@ export const statementGenMethods = {
 		const init = stmt.init;
 		const range = init.rhs[0];
 		const lhs = init.lhs.map((e) => e.name ?? this.genExpr(e));
-		const iteree = this.genExpr(range.expr);
 		const iterType = range.expr._type;
+		const wrapField = this._namedWrapperField(iterType, range.expr);
+		const iteree = wrapField
+			? `${this.genExpr(range.expr)}.${wrapField}`
+			: this.genExpr(range.expr);
 
 		let iterExpr;
 		if (

package/src/codegen.js

@@ -35,10 +35,12 @@ export class CodeGen {
 		this.out = [];
 		this.indent = 0;
 		this.structNames = new Set();
+		this.namedWrapperNames = new Set();
 		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 +69,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);
 	}
@@ -90,7 +93,7 @@ export class CodeGen {
 			}
 		}
 
-		// Build a map: structName → [MethodDecl, ...]
+		// Build a map: typeName → [MethodDecl, ...]
 		const methods = new Map();
 		for (const d of program.decls) {
 			if (d.kind === "MethodDecl") {
@@ -100,6 +103,18 @@ export class CodeGen {
 			}
 		}
 
+		// Collect named non-struct types that have methods (emitted as wrapper classes)
+		for (const d of program.decls) {
+			if (
+				d.kind === "TypeDecl" &&
+				d.type.kind !== "StructType" &&
+				d.type.kind !== "InterfaceType" &&
+				(methods.get(d.name) ?? []).length > 0
+			) {
+				this.namedWrapperNames.add(d.name);
+			}
+		}
+
 		// Emit ESM import statements for npm packages
 		for (const [importPath, names] of this.jsImports) {
 			if (names.length === 0) continue;
@@ -109,6 +124,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 +132,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 +148,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 +171,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 +215,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 +235,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 ────────────────────────────────────────
@@ -234,13 +261,41 @@ export class CodeGen {
 		} else if (decl.type.kind === "InterfaceType") {
 			// Interfaces are compile-time only — no JS output needed.
 			this.line(`// interface ${decl.name} (compile-time only)`);
+		} else if (methodDecls.length > 0) {
+			// Named non-struct type with methods — emit an ES6 wrapper class.
+			this.genNamedTypeClass(decl.name, methodDecls);
 		} else {
-			// Type alias — no JS equivalent needed unless it's used as a constructor.
-			// e.g. type MyInt int → just a comment
 			this.line(`// type ${decl.name} = ${this.typeComment(decl.type)}`);
 		}
 	}
 
+	genNamedTypeClass(name, methodDecls) {
+		const namedType = this.checker?.types.get(name);
+		const underlying = namedType?.underlying;
+		let field, ctorDefault;
+		if (underlying?.kind === "func") {
+			field = "_fn";
+			ctorDefault = "null";
+		} else if (underlying?.kind === "map") {
+			field = "_map";
+			ctorDefault = "{}";
+		} else {
+			field = "_items";
+			ctorDefault = "[]";
+		}
+		this.line(`class ${name} {`);
+		this.indented(() => {
+			this.line(
+				`constructor(${field} = ${ctorDefault}) { this.${field} = ${field}; }`,
+			);
+			for (const m of methodDecls) {
+				this.blank();
+				this.genMethod(m, field);
+			}
+		});
+		this.line("}");
+	}
+
 	genStruct(name, structTypeAst, methodDecls) {
 		const fields = [];
 		if (this.checker) {
@@ -303,23 +358,45 @@ export class CodeGen {
 		this.line("}");
 	}
 
-	genMethod(decl) {
+	genMethod(decl, recvField = null) {
 		const params = decl.params.map((p) => p.name).join(", ");
 		const asyncPrefix = decl.async ? "async " : "";
 		this.line(`${asyncPrefix}${decl.name}(${params}) {`);
 		const prevBoxed = this._boxedVars;
 		this._boxedVars = new Set();
 		this._scanAddressTaken(decl.body);
+		const prevUnwrapped = this._unwrappedRecv;
 		this.indented(() => {
 			if (decl.recvName && decl.recvName !== "_") {
-				this.line(`const ${decl.recvName} = this;`);
+				if (recvField) {
+					this.line(`const ${decl.recvName} = this.${recvField};`);
+					this._unwrappedRecv = decl.recvName;
+				} else {
+					this.line(`const ${decl.recvName} = this;`);
+				}
 			}
 			this._withNamedReturns(decl, () => this._genBody(decl.body));
 		});
+		this._unwrappedRecv = prevUnwrapped;
 		this._boxedVars = prevBoxed;
 		this.line("}");
 	}
 
+	// Returns the wrapper field name ("_fn", "_items", "_map") if `type` is a named
+	// non-struct type emitted as a wrapper class, or null otherwise.
+	// Pass `expr` so we can skip unwrapping when the expression is the method receiver
+	// (which was already unwrapped to `this.<field>` at the top of the method body).
+	_namedWrapperField(type, expr = null) {
+		if (type?.kind !== "named") return null;
+		if (!this.namedWrapperNames.has(type.name)) return null;
+		if (expr?.kind === "Ident" && expr.name === this._unwrappedRecv)
+			return null;
+		const u = type.underlying;
+		if (u?.kind === "func") return "_fn";
+		if (u?.kind === "map") return "_map";
+		return "_items";
+	}
+
 	// ── Function declarations ────────────────────────────────────
 
 	genFuncDecl(decl, nameOverride) {

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/parser.js

@@ -308,16 +308,6 @@ export class Parser {
 		return this.looksLikeType(next) || next.type === T.ELLIPSIS;
 	}
 
-	// Heuristic: peek2 is a param-name separator if it's a comma, rparen, or a type token
-	isParamType(tok) {
-		if (!tok) return false;
-		// T.RPAREN is intentionally excluded: when peek2 is ")", the current IDENT
-		// is the type of an unnamed param (e.g. func(int)), not a param name.
-		return (
-			tok.type === T.COMMA || tok.type === T.ELLIPSIS || this.looksLikeType(tok)
-		);
-	}
-
 	looksLikeType(tok) {
 		return (
 			tok.type === T.LBRACKET ||