gofront 1.6.1 → 1.8.0

package/src/index.js

@@ -14,30 +14,30 @@
 //   gofront init [dir]             — scaffold a new GoFront project
 
 import { statSync } from "node:fs";
-import { dirname, relative, resolve } from "node:path";
-import { copyAssets } from "./asset-manager.js";
+import { dirname, resolve } from "node:path";
 import {
-	formatBuildSummary,
+	devReporters,
 	formatPrepSummary,
 	formatWrittenDesc,
 	GOFRONT_VERSION,
+	HELP_TEXT,
 	handleBuild,
 	handleCheck,
 	handleDev,
 	handleInit,
 	handlePrep,
 	handleTest,
-	maybeMinify,
 	parseBuildArgs,
 	parseCheckArgs,
 	parseDevArgs,
 	parseLegacyArgs,
 	parsePrepArgs,
 	parseTestArgs,
-	runCompile,
-	writeCompileOutput,
-} from "./cli-core.js";
-import { colors, formatDiagnostic, log, ms, stamp } from "./colors.js";
+	reportBuild,
+	reportCheck,
+	runSingleShot,
+} from "./cli/cli-core.js";
+import { colors, log, stamp } from "./cli/colors.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
 
@@ -48,35 +48,7 @@ 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 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, --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 (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)
-  gofront <input> -o out.js --serve --port 8080  Use a custom port
-  gofront <input> -o out.js --copy-assets    Compile and synchronize static assets
-  gofront <input> --source-map   Append inline source map to output
-  gofront <input> --minify       Minify output
-  gofront <input> --minify --mangle  Minify and mangle identifiers
-  gofront <file.go> --ast        Dump AST (debug)
-  gofront <file.go> --tokens     Dump tokens (debug)
-  gofront --version              Print version
-`.trim(),
-	);
+	console.log(HELP_TEXT);
 	process.exit(0);
 }
 
@@ -131,19 +103,7 @@ if (args[0] === "test") {
 if (args[0] === "check") {
 	const { targetDir, forceTarget } = parseCheckArgs(args.slice(1));
 	try {
-		const { elapsedMs, packages } = handleCheck(targetDir, { forceTarget });
-		const okLine = (label, t) =>
-			log.info(`${colors.cyan(label)} — ${colors.green("OK")} ${ms(t)}`);
-		if (packages) {
-			for (const pkg of packages) {
-				okLine(relative(process.cwd(), pkg.dir) || ".", pkg.elapsedMs);
-			}
-			log.info(
-				`${colors.bold(`${packages.length} packages`)} — ${colors.bold(colors.green("OK"))} ${ms(elapsedMs)}`,
-			);
-		} else {
-			okLine(targetDir, elapsedMs);
-		}
+		reportCheck(handleCheck(targetDir, { forceTarget }), targetDir);
 		process.exit(0);
 	} catch (e) {
 		log.fail(e.message);
@@ -157,13 +117,7 @@ if (args[0] === "build") {
 	const buildOptions = parseBuildArgs(args.slice(1));
 	try {
 		const result = await handleBuild(buildOptions.targetDir, buildOptions);
-		for (const line of formatBuildSummary(result)) {
-			log.info(
-				line
-					.replace(/^build complete/, colors.green("build complete"))
-					.replace(/\(([\d.]+ kB)\)$/, (_, s) => colors.dim(`(${s})`)),
-			);
-		}
+		reportBuild(result);
 		process.exit(0);
 	} catch (e) {
 		log.fail(e.message);
@@ -200,22 +154,19 @@ if (args[0] === "dev") {
 	}
 }
 
+const flags = parseLegacyArgs(args);
 const {
 	inputArg,
 	outputFile,
-	checkOnly,
-	dumpAst,
-	dumpTokens,
 	sourceMap,
 	serve: serveMode,
 	watch: watchMode,
 	copyAssets: copyAssetsFlag,
-	wasmOpt,
 	minify: minifyOutput,
 	mangle: mangleOutput,
 	port: servePort,
 	forceTarget,
-} = parseLegacyArgs(args);
+} = flags;
 
 // ── Determine input mode ─────────────────────────────────────
 
@@ -228,96 +179,10 @@ 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) {
-	let result;
-	const startMs = performance.now();
-	try {
-		result = runCompile(inputPath, isDir, {
-			sourceMap,
-			outputFile,
-			dumpTokens,
-			dumpAst,
-			wasmOpt,
-			forceTarget,
-		});
-	} catch (e) {
-		log.fail(e.message);
-		process.exit(1);
-	}
-
-	if (result.tokens) {
-		for (const tok of result.tokens) console.log(tok.toString());
-		process.exit(0);
-	}
-	if (result.ast) {
-		console.log(JSON.stringify(result.ast, null, 2));
-		process.exit(0);
-	}
-
-	if (checkOnly) {
-		const elapsedMs = (performance.now() - startMs).toFixed(0);
-		log.info(
-			`${colors.cyan(inputArg)} — ${colors.green("OK")} ${ms(elapsedMs)}`,
-		);
-		process.exit(0);
-	}
-
-	let js;
-	try {
-		js = maybeMinify(result.js, {
-			minify: minifyOutput,
-			mangle: mangleOutput,
-			sourceMap,
-		});
-	} catch (e) {
-		log.fail(`minify failed: ${e.message}`);
-		process.exit(1);
-	}
-
-	const elapsedMs = (performance.now() - startMs).toFixed(0);
-
-	if (outputFile) {
-		try {
-			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 (result.wasm) {
-			log.warn(
-				"wasm packages were linked but app.wasm needs -o <file> to be written",
-			);
-		}
-	}
-
-	if (copyAssetsFlag) copyProjectAssets(true);
-
-	process.exit(0);
+	process.exit(runSingleShot(inputPath, isDir, flags));
 }
 
 // ── Watch mode ───────────────────────────────────────────────
@@ -342,26 +207,7 @@ try {
 		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}`);
-			}
-			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}`);
-		},
+		...devReporters({ outputFile, copyAssets: copyAssetsFlag }),
 	});
 } catch (e) {
 	log.fail(e.message);

package/src/{lexer.js → lexer/lexer.js}

@@ -52,8 +52,8 @@ const KEYWORDS = new Set([
 	"case",
 	"default",
 	"map",
-	"new",
 	"fallthrough",
+	"goto",
 	"defer",
 	"async",
 	"await",
@@ -86,6 +86,11 @@ const ASSIGN_OP = {
 	":": [T.DEFINE, ":=", T.COLON, ":"],
 };
 
+const UNICODE_LETTER = /^\p{L}$/u;
+const UNICODE_DIGIT = /^\p{Nd}$/u;
+const isUnicodeLetter = (cp) => UNICODE_LETTER.test(String.fromCodePoint(cp));
+const isUnicodeDigit = (cp) => UNICODE_DIGIT.test(String.fromCodePoint(cp));
+
 export class LexError extends Error {
 	constructor(msg, line, col, filename, sourceCode) {
 		const loc = filename ? `${filename}:${line}:${col}` : `${line}:${col}`;
@@ -103,6 +108,17 @@ export class LexError extends Error {
 	}
 }
 
+const SIMPLE_ESCAPES = {
+	a: 7,
+	b: 8,
+	f: 12,
+	n: 10,
+	r: 13,
+	t: 9,
+	v: 11,
+	"\\": 92,
+};
+
 export class Lexer {
 	constructor(source, filename = null) {
 		this.src = source;
@@ -113,6 +129,8 @@ export class Lexer {
 		this.filename = filename;
 		this.target = null;
 		this.targetDirective = null;
+		this.intrinsics = new Map(); // line -> name of a //gofront:intrinsic
+		this.embedDirectives = []; // {line, col} of each //go:embed line comment
 	}
 
 	// ── Primitives ──────────────────────────────────────────────
@@ -158,6 +176,15 @@ export class Lexer {
 				while (this.pos < this.src.length && this.peek() !== "\n")
 					this.advance();
 				const comment = this.src.slice(start, this.pos);
+				if (
+					/^\/\/go:embed(?:\s|$)/.test(comment) &&
+					/^[ \t]*$/.test(
+						this.src.slice(this.src.lastIndexOf("\n", start - 1) + 1, start),
+					)
+				)
+					this.embedDirectives.push({ line, col });
+				const intrinsic = comment.match(/^\/\/gofront:intrinsic\s+(\S+)/);
+				if (intrinsic) this.intrinsics.set(line, intrinsic[1]);
 				const match = comment.match(/^\/\/gofront:target\s+(\S+)/);
 				if (match) {
 					this.target = match[1];
@@ -222,29 +249,7 @@ export class Lexer {
 				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":
-						parts.push("\n");
-						break;
-					case "t":
-						parts.push("\t");
-						break;
-					case "r":
-						parts.push("\r");
-						break;
-					case '"':
-						parts.push('"');
-						break;
-					case "\\":
-						parts.push("\\");
-						break;
-					case "0":
-						parts.push("\0");
-						break;
-					default:
-						parts.push(`\\${esc}`);
-				}
+				parts.push(String.fromCodePoint(this.readEscape('"')));
 				start = this.pos;
 			} else {
 				this.advance();
@@ -253,6 +258,46 @@ export class Lexer {
 		throw new LexError("Unterminated string", l, c, this.filename, this.src);
 	}
 
+	// Reads the escape after a consumed backslash and returns its code point.
+	// `quote` is the enclosing delimiter: `\'` is valid only in runes and
+	// `\"` only in strings. `\xNN` and octal escapes give U+0000-U+00FF (see
+	// plan §1.1: strings are JS strings, so \x80-\xff are code points, not raw bytes).
+	readEscape(quote) {
+		const l = this.line,
+			c = this.col;
+		const fail = (msg) => {
+			throw new LexError(msg, l, c, this.filename, this.src);
+		};
+		const esc = this.advance();
+		const simple = SIMPLE_ESCAPES[esc];
+		if (simple !== undefined) return simple;
+		if (esc === quote) return esc.charCodeAt(0);
+		if (esc === "x") return this.readEscapeDigits(2, 16, fail);
+		if (esc === "u" || esc === "U") {
+			const v = this.readEscapeDigits(esc === "u" ? 4 : 8, 16, fail);
+			if (v > 0x10ffff || (v >= 0xd800 && v < 0xe000))
+				fail("escape is invalid Unicode code point");
+			return v;
+		}
+		if (esc >= "0" && esc <= "7") {
+			const v = Number(esc) * 64 + this.readEscapeDigits(2, 8, fail);
+			if (v > 255) fail("octal escape value exceeds 255");
+			return v;
+		}
+		return fail(`unknown escape sequence: \\${esc}`);
+	}
+
+	readEscapeDigits(n, radix, fail) {
+		let v = 0;
+		for (let i = 0; i < n; i++) {
+			const d = Number.parseInt(this.src[this.pos] ?? "", radix);
+			if (Number.isNaN(d)) fail("invalid character in escape sequence");
+			v = v * radix + d;
+			this.advance();
+		}
+		return v;
+	}
+
 	readRawString() {
 		const l = this.line,
 			c = this.col;
@@ -279,35 +324,7 @@ export class Lexer {
 		let code;
 		if (this.peek() === "\\") {
 			this.advance();
-			const esc = this.advance();
-			switch (esc) {
-				case "n":
-					code = 10;
-					break;
-				case "t":
-					code = 9;
-					break;
-				case "r":
-					code = 13;
-					break;
-				case "'":
-					code = 39;
-					break;
-				case "\\":
-					code = 92;
-					break;
-				case "0":
-					code = 0;
-					break;
-				default:
-					throw new LexError(
-						`Unknown escape in rune literal: \\${esc}`,
-						l,
-						c,
-						this.filename,
-						this.src,
-					);
-			}
+			code = this.readEscape("'");
 		} else if (this.peek() !== "'") {
 			code = this.src.codePointAt(this.pos);
 			this.advance();
@@ -392,6 +409,20 @@ export class Lexer {
 		return { n, isFloat: false };
 	}
 
+	// The leading "." is already consumed; reads digits and an optional exponent.
+	_readLeadingDotFloat() {
+		let n = "0.";
+		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;
+		}
+		const c = this.src.charCodeAt(this.pos);
+		if (c === 101 || c === 69) n = this._readDecimalExponent(n);
+		return { n };
+	}
+
 	_readDecimalExponent(n) {
 		n += this.advance(); // consume e/E
 		if (this.peek() === "+" || this.peek() === "-") n += this.advance();
@@ -450,6 +481,13 @@ export class Lexer {
 		return { n, isFloat };
 	}
 
+	_startsUnicodeIdent() {
+		return (
+			this.peek().charCodeAt(0) > 127 &&
+			isUnicodeLetter(this.src.codePointAt(this.pos))
+		);
+	}
+
 	readIdent() {
 		const start = this.pos;
 		while (this.pos < this.src.length) {
@@ -461,6 +499,10 @@ export class Lexer {
 				code === 95
 			) {
 				this.pos++;
+			} else if (code > 127) {
+				const cp = this.src.codePointAt(this.pos);
+				if (!isUnicodeLetter(cp) && !isUnicodeDigit(cp)) break;
+				this.pos += cp > 0xffff ? 2 : 1;
 			} else {
 				break;
 			}
@@ -526,7 +568,7 @@ export class Lexer {
 			}
 
 			// Identifiers & keywords
-			if (/[a-zA-Z_]/.test(ch)) {
+			if (/[a-zA-Z_]/.test(ch) || this._startsUnicodeIdent()) {
 				const id = this.readIdent();
 				this.push(KEYWORDS.has(id) ? id : T.IDENT, id, l, c);
 				continue;
@@ -541,6 +583,8 @@ export class Lexer {
 		this.push(T.EOF, "", this.line, this.col);
 		this.tokens.target = this.target;
 		this.tokens.targetDirective = this.targetDirective;
+		this.tokens.intrinsics = this.intrinsics;
+		this.tokens.embedDirectives = this.embedDirectives;
 		return this.tokens;
 	}
 	_readPlusOp(l, c) {
@@ -614,7 +658,10 @@ export class Lexer {
 				else this.push(T.PIPE, "|", l, c);
 				break;
 			case ".":
-				if (this.peek() === "." && this.peek(1) === ".") {
+				if (/[0-9]/.test(this.peek() ?? "")) {
+					const { n } = this._readLeadingDotFloat();
+					this.push(T.FLOAT, n, l, c);
+				} else if (this.peek() === "." && this.peek(1) === ".") {
 					this.advance();
 					this.advance();
 					this.push(T.ELLIPSIS, "...", l, c);

package/src/{tokens.js → lexer/tokens.js}

@@ -80,6 +80,7 @@ export const T = {
 	RSHIFT: ">>",
 	ELLIPSIS: "...",
 	FALLTHROUGH: "fallthrough",
+	GOTO: "goto",
 
 	// Delimiters
 	LPAREN: "(",

package/src/link/sourcemap.js

@@ -0,0 +1,97 @@
+// Source-map merging for the bundle: chunk concatenation with line-offset
+// mappings, the inline JS source map and the function-level wasm map.
+
+import { relative, resolve } from "node:path";
+import { buildSourceMap, buildWasmSourceMap } from "../backend/js/index.js";
+
+function normalizeChunk(c) {
+	if (typeof c === "string") {
+		return { js: c, sourceFiles: [], sourcesContent: [], mappings: [] };
+	}
+	return c;
+}
+
+function appendChunkMappings(dest, mappings, localToUnifiedIdx, lineOffset) {
+	if (!mappings) return;
+	for (const m of mappings) {
+		dest.push({
+			genLine: m.genLine + lineOffset,
+			srcLine: m.srcLine,
+			srcFileIdx: localToUnifiedIdx[m.srcFileIdx ?? 0] ?? 0,
+		});
+	}
+}
+
+export function mergeCompilationChunks(chunks) {
+	const activeChunks = chunks
+		.filter(Boolean)
+		.map(normalizeChunk)
+		.filter((c) => c.js.length > 0);
+
+	if (activeChunks.length === 0) {
+		return { js: "", sourceFiles: [], sourcesContent: [], mappings: [] };
+	}
+
+	const unifiedSources = [];
+	const unifiedSourcesContent = [];
+	const fileIdxMap = new Map();
+
+	function getOrAddFile(filePath, content) {
+		const key = resolve(filePath);
+		let idx = fileIdxMap.get(key);
+		if (idx === undefined) {
+			idx = unifiedSources.length;
+			fileIdxMap.set(key, idx);
+			unifiedSources.push(key);
+			unifiedSourcesContent.push(content);
+		}
+		return idx;
+	}
+
+	const combinedJsParts = [];
+	const mergedMappings = [];
+	let currentLineOffset = 0;
+
+	for (const chunk of activeChunks) {
+		combinedJsParts.push(chunk.js);
+		const localToUnifiedIdx = (chunk.sourceFiles ?? []).map((file, i) =>
+			getOrAddFile(file, chunk.sourcesContent?.[i] ?? ""),
+		);
+		appendChunkMappings(
+			mergedMappings,
+			chunk.mappings,
+			localToUnifiedIdx,
+			currentLineOffset,
+		);
+		currentLineOffset += chunk.js.split("\n").length;
+	}
+
+	return {
+		js: combinedJsParts.join("\n"),
+		sourceFiles: unifiedSources,
+		sourcesContent: unifiedSourcesContent,
+		mappings: mergedMappings,
+	};
+}
+
+export function attachSourceMap(merged, outputDir) {
+	const relativeSources = merged.sourceFiles.map((f) => relative(outputDir, f));
+	const mapJson = buildSourceMap(
+		relativeSources,
+		merged.mappings,
+		merged.sourcesContent,
+	);
+	const b64 = Buffer.from(mapJson).toString("base64");
+	merged.js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
+}
+
+export const WASM_MAP_URL = "app.wasm.map";
+
+// Function-level `app.wasm.map` (sources relative to the output dir).
+export function buildWasmMap(info, outputDir) {
+	if (!info || info.mappings.length === 0) return null;
+	return buildWasmSourceMap(
+		info.sources.map((f) => relative(outputDir, f)),
+		info.mappings,
+	);
+}