gofront 1.4.0 → 1.6.0

package/src/dev-server.js

@@ -1,7 +1,7 @@
 // Minimal dev server for gofront --serve watch mode.
 // Serves static files and pushes reload / error / css-update events via SSE.
 
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { createServer } from "node:http";
 import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { colors, log } from "./colors.js";
@@ -9,8 +9,10 @@ import { colors, log } from "./colors.js";
 export const MIME = {
 	".html": "text/html; charset=utf-8",
 	".js": "application/javascript; charset=utf-8",
+	".wasm": "application/wasm",
 	".css": "text/css; charset=utf-8",
 	".json": "application/json; charset=utf-8",
+	".map": "application/json; charset=utf-8",
 	".go": "text/plain; charset=utf-8",
 	".svg": "image/svg+xml",
 	".png": "image/png",
@@ -151,7 +153,11 @@ function handleSseRequest(req, res, clients, lastError = null) {
 	if (lastError)
 		res.write(`event: build-error\ndata: ${JSON.stringify(lastError)}\n\n`);
 	clients.add(res);
-	req.on?.("close", () => clients.delete(res));
+	const cleanup = () => clients.delete(res);
+	req.on?.("close", cleanup);
+	res.on?.("close", cleanup);
+	res.on?.("finish", cleanup);
+	res.on?.("error", cleanup);
 }
 
 function resolveStaticPath(serveDir, urlPath) {
@@ -161,49 +167,73 @@ function resolveStaticPath(serveDir, urlPath) {
 			: urlPath.startsWith("/")
 				? urlPath
 				: `/${urlPath}`;
-	const filePath = resolve(serveDir, `.${cleanPath}`);
-	if (!isInsideDir(resolve(serveDir), filePath)) return { forbidden: true };
+	const rootPath = existsSync(serveDir)
+		? realpathSync(resolve(serveDir))
+		: resolve(serveDir);
+	const filePath = resolve(rootPath, `.${cleanPath}`);
+	if (!isInsideDir(rootPath, filePath)) return { forbidden: true };
 
 	if (existsSync(filePath)) {
-		const stat = statSync(filePath);
+		const realTarget = realpathSync(filePath);
+		if (!isInsideDir(rootPath, realTarget)) return { forbidden: true };
+		const stat = statSync(realTarget);
 		if (stat.isDirectory()) {
-			const dirIndex = join(filePath, "index.html");
-			if (existsSync(dirIndex)) return { filePath: dirIndex };
-			const rootIndex = join(serveDir, "index.html");
-			if (existsSync(rootIndex)) return { filePath: rootIndex };
+			const dirIndex = join(realTarget, "index.html");
+			if (
+				existsSync(dirIndex) &&
+				isInsideDir(rootPath, realpathSync(dirIndex))
+			) {
+				return { filePath: dirIndex };
+			}
+			const rootIndex = join(rootPath, "index.html");
+			if (
+				existsSync(rootIndex) &&
+				isInsideDir(rootPath, realpathSync(rootIndex))
+			) {
+				return { filePath: rootIndex };
+			}
 			return { notFound: true };
 		}
-		return { filePath };
+		return { filePath: realTarget };
 	}
 
 	// SPA fallback: clean paths with no file extension fall back to index.html
 	if (!extname(cleanPath)) {
-		const indexPath = join(serveDir, "index.html");
+		const indexPath = join(rootPath, "index.html");
 		if (existsSync(indexPath)) return { filePath: indexPath };
 	}
 
 	return { notFound: true };
 }
 
-function sendStaticFile(res, filePath, shouldInject) {
+function sendStaticFile(res, filePath, shouldInject, req = null) {
 	try {
 		const ext = extname(filePath);
+		const isHead = req?.method === "HEAD";
 		if (ext === ".html") {
 			const data = readFileSync(filePath, "utf8");
 			const body = shouldInject ? injectLiveReload(data) : data;
 			res.writeHead(200, {
 				"Content-Type": MIME[".html"],
+				"X-Content-Type-Options": "nosniff",
 				"Cache-Control": "no-cache, no-store, must-revalidate",
 			});
-			res.end(body);
+			if (isHead) res.end();
+			else res.end(body);
 			return;
 		}
 
 		const data = readFileSync(filePath);
 		res.writeHead(200, {
 			"Content-Type": MIME[ext] ?? "application/octet-stream",
-			"Cache-Control": "no-cache, no-store, must-revalidate",
+			"X-Content-Type-Options": "nosniff",
+			"Cache-Control":
+				ext === ".wasm" ? "no-store" : "no-cache, no-store, must-revalidate",
 		});
+		if (isHead) {
+			res.end();
+			return;
+		}
 		res.end(data);
 	} catch {
 		res.writeHead(500, { "Content-Type": "text/plain" });
@@ -218,7 +248,18 @@ export function handleDevRequest(
 	clients = new Set(),
 	options = {},
 ) {
+	if (req.method && req.method !== "GET" && req.method !== "HEAD") {
+		res.writeHead(405, { "Content-Type": "text/plain", Allow: "GET, HEAD" });
+		res.end("Method Not Allowed");
+		return;
+	}
+
 	if (req.url === "/_gofront/events") {
+		if (req.method && req.method !== "GET") {
+			res.writeHead(405, { "Content-Type": "text/plain", Allow: "GET" });
+			res.end("Method Not Allowed");
+			return;
+		}
 		handleSseRequest(req, res, clients, options.getLastError?.() ?? null);
 		return;
 	}
@@ -240,7 +281,7 @@ export function handleDevRequest(
 		return;
 	}
 
-	sendStaticFile(res, resolved.filePath, options.injectReload ?? true);
+	sendStaticFile(res, resolved.filePath, options.injectReload ?? true, req);
 }
 
 function broadcastToClients(clients, event, payload) {

package/src/index.js

@@ -18,12 +18,13 @@ import { createRequire } from "node:module";
 const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
-import { mkdirSync, statSync, watch, writeFileSync } 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,
 	handleBuild,
 	handleCheck,
 	handleDev,
@@ -34,12 +35,13 @@ 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 ───────────────────────────────────────────
 
@@ -52,18 +54,20 @@ if (args[0] === "--version" || args[0] === "-v") {
 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)
+  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
   gofront init [dir]             Scaffold a new GoFront project
   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
+  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)
@@ -129,9 +133,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) {
@@ -180,7 +184,7 @@ if (args[0] === "dev") {
 		if (dev.initialError) {
 			log.error(dev.initialError.message);
 		} else {
-			log.ok(`— wrote ${colors.cyan(dev.outputFile)}`);
+			log.ok(`— wrote ${formatWrittenDesc(dev.written, dev.outputFile)}`);
 		}
 		log.info(
 			`dev server running → ${colors.cyan(`http://localhost:${dev.port}`)}`,
@@ -200,20 +204,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 ─────────────────────────────────────
 
@@ -226,6 +232,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) {
@@ -237,6 +254,8 @@ if (!watchMode) {
 			outputFile,
 			dumpTokens,
 			dumpAst,
+			wasmOpt,
+			forceTarget,
 		});
 	} catch (e) {
 		log.fail(e.message);
@@ -276,121 +295,81 @@ if (!watchMode) {
 
 	if (outputFile) {
 		try {
-			mkdirSync(dirname(resolve(outputFile)), { recursive: true });
-			writeFileSync(outputFile, `${js}\n`);
-			log.info(`wrote ${colors.cyan(outputFile)} ${ms(elapsedMs)}`);
+			const written = writeCompileOutput(resolve(outputFile), result, js);
+			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);
 		}
 	} else {
 		console.log(js);
-	}
-
-	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 (result.wasm) {
+			log.warn(
+				"wasm packages were linked but app.wasm needs -o <file> to be written",
+			);
 		}
 	}
 
+	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) {
-			writeFileSync(outputFile, `${js}\n`);
-			console.error(
-				`${stamp()} ${colors.bold("gofront:")} ${colors.green("OK")} — wrote ${colors.cyan(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

@@ -111,6 +111,8 @@ export class Lexer {
 		this.col = 1;
 		this.tokens = [];
 		this.filename = filename;
+		this.target = null;
+		this.targetDirective = null;
 	}
 
 	// ── Primitives ──────────────────────────────────────────────
@@ -150,8 +152,22 @@ export class Lexer {
 			if (ch === " " || ch === "\t" || ch === "\r") {
 				this.advance();
 			} else if (ch === "/" && this.peek(1) === "/") {
+				const start = this.pos;
+				const line = this.line,
+					col = this.col;
 				while (this.pos < this.src.length && this.peek() !== "\n")
 					this.advance();
+				const comment = this.src.slice(start, this.pos);
+				const match = comment.match(/^\/\/gofront:target\s+(\S+)/);
+				if (match) {
+					this.target = match[1];
+					this.targetDirective = {
+						value: match[1],
+						line,
+						col,
+						beforePackage: this.tokens.length === 0,
+					};
+				}
 			} else if (ch === "/" && this.peek(1) === "*") {
 				const startLine = this.line,
 					startCol = this.col;
@@ -472,6 +488,8 @@ export class Lexer {
 
 		if (this.shouldSemi()) this.push(T.SEMICOLON, ";", this.line, this.col);
 		this.push(T.EOF, "", this.line, this.col);
+		this.tokens.target = this.target;
+		this.tokens.targetDirective = this.targetDirective;
 		return this.tokens;
 	}
 	_readPlusOp(l, c) {

package/src/lower/boxing.js

@@ -0,0 +1,35 @@
+// 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;
+	return (
+		base?.kind === "struct" ||
+		base?.kind === "slice" ||
+		base?.kind === "map" ||
+		base?.kind === "func" ||
+		base?.kind === "interface"
+	);
+}
+
+// Scan AST node for _addressTaken idents on scalars and populate a Set of boxed variable names.
+export function scanAddressTaken(node, boxedVars = new Set()) {
+	if (!node || typeof node !== "object") return boxedVars;
+	if (Array.isArray(node)) {
+		for (const child of node) scanAddressTaken(child, boxedVars);
+		return boxedVars;
+	}
+	// &x — the operand ident will have _addressTaken set by typechecker
+	if (node.kind === "Ident" && node._addressTaken) {
+		const t = node._type;
+		if (t && !isReferenceType(t)) {
+			boxedVars.add(node.name);
+		}
+	}
+	// Recurse into FuncLit too — closures may take address of outer vars
+	forEachChild(node, (child) => scanAddressTaken(child, boxedVars));
+	return boxedVars;
+}