gofront 1.4.0 → 1.6.0

package/src/typechecker/index.js

@@ -25,9 +25,18 @@ import {
 	TAINTED_ANY,
 	TypeCheckError,
 	typeStr,
+	VALID_TARGETS,
 	VOID,
 } from "./types.js";
 
+function rootIdentName(e) {
+	if (!e) return null;
+	if (e.kind === "Ident") return e.name;
+	if (e.kind === "SelectorExpr" || e.kind === "IndexExpr")
+		return rootIdentName(e.expr);
+	return null;
+}
+
 // Re-export for consumers that import from typechecker.js
 export { TypeCheckError, typeStr };
 
@@ -36,6 +45,11 @@ export class TypeChecker {
 		this.types = new Map(); // named types
 		this.globals = new Scope();
 		this.errors = [];
+		this.warnings = []; // non-fatal diagnostics (e.g. boundary-call-in-loop hints)
+		this.target = "js";
+		this.pkgName = null;
+		this.blockers = new Map();
+		this.summary = null;
 		this._currentFile = null; // filename of file currently being checked
 		this._currentSource = null;
 		this._loopDepth = 0; // for break/continue validation
@@ -64,7 +78,8 @@ export class TypeChecker {
 	// Add an imported GoFront package as a qualified namespace.
 	// e.g. addPackageNamespace('utils', symbolsMap, typesMap)
 	// lets callers type-check `utils.Foo` via SelectorExpr.
-	addPackageNamespace(pkgName, symbols, types) {
+	// `target` is the imported package's compile target ("js"/"wasm"/"both").
+	addPackageNamespace(pkgName, symbols, types, target = null) {
 		const members = {};
 		for (const [name, type] of symbols) members[name] = type;
 		// _gofront: true marks this as a GoFront package — exported identifier rules apply
@@ -73,6 +88,7 @@ export class TypeChecker {
 			name: pkgName,
 			members,
 			_gofront: true,
+			_target: target,
 		});
 		for (const [name, type] of types) {
 			this.types.set(name, type);
@@ -117,17 +133,62 @@ export class TypeChecker {
 		return new Map(this.types);
 	}
 
-	err(msg, node) {
+	recordBlocker(category, item = null) {
+		if (!this.blockers.has(category)) {
+			this.blockers.set(category, []);
+		}
+		this.blockers.get(category).push(item);
+	}
+
+	getSummary() {
+		if (this.blockers.size === 0) return null;
+		let total = 0;
+		const parts = [];
+		for (const [category, items] of this.blockers) {
+			const uniqueItems = [
+				...new Set(items.filter((x) => x != null && x !== "")),
+			];
+			const count = uniqueItems.length > 0 ? uniqueItems.length : items.length;
+			total += count;
+			const itemsStr =
+				uniqueItems.length > 0 ? ` (${uniqueItems.join(", ")})` : "";
+			// "gom usage" is a mass noun; everything else pluralises on the last word.
+			const label =
+				count === 1 || category === "gom usage" ? category : `${category}s`;
+			parts.push(`${count} ${label}${itemsStr}`);
+		}
+		const noun = total === 1 ? "blocker" : "blockers";
+		const what = this.target === "both" ? "both" : "wasm";
+		return `package '${this.pkgName}' cannot be ${what}: ${total} ${noun} — ${parts.join(", ")}`;
+	}
+
+	err(msg, node, hint = null) {
 		const e = new TypeCheckError(
 			msg,
 			node,
 			this._currentFile,
 			this._currentSource,
+			hint,
 		);
 		this.errors.push(e);
 		return TAINTED_ANY; // tainted recovery type — suppresses downstream cascade errors
 	}
 
+	// Non-fatal diagnostic: formatted like an error but collected separately so
+	// the build still succeeds. The compiler prints these as warnings.
+	warn(msg, node, hint = null) {
+		const e = new TypeCheckError(
+			msg,
+			node,
+			this._currentFile,
+			this._currentSource,
+			hint,
+		);
+		// `log.warn` adds the "warning:" label, so strip the error one here:
+		// "Type error in main.go at line 3:5: msg" → "main.go at line 3:5: msg".
+		this.warnings.push(e.message.replace(/^Type error(?: in)?[: ]\s*/, ""));
+	}
+
 	_reportUnused(scope, node) {
 		for (const name of scope.unusedLocals()) {
 			this.err(`'${name}' declared and not used`, node);
@@ -163,18 +224,181 @@ export class TypeChecker {
 		}
 	}
 
-	// Like check() but operates over multiple programs (same-package multi-file).
-	// All passes run across all files before moving to the next pass,
-	// so every file sees every other file's declarations.
 	checkAll(programs) {
+		for (const p of programs) {
+			const d = p._targetDirective;
+			if (!d) continue;
+			this._setCurrentFile(p);
+			if (!VALID_TARGETS.has(d.value)) {
+				this.err(
+					`unknown //gofront:target '${d.value}' (expected js, wasm or both)`,
+					d,
+				);
+				p.target = null;
+				if (this.target === d.value) this.target = "js";
+			} else if (!d.beforePackage) {
+				this.err("//gofront:target must appear before the package clause", d);
+			}
+		}
+		if (programs.length > 0) {
+			if (!this.target || this.target === "js") {
+				const pTarget = programs.find((p) => p.target)?.target;
+				if (pTarget) this.target = pTarget;
+			}
+			if (!this.pkgName) {
+				this.pkgName = programs[0].pkg?.name ?? null;
+			}
+		}
+
+		if (this.target === "wasm" || this.target === "both") {
+			for (const p of programs) {
+				if (p._filename?.endsWith(".templ")) {
+					this._setCurrentFile(p);
+					const fileName = p._filename.split("/").pop();
+					this.recordBlocker(".templ file", fileName);
+					this.err(
+						`.templ files are not allowed in wasm packages; move '${fileName}' to a js package`,
+						p.pkg,
+					);
+				}
+			}
+		}
+
 		this._collectTypesPass(programs);
 		this._collectFuncsPass(programs);
 		this._promoteEmbeddedMethods();
 		this._collectVarsConstsPass(programs);
 		this._checkTopDeclsPass(programs);
+
+		if (this.target === "both") {
+			this._checkMutablePackageVars(programs);
+		}
+
+		if (this.blockers.size > 0) {
+			const summaryLine = this.getSummary();
+			this.summary = summaryLine;
+			const summaryErr = new Error(summaryLine);
+			summaryErr.isSummary = true;
+			this.errors.push(summaryErr);
+		}
+
 		return this.errors;
 	}
 
+	_checkMutablePackageVars(programs) {
+		const pkgVars = new Set();
+		for (const p of programs) {
+			for (const d of p.decls) {
+				if (d.kind === "VarDecl") {
+					for (const spec of d.decls) {
+						for (const name of spec.names) {
+							if (name !== "_") pkgVars.add(name);
+						}
+					}
+				}
+			}
+		}
+		if (pkgVars.size === 0) return;
+
+		const SCOPE_KINDS = new Set([
+			"Block",
+			"FuncLit",
+			"ForStmt",
+			"IfStmt",
+			"SwitchStmt",
+			"TypeSwitchStmt",
+			"CaseClause",
+		]);
+
+		const report = (root, node) => {
+			this.recordBlocker("mutable package variable", root);
+			this.err(
+				`package-level variable '${root}' is mutated; not allowed in 'both' packages (each target gets its own copy)`,
+				node,
+			);
+		};
+
+		const checkBody = (body, initialLocals) => {
+			const scopes = [new Set(initialLocals)];
+			const isLocal = (name) => scopes.some((s) => s.has(name));
+			const declare = (name) => {
+				if (name && name !== "_") scopes[scopes.length - 1].add(name);
+			};
+			const flag = (e, node) => {
+				const root = rootIdentName(e);
+				if (root && pkgVars.has(root) && !isLocal(root)) report(root, node);
+			};
+
+			const walk = (node) => {
+				if (!node || typeof node !== "object") return;
+				if (Array.isArray(node)) {
+					for (const item of node) walk(item);
+					return;
+				}
+				const opensScope = SCOPE_KINDS.has(node.kind);
+				if (opensScope) scopes.push(new Set());
+				switch (node.kind) {
+					case "FuncLit":
+						for (const p of node.params ?? []) declare(p.name);
+						for (const r of node.returnType?._namedReturns ?? [])
+							declare(r.name);
+						break;
+					case "VarDecl":
+						for (const spec of node.decls ?? [])
+							for (const name of spec.names ?? []) declare(name);
+						break;
+					case "DefineStmt":
+						for (const e of node.lhs ?? [])
+							if (e.kind === "Ident") declare(e.name);
+						break;
+					case "TypeSwitchStmt":
+						declare(node.assign);
+						break;
+					case "AssignStmt":
+						for (const e of node.lhs) flag(e, node);
+						break;
+					case "IncDecStmt":
+						flag(node.expr, node);
+						break;
+					case "UnaryExpr":
+						if (node.op === "&") flag(node.operand, node);
+						break;
+					case "SelectorExpr":
+						// Pointer-receiver method call or value: `G.Bump()` mutates G.
+						if (node._isMethodValue && node._type?._ptrRecv)
+							flag(node.expr, node);
+						break;
+				}
+				for (const key of Object.keys(node)) {
+					if (key.startsWith("_")) continue;
+					walk(node[key]);
+				}
+				if (opensScope) scopes.pop();
+			};
+			walk(body);
+		};
+
+		for (const p of programs) {
+			if (p._filename?.endsWith("_test.go")) continue;
+			this._currentFile = p._filename;
+			this._currentSource = p._source;
+			for (const d of p.decls) {
+				if ((d.kind === "FuncDecl" || d.kind === "MethodDecl") && d.body) {
+					if (d.name === "init" && d.kind === "FuncDecl") continue;
+					const locals = [];
+					if (d.recvName) locals.push(d.recvName);
+					for (const prm of d.params ?? []) if (prm.name) locals.push(prm.name);
+					for (const r of d.returnType?._namedReturns ?? [])
+						if (r.name) locals.push(r.name);
+					checkBody(d.body, locals);
+				} else if (d.kind === "VarDecl") {
+					// Closures in package-level initializers run after init.
+					for (const spec of d.decls ?? []) checkBody(spec.value, []);
+				}
+			}
+		}
+	}
+
 	_collectTypesPass(programs) {
 		for (const p of programs) {
 			for (const d of p.decls) {
@@ -318,6 +542,7 @@ export class TypeChecker {
 					? existing
 					: { kind: "named", name: decl.name };
 			named.underlying = underlying;
+			named._target = this.target;
 			named._generic = {
 				typeParams: typeParamTypes,
 				declNode: decl,
@@ -343,6 +568,7 @@ export class TypeChecker {
 				? existing
 				: { kind: "named", name: decl.name };
 		named.underlying = underlying;
+		named._target = this.target;
 		if (underlying.kind === "struct") {
 			underlying.name = decl.name;
 			underlying.methods = new Map();
@@ -507,6 +733,10 @@ export class TypeChecker {
 	}
 
 	_collectCssDecl(decl) {
+		if (this.target === "wasm" || this.target === "both") {
+			this.recordBlocker("css declaration");
+			this.err("css declarations are not allowed in wasm packages", decl);
+		}
 		const paramTypes = (decl.params || []).map((p) =>
 			this.resolveTypeNode(p.type, this.globals),
 		);
@@ -551,17 +781,40 @@ export class TypeChecker {
 	}
 
 	checkFuncDecl(decl, outer) {
+		if (
+			(this.target === "wasm" || this.target === "both") &&
+			(decl.async || decl.isAsync)
+		) {
+			this.recordBlocker("async function", decl.name);
+			this.err(
+				"async functions are not supported in wasm packages; keep async code in a js package",
+				decl,
+			);
+		}
 		const inner = new Scope(outer);
 		this._injectTypeParams(decl, inner, outer);
 		for (const p of decl.params) {
 			inner.define(p.name, this.resolveTypeNode(p.type, inner));
 		}
 		const returnType = this._setupFuncReturnType(decl, inner, outer);
+		const savedSharedAlloc = this._sharedAllocOk;
+		this._sharedAllocOk = decl.name === "init";
 		this._runFuncBody(decl, inner, returnType);
+		this._sharedAllocOk = savedSharedAlloc;
 		this._checkMissingReturn(decl, returnType, "function");
 	}
 
 	checkMethodDecl(decl, outer) {
+		if (
+			(this.target === "wasm" || this.target === "both") &&
+			(decl.async || decl.isAsync)
+		) {
+			this.recordBlocker("async function", decl.name);
+			this.err(
+				"async functions are not supported in wasm packages; keep async code in a js package",
+				decl,
+			);
+		}
 		const inner = new Scope(outer);
 		const recvTypeName =
 			decl.recvType.kind === "GenericTypeName"
@@ -640,6 +893,8 @@ export class TypeChecker {
 	}
 
 	checkVarDecl(decl, scope) {
+		const savedSharedAlloc = this._sharedAllocOk;
+		this._sharedAllocOk = scope === this.globals;
 		for (const spec of decl.decls) {
 			let type = spec.type ? this.resolveTypeNode(spec.type, scope) : null;
 			if (spec.value) {
@@ -653,6 +908,7 @@ export class TypeChecker {
 			if (!type) type = ANY;
 			for (const name of spec.names) scope.defineLocal(name, type);
 		}
+		this._sharedAllocOk = savedSharedAlloc;
 	}
 
 	checkConstDecl(decl, scope) {

package/src/typechecker/resolve.js

@@ -4,6 +4,7 @@
 import {
 	ANY,
 	BASIC_TYPES,
+	COMPARABLE,
 	defaultType,
 	isAny,
 	isTypedArraySlice,
@@ -12,6 +13,7 @@ import {
 	typedArrayConstructorForElem,
 	typeStr,
 	VOID,
+	WASM_STDLIB_MEMBERS,
 } from "./types.js";
 
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
@@ -81,8 +83,7 @@ export const resolveMethods = {
 		switch (node.kind) {
 			case "TypeName": {
 				if (BASIC_TYPES[node.name]) return BASIC_TYPES[node.name];
-				if (node.name === "comparable")
-					return { kind: "basic", name: "comparable" };
+				if (node.name === "comparable") return COMPARABLE;
 				if (scope) {
 					const fromScope = scope.lookup(node.name);
 					if (fromScope?.kind === "typeParam") return fromScope;
@@ -99,12 +100,16 @@ export const resolveMethods = {
 			case "GenericTypeName": {
 				const base = this.types.get(node.name);
 				if (!base) return this.err(`Unknown type '${node.name}'`, node);
-				if (base.kind === "named" && base._generic)
-					return this.instantiateGenericType(
+				if (base.kind === "named" && base._generic) {
+					const res = this.instantiateGenericType(
 						base._generic,
 						node.typeArgs,
 						scope,
 					);
+					node._typeArgs = res.typeArgs;
+					node._genericType = base;
+					return res;
+				}
 				return this.err(`Type '${node.name}' is not generic`, node);
 			}
 			case "TypeParam": {
@@ -266,12 +271,15 @@ export const resolveMethods = {
 		const typeArgs = typeArgNodes.map((n) => this.resolveTypeNode(n, scope));
 		for (let i = 0; i < generic.typeParams.length; i++)
 			map.set(generic.typeParams[i].name, typeArgs[i] ?? ANY);
+		// Resolve the declaration with its type params in scope (as typeParams,
+		// never as value symbols), then substitute the concrete arguments.
 		const typeScope = new Scope(this.globals);
-		for (const [name, type] of map) typeScope.define(name, type);
+		for (const tp of generic.typeParams) typeScope.define(tp.name, tp);
 		const underlying = this.resolveTypeNode(generic.declNode.type, typeScope);
 		const instantiated = this.substituteType(underlying, map);
 		if (instantiated.kind === "struct") {
 			instantiated.name = generic.declNode.name;
+			instantiated.typeArgs = typeArgs;
 			if (!instantiated.methods) instantiated.methods = new Map();
 			if (generic.methods) {
 				for (const [mName, mType] of generic.methods)
@@ -281,6 +289,7 @@ export const resolveMethods = {
 		return {
 			kind: "named",
 			name: generic.declNode.name,
+			typeArgs,
 			underlying: instantiated,
 		};
 	},
@@ -406,6 +415,9 @@ export const resolveMethods = {
 				return this._fieldTypeInterface(base, baseType, field, node);
 			case "namespace":
 				return this._fieldTypeNamespace(base, field, node);
+			case "shared":
+				if (base.methods?.has(field)) return base.methods.get(field);
+				return this.err(`No method '${field}' on ${typeStr(baseType)}`, node);
 			case "slice":
 				if (isTypedArraySlice(base)) {
 					return this._fieldTypeTypedArraySlice(base, baseType, field, node);
@@ -475,7 +487,24 @@ export const resolveMethods = {
 				`cannot refer to unexported name ${base.name}.${field}`,
 				node,
 			);
-		if (field in base.members) return base.members[field];
+		if (field in base.members) {
+			if (
+				(this.target === "wasm" || this.target === "both") &&
+				WASM_STDLIB_MEMBERS.has(base.name)
+			) {
+				const allowed = WASM_STDLIB_MEMBERS.get(base.name);
+				if (allowed && !allowed.has(field)) {
+					const name = `${base.name}.${field}`;
+					this.recordBlocker("unsupported stdlib member", name);
+					return this.err(
+						`'${name}' is not yet available in wasm packages`,
+						node,
+						"move this call to a JS package, or use a supported alternative",
+					);
+				}
+			}
+			return base.members[field];
+		}
 		return this.err(`No member '${field}' in namespace ${base.name}`, node);
 	},
 };

package/src/typechecker/stdlib/core.js

@@ -9,6 +9,8 @@ import {
 	INT,
 	STRING,
 	UINT8,
+	UINT32,
+	UINT64,
 	VOID,
 } from "../types.js";
 
@@ -428,6 +430,21 @@ export function setupCoreGlobals(globals, types) {
 		},
 	});
 
+	globals.define("bits", {
+		kind: "namespace",
+		name: "bits",
+		members: {
+			LeadingZeros32: { kind: "func", params: [UINT32], returns: [INT] },
+			TrailingZeros32: { kind: "func", params: [UINT32], returns: [INT] },
+			OnesCount32: { kind: "func", params: [UINT32], returns: [INT] },
+			RotateLeft32: { kind: "func", params: [UINT32, INT], returns: [UINT32] },
+			LeadingZeros64: { kind: "func", params: [UINT64], returns: [INT] },
+			TrailingZeros64: { kind: "func", params: [UINT64], returns: [INT] },
+			OnesCount64: { kind: "func", params: [UINT64], returns: [INT] },
+			RotateLeft64: { kind: "func", params: [UINT64, INT], returns: [UINT64] },
+		},
+	});
+
 	globals.define("errors", {
 		kind: "namespace",
 		name: "errors",
@@ -523,6 +540,14 @@ export function setupCoreGlobals(globals, types) {
 		},
 	});
 
+	// Slice helpers that return a slice of the same type as their first argument.
+	const sameSlice = (params, extra = {}) => ({
+		kind: "func",
+		params,
+		returns: [ANY],
+		_derivedReturn: "arg0",
+		...extra,
+	});
 	globals.define("slices", {
 		kind: "namespace",
 		name: "slices",
@@ -541,26 +566,16 @@ export function setupCoreGlobals(globals, types) {
 			Min: { kind: "func", params: [ANY], returns: [ANY] },
 			MaxFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
 			MinFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-			Clone: { kind: "func", params: [ANY], returns: [ANY] },
-			Compact: { kind: "func", params: [ANY], returns: [ANY] },
-			CompactFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+			Clone: sameSlice([ANY]),
+			Compact: sameSlice([ANY]),
+			CompactFunc: sameSlice([ANY, ANY]),
 			Concat: { kind: "func", params: [ANY], returns: [ANY], variadic: true },
-			Delete: { kind: "func", params: [ANY, INT, INT], returns: [ANY] },
-			DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-			Insert: {
-				kind: "func",
-				params: [ANY, INT, ANY],
-				returns: [ANY],
-				variadic: true,
-			},
-			Replace: {
-				kind: "func",
-				params: [ANY, INT, INT, ANY],
-				returns: [ANY],
-				variadic: true,
-			},
-			Grow: { kind: "func", params: [ANY, INT], returns: [ANY] },
-			Clip: { kind: "func", params: [ANY], returns: [ANY] },
+			Delete: sameSlice([ANY, INT, INT]),
+			DeleteFunc: sameSlice([ANY, ANY]),
+			Insert: sameSlice([ANY, INT, ANY], { variadic: true }),
+			Replace: sameSlice([ANY, INT, INT, ANY], { variadic: true }),
+			Grow: sameSlice([ANY, INT]),
+			Clip: sameSlice([ANY]),
 		},
 	});
 

package/src/typechecker/stdlib/extended.js

@@ -160,9 +160,24 @@ export function setupExtendedGlobals(globals, types) {
 		kind: "namespace",
 		name: "maps",
 		members: {
-			Keys: { kind: "func", params: [ANY], returns: [ANY] },
-			Values: { kind: "func", params: [ANY], returns: [ANY] },
-			Clone: { kind: "func", params: [ANY], returns: [ANY] },
+			Keys: {
+				kind: "func",
+				params: [ANY],
+				returns: [ANY],
+				_derivedReturn: "keysOfArg0",
+			},
+			Values: {
+				kind: "func",
+				params: [ANY],
+				returns: [ANY],
+				_derivedReturn: "valuesOfArg0",
+			},
+			Clone: {
+				kind: "func",
+				params: [ANY],
+				returns: [ANY],
+				_derivedReturn: "arg0",
+			},
 			Copy: { kind: "func", params: [ANY, ANY], returns: [VOID] },
 			Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
 			EqualFunc: { kind: "func", params: [ANY, ANY, ANY], returns: [BOOL] },

package/src/typechecker/stdlib/shared.js

@@ -0,0 +1,53 @@
+// `gofront/shared` — fixed-size linear-memory buffers shared zero-copy between
+// wasm packages and JS. Each `shared.Xxx` is a named type whose underlying kind
+// is "shared" (not a slice): it supports indexing, len() and `.Subarray(lo, hi)`
+// but not slicing, append or implicit conversion to GC slices.
+
+import {
+	FLOAT32,
+	FLOAT64,
+	INT,
+	INT8,
+	INT16,
+	INT32,
+	UINT8,
+	UINT16,
+	UINT32,
+} from "../types.js";
+
+// key → [elem type, JS TypedArray ctor, byte size]
+export const SHARED_KINDS = {
+	Float32: { elem: FLOAT32, ctor: "Float32Array", bytes: 4, key: "f32" },
+	Float64: { elem: FLOAT64, ctor: "Float64Array", bytes: 8, key: "f64" },
+	Int8: { elem: INT8, ctor: "Int8Array", bytes: 1, key: "i8" },
+	Int16: { elem: INT16, ctor: "Int16Array", bytes: 2, key: "i16" },
+	Int32: { elem: INT32, ctor: "Int32Array", bytes: 4, key: "i32" },
+	Uint8: { elem: UINT8, ctor: "Uint8Array", bytes: 1, key: "u8" },
+	Uint16: { elem: UINT16, ctor: "Uint16Array", bytes: 2, key: "u16" },
+	Uint32: { elem: UINT32, ctor: "Uint32Array", bytes: 4, key: "u32" },
+};
+
+export function setupSharedGlobals(globals, types) {
+	const members = {};
+	for (const [name, info] of Object.entries(SHARED_KINDS)) {
+		const t = {
+			kind: "named",
+			name: `shared.${name}`,
+			underlying: { kind: "shared", elem: info.elem, shared: name },
+		};
+		t.underlying.methods = new Map([
+			["Subarray", { kind: "func", params: [INT, INT], returns: [t] }],
+		]);
+		types.set(t.name, t);
+		members[name] = t;
+		members[`New${name}`] = { kind: "func", params: [INT], returns: [t] };
+	}
+	globals.define("shared", { kind: "namespace", name: "shared", members });
+}
+
+// Returns the SHARED_KINDS entry for a (possibly named) shared type, or null.
+export function sharedInfo(t) {
+	const u = t?.kind === "named" ? t.underlying : t;
+	if (u?.kind !== "shared") return null;
+	return { name: u.shared, ...SHARED_KINDS[u.shared] };
+}

package/src/typechecker/stdlib.js

@@ -9,10 +9,12 @@
 
 import { setupCoreGlobals } from "./stdlib/core.js";
 import { setupExtendedGlobals } from "./stdlib/extended.js";
+import { setupSharedGlobals } from "./stdlib/shared.js";
 import { setupWebGlobals } from "./stdlib/web.js";
 
 export function setupGlobals(globals, types) {
 	setupCoreGlobals(globals, types);
 	setupExtendedGlobals(globals, types);
+	setupSharedGlobals(globals, types);
 	setupWebGlobals(globals, types);
 }