gofront 1.5.1 → 1.6.1

package/src/index.js

@@ -13,18 +13,14 @@
 //   gofront <file.go> --tokens     — dump tokens of first file (debug)
 //   gofront init [dir]             — scaffold a new GoFront project
 
-import { createRequire } from "node:module";
-
-const _require = createRequire(import.meta.url);
-const { version } = _require("../package.json");
-
-import { statSync, watch } from "node:fs";
+import { statSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { copyAssets } from "./asset-manager.js";
 import {
 	formatBuildSummary,
 	formatPrepSummary,
 	formatWrittenDesc,
+	GOFRONT_VERSION,
 	handleBuild,
 	handleCheck,
 	handleDev,
@@ -35,30 +31,30 @@ import {
 	parseBuildArgs,
 	parseCheckArgs,
 	parseDevArgs,
+	parseLegacyArgs,
 	parsePrepArgs,
 	parseTestArgs,
 	runCompile,
 	writeCompileOutput,
 } from "./cli-core.js";
 import { colors, formatDiagnostic, log, ms, stamp } from "./colors.js";
-import { createDevServer } from "./dev-server.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
 
 const args = process.argv.slice(2);
 if (args[0] === "--version" || args[0] === "-v") {
-	console.log(`gofront ${version}`);
+	console.log(`gofront ${GOFRONT_VERSION}`);
 	process.exit(0);
 }
 
 if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
 	console.log(
 		`
-GoFront — a Go-inspired language that compiles to JavaScript
+GoFront — a Go-inspired language that compiles to JavaScript and WebAssembly
 
 Usage:
   gofront dev [dir] [options]    Start dev server with live reload (default port 3000)
-  gofront build [dir] [options]  Build production bundle (-o <dir>, --pwa, --minify, --emit-wat)
+  gofront build [dir] [options]  Build production bundle (-o <dir>, --pwa, --minify, --emit-wat, --release, --wasm-opt, --js-only)
   gofront check [dir|dir/...]    Type-check only (dir/... recurses into every package)
   gofront test [dir|dir/...] [--dom]  Run unit tests (-v verbose, -run <regex>)
   gofront prep [dir] [--minify]  Copy static assets and bundle vendor dependencies
@@ -66,6 +62,8 @@ Usage:
   gofront <file.go>              Compile single file and print to stdout
   gofront <dir>  (or gofront .)  Compile all *.go in directory as one bundle
   gofront <input> -o out.js      Compile and write to file (wasm packages also emit app.wasm)
+  gofront <input> --release      Production build with minification and Binaryen wasm optimization
+  gofront <input> --wasm-opt     Optimize wasm output with Binaryen (-O3 + GUFA)
   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)
@@ -131,9 +129,9 @@ if (args[0] === "test") {
 // ── check subcommand ──────────────────────────────────────────
 
 if (args[0] === "check") {
-	const { targetDir } = parseCheckArgs(args.slice(1));
+	const { targetDir, forceTarget } = parseCheckArgs(args.slice(1));
 	try {
-		const { elapsedMs, packages } = handleCheck(targetDir);
+		const { elapsedMs, packages } = handleCheck(targetDir, { forceTarget });
 		const okLine = (label, t) =>
 			log.info(`${colors.cyan(label)} — ${colors.green("OK")} ${ms(t)}`);
 		if (packages) {
@@ -202,20 +200,22 @@ if (args[0] === "dev") {
 	}
 }
 
-const inputArg = args[0];
-const outputFlag = args.indexOf("-o");
-const outputFile = outputFlag !== -1 ? args[outputFlag + 1] : null;
-const checkOnly = args.includes("--check");
-const dumpAst = args.includes("--ast");
-const dumpTokens = args.includes("--tokens");
-const sourceMap = args.includes("--source-map");
-const serveMode = args.includes("--serve");
-const watchMode = args.includes("--watch") || serveMode;
-const copyAssetsFlag = args.includes("--copy-assets");
-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;
+const {
+	inputArg,
+	outputFile,
+	checkOnly,
+	dumpAst,
+	dumpTokens,
+	sourceMap,
+	serve: serveMode,
+	watch: watchMode,
+	copyAssets: copyAssetsFlag,
+	wasmOpt,
+	minify: minifyOutput,
+	mangle: mangleOutput,
+	port: servePort,
+	forceTarget,
+} = parseLegacyArgs(args);
 
 // ── Determine input mode ─────────────────────────────────────
 
@@ -228,6 +228,17 @@ try {
 	process.exit(1);
 }
 
+function copyProjectAssets(verbose) {
+	try {
+		const { copied, skipped } = copyAssets(resolve("."));
+		if (verbose && (copied > 0 || skipped > 0)) {
+			log.info(`copied ${copied} assets (${skipped} skipped)`);
+		}
+	} catch (e) {
+		log.warn(`asset copy failed: ${e.message}`);
+	}
+}
+
 // ── Single-shot mode ─────────────────────────────────────────
 
 if (!watchMode) {
@@ -239,6 +250,8 @@ if (!watchMode) {
 			outputFile,
 			dumpTokens,
 			dumpAst,
+			wasmOpt,
+			forceTarget,
 		});
 	} catch (e) {
 		log.fail(e.message);
@@ -282,6 +295,13 @@ if (!watchMode) {
 			log.info(
 				`wrote ${formatWrittenDesc(written, outputFile)} ${ms(elapsedMs)}`,
 			);
+			if (result.wasmOptInfo && result.wasmOptInfo.originalSize > 0) {
+				const origKb = (result.wasmOptInfo.originalSize / 1024).toFixed(1);
+				const optKb = (result.wasmOptInfo.optimizedSize / 1024).toFixed(1);
+				log.info(
+					`wasm-opt: app.wasm ${origKb} kB → ${optKb} kB (-${result.wasmOptInfo.percentSaved}%) [${result.wasmOptInfo.engine}]`,
+				);
+			}
 		} catch (e) {
 			log.fail(`cannot write '${outputFile}': ${e.message}`);
 			process.exit(1);
@@ -295,110 +315,57 @@ if (!watchMode) {
 		}
 	}
 
-	if (copyAssetsFlag) {
-		try {
-			const projectDir = resolve(".");
-			const { copied, skipped } = copyAssets(projectDir);
-			if (copied > 0 || skipped > 0) {
-				log.info(`copied ${copied} assets (${skipped} skipped)`);
-			}
-		} catch (e) {
-			log.warn(`asset copy failed: ${e.message}`);
-		}
-	}
+	if (copyAssetsFlag) copyProjectAssets(true);
 
 	process.exit(0);
 }
 
 // ── Watch mode ───────────────────────────────────────────────
 
-// Start dev server before first build so the browser can connect immediately
-let devServer = null;
-if (serveMode) {
-	if (!outputFile) {
-		log.fail("--serve requires -o <output file>");
-		process.exit(1);
-	}
-	const serveDir = dirname(resolve(outputFile));
-	devServer = createDevServer(serveDir, servePort);
+if (serveMode && !outputFile) {
+	log.fail("--serve requires -o <output file>");
+	process.exit(1);
 }
 
-function buildOnce(changedFile = null) {
-	try {
-		const startMs = performance.now();
-		const result = runCompile(inputPath, isDir, { sourceMap, outputFile });
-		const js = maybeMinify(result.js, {
-			minify: minifyOutput,
-			mangle: mangleOutput,
-			sourceMap,
-		});
-		const elapsedMs = (performance.now() - startMs).toFixed(0);
-		const changeNote = changedFile ? ` — ${changedFile} changed` : "";
-		const timing = colors.dim(`(${elapsedMs}ms${changeNote})`);
-		if (outputFile) {
-			const written = writeCompileOutput(resolve(outputFile), result, js);
-			console.error(
-				`${stamp()} ${colors.bold("gofront:")} ${colors.green("OK")} — wrote ${formatWrittenDesc(written, outputFile)} ${timing}`,
-			);
-		} else {
-			// Clear screen then print
-			process.stdout.write("\x1Bc");
-			console.log(js);
-			console.error(
-				`${stamp()} ${colors.bold("gofront:")} ${colors.green("OK")} ${timing}`,
-			);
-		}
+const prefix = () => `${stamp()} ${colors.bold("gofront:")}`;
 
-		if (copyAssetsFlag) {
-			try {
-				copyAssets(resolve("."));
-			} catch (e) {
-				log.warn(`asset copy failed: ${e.message}`);
+try {
+	await handleDev(".", {
+		srcDir: inputPath,
+		outputFile,
+		serve: serveMode,
+		serveDir: outputFile ? dirname(resolve(outputFile)) : undefined,
+		port: servePort,
+		silent: false,
+		sourceMap,
+		minify: minifyOutput,
+		mangle: mangleOutput,
+		copyAssets: copyAssetsFlag,
+		forceTarget,
+		onBuild: ({ js, written, elapsedMs, changedFile }) => {
+			const changeNote = changedFile ? ` — ${changedFile} changed` : "";
+			const timing = colors.dim(`(${elapsedMs}ms${changeNote})`);
+			if (outputFile) {
+				console.error(
+					`${prefix()} ${colors.green("OK")} — wrote ${formatWrittenDesc(written, outputFile)} ${timing}`,
+				);
+			} else {
+				// Clear screen then print
+				process.stdout.write("\x1Bc");
+				console.log(js);
+				console.error(`${prefix()} ${colors.green("OK")} ${timing}`);
 			}
-		}
-
-		devServer?.notify();
-	} catch (e) {
-		console.error(
-			`${stamp()} ${colors.bold("gofront:")} ${colors.bold(colors.red("ERROR"))}`,
-		);
-		for (const line of formatDiagnostic(e.message).split("\n"))
-			console.error(`  ${line}`);
-		devServer?.notifyError?.(e);
-	}
-}
-
-// Initial build
-buildOnce();
-
-// Determine what to watch
-const watchTarget = isDir ? inputPath : dirname(inputPath);
-
-function handleCssWatch(filename) {
-	if (copyAssetsFlag) {
-		try {
-			copyAssets(resolve("."));
-		} catch (e) {
-			log.warn(`asset copy failed: ${e.message}`);
-		}
-	}
-	devServer?.notifyCss?.(filename);
+			if (copyAssetsFlag) copyProjectAssets(false);
+		},
+		onError: (e) => {
+			console.error(`${prefix()} ${colors.bold(colors.red("ERROR"))}`);
+			for (const line of formatDiagnostic(e.message).split("\n"))
+				console.error(`  ${line}`);
+		},
+	});
+} catch (e) {
+	log.fail(e.message);
+	process.exit(1);
 }
 
-let debounce = null;
-let cssDebounce = null;
-watch(watchTarget, { recursive: true }, (_event, filename) => {
-	if (!filename) return;
-	if (filename.endsWith(".css")) {
-		clearTimeout(cssDebounce);
-		cssDebounce = setTimeout(() => handleCssWatch(filename), 50);
-		return;
-	}
-	if (!filename.endsWith(".go") && !filename.endsWith(".templ")) return;
-	clearTimeout(debounce);
-	debounce = setTimeout(() => buildOnce(filename), 80);
-});
-
-console.error(
-	`${stamp()} ${colors.bold("gofront:")} watching ${colors.cyan(inputArg)} ...`,
-);
+console.error(`${prefix()} watching ${colors.cyan(inputArg)} ...`);

package/src/lexer.js

@@ -203,11 +203,25 @@ export class Lexer {
 		const l = this.line,
 			c = this.col;
 		this.advance(); // opening "
-		const parts = [];
-		while (this.pos < this.src.length && this.peek() !== '"') {
-			if (this.peek() === "\n") this.err("Unterminated string literal");
-			if (this.peek() === "\\") {
-				this.advance();
+		let start = this.pos;
+		let parts = null;
+		while (this.pos < this.src.length) {
+			const ch = this.src[this.pos];
+			if (ch === '"') {
+				if (parts === null) {
+					const str = this.src.slice(start, this.pos);
+					this.advance(); // closing "
+					return str;
+				}
+				parts.push(this.src.slice(start, this.pos));
+				this.advance(); // closing "
+				return parts.join("");
+			}
+			if (ch === "\n") this.err("Unterminated string literal");
+			if (ch === "\\") {
+				if (parts === null) parts = [];
+				if (this.pos > start) parts.push(this.src.slice(start, this.pos));
+				this.advance(); // skip \
 				const esc = this.advance();
 				switch (esc) {
 					case "n":
@@ -231,14 +245,12 @@ export class Lexer {
 					default:
 						parts.push(`\\${esc}`);
 				}
+				start = this.pos;
 			} else {
-				parts.push(this.advance());
+				this.advance();
 			}
 		}
-		if (this.pos >= this.src.length)
-			throw new LexError("Unterminated string", l, c, this.filename, this.src);
-		this.advance(); // closing "
-		return parts.join("");
+		throw new LexError("Unterminated string", l, c, this.filename, this.src);
 	}
 
 	readRawString() {
@@ -383,39 +395,78 @@ export class Lexer {
 	_readDecimalExponent(n) {
 		n += this.advance(); // consume e/E
 		if (this.peek() === "+" || this.peek() === "-") n += this.advance();
-		while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
-			const ch = this.advance();
-			if (ch !== "_") n += ch;
+		while (this.pos < this.src.length) {
+			const c = this.src.charCodeAt(this.pos);
+			if (c >= 48 && c <= 57) {
+				n += this.advance();
+			} else if (c === 95) {
+				this.advance();
+			} else {
+				break;
+			}
 		}
 		return n;
 	}
 
 	_readDecimalNumber(n) {
 		let isFloat = false;
-		while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
-			const ch = this.advance();
-			if (ch !== "_") n += ch;
+		while (this.pos < this.src.length) {
+			const c = this.src.charCodeAt(this.pos);
+			if (c >= 48 && c <= 57) {
+				n += this.advance();
+			} else if (c === 95) {
+				this.advance(); // skip _
+			} else {
+				break;
+			}
 		}
-		if (this.peek() === "." && /[0-9]/.test(this.peek(1))) {
-			isFloat = true;
-			n += this.advance();
-			while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
-				const ch = this.advance();
-				if (ch !== "_") n += ch;
+		if (
+			this.pos + 1 < this.src.length &&
+			this.src.charCodeAt(this.pos) === 46
+		) {
+			const next = this.src.charCodeAt(this.pos + 1);
+			if (next >= 48 && next <= 57) {
+				isFloat = true;
+				n += this.advance();
+				while (this.pos < this.src.length) {
+					const c = this.src.charCodeAt(this.pos);
+					if (c >= 48 && c <= 57) {
+						n += this.advance();
+					} else if (c === 95) {
+						this.advance(); // skip _
+					} else {
+						break;
+					}
+				}
 			}
 		}
-		if (this.peek() === "e" || this.peek() === "E") {
-			isFloat = true;
-			n = this._readDecimalExponent(n);
+		if (this.pos < this.src.length) {
+			const c = this.src.charCodeAt(this.pos);
+			if (c === 101 || c === 69) {
+				isFloat = true;
+				n = this._readDecimalExponent(n);
+			}
 		}
 		return { n, isFloat };
 	}
 
 	readIdent() {
-		let s = "";
-		while (this.pos < this.src.length && /[a-zA-Z0-9_]/.test(this.peek()))
-			s += this.advance();
-		return s;
+		const start = this.pos;
+		while (this.pos < this.src.length) {
+			const code = this.src.charCodeAt(this.pos);
+			if (
+				(code >= 97 && code <= 122) ||
+				(code >= 65 && code <= 90) ||
+				(code >= 48 && code <= 57) ||
+				code === 95
+			) {
+				this.pos++;
+			} else {
+				break;
+			}
+		}
+		this.col += this.pos - start;
+		return this.src.slice(start, this.pos);
 	}
 
 	// ── Semicolon insertion ──────────────────────────────────────

package/src/lower/boxing.js

@@ -1,6 +1,8 @@
 // src/lower/boxing.js
 // Identifies address-taken scalar variables that require heap boxing ({ value: x }).
 
+import { forEachChild } from "./walk.js";
+
 export function isReferenceType(t) {
 	if (!t) return false;
 	const base = t.kind === "named" ? t.underlying : t;
@@ -8,8 +10,7 @@ export function isReferenceType(t) {
 		base?.kind === "struct" ||
 		base?.kind === "slice" ||
 		base?.kind === "map" ||
-		base?.kind === "func" ||
-		base?.kind === "interface"
+		base?.kind === "func"
 	);
 }
 
@@ -28,9 +29,6 @@ export function scanAddressTaken(node, boxedVars = new Set()) {
 		}
 	}
 	// Recurse into FuncLit too — closures may take address of outer vars
-	for (const key of Object.keys(node)) {
-		if (key.startsWith("_")) continue;
-		scanAddressTaken(node[key], boxedVars);
-	}
+	forEachChild(node, (child) => scanAddressTaken(child, boxedVars));
 	return boxedVars;
 }

package/src/lower/captures.js

@@ -2,7 +2,8 @@
 // Identifies free variables captured by closures and determines which ones
 // are mutated and thus require heap-allocated environment cells for WASM closures.
 
-import { collectMutatedVars, nodeMutatesVar } from "./ownership.js";
+import { collectMutatedVars } from "./ownership.js";
+import { forEachChild } from "./walk.js";
 
 /**
  * Result of capture analysis on a function or closure.
@@ -41,17 +42,14 @@ export function collectDeclaredNames(node, names = new Set()) {
 	// Do not descend into nested functions when collecting local declarations
 	if (node.kind === "FuncLit") return names;
 
-	for (const key of Object.keys(node)) {
-		if (key.startsWith("_")) continue;
-		collectDeclaredNames(node[key], names);
-	}
+	forEachChild(node, (child) => collectDeclaredNames(child, names));
 	return names;
 }
 
 /**
  * Finds all identifier references in a node that are not shadowed by inner declarations.
  */
-export function collectReferencedNames(node, localDecls, refs = new Set()) {
+function collectReferencedNames(node, localDecls, refs = new Set()) {
 	if (!node || typeof node !== "object") return refs;
 	if (Array.isArray(node)) {
 		for (const item of node) collectReferencedNames(item, localDecls, refs);
@@ -73,10 +71,9 @@ export function collectReferencedNames(node, localDecls, refs = new Set()) {
 			if (r.name && r.name !== "_") innerLocals.add(r.name);
 		}
 		collectDeclaredNames(node.body, innerLocals);
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			collectReferencedNames(node[key], innerLocals, refs);
-		}
+		forEachChild(node, (child) =>
+			collectReferencedNames(child, innerLocals, refs),
+		);
 		return refs;
 	}
 
@@ -89,10 +86,9 @@ export function collectReferencedNames(node, localDecls, refs = new Set()) {
 	}
 
 	// For nested closures, free variables are also referenced
-	for (const key of Object.keys(node)) {
-		if (key.startsWith("_")) continue;
-		collectReferencedNames(node[key], localDecls, refs);
-	}
+	forEachChild(node, (child) =>
+		collectReferencedNames(child, localDecls, refs),
+	);
 	return refs;
 }
 
@@ -155,11 +151,7 @@ export function analyzeCaptures(fnDecl) {
 			result.capturesByClosure.set(node, captured);
 
 			for (const varName of captured) {
-				if (
-					mutatedVars.has(varName) ||
-					nodeMutatesVar(fnDecl.body, varName) ||
-					nodeMutatesVar(node.body, varName)
-				) {
+				if (mutatedVars.has(varName)) {
 					result.mutatedCaptures.add(varName);
 				}
 			}
@@ -168,10 +160,7 @@ export function analyzeCaptures(fnDecl) {
 			return;
 		}
 
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			walkClosures(node[key], scopeStack);
-		}
+		forEachChild(node, (child) => walkClosures(child, scopeStack));
 	};
 
 	walkClosures(fnDecl.body, [rootScope]);

package/src/lower/escape.js

@@ -6,6 +6,7 @@
 
 import { collectDeclaredNames } from "./captures.js";
 import { rootIdentName } from "./ownership.js";
+import { forEachChild } from "./walk.js";
 
 /**
  * Checks whether an expression evaluates to one of the target pointer variables
@@ -15,7 +16,7 @@ import { rootIdentName } from "./ownership.js";
  * @param {Set<string>} targetNames Set of identifier names being tracked
  * @returns {boolean}
  */
-export function evaluatesToPointer(expr, targetNames) {
+function evaluatesToPointer(expr, targetNames) {
 	if (!expr || typeof expr !== "object") return false;
 	if (expr.kind === "Ident") {
 		return targetNames.has(expr.name);
@@ -144,10 +145,7 @@ export function paramEscapes(body, paramName) {
 					captured = true;
 					return;
 				}
-				for (const k of Object.keys(cNode)) {
-					if (k.startsWith("_")) continue;
-					checkClosure(cNode[k]);
-				}
+				forEachChild(cNode, checkClosure);
 			};
 			checkClosure(node.body);
 			if (captured) {
@@ -158,10 +156,7 @@ export function paramEscapes(body, paramName) {
 			return;
 		}
 
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			walk(node[key]);
-		}
+		forEachChild(node, walk);
 	};
 
 	walk(body);