gofront 1.4.0 → 1.5.1

package/src/cli-core.js

@@ -23,6 +23,7 @@ import {
 	sep,
 } from "node:path";
 import { copyAssets } from "./asset-manager.js";
+import { isGoFrontWasm } from "./backend/wasm/index.js";
 import { colors, log } from "./colors.js";
 import { compileDir, compileSingleFile } from "./compiler.js";
 import { createDevServer } from "./dev-server.js";
@@ -42,11 +43,12 @@ export function runCompile(inputPath, isDir, options) {
 		outputFile = null,
 		dumpTokens = false,
 		dumpAst = false,
+		emitWat = false,
 	} = options ?? {};
 
 	if (isDir) {
 		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
-		return compileDir(inputPath, { sourceMap, outputDir });
+		return compileDir(inputPath, { sourceMap, outputDir, emitWat });
 	}
 
 	return compileSingleFile(inputPath, {
@@ -54,9 +56,49 @@ export function runCompile(inputPath, isDir, options) {
 		outputFile,
 		dumpTokens,
 		dumpAst,
+		emitWat,
 	});
 }
 
+// Writes the JS bundle plus, when the project links wasm packages, the
+// sibling `app.wasm` (and `app.wat` when requested).  Stale wasm artifacts
+// are removed so a project that drops its wasm packages serves clean output —
+// but only when the existing file is one GoFront produced (recognised by its
+// `gofront` custom section), so a hand-placed `app.wasm` is left alone.
+export function writeCompileOutput(outputFile, result, js = result.js) {
+	mkdirSync(dirname(outputFile), { recursive: true });
+	writeFileSync(outputFile, `${js}\n`);
+	const wasmFile = join(dirname(outputFile), "app.wasm");
+	const watFile = join(dirname(outputFile), "app.wat");
+	const written = [outputFile];
+	let ownsWasm = Boolean(result.wasm);
+	if (result.wasm) {
+		writeFileSync(wasmFile, result.wasm);
+		written.push(wasmFile);
+	} else if (existsSync(wasmFile)) {
+		if (isGoFrontWasm(readFileSync(wasmFile))) {
+			rmSync(wasmFile);
+			ownsWasm = true;
+		}
+	}
+	if (result.wat) {
+		writeFileSync(watFile, result.wat);
+		written.push(watFile);
+	} else if (ownsWasm && existsSync(watFile)) {
+		rmSync(watFile);
+	}
+	return written;
+}
+
+export function formatWrittenDesc(written, outputFile = written?.[0] ?? "") {
+	if (!written || written.length <= 1) return colors.cyan(outputFile);
+	const extras = written
+		.slice(1)
+		.map((p) => colors.cyan(basename(p)))
+		.join(" + ");
+	return `${colors.cyan(outputFile)} + ${extras}`;
+}
+
 export function maybeMinify(js, options) {
 	const {
 		minify: doMinify = false,
@@ -460,6 +502,7 @@ export function parseBuildArgs(argv) {
 	const sourceMap = argv.includes("--source-map");
 	const noMinify = argv.includes("--no-minify");
 	const noMangle = argv.includes("--no-mangle");
+	const emitWat = argv.includes("--emit-wat");
 
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
@@ -477,6 +520,7 @@ export function parseBuildArgs(argv) {
 		outDir,
 		pwa,
 		sourceMap,
+		emitWat,
 		minify: !noMinify,
 		mangle: !noMangle && !noMinify,
 	};
@@ -667,6 +711,7 @@ export async function handleBuild(targetDir = ".", options = {}) {
 	const compileResult = runCompile(srcDir, isDir, {
 		outputFile,
 		sourceMap: options.sourceMap ?? false,
+		emitWat: options.emitWat ?? false,
 	});
 
 	const doMinify = options.minify ?? true;
@@ -676,7 +721,7 @@ export async function handleBuild(targetDir = ".", options = {}) {
 		mangle: doMangle,
 		sourceMap: options.sourceMap ?? false,
 	});
-	writeFileSync(outputFile, `${js}\n`);
+	writeCompileOutput(outputFile, compileResult, js);
 
 	let vendor = null;
 	try {
@@ -752,12 +797,11 @@ function buildDevOnce(
 			outputFile,
 			sourceMap: sourceMap ?? true,
 		});
-		mkdirSync(dirname(outputFile), { recursive: true });
-		writeFileSync(outputFile, `${result.js}\n`);
+		const written = writeCompileOutput(outputFile, result);
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
 		const note = changedFile ? ` — ${changedFile} changed` : "";
 		log.ok(
-			`— wrote ${colors.cyan(outputFile)} ${colors.dim(`(${elapsedMs}ms${note})`)}`,
+			`— wrote ${formatWrittenDesc(written, outputFile)} ${colors.dim(`(${elapsedMs}ms${note})`)}`,
 		);
 		devServer.notify();
 	} catch (e) {
@@ -878,13 +922,13 @@ export async function handleDev(targetDir = ".", options = {}) {
 	});
 	let initialError = null;
 
+	let written = null;
 	try {
 		const result = runCompile(srcDir, isDir, {
 			outputFile,
 			sourceMap: options.sourceMap ?? true,
 		});
-		mkdirSync(dirname(outputFile), { recursive: true });
-		writeFileSync(outputFile, `${result.js}\n`);
+		written = writeCompileOutput(outputFile, result);
 	} catch (err) {
 		initialError = err;
 		devServer.notifyError(err);
@@ -914,6 +958,7 @@ export async function handleDev(targetDir = ".", options = {}) {
 		srcDir,
 		outputFile,
 		initialError,
+		written,
 		close: async () => {
 			watcherController?.close();
 			await devServer.close();

package/src/compiler.js

@@ -19,16 +19,23 @@
 
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
-import { CodeGen } from "./codegen/index.js";
-import { buildSourceMap } from "./codegen/source-map.js";
+import { buildSourceMap, CodeGen } from "./backend/js/index.js";
+import { compileWasmModule } from "./backend/wasm/index.js";
 import { log } from "./colors.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
+import { lower } from "./lower/index.js";
 import { Parser } from "./parser/index.js";
-import { isLocalPath, resolveAll, resolveGwDir } from "./resolver.js";
+import {
+	isBuiltinPackage,
+	isLocalPath,
+	resolveAll,
+	resolveGwDir,
+} from "./resolver.js";
 import { TemplLexer } from "./templ-lexer.js";
 import { TemplParser } from "./templ-parser.js";
 import { TypeChecker } from "./typechecker/index.js";
+import { WASM_SUPPORTED_STDLIB } from "./typechecker/types.js";
 
 // ── Parse cache ──────────────────────────────────────────────
 
@@ -156,6 +163,147 @@ function attachSourceMap(merged, outputDir) {
 	merged.js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 }
 
+// ── WASM linking ──────────────────────────────────────────────
+//
+// Every `wasm`/`both` package reached during a build registers a unit in the
+// shared `options.wasmUnits` array.  The root compile links all units into a
+// single `app.wasm` and splices the generated JS facade into the bundle where
+// the first wasm package's JS would have been.
+
+const WASM_MARKER_RE = /^\/\*__GOFRONT_WASM_UNIT:[^*]*\*\/$/m;
+
+function wasmMarker(pkgName) {
+	return `/*__GOFRONT_WASM_UNIT:${pkgName}*/`;
+}
+
+function registerWasmUnit(options, unit) {
+	const units = options.wasmUnits;
+	if (!units) return;
+	if (units.some((u) => u.key === unit.key)) return;
+	units.push(unit);
+}
+
+// Registers a `wasm`/`both` package as a link unit and returns the target the
+// package's own code is emitted for.  `options.wasmTests` runs a `both`
+// package's tests through the wasm backend (the package is then treated as
+// `wasm` for linking so its test functions are exposed by the facade).
+function registerPackageUnit(options, unit) {
+	const { pkgTarget, programs } = unit;
+	if (pkgTarget !== "wasm" && pkgTarget !== "both") return pkgTarget;
+	const emitTarget =
+		options.wasmTests && options.isTest && pkgTarget === "both"
+			? "wasm"
+			: pkgTarget;
+	registerWasmUnit(options, {
+		...unit,
+		target: emitTarget,
+		programs:
+			emitTarget === pkgTarget
+				? programs
+				: programs.map((p) => ({ ...p, target: emitTarget })),
+	});
+	return emitTarget;
+}
+
+function linkWasmUnits(units, { emitWat = false, rootTarget = "js" } = {}) {
+	if (!units.some((u) => u.target === "wasm")) return null;
+	checkLinkCollisions(units);
+
+	const types = new Map();
+	const bundledPackages = new Set();
+	const programs = [];
+	for (const u of units) {
+		for (const [k, v] of u.types) types.set(k, v);
+		for (const b of u.bundledPackages) bundledPackages.add(b);
+		programs.push(...u.programs);
+	}
+	const checker = { types };
+	const lowerRes = lower(programs, checker);
+	return compileWasmModule(programs, checker, lowerRes, {
+		boundary: true,
+		bundledPackages,
+		emitWat,
+		callMain: rootTarget === "wasm",
+	});
+}
+
+// The linked module is one flat namespace (like the JS bundle), so a top-level
+// name declared by two different packages would silently resolve to whichever
+// was emitted last.  Reject it up front.
+function topLevelDeclNames(decl) {
+	switch (decl.kind) {
+		case "FuncDecl":
+			return [decl.name];
+		case "MethodDecl":
+			return [`${decl.recvType?.name ?? "?"}.${decl.name}`];
+		case "TypeDecl":
+			return [decl.name];
+		case "VarDecl":
+		case "ConstDecl":
+			return (decl.decls ?? []).flatMap((spec) => spec.names ?? []);
+		default:
+			return [];
+	}
+}
+
+function checkLinkCollisions(units) {
+	const owner = new Map(); // name -> pkgName
+	const errors = [];
+	for (const u of units) {
+		for (const p of u.programs) {
+			for (const d of p.decls ?? []) {
+				for (const name of topLevelDeclNames(d)) {
+					if (name === "_") continue;
+					const prev = owner.get(name);
+					if (prev === undefined) owner.set(name, u.pkgName);
+					else if (prev !== u.pkgName)
+						errors.push(
+							`cannot link wasm packages: '${name}' is declared in both '${prev}' and '${u.pkgName}' (linked wasm packages share one namespace)`,
+						);
+				}
+			}
+		}
+	}
+	if (errors.length > 0) throw new Error([...new Set(errors)].join("\n"));
+}
+
+// Replaces the first wasm marker with the facade (dropping the others) and
+// shifts source-map lines that follow it.
+function spliceFacade(merged, facade) {
+	const lines = merged.js.split("\n");
+	const first = lines.findIndex((l) => WASM_MARKER_RE.test(l));
+	if (first < 0) {
+		merged.js = `${facade}\n${merged.js}`;
+		const shift = facade.split("\n").length;
+		for (const m of merged.mappings) m.genLine += shift;
+		return;
+	}
+	const facadeLines = facade.split("\n");
+	const delta = facadeLines.length - 1;
+	for (const m of merged.mappings) {
+		if (m.genLine > first) m.genLine += delta;
+	}
+	const out = [...lines.slice(0, first), ...facadeLines];
+	for (let i = first + 1; i < lines.length; i++) {
+		if (!WASM_MARKER_RE.test(lines[i])) out.push(lines[i]);
+	}
+	merged.js = out.join("\n");
+}
+
+// Root compiles only: link every registered unit into app.wasm and splice the
+// facade into the merged bundle.  Returns `{ wasm, wat }` (nulls when there
+// is nothing to link).
+function linkIntoBundle(options, merged, pkgTarget) {
+	if (options.isDependency) return { wasm: null, wat: null };
+	const linked = linkWasmUnits(options.wasmUnits, {
+		emitWat: options.emitWat,
+		rootTarget: pkgTarget,
+	});
+	if (!linked) return { wasm: null, wat: null };
+	spliceFacade(merged, linked.facade);
+	return { wasm: linked.wasm, wat: linked.wat ?? null };
+}
+
 // ── Import resolution ─────────────────────────────────────────
 //
 // Shared by compileFiles (multi-file) and the single-file path in index.js.
@@ -173,6 +321,55 @@ export function resolveImports(
 ) {
 	const fromDir = dirname(resolve(fromFile));
 	const allImports = programs.flatMap((p) => p.imports);
+	const pkgTarget = checker.target ?? "js";
+	const pkgName = checker.pkgName ?? programs[0]?.pkg?.name ?? "main";
+
+	// Validate target rules on non-local imports
+	if (pkgTarget === "wasm" || pkgTarget === "both") {
+		for (const p of programs) {
+			const saved = [checker._currentFile, checker._currentSource];
+			checker._currentFile = p._filename ?? null;
+			checker._currentSource = p._source ?? null;
+			for (const imp of p.imports) {
+				for (const { path, _line, _col, line, col } of imp.imports) {
+					const impNode = {
+						_line,
+						_col,
+						line: line ?? _line,
+						col: col ?? _col ?? 1,
+					};
+					if (path.startsWith("js:")) {
+						checker.recordBlocker("js: import", path);
+						checker.err(
+							"js: imports are not allowed in wasm packages",
+							impNode,
+						);
+					} else if (path === "gom") {
+						checker.recordBlocker("gom usage", "gom");
+						checker.err(
+							"package 'gom' is not available in wasm packages",
+							impNode,
+						);
+					} else if (!isLocalPath(path)) {
+						if (!isBuiltinPackage(path)) {
+							checker.recordBlocker("js: import", path);
+							checker.err(
+								"js: imports are not allowed in wasm packages",
+								impNode,
+							);
+						} else if (!WASM_SUPPORTED_STDLIB.has(path)) {
+							checker.recordBlocker("unsupported stdlib import", path);
+							checker.err(
+								`'${path}' is not yet available in wasm packages`,
+								impNode,
+							);
+						}
+					}
+				}
+			}
+			[checker._currentFile, checker._currentSource] = saved;
+		}
+	}
 
 	// js: prefix — local .d.ts files
 	for (const imp of allImports) {
@@ -205,7 +402,7 @@ export function resolveImports(
 	const seenLocalPaths = new Set();
 	for (const p of programs) {
 		for (const imp of p.imports) {
-			for (const { path, alias, _line } of imp.imports) {
+			for (const { path, alias, _line, _col, line, col } of imp.imports) {
 				if (!isLocalPath(path) || seenLocalPaths.has(path)) continue;
 				seenLocalPaths.add(path);
 				const depDir = resolveGwDir(path, fromFile);
@@ -226,6 +423,44 @@ export function resolveImports(
 					isDependency: true,
 				});
 				if (!alreadyBundled) preambles.push(dep);
+
+				// Target import rules for local packages
+				const impNode = {
+					_line,
+					_col,
+					line: line ?? _line,
+					col: col ?? _col ?? 1,
+				};
+				if (pkgTarget === "wasm" && dep.target === "js") {
+					const saved = [checker._currentFile, checker._currentSource];
+					checker._currentFile = p._filename ?? null;
+					checker._currentSource = p._source ?? null;
+					checker.recordBlocker("js package import", dep.pkgName);
+					checker.err(
+						`package '${pkgName}' (wasm) cannot import '${dep.pkgName}' (js)`,
+						impNode,
+					);
+					[checker._currentFile, checker._currentSource] = saved;
+				} else if (pkgTarget === "both") {
+					const saved = [checker._currentFile, checker._currentSource];
+					checker._currentFile = p._filename ?? null;
+					checker._currentSource = p._source ?? null;
+					if (dep.target === "js") {
+						checker.recordBlocker("js package import", dep.pkgName);
+						checker.err(
+							`package '${pkgName}' (both) cannot import '${dep.pkgName}' (js)`,
+							impNode,
+						);
+					} else if (dep.target === "wasm") {
+						checker.recordBlocker("wasm package import", dep.pkgName);
+						checker.err(
+							`package '${pkgName}' (both) can only import 'both' packages; '${dep.pkgName}' is wasm`,
+							impNode,
+						);
+					}
+					[checker._currentFile, checker._currentSource] = saved;
+				}
+
 				if (alias === "_") continue;
 				if (alias === ".") {
 					checker.addDefinitions(dep.exportedTypes, dep.exportedSymbols);
@@ -253,6 +488,7 @@ export function compileSingleFile(inputPath, options = {}) {
 		dumpTokens = false,
 		dumpAst = false,
 	} = options;
+	options = { ...options, wasmUnits: options.wasmUnits ?? [] };
 
 	let source;
 	try {
@@ -277,6 +513,11 @@ export function compileSingleFile(inputPath, options = {}) {
 	const bundledPackages = new Set();
 	const preambles = [];
 
+	const pkgTarget = ast.target ?? options.target ?? "js";
+	ast.target = pkgTarget;
+	checker.target = pkgTarget;
+	checker.pkgName = ast.pkg?.name ?? "main";
+
 	resolveImports(
 		[ast],
 		inputPath,
@@ -294,23 +535,40 @@ export function compileSingleFile(inputPath, options = {}) {
 		throw new Error(errors.map((e) => e.message).join("\n"));
 	}
 
-	const cg = new CodeGen(checker, jsImports, bundledPackages);
-	const mainJs = cg.generate(ast);
+	if (pkgTarget === "wasm" || pkgTarget === "both") {
+		registerWasmUnit(options, {
+			key: resolve(inputPath),
+			pkgName: checker.pkgName,
+			target: pkgTarget,
+			programs: [ast],
+			types: checker.types,
+			bundledPackages,
+		});
+	}
+
+	const isStrict = Boolean(options.strict || pkgTarget === "both");
+	const cg = new CodeGen(checker, jsImports, bundledPackages, {
+		target: pkgTarget,
+		strict: isStrict,
+	});
+	const mainJs =
+		pkgTarget === "wasm" ? wasmMarker(checker.pkgName) : cg.generate(ast);
 
 	const mainChunk = {
 		js: mainJs,
 		sourceFiles: [resolve(inputPath)],
 		sourcesContent: [source],
-		mappings: cg.getMappings(),
+		mappings: pkgTarget === "wasm" ? [] : cg.getMappings(),
 	};
 
 	const merged = mergeCompilationChunks([...preambles, mainChunk]);
+	const { wasm, wat } = linkIntoBundle(options, merged, pkgTarget);
 
 	if (sourceMap && !options.isDependency) {
 		attachSourceMap(merged, outputDir);
 	}
 
-	return { js: merged.js, css: cg.getCss() };
+	return { js: merged.js, css: cg.getCss(), target: pkgTarget, wasm, wat };
 }
 
 export function compileDir(dir, options = {}) {
@@ -325,7 +583,15 @@ export function compilePackageTests(dir, options = {}) {
 	return compileFiles(files, { ...options, fromDir: dir, isTest: true });
 }
 
+// Compiles a `both` package's tests through the wasm backend (the JS run uses
+// compilePackageTests).  Returns null for packages that are not `both`.
+export function compilePackageTestsWasm(dir, options = {}) {
+	const res = compilePackageTests(dir, { ...options, wasmTests: true });
+	return res.target === "both" ? res : null;
+}
+
 export function compileFiles(files, options = {}) {
+	options = { ...options, wasmUnits: options.wasmUnits ?? [] };
 	const fromDir = options.fromDir ?? dirname(resolve(files[0]));
 	const outputDir =
 		options.outputDir ??
@@ -353,8 +619,32 @@ export function compileFiles(files, options = {}) {
 		);
 	const pkgName = pkgNames[0];
 
+	// Validate target directives across files in this package
+	const declaredTargets = new Map();
+	for (const p of programs) {
+		if (p.target) {
+			if (!declaredTargets.has(p.target)) declaredTargets.set(p.target, []);
+			declaredTargets.get(p.target).push(p._filename);
+		}
+	}
+	if (declaredTargets.size > 1) {
+		const list = [...declaredTargets.entries()]
+			.map(([t, fList]) => `${t} (${fList.join(", ")})`)
+			.join(" vs ");
+		throw new Error(
+			`Conflicting //gofront:target directives in package '${pkgName}': ${list}`,
+		);
+	}
+	const pkgTarget =
+		declaredTargets.size === 1
+			? declaredTargets.keys().next().value
+			: (options.target ?? "js");
+	for (const p of programs) p.target = pkgTarget;
+
 	// ── 2. Resolve imports ────────────────────────────────────────
 	const checker = new TypeChecker();
+	checker.target = pkgTarget;
+	checker.pkgName = pkgName;
 	const jsImports = new Map(); // npm imports → exported names (for ESM emit)
 	const bundledPackages = new Set(); // package names whose code is inlined
 	const preambles = []; // JS code / chunks from compiled sub-packages
@@ -380,19 +670,36 @@ export function compileFiles(files, options = {}) {
 	}
 
 	// ── 4. Code generation ────────────────────────────────────────
-	const codegen = new CodeGen(checker, jsImports, bundledPackages);
-	const mainJs = codegen.generateAll(programs, {
-		isTest: options.isTest ?? false,
+	const emitTarget = registerPackageUnit(options, {
+		key: resolve(fromDir),
+		pkgName,
+		pkgTarget,
+		programs,
+		types: checker.types,
+		bundledPackages,
 	});
 
+	const isStrict = Boolean(options.strict || pkgTarget === "both");
+	const codegen = new CodeGen(checker, jsImports, bundledPackages, {
+		target: pkgTarget,
+		strict: isStrict,
+	});
+	const mainJs =
+		emitTarget === "wasm"
+			? wasmMarker(pkgName)
+			: codegen.generateAll(programs, {
+					isTest: options.isTest ?? false,
+				});
+
 	const mainChunk = {
 		js: mainJs,
 		sourceFiles: files.map((f) => resolve(f)),
 		sourcesContent: files.map((f) => readFileSync(f, "utf8")),
-		mappings: codegen.getMappings(),
+		mappings: emitTarget === "wasm" ? [] : codegen.getMappings(),
 	};
 
 	const merged = mergeCompilationChunks([...preambles, mainChunk]);
+	const { wasm, wat } = linkIntoBundle(options, merged, pkgTarget);
 
 	if (options.sourceMap && !options.isDependency) {
 		attachSourceMap(merged, outputDir);
@@ -405,8 +712,11 @@ export function compileFiles(files, options = {}) {
 
 	return {
 		pkgName,
+		target: pkgTarget,
 		js: merged.js,
 		css: allCss,
+		wasm,
+		wat,
 		programs,
 		exportedSymbols: checker.getExportedSymbols(),
 		exportedTypes: checker.getExportedTypes(),