gofront 0.0.4 → 0.0.6

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

@@ -1,5 +1,7 @@
 // CodeGen statement methods — installed as a mixin on CodeGen.prototype.
 
+import { isComplex } from "../typechecker/types.js";
+
 export const statementGenMethods = {
 	genBlock(block) {
 		for (const stmt of block.stmts) this.genStmt(stmt);
@@ -45,10 +47,16 @@ export const statementGenMethods = {
 				const redecls = stmt.lhs.map((e) => !!e._redecl);
 				const anyRedecl = redecls.some((r) => r);
 				if (lhs.length === 1) {
+					const isBoxed = this._boxedVars.has(lhs[0]);
+					const val = isBoxed && !redecls[0] ? `{ value: ${rhs[0]} }` : rhs[0];
 					if (redecls[0]) {
-						this.line(`${lhs[0]} = ${rhs[0]};`);
+						if (isBoxed) {
+							this.line(`${lhs[0]}.value = ${rhs[0]};`);
+						} else {
+							this.line(`${lhs[0]} = ${val};`);
+						}
 					} else {
-						this.line(`let ${lhs[0]} = ${rhs[0]};`);
+						this.line(`let ${lhs[0]} = ${val};`);
 					}
 				} else if (!anyRedecl) {
 					// All new: let [a, b] = ...
@@ -75,6 +83,38 @@ export const statementGenMethods = {
 			}
 
 			case "AssignStmt": {
+				// Complex compound assignment: z += w → z = z + w (with complex codegen)
+				if (
+					stmt.op !== "=" &&
+					stmt.lhs.length === 1 &&
+					stmt.rhs.length === 1 &&
+					isComplex(stmt.lhs[0]._type)
+				) {
+					const lhsStr = stmt.lhs[0].name ?? this.genExpr(stmt.lhs[0]);
+					const rhsExpr = this._genComplexOperand(stmt.rhs[0]);
+					const baseOp = stmt.op.slice(0, -1); // "+=" → "+"
+					let result;
+					switch (baseOp) {
+						case "+":
+							result = `{ re: ${lhsStr}.re + ${rhsExpr}.re, im: ${lhsStr}.im + ${rhsExpr}.im }`;
+							break;
+						case "-":
+							result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
+							break;
+						case "*":
+							this._usesCmul = true;
+							result = `__cmul(${lhsStr}, ${rhsExpr})`;
+							break;
+						case "/":
+							this._usesCdiv = true;
+							result = `__cdiv(${lhsStr}, ${rhsExpr})`;
+							break;
+						default:
+							result = rhsExpr;
+					}
+					this.line(`${lhsStr} = ${result};`);
+					break;
+				}
 				// comma-ok map index: v, ok = m["key"]
 				if (stmt._commaOkMap) {
 					const rhsNode = stmt.rhs[0];
@@ -113,7 +153,15 @@ export const statementGenMethods = {
 				}
 				const rhs = stmt.rhs.map((e) => this.genExpr(e));
 				for (const e of stmt.lhs) if (e.kind === "IndexExpr") e._lvalue = true;
-				const lhs = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
+				const lhs = stmt.lhs.map((e) => {
+					if (
+						e.kind === "Ident" &&
+						e.name !== "_" &&
+						this._boxedVars.has(e.name)
+					)
+						return `${e.name}.value`;
+					return e.name ?? this.genExpr(e);
+				});
 				// Filter out blank identifier assignments entirely
 				const pairs = lhs.map((l, i) => ({ l, r: rhs[i] ?? rhs[0] }));
 				const active = pairs.filter((p) => p.l !== "_");
@@ -151,6 +199,21 @@ export const statementGenMethods = {
 				break;
 
 			case "ReturnStmt": {
+				if (this._inIteratorBody) {
+					if (stmt.values.length === 0 && !this.namedReturnVars?.length) {
+						this.line(`${this._iterReturnFlag} = true; return false;`);
+					} else {
+						const vals =
+							stmt.values.length > 0
+								? stmt.values.map((v) => this.genExpr(v))
+								: (this.namedReturnVars ?? []);
+						const stored = vals.length === 1 ? vals[0] : `[${vals.join(", ")}]`;
+						this.line(
+							`${this._iterReturnFlag} = true; ${this._iterReturnVar} = ${stored}; return false;`,
+						);
+					}
+					break;
+				}
 				if (stmt.values.length === 0) {
 					// bare return — emit named return vars if present
 					if (this.namedReturnVars?.length > 0) {
@@ -210,6 +273,16 @@ export const statementGenMethods = {
 				break;
 
 			case "BranchStmt":
+				if (this._inIteratorBody && !stmt.label) {
+					if (stmt.keyword === "break") {
+						this.line(`${this._iterBreakFlag} = true; return false;`);
+						break;
+					}
+					if (stmt.keyword === "continue") {
+						this.line("return true;");
+						break;
+					}
+				}
 				if (stmt.keyword !== "fallthrough")
 					this.line(
 						stmt.label ? `${stmt.keyword} ${stmt.label};` : `${stmt.keyword};`,
@@ -255,14 +328,22 @@ export const statementGenMethods = {
 	},
 
 	genFor(stmt) {
-		// Detect range: init is DefineStmt with rhs[0] being a RangeExpr
+		// Detect range: init is DefineStmt/AssignStmt with rhs[0] being a RangeExpr
 		if (this.isRangeFor(stmt)) {
-			this.genRangeFor(stmt);
+			if (stmt.init.rhs[0]._isIterator) {
+				this.genIteratorFor(stmt);
+			} else {
+				this.genRangeFor(stmt);
+			}
 			return;
 		}
 
-		// for range N { } — no variable, just repeat N times
+		// for range expr — no variable; could be int range or 0-param iterator
 		if (stmt.cond?.kind === "RangeExpr") {
+			if (stmt.cond._isIterator) {
+				this.genIteratorForCond(stmt);
+				return;
+			}
 			const iteree = this.genExpr(stmt.cond.expr);
 			this.line(`for (let _$ = 0; _$ < ${iteree}; _$++) {`);
 			this.indented(() => this.genBlock(stmt.body));
@@ -361,6 +442,112 @@ export const statementGenMethods = {
 		this.line("}");
 	},
 
+	genIteratorFor(stmt) {
+		const range = stmt.init.rhs[0];
+		const lhs = stmt.init.lhs.map((e) => e.name ?? this.genExpr(e));
+		let iteree = this.genExpr(range.expr);
+		const yieldParams = range._yieldParams;
+
+		// Wrap bare function expressions to avoid "Function statements require a name"
+		if (range.expr.kind === "FuncLit") {
+			iteree = `(${iteree})`;
+		}
+
+		const d = this._iterDepth++;
+		const breakFlag = `__broke${d}`;
+		const retFlag = `__returned${d}`;
+		const retVar = `__retVal${d}`;
+
+		// Yield callback param names (blank vars get _$N to avoid JS syntax error)
+		const cbParams = lhs.map((n, i) => (n === "_" ? `_$${i}` : n));
+
+		this.line("{");
+		this.indented(() => {
+			this.line(`let ${breakFlag} = false;`);
+			this.line(`let ${retFlag} = false;`);
+			this.line(`let ${retVar};`);
+
+			const params = yieldParams.length === 0 ? "" : cbParams.join(", ");
+			this.line(`${iteree}(function(${params}) {`);
+			this.indented(() => {
+				this.line(`if (${breakFlag}) return false;`);
+				const prev = {
+					in: this._inIteratorBody,
+					break: this._iterBreakFlag,
+					ret: this._iterReturnFlag,
+					retVar: this._iterReturnVar,
+				};
+				this._inIteratorBody = true;
+				this._iterBreakFlag = breakFlag;
+				this._iterReturnFlag = retFlag;
+				this._iterReturnVar = retVar;
+
+				this.genBlock(stmt.body);
+
+				this._inIteratorBody = prev.in;
+				this._iterBreakFlag = prev.break;
+				this._iterReturnFlag = prev.ret;
+				this._iterReturnVar = prev.retVar;
+
+				this.line("return true;");
+			});
+			this.line("});");
+			this.line(`if (${retFlag}) return ${retVar};`);
+		});
+		this.line("}");
+		this._iterDepth--;
+	},
+
+	// 0-param iterator: for range iter { body }
+	genIteratorForCond(stmt) {
+		const range = stmt.cond;
+		let iteree = this.genExpr(range.expr);
+
+		if (range.expr.kind === "FuncLit") {
+			iteree = `(${iteree})`;
+		}
+
+		const d = this._iterDepth++;
+		const breakFlag = `__broke${d}`;
+		const retFlag = `__returned${d}`;
+		const retVar = `__retVal${d}`;
+
+		this.line("{");
+		this.indented(() => {
+			this.line(`let ${breakFlag} = false;`);
+			this.line(`let ${retFlag} = false;`);
+			this.line(`let ${retVar};`);
+
+			this.line(`${iteree}(function() {`);
+			this.indented(() => {
+				this.line(`if (${breakFlag}) return false;`);
+				const prev = {
+					in: this._inIteratorBody,
+					break: this._iterBreakFlag,
+					ret: this._iterReturnFlag,
+					retVar: this._iterReturnVar,
+				};
+				this._inIteratorBody = true;
+				this._iterBreakFlag = breakFlag;
+				this._iterReturnFlag = retFlag;
+				this._iterReturnVar = retVar;
+
+				this.genBlock(stmt.body);
+
+				this._inIteratorBody = prev.in;
+				this._iterBreakFlag = prev.break;
+				this._iterReturnFlag = prev.ret;
+				this._iterReturnVar = prev.retVar;
+
+				this.line("return true;");
+			});
+			this.line("});");
+			this.line(`if (${retFlag}) return ${retVar};`);
+		});
+		this.line("}");
+		this._iterDepth--;
+	},
+
 	// Inline a statement as a for-init/post string (no semicolon)
 	stmtInline(stmt) {
 		switch (stmt.kind) {

package/src/codegen.js

@@ -20,6 +20,7 @@
 import { expressionGenMethods } from "./codegen/expressions.js";
 import { buildSourceMap } from "./codegen/source-map.js";
 import { statementGenMethods } from "./codegen/statements.js";
+import { isComplex, isNumeric } from "./typechecker/types.js";
 
 export class CodeGen {
 	// jsImports:       Map<importPath, string[]> — npm package imports to emit at top of file
@@ -37,13 +38,25 @@ 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;
 		this._usesAppend = false;
 		this._usesSliceGuard = false;
 		this._usesSprintf = false;
 		this._usesEqual = false;
+		this._usesCmul = false;
+		this._usesCdiv = false;
+		this._usesError = false;
+		this._usesErrorIs = false;
+		// Iterator (range-over-func) context
+		this._inIteratorBody = false;
+		this._iterDepth = 0;
+		this._iterBreakFlag = null;
+		this._iterReturnFlag = null;
+		this._iterReturnVar = null;
 	}
 
 	// ── Output helpers ───────────────────────────────────────────
@@ -55,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);
 	}
@@ -97,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();
 			}
@@ -104,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();
 			}
@@ -118,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);
@@ -140,21 +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(
+				"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(
+				"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]*)[sdvftxXqobeEgG%]/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]*)/)||[];",
@@ -162,7 +190,7 @@ export class CodeGen {
 					"switch(verb){",
 					"case's':return pad(String(v==null?'<nil>':v),width,false);",
 					"case'd':return pad(String(Math.trunc(Number(v))),width,zero);",
-					"case'v':return pad(String(v==null?'<nil>':v),width,false);",
+					"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);}return pad(String(v==null?'<nil>':v),width,false);}",
 					"case'f':{const n=Number(v),p=prec!==''?parseInt(prec):6;return pad(n.toFixed(p),width,zero);}",
 					"case't':return pad(String(!!v),width,false);",
 					"case'x':return pad((Number(v)>>>0).toString(16),width,zero);",
@@ -172,10 +200,19 @@ export class CodeGen {
 					"case'q':return pad('\"'+String(v==null?'':v).replace(/\\\\/g,'\\\\\\\\').replace(/\"/g,'\\\\\"')+'\"',width,false);",
 					"case'e':case'E':{const n=Number(v),p=prec!==''?parseInt(prec):6;return pad(n.toExponential(p),width,zero);}",
 					"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(
+				"var __error = __error || function(msg, cause) { return { Error() { return msg; }, toString() { return msg; }, _msg: msg, _cause: cause ?? null }; };",
+			);
+		if (this._usesErrorIs)
+			helpers.push(
+				'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, "");
 
@@ -185,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 ────────────────────────────────────────
@@ -278,12 +321,16 @@ export class CodeGen {
 		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);
 		this.indented(() => {
 			if (decl.recvName && decl.recvName !== "_") {
 				this.line(`const ${decl.recvName} = this;`);
 			}
 			this._withNamedReturns(decl, () => this._genBody(decl.body));
 		});
+		this._boxedVars = prevBoxed;
 		this.line("}");
 	}
 
@@ -302,9 +349,13 @@ export class CodeGen {
 			`${asyncPrefix}function ${name}(${params}) {`,
 			srcLine ? srcLine - 1 : null,
 		);
+		const prevBoxed = this._boxedVars;
+		this._boxedVars = new Set();
+		this._scanAddressTaken(decl.body);
 		this.indented(() =>
 			this._withNamedReturns(decl, () => this._genBody(decl.body)),
 		);
+		this._boxedVars = prevBoxed;
 		this.line("}");
 	}
 
@@ -357,12 +408,61 @@ export class CodeGen {
 		}
 	}
 
+	// Scan AST node for _addressTaken idents on scalars and populate _boxedVars.
+	_scanAddressTaken(node) {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const child of node) this._scanAddressTaken(child);
+			return;
+		}
+		// &x — the operand ident will have _addressTaken set by typechecker
+		if (node.kind === "Ident" && node._addressTaken) {
+			// Check if the type is a scalar (needs boxing) vs reference type (no boxing)
+			const t = node._type;
+			if (t && !this._isReferenceType(t)) {
+				this._boxedVars.add(node.name);
+			}
+		}
+		// Recurse into FuncLit too — closures may take address of outer vars
+		for (const key of Object.keys(node)) {
+			if (key.startsWith("_")) continue;
+			this._scanAddressTaken(node[key]);
+		}
+	}
+
+	_isReferenceType(t) {
+		if (!t) return false;
+		const base = t.kind === "named" ? t.underlying : t;
+		return (
+			base?.kind === "struct" ||
+			base?.kind === "slice" ||
+			base?.kind === "map" ||
+			base?.kind === "func" ||
+			base?.kind === "interface"
+		);
+	}
+
 	// ── Variable / const declarations ────────────────────────────
 
 	genVarDecl(decl) {
 		for (const spec of decl.decls) {
 			if (spec.value) {
-				const vals = spec.value.map((v) => this.genExpr(v));
+				const vals = spec.value.map((v) => {
+					const js = this.genExpr(v);
+					// Wrap numeric values assigned to complex-typed vars
+					if (
+						spec.type?.name === "complex128" ||
+						spec.type?.name === "complex64"
+					) {
+						if (
+							!isComplex(v._type) &&
+							(isNumeric(v._type) || v._type?.kind === "untyped")
+						) {
+							return `{ re: ${js}, im: 0 }`;
+						}
+					}
+					return js;
+				});
 				if (spec.names.length === 1) {
 					this.line(`let ${spec.names[0]} = ${vals[0]};`);
 				} else {

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

@@ -74,7 +74,7 @@ export class DtsParser {
 				this.pos += 2;
 				while (!this.eof() && !(this.ch() === "*" && this.ch1() === "/"))
 					this.pos++;
-				this.pos += 2;
+				if (!this.eof()) this.pos += 2;
 				continue;
 			}
 			break;