gofront 1.3.6 → 1.3.8

package/README.md

@@ -79,7 +79,7 @@ identifier, literal, `)`, `]`, `}`, or certain keywords (`return`, `break`, `con
 `fallthrough`). This is why Go doesn't need explicit semicolons — and neither does
 GoFront.
 
-### 2. Parser (`src/parser.js`)
+### 2. Parser (`src/parser/`)
 
 A hand-written recursive-descent parser. No parser generators, no grammar files — just
 straightforward top-down parsing. Produces an AST where every node is a plain JS object
@@ -88,7 +88,7 @@ with a `kind` field (`"FuncDecl"`, `"IfStmt"`, `"BinaryExpr"`, etc.).
 Operator precedence is handled via a Pratt-style expression parser with numeric
 precedence levels.
 
-### 3. Type Checker (`src/typechecker.js`)
+### 3. Type Checker (`src/typechecker/`)
 
 Three-pass type checker operating on the AST:
 
@@ -103,7 +103,7 @@ Types are plain JS objects (`{ kind: "basic", name: "int" }`, `{ kind: "slice",
 elem: ... }`, etc.). The special `any` type acts as a recovery/escape hatch — any
 operation on it is silently permitted, preventing cascading errors.
 
-### 4. Code Generator (`src/codegen.js`)
+### 4. Code Generator (`src/codegen/`)
 
 Walks the typed AST and emits clean, readable JavaScript. No intermediate representation
 — the codegen writes directly to an output buffer with indentation tracking.
@@ -123,10 +123,11 @@ readable and debuggable — no name mangling, no opaque wrappers.
 
 | Go | JavaScript | Notes |
 |---|---|---|
-| `struct` | ES6 `class` | Single destructured-object constructor: `new Point({ X: 1, Y: 2 })` |
-| Methods | Class instance methods | Receiver is `this` |
+| `struct` | ES6 `class` | Positional constructor with zero-value defaults: `new Point(1, 2)`; a generated `__clone()` gives struct values Go copy semantics on assignment, call, return, `append`, and `range` |
+| Methods | Class instance methods | Receiver is `this` (typed `*T` for pointer receivers) |
 | Embedded structs | Flattened fields + delegation stubs | `Greet(...a) { return Base.prototype.Greet.call(this, ...a); }` |
-| `[]T` (slice) | `Array` | `append` → spread, `len` → `.length` |
+| `[]T` (slice) | `Array` | `append` → `__append`, `len` → `__len` |
+| `[]float32`, `[]int8`…`[]int32`, `[]uint8`/`[]byte`…`[]uint32`, `[]rune` | TypedArray (`Float32Array`, `Int32Array`, `Uint8Array`, …) | `[]float64` and `[]int` stay plain `Array`; slicing → `.subarray` |
 | `map[K]V` | Plain object `{}` | Key access via `[]`, iteration via `Object.entries()` |
 | `nil` | `null` | |
 | `error` | `__error` object | `error("msg")` → `__error("msg")`, `.Error()` → real method call. `toString()` for string context compat |
@@ -386,6 +387,8 @@ gofront <file.go>                compile single file → stdout
 gofront <dir>                    compile all *.go in directory → stdout
 gofront <input> -o out.js        write output to file (prints elapsed compile time e.g. "15ms")
 gofront <input> --check                    type-check only
+gofront check <dir>/...                    type-check every package under <dir> (Go-style `./...`)
+gofront test <dir>/... [--dom]             run tests for every package under <dir>
 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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.3.6",
+	"version": "1.3.8",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {

package/src/cli-core.js

@@ -229,6 +229,9 @@ export function parseTestArgs(argv) {
 }
 
 export function handleTest(targetDir = ".", options = {}) {
+	const pattern = parsePackagePattern(targetDir);
+	if (pattern) return runTestsRecursive(pattern, options);
+
 	let testTarget = targetDir;
 	try {
 		const project = detectProject(targetDir);
@@ -246,6 +249,69 @@ export function handleTest(targetDir = ".", options = {}) {
 	return runTests(testTarget, options);
 }
 
+async function runTestsRecursive(rootDir, options) {
+	const dirs = findPackageDirs(rootDir);
+	if (dirs.length === 0) {
+		throw new Error(`No .go files found under ${rootDir}`);
+	}
+	let exitCode = 0;
+	let stdout = "";
+	let stderr = "";
+	for (const dir of dirs) {
+		const result = await runTests(dir, options);
+		if (result.exitCode !== 0) exitCode = result.exitCode;
+		if (options.captureOutput) {
+			stdout += result.stdout ?? "";
+			stderr += result.stderr ?? "";
+		}
+	}
+	return options.captureOutput
+		? { exitCode, stdout, stderr, packages: dirs }
+		: { exitCode, packages: dirs };
+}
+
+// ── Package patterns (`dir/...`) ──────────────────────────────
+
+// Returns the root directory of a Go-style recursive pattern (`./...`,
+// `app/src/...`), or null when the argument is a plain path.
+export function parsePackagePattern(arg) {
+	if (arg === "...") return resolve(".");
+	if (!arg.endsWith("/...")) return null;
+	return resolve(arg.slice(0, -4) || ".");
+}
+
+const SKIPPED_DIRS = new Set(["node_modules", "dist", "public"]);
+
+// Lists every directory under root (inclusive) that contains .go or .templ
+// files, in sorted order, skipping hidden directories and build output.
+export function findPackageDirs(root) {
+	const out = [];
+	const walk = (dir) => {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+		if (
+			entries.some(
+				(e) =>
+					e.isFile() && (e.name.endsWith(".go") || e.name.endsWith(".templ")),
+			)
+		) {
+			out.push(dir);
+		}
+		for (const e of entries) {
+			if (!e.isDirectory()) continue;
+			if (e.name.startsWith(".") || SKIPPED_DIRS.has(e.name)) continue;
+			walk(join(dir, e.name));
+		}
+	};
+	walk(resolve(root));
+	return out;
+}
+
 // ── Project detection ─────────────────────────────────────────
 
 function loadProjectConfig(projectRoot) {
@@ -357,6 +423,26 @@ export function parseCheckArgs(argv) {
 }
 
 export function handleCheck(targetDir = ".", options = {}) {
+	const pattern = parsePackagePattern(targetDir);
+	if (pattern) {
+		const dirs = findPackageDirs(pattern);
+		if (dirs.length === 0) {
+			throw new Error(`No .go files found under ${targetDir}`);
+		}
+		const startMs = performance.now();
+		const packages = [];
+		for (const dir of dirs) {
+			const pkgStart = performance.now();
+			runCompile(dir, true, { ...options });
+			packages.push({
+				dir,
+				elapsedMs: (performance.now() - pkgStart).toFixed(0),
+			});
+		}
+		const elapsedMs = (performance.now() - startMs).toFixed(0);
+		return { target: targetDir, compileTarget: pattern, elapsedMs, packages };
+	}
+
 	const project = detectProject(targetDir);
 	const targetPath = resolve(targetDir);
 	let isDir = false;

package/src/codegen/expressions.js

@@ -610,16 +610,23 @@ export const expressionGenMethods = {
 	},
 
 	_genTypeAssertExpr(expr) {
-		const val = this.genExpr(expr.expr);
+		const src = this.genExpr(expr.expr);
+		// The operand appears in both the check and the result; hoist calls so
+		// they run once.
+		const hoist = this._hasCallExpr(expr.expr);
+		const val = hoist ? "__v" : src;
 		const check = this._typeCheckExpr(expr.type, val);
+		const wrap = (body) => (hoist ? `((__v) => ${body})(${src})` : body);
 		if (!expr._commaOk) {
 			// plain assertion: panic if check fails (matches Go behavior)
-			if (check === "true") return val; // can't check at runtime — pass through
-			return `(${check} ? ${val} : (() => { throw new Error("interface conversion: type assertion failed"); })())`;
+			if (check === "true") return src; // can't check at runtime — pass through
+			return wrap(
+				`(${check} ? ${val} : (() => { throw new Error("interface conversion: type assertion failed"); })())`,
+			);
 		}
 		// comma-ok: emit [value-or-zero, runtimeTypeCheck]
 		const zero = this.zeroValueForTypeNode(expr.type);
-		return `(${check} ? [${val}, true] : [${zero}, false])`;
+		return wrap(`(${check} ? [${val}, true] : [${zero}, false])`);
 	},
 
 	_genTypeConversionCall(expr) {
@@ -1028,16 +1035,28 @@ export const expressionGenMethods = {
 
 	getTypeName(typeNode) {
 		if (!typeNode) return null;
-		if (typeNode.kind === "TypeName") return typeNode.name;
+		if (typeNode.kind === "TypeName") return this._dequalify(typeNode.name);
 		if (typeNode.kind === "GenericTypeName") return typeNode.name;
 		if (typeNode.kind === "Ident") return typeNode.name;
 		if (typeNode.kind === "InstantiationExpr")
 			return this.getTypeName(typeNode.expr);
-		if (typeNode.kind === "SelectorExpr")
-			return `${this.getTypeName(typeNode.expr)}.${typeNode.field}`;
+		if (typeNode.kind === "SelectorExpr") {
+			const base = this.getTypeName(typeNode.expr);
+			if (this.bundledPackages.has(base)) return typeNode.field;
+			return `${base}.${typeNode.field}`;
+		}
 		return null;
 	},
 
+	// Bundled GoFront packages are inlined, so `pkg.T` names the class `T`.
+	_dequalify(name) {
+		const dot = name.indexOf(".");
+		if (dot < 0) return name;
+		return this.bundledPackages.has(name.slice(0, dot))
+			? name.slice(dot + 1)
+			: name;
+	},
+
 	isIntType(t) {
 		if (!t) return false;
 		if (t.kind === "untyped") return t.base === "int";
@@ -1063,6 +1082,7 @@ export const expressionGenMethods = {
 	_zeroForNamedType(name) {
 		if (name === "strings.Builder") return '{ _buf: "" }';
 		if (name === "bytes.Buffer") return "{ _buf: [] }";
+		name = this._dequalify(name);
 		if (this.structNames.has(name)) return `new ${name}()`;
 		return "null";
 	},

package/src/codegen/index.js

@@ -31,6 +31,7 @@ import {
 	HELPER_PATH_CLEAN,
 	HELPER_S,
 	HELPER_SCLONE,
+	HELPER_SORT_SLICE,
 	HELPER_SPRINTF,
 	HELPER_TESTING,
 	HELPER_TIME_FMT,
@@ -113,6 +114,7 @@ export class CodeGen {
 		this._usesError = false;
 		this._usesErrorIs = false;
 		this._usesPathClean = false;
+		this._usesSortSlice = false;
 		this._usesTimeFmt = false;
 		this._usesTimeParse = false;
 		this._usesTesting = false;
@@ -319,6 +321,15 @@ export class CodeGen {
 			if (d.kind === "TypeDecl" && d.type.kind === "StructType")
 				this.structNames.add(d.name);
 		}
+		// Structs from bundled GoFront packages are inlined under their bare name.
+		// Skip aliases (key differs from the type's own name) — no class is emitted for them.
+		if (this.checker) {
+			for (const [name, t] of this.checker.types) {
+				if (name.includes(".") || t?.name !== name) continue;
+				if (t.kind === "named" && t.underlying?.kind === "struct")
+					this.structNames.add(name);
+			}
+		}
 	}
 
 	_collectMethodMap(program) {
@@ -368,6 +379,7 @@ export class CodeGen {
 			[this._usesError, HELPER_ERROR],
 			[this._usesErrorIs, HELPER_ERROR_IS],
 			[this._usesPathClean, HELPER_PATH_CLEAN],
+			[this._usesSortSlice, HELPER_SORT_SLICE],
 			[this._usesTimeFmt, HELPER_TIME_FMT],
 			[this._usesTimeParse, HELPER_TIME_PARSE],
 			[needsTesting, HELPER_TESTING],

package/src/codegen/runtime.js

@@ -19,6 +19,21 @@ export const HELPER_APPEND = `var __append = __append || function(a, ...b) {
 
 export const HELPER_S = "var __s = __s || function(a) { return a || []; };";
 
+// In-place stable sort driven by Go's less(i, j) index comparator. The
+// comparator reads the live slice, so elements are moved as it runs
+// (binary insertion: O(n log n) compares, O(n^2) moves, fine for typed arrays).
+export const HELPER_SORT_SLICE = `var __sortSlice = __sortSlice || function(s, less) {
+  if (!s) return;
+  for (let i = 1; i < s.length; i++) {
+    let lo = 0, hi = i;
+    while (lo < hi) { const mid = (lo + hi) >>> 1; if (less(i, mid)) hi = mid; else lo = mid + 1; }
+    if (lo === i) continue;
+    const v = s[i];
+    for (let k = i; k > lo; k--) s[k] = s[k - 1];
+    s[lo] = v;
+  }
+};`;
+
 // Copy of a struct value whose class is not statically known.
 export const HELPER_SCLONE = `var __sclone = __sclone || function(x) {
   if (x === null || typeof x !== "object") return x;

package/src/codegen/statements.js

@@ -253,8 +253,9 @@ export const statementGenMethods = {
 	_genCommaOkTypeAssert(stmt) {
 		const val = this.genExpr(stmt.rhs[0]);
 		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
-		const tmp = "__ta";
-		this.line(`let ${tmp} = ${val};`);
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const tmp = `__ta${this._tmpCounter}`;
+		this.line(`const ${tmp} = ${val};`);
 		if (vName !== "_") this.line(`${vName} = ${tmp}[0];`);
 		if (okName !== "_") this.line(`${okName} = ${tmp}[1];`);
 	},
@@ -273,8 +274,9 @@ export const statementGenMethods = {
 	},
 
 	_genMultiAssignWithBlanks(stmt, lhs, rhs, rhsStr) {
-		const tmp = "__t";
-		this.line(`let ${tmp} = ${rhsStr};`);
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const tmp = `__t${this._tmpCounter}`;
+		this.line(`const ${tmp} = ${rhsStr};`);
 		for (let i = 0; i < lhs.length; i++) {
 			if (lhs[i] !== "_") {
 				const src = rhs.length === 1 ? `${tmp}[${i}]` : rhs[i];

package/src/codegen/stdlib/math.js

@@ -6,7 +6,6 @@ const MATH1 = {
 	Abs: "abs",
 	Floor: "floor",
 	Ceil: "ceil",
-	Round: "round",
 	Sqrt: "sqrt",
 	Cbrt: "cbrt",
 	Log: "log",
@@ -29,6 +28,8 @@ const MATH2 = {
 	Hypot: "hypot",
 };
 const MATH_EXTRA = {
+	// Go rounds half away from zero; Math.round rounds half toward +Infinity.
+	Round: ([x]) => `(Math.sign(${x}) * Math.round(Math.abs(${x})))`,
 	Mod: ([x, y]) => `${x} % ${y}`,
 	Inf: ([x]) => `(${x} >= 0 ? Infinity : -Infinity)`,
 	IsNaN: ([x]) => `Number.isNaN(${x})`,

package/src/codegen/stdlib/sort.js

@@ -6,12 +6,10 @@ const SORT_DISPATCH = {
 	Ints: (a) => `${a[0]}.sort((a, b) => a - b)`,
 	Float64s: (a) => `${a[0]}.sort((a, b) => a - b)`,
 	Strings: (a) => `${a[0]}.sort()`,
-	Slice: (a) =>
-		`${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`,
-	SliceStable: (a) =>
-		`${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`,
+	Slice: (a) => `__sortSlice(${a[0]}, ${a[1]})`,
+	SliceStable: (a) => `__sortSlice(${a[0]}, ${a[1]})`,
 	SliceIsSorted: (a) =>
-		`${a[0]}.every((v, i, a) => i === 0 || ${a[1]}(a[i - 1], v))`,
+		`((s, less) => { for (let i = (s?.length ?? 0) - 1; i > 0; i--) if (less(i, i - 1)) return false; return true; })(${a[0]}, ${a[1]})`,
 	Search: (a) =>
 		`((n, f) => { let lo = 0, hi = n; while (lo < hi) { const mid = (lo + hi) >>> 1; if (f(mid)) hi = mid; else lo = mid + 1; } return lo; })(${a[0]}, ${a[1]})`,
 	IntsAreSorted: (a) =>
@@ -25,6 +23,7 @@ const SORT_DISPATCH = {
 /** @type {ThisType<CodeGen>} */
 export const sortMethods = {
 	_genSort(fn, a) {
+		if (fn === "Slice" || fn === "SliceStable") this._usesSortSlice = true;
 		const gen = SORT_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;
 	},

package/src/compiler.js

@@ -85,6 +85,7 @@ export function resolveImports(
 	jsImports,
 	bundledPackages,
 	preambles,
+	bundledDirs = new Set(),
 ) {
 	const fromDir = dirname(resolve(fromFile));
 	const allImports = programs.flatMap((p) => p.imports);
@@ -130,8 +131,13 @@ export function resolveImports(
 					);
 					continue;
 				}
-				const dep = compileDir(depDir);
-				preambles.push(dep.js);
+				// Diamond imports: a package reached through several paths is
+				// compiled for its symbols each time but emitted only once.
+				const depKey = resolve(depDir);
+				const alreadyBundled = bundledDirs.has(depKey);
+				bundledDirs.add(depKey);
+				const dep = compileDir(depDir, { bundledDirs });
+				if (!alreadyBundled) preambles.push(dep.js);
 				if (alias === "_") continue;
 				if (alias === ".") {
 					checker.addDefinitions(dep.exportedTypes, dep.exportedSymbols);
@@ -260,6 +266,7 @@ export function compileFiles(files, options = {}) {
 		jsImports,
 		bundledPackages,
 		preambles,
+		options.bundledDirs ?? new Set(),
 	);
 
 	// ── 3. Type-check ─────────────────────────────────────────────

package/src/index.js

@@ -19,7 +19,7 @@ const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
 import { mkdirSync, statSync, watch, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname, relative, resolve } from "node:path";
 import { copyAssets } from "./asset-manager.js";
 import {
 	formatBuildSummary,
@@ -56,8 +56,8 @@ GoFront — a Go-inspired language that compiles to JavaScript
 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 check [dir]            Type-check only
-  gofront test [dir] [--dom]     Run unit tests (-v verbose, -run <regex>)
+  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
@@ -131,8 +131,19 @@ if (args[0] === "test") {
 if (args[0] === "check") {
 	const { targetDir } = parseCheckArgs(args.slice(1));
 	try {
-		const { elapsedMs } = handleCheck(targetDir);
-		console.error(`gofront: ${targetDir} — OK (${elapsedMs}ms)`);
+		const { elapsedMs, packages } = handleCheck(targetDir);
+		if (packages) {
+			for (const pkg of packages) {
+				console.error(
+					`gofront: ${relative(process.cwd(), pkg.dir) || "."} — OK (${pkg.elapsedMs}ms)`,
+				);
+			}
+			console.error(
+				`gofront: ${packages.length} packages — OK (${elapsedMs}ms)`,
+			);
+		} else {
+			console.error(`gofront: ${targetDir} — OK (${elapsedMs}ms)`);
+		}
 		process.exit(0);
 	} catch (e) {
 		console.error(`gofront: ${e.message}`);

package/src/parser/expressions.js

@@ -352,6 +352,7 @@ export const expressionParserMethods = {
 			if (
 				tt === T.MAP ||
 				tt === T.IDENT ||
+				tt === T.DOT || // qualified types: []pkg.Type{...}
 				tt === T.STAR ||
 				tt === T.INT ||
 				tt === T.FLOAT ||

package/src/typechecker/assignability.js

@@ -343,6 +343,8 @@ export const assignabilityMethods = {
 	},
 
 	implements(srcType, iface, _node) {
+		// *T has the full method set of T (value + pointer receivers).
+		if (srcType?.kind === "pointer") srcType = this.resolveType(srcType.base);
 		let base = srcType.kind === "named" ? srcType.underlying : srcType;
 		base = this.resolveType(base);
 		const methodMap =

package/src/typechecker/expressions.js

@@ -430,9 +430,39 @@ export const expressionCheckMethods = {
 			}
 			return this.instantiateGenericFunc(baseType, typeArgs);
 		}
+		// The parser's type-arg heuristic mistakes `xs[d.Field]` (uppercase field
+		// selector as index) for a generic instantiation. When the base is an
+		// indexable value and the sole "type arg" is a plain/qualified name,
+		// rewrite the node in place into an IndexExpr and check that instead.
+		const indexExpr = this._instantiationAsIndex(expr, baseType);
+		if (indexExpr) return this._checkIndexExpr(indexExpr, scope);
 		return baseType;
 	},
 
+	_instantiationAsIndex(expr, baseType) {
+		if (!baseType || expr.typeArgs.length !== 1) return null;
+		const ta = expr.typeArgs[0];
+		if (ta.kind !== "TypeName") return null;
+		const btu =
+			baseType.kind === "named"
+				? (this.resolveType(baseType.underlying) ?? baseType.underlying)
+				: baseType;
+		const indexable =
+			btu?.kind === "slice" ||
+			btu?.kind === "array" ||
+			btu?.kind === "map" ||
+			isString(baseType);
+		if (!indexable) return null;
+		const parts = ta.name.split(".");
+		let index = { kind: "Ident", name: parts[0], _line: expr._line };
+		for (let i = 1; i < parts.length; i++)
+			index = { kind: "SelectorExpr", expr: index, field: parts[i] };
+		expr.kind = "IndexExpr";
+		expr.index = index;
+		delete expr.typeArgs;
+		return expr;
+	},
+
 	_constIntValue(expr) {
 		if (expr.kind === "BasicLit" && expr.litKind === "INT")
 			return Number(expr.value);

package/src/typechecker/index.js

@@ -505,7 +505,10 @@ export class TypeChecker {
 		const recvNamedType = this.types.get(recvTypeName);
 		this._injectGenericReceiverTypeParams(inner, recvNamedType);
 		const recvType = this.resolveTypeNodeName(decl.recvType, outer);
-		inner.define(decl.recvName, recvType);
+		inner.define(
+			decl.recvName,
+			decl.recvPointer ? { kind: "pointer", base: recvType } : recvType,
+		);
 		for (const p of decl.params) {
 			inner.define(p.name, this.resolveTypeNode(p.type, inner));
 		}

package/src/typechecker/resolve.js

@@ -88,7 +88,12 @@ export const resolveMethods = {
 					if (fromScope?.kind === "typeParam") return fromScope;
 				}
 				const named = this.types.get(node.name);
-				if (named) return named;
+				if (named) {
+					// `pkg.T` in a type position counts as using the import.
+					const dot = node.name.indexOf(".");
+					if (dot > 0) this.globals.lookup(node.name.slice(0, dot));
+					return named;
+				}
 				return this.err(`Unknown type '${node.name}'`, node);
 			}
 			case "GenericTypeName": {
@@ -132,6 +137,18 @@ export const resolveMethods = {
 					{ kind: "TypeName", name: node.name },
 					scope,
 				);
+			case "SelectorExpr":
+				// `pkg.T{}` composite literal — the parser keeps the type as a
+				// SelectorExpr; resolve it like a qualified TypeName.
+				if (node.expr?.kind === "Ident" && typeof node.field === "string") {
+					const qualified = `${node.expr.name}.${node.field}`;
+					if (this.types.has(qualified))
+						return this.resolveTypeNode(
+							{ kind: "TypeName", name: qualified },
+							scope,
+						);
+				}
+				return ANY;
 			case "ArrayType":
 				return this._resolveArrayTypeNode(node, scope);
 			case "FuncType":

package/src/typechecker/stdlib/extended.js

@@ -5,6 +5,7 @@ import {
 	ANY,
 	BOOL,
 	ERROR,
+	FLOAT32,
 	FLOAT64,
 	INT,
 	STRING,
@@ -256,7 +257,7 @@ export function setupExtendedGlobals(globals, types) {
 		members: {
 			Intn: { kind: "func", params: [INT], returns: [INT] },
 			Float64: { kind: "func", params: [], returns: [FLOAT64] },
-			Float32: { kind: "func", params: [], returns: [FLOAT64] },
+			Float32: { kind: "func", params: [], returns: [FLOAT32] },
 			Int: { kind: "func", params: [], returns: [INT] },
 			Int63: { kind: "func", params: [], returns: [INT] },
 			Int63n: { kind: "func", params: [INT], returns: [INT] },