gofront 1.3.5 → 1.3.6

package/src/codegen/stdlib/builder.js

@@ -28,12 +28,17 @@ const BUILDER_COMMON = {
 export const builderMethods = {
 	_genBuilderCall(typeName, method, expr) {
 		const recv = expr.func.expr;
-		const recvJs = this.genExpr(recv);
-		const base = `(${recvJs}?.value ?? ${recvJs})`;
+		const base = this._unboxWriter(this.genExpr(recv));
 		const args = expr.args.map((a) => this.genExpr(a));
 		const isStr = typeName === "strings.Builder";
 		const table = isStr ? BUILDER_STR : BUILDER_BYTES;
 		const gen = table[method] ?? BUILDER_COMMON[method];
 		return gen ? gen(base, args) : undefined;
 	},
+
+	// Accepts a Builder/Buffer or a pointer box around one; evaluates `js` once.
+	_unboxWriter(js) {
+		if (/^[\w$.]+$/.test(js)) return `(${js}?.value ?? ${js})`;
+		return `((__w) => __w?.value ?? __w)(${js})`;
+	},
 };

package/src/codegen/stdlib/fmt.js

@@ -80,12 +80,12 @@ export const fmtMethods = {
 		const sprintfCall = this._buildFprintSprintfCall(fn, rest.length, restJs);
 		if (targetTypeName === "strings.Builder") {
 			const w = this.genExpr(writerArg);
-			const base = `(${w}?.value ?? ${w})`;
+			const base = this._unboxWriter(w);
 			return `(${base}._buf += ${sprintfCall})`;
 		}
 		if (targetTypeName === "bytes.Buffer") {
 			const w = this.genExpr(writerArg);
-			const base = `(${w}?.value ?? ${w})`;
+			const base = this._unboxWriter(w);
 			return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${sprintfCall})`;
 		}
 		// Generic io.Writer fallback — call .WriteString if available

package/src/codegen/stdlib/io.js

@@ -14,7 +14,7 @@ export const ioMethods = {
 					(writerType?.kind === "pointer" ? writerType.base?.name : null);
 				const w = this.genExpr(writerArg);
 				const s = this.genExpr(expr.args[1]);
-				const base = `(${w}?.value ?? ${w})`;
+				const base = this._unboxWriter(w);
 				if (typeName === "strings.Builder") {
 					return `((b,s) => { b._buf += s; return [s.length, null]; })(${base}, ${s})`;
 				}

package/src/dev-server.js

@@ -140,13 +140,15 @@ function isInsideDir(root, target) {
 	return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
 }
 
-function handleSseRequest(req, res, clients) {
+function handleSseRequest(req, res, clients, lastError = null) {
 	res.writeHead(200, {
 		"Content-Type": "text/event-stream",
 		"Cache-Control": "no-cache",
 		Connection: "keep-alive",
 	});
 	res.write(": connected\n\n");
+	if (lastError)
+		res.write(`event: build-error\ndata: ${JSON.stringify(lastError)}\n\n`);
 	clients.add(res);
 	req.on?.("close", () => clients.delete(res));
 }
@@ -216,7 +218,7 @@ export function handleDevRequest(
 	options = {},
 ) {
 	if (req.url === "/_gofront/events") {
-		handleSseRequest(req, res, clients);
+		handleSseRequest(req, res, clients, options.getLastError?.() ?? null);
 		return;
 	}
 
@@ -312,15 +314,19 @@ function closeServer(server, clients, timer) {
 export function createDevServer(serveDir, port = 3000, options = {}) {
 	const clients = new Set();
 	const heartbeatMs = options.heartbeatInterval ?? 15000;
+	const host = options.host ?? "localhost";
+	// Kept so browsers that connect (or reload) after a failed build still see the overlay.
+	let lastError = null;
+	const requestOptions = { ...options, getLastError: () => lastError };
 
 	const server = createServer((req, res) => {
-		handleDevRequest(req, res, serveDir, clients, options);
+		handleDevRequest(req, res, serveDir, clients, requestOptions);
 	});
 
 	server.on("error", (err) => handleServerError(err, port));
-	server.listen(port, () => {
+	server.listen(port, host, () => {
 		const actualPort = server.address()?.port ?? port;
-		if (port !== 0) {
+		if (port !== 0 && !options.silent) {
 			console.error(`gofront: dev server → http://localhost:${actualPort}`);
 		}
 	});
@@ -329,17 +335,23 @@ export function createDevServer(serveDir, port = 3000, options = {}) {
 		heartbeatMs > 0 ? setInterval(() => sendPings(clients), heartbeatMs) : null;
 	heartbeatTimer?.unref?.();
 
-	const notify = createNotify(clients);
+	const broadcastNotify = createNotify(clients);
+	const notify = (arg) => {
+		if (!arg?.type) lastError = null;
+		broadcastNotify(arg);
+	};
+	const notifyError = (err) => {
+		lastError = buildErrorPayload(err);
+		broadcastToClients(clients, "build-error", lastError);
+	};
 
 	return {
 		broadcast: (event, data) => broadcastToClients(clients, event, data),
 		notify,
 		notifyCss: (file) =>
 			broadcastToClients(clients, "css-update", { type: "css-update", file }),
-		notifyError: (err) =>
-			broadcastToClients(clients, "build-error", buildErrorPayload(err)),
-		notifyBuildError: (err) =>
-			broadcastToClients(clients, "build-error", buildErrorPayload(err)),
+		notifyError,
+		notifyBuildError: notifyError,
 		ping: () => sendPings(clients),
 		clients,
 		server,

package/src/index.js

@@ -162,8 +162,14 @@ if (args[0] === "dev") {
 	const devOptions = parseDevArgs(args.slice(1));
 	try {
 		const dev = await handleDev(devOptions.targetDir, devOptions);
-		const port = dev.port ?? devOptions.port ?? 3000;
-		console.error(`gofront: dev server running → http://localhost:${port}`);
+		if (dev.initialError) {
+			console.error("gofront: ERROR");
+			for (const line of dev.initialError.message.split("\n"))
+				console.error(`  ${line}`);
+		} else {
+			console.error(`gofront: OK — wrote ${dev.outputFile}`);
+		}
+		console.error(`gofront: dev server running → http://localhost:${dev.port}`);
 		console.error(`gofront: watching ${dev.srcDir} for changes...`);
 
 		const shutdown = async () => {

package/src/parser/declarations.js

@@ -29,7 +29,7 @@ export const declarationParseMethods = {
 				this.check(T.IDENT) && !this.isReceiverTerminator(this.peek2())
 					? this.advance().value
 					: "_";
-			this.match(T.STAR); // pointer receiver: (c *Counter) — strip *, treat same as value receiver
+			const recvPointer = Boolean(this.match(T.STAR));
 			const recvType = this.parseTypeName();
 			this.expect(T.RPAREN);
 			const name = this.expect(T.IDENT).value;
@@ -40,6 +40,7 @@ export const declarationParseMethods = {
 				kind: "MethodDecl",
 				recvName,
 				recvType,
+				recvPointer,
 				name,
 				params,
 				returnType,

package/src/pwa.js

@@ -86,7 +86,9 @@ self.addEventListener("fetch", (event) => {
 				return response;
 			}).catch(() => {
 				if (event.request.headers?.get?.("accept")?.includes("text/html")) {
-					return caches.match("./") || caches.match("./index.html");
+					return caches
+						.match("./")
+						.then((r) => r || caches.match("./index.html"));
 				}
 			});
 		}),

package/src/typechecker/assignability.js

@@ -14,6 +14,7 @@ import {
 	isNumeric,
 	isPointer,
 	isString,
+	isTypedArraySlice,
 	isUntyped,
 	LOG_OPS,
 	SIZED_FLOAT_NAMES,
@@ -157,6 +158,7 @@ export const assignabilityMethods = {
 		if (!target || !source) return;
 		target = this.resolveType(target);
 		source = this.resolveType(source);
+		this._markIfaceBox(target, source, node);
 		if (this._assertAssignableEarlyReturn(target, source)) return;
 		if (isPointer(target) && isPointer(source)) {
 			this.assertAssignable(
@@ -170,10 +172,34 @@ export const assignabilityMethods = {
 		if (this._isNumericCoercible(target, source)) return;
 		if (this._checkArrayAssignable(target, source, node)) return;
 		if (this._checkTypedArrayAssignable(target, source, node)) return;
+		if (this._checkFuncAssignable(target, source, node)) return;
 		if (typeStr(target) !== typeStr(source))
 			this._assertAssignableTypeMismatch(target, source, node);
 	},
 
+	// Tags struct values / struct pointers flowing into an interface so codegen can
+	// tell `T` from `*T` at runtime (both compile to the same class instance).
+	_markIfaceBox(target, source, node) {
+		if (this._skipIfaceMark) return;
+		if (!node || typeof node !== "object" || !target || !source) return;
+		if (target.kind === "typeParam") return;
+		const tBase = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		if (!isAny(target) && tBase?.kind !== "interface") return;
+		const structOf = (t) => {
+			const r = this.resolveType(t);
+			const b = r?.kind === "named" ? this.resolveType(r.underlying) : r;
+			return b?.kind === "struct";
+		};
+		const sBase = this.resolveType(
+			source.kind === "named" ? source.underlying : source,
+		);
+		if (sBase?.kind === "struct") node._ifaceBox = "value";
+		else if (sBase?.kind === "pointer" && structOf(sBase.base))
+			node._ifaceBox = "ptr";
+	},
+
 	_assertAssignableEarlyReturn(target, source) {
 		return (
 			target?.kind === "typeParam" ||
@@ -211,9 +237,13 @@ export const assignabilityMethods = {
 
 	_isNumericCoercible(target, source) {
 		if (target.kind !== "basic" || source.kind !== "basic") return false;
+		const pair = `${target.name}:${source.name}`;
 		return (
-			(target.name === "float64" && source.name === "int") ||
-			(target.name === "int" && source.name === "float64")
+			pair === "float64:int" ||
+			pair === "int:float64" ||
+			// rune was historically int in GoFront; keep rune/int interchangeable.
+			pair === "int:int32" ||
+			pair === "int32:int"
 		);
 	},
 
@@ -258,8 +288,9 @@ export const assignabilityMethods = {
 			const taElem = targetTa
 				? (target.underlying?._elemType ?? target._elemType)
 				: (source.underlying?._elemType ?? source._elemType);
-			const slElem = targetSlice ? targetSlice.elem : sourceSlice.elem;
-			if (typeStr(taElem) === typeStr(slElem)) return true;
+			const slice = targetSlice ?? sourceSlice;
+			if (isTypedArraySlice(slice) && typeStr(taElem) === typeStr(slice.elem))
+				return true;
 			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
 			return true;
 		}
@@ -275,6 +306,21 @@ export const assignabilityMethods = {
 		return false;
 	},
 
+	_checkFuncAssignable(target, source, node) {
+		const tFunc = target.kind === "named" ? target.underlying : target;
+		const sFunc = source.kind === "named" ? source.underlying : source;
+		if (tFunc?.kind === "func" && sFunc?.kind === "func") {
+			if (!this._implementsMethod(tFunc, sFunc)) {
+				this.err(
+					`Cannot assign ${typeStr(source)} to ${typeStr(target)}`,
+					node,
+				);
+			}
+			return true;
+		}
+		return false;
+	},
+
 	// ── Interface satisfaction ────────────────────────────────────────
 
 	_sigParamsMatch(reqList, actList) {

package/src/typechecker/expressions.js

@@ -15,6 +15,7 @@ import {
 	isNumeric,
 	isString,
 	NIL,
+	RUNE,
 	Scope,
 	STRING,
 	TAINTED_ANY,
@@ -40,6 +41,17 @@ const BUILTIN_CHECK = {
 			s.err(`cannot append to array (type ${typeStr(st)})`, e);
 			return st;
 		}
+		const sb = s.resolveType(st?.kind === "named" ? st.underlying : st);
+		if (sb?.kind === "slice") {
+			for (let i = 1; i < e.args.length; i++) {
+				if (!e.args[i]._spread && at[i])
+					s._markIfaceBox(
+						s.resolveType(sb.elem),
+						s.resolveType(at[i]),
+						e.args[i],
+					);
+			}
+		}
 		return st;
 	},
 	copy: () => INT,
@@ -379,7 +391,7 @@ export const expressionCheckMethods = {
 	},
 
 	_rangeCollTypeTuple(resolved, collType) {
-		if (isString(resolved)) return { kind: "tuple", types: [INT, INT] };
+		if (isString(resolved)) return { kind: "tuple", types: [INT, RUNE] };
 		if (resolved?.kind === "slice" || resolved?.kind === "array")
 			return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
 		if (resolved?.kind === "map")

package/src/typechecker/index.js

@@ -185,12 +185,55 @@ export class TypeChecker {
 				}
 			}
 		}
+		const all = [];
 		for (const p of programs) {
-			this._setCurrentFile(p);
-			for (const d of p.decls) if (d.kind === "TypeDecl") this.collectType(d);
+			for (const d of p.decls) if (d.kind === "TypeDecl") all.push({ p, d });
+		}
+		// Collect in dependency order so aliases, generics, embedded and by-value
+		// field types declared later (or in other files) are ready when needed.
+		let pending = all;
+		while (pending.length > 0) {
+			const pendingNames = new Map(pending.map((x) => [x.d.name, x.d]));
+			const ready = pending.filter(
+				(x) => !this._typeDeclBlocked(x.d, pendingNames),
+			);
+			const batch = ready.length > 0 ? ready : pending;
+			for (const { p, d } of batch) {
+				this._setCurrentFile(p);
+				this.collectType(d);
+			}
+			pending =
+				ready.length > 0 ? pending.filter((x) => !ready.includes(x)) : [];
 		}
 	}
 
+	_typeDeclBlocked(decl, pendingNames) {
+		const visit = (node, indirect) => {
+			if (!node || typeof node !== "object") return false;
+			if (Array.isArray(node)) return node.some((n) => visit(n, indirect));
+			if (
+				(node.kind === "TypeName" || node.kind === "GenericTypeName") &&
+				node.name !== decl.name
+			) {
+				const dep = pendingNames.get(node.name);
+				if (dep && (!indirect || dep.isAlias || dep.typeParams)) return true;
+			}
+			const nextIndirect =
+				indirect ||
+				[
+					"PointerType",
+					"SliceType",
+					"MapType",
+					"FuncType",
+					"ChanType",
+				].includes(node.kind);
+			return Object.keys(node).some(
+				(k) => !k.startsWith("_") && visit(node[k], nextIndirect),
+			);
+		};
+		return visit(decl.type, false);
+	}
+
 	_collectFuncsPass(programs) {
 		for (const p of programs) {
 			this._setCurrentFile(p);
@@ -390,6 +433,7 @@ export class TypeChecker {
 	}
 
 	_attachMethod(decl, funcType) {
+		funcType._ptrRecv = Boolean(decl.recvPointer);
 		const recvNamedType = this.types.get(decl.recvType.name);
 		if (recvNamedType?._generic)
 			this._attachGenericMethod(recvNamedType, decl, funcType);

package/src/typechecker/resolve.js

@@ -411,6 +411,8 @@ export const resolveMethods = {
 	_fieldTypeInterface(base, baseType, field, node) {
 		if (base.methods?.has(field)) return base.methods.get(field);
 		if (base.fields?.has(field)) return base.fields.get(field);
+		if (base._excluded?.has(field))
+			return this.err(`No member '${field}' on ${typeStr(baseType)}`, node);
 		if (base._isOpen) return ANY;
 		return this.err(`No method '${field}' on ${typeStr(baseType)}`, node);
 	},

package/src/typechecker/statements.js

@@ -148,8 +148,17 @@ export const statementCheckMethods = {
 		for (let i = 0; i < lhsTypes.length; i++) {
 			if (stmt.lhs[i]?.kind === "Ident" && stmt.lhs[i]?.name === "_") continue;
 			const r = rhsFlat[i] ?? ANY;
-			if (!isAny(lhsTypes[i]) && !isAny(r))
+			if (stmt.rhs.length === lhsTypes.length && lhsTypes[i] && r)
+				this._markIfaceBox(
+					this.resolveType(lhsTypes[i]),
+					this.resolveType(r),
+					stmt.rhs[i],
+				);
+			if (!isAny(lhsTypes[i]) && !isAny(r)) {
+				this._skipIfaceMark = true;
 				this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
+				this._skipIfaceMark = false;
+			}
 		}
 	},
 

package/src/typechecker/stdlib/web.js

@@ -23,6 +23,25 @@ const func = (params, returns = [VOID], variadic = false) => ({
 	variadic,
 });
 
+// Last parameter is optional (modelled as variadic).
+const optLast = (params, returns = [VOID]) => func(params, returns, true);
+
+const WEBGL2_ONLY_CONSTANTS = new Set([
+	"UNIFORM_BUFFER",
+	"HALF_FLOAT",
+	"RGBA8",
+	"RGBA32F",
+]);
+
+const WEBGL2_ONLY_METHODS = new Set([
+	"VertexAttribIPointer",
+	"DrawArraysInstanced",
+	"DrawElementsInstanced",
+	"CreateVertexArray",
+	"BindVertexArray",
+	"DeleteVertexArray",
+]);
+
 const WEBGL_CONSTANTS_LIST = {
 	ARRAY_BUFFER: 0x8892,
 	ELEMENT_ARRAY_BUFFER: 0x8893,
@@ -113,7 +132,7 @@ function buildArrayBufferType() {
 		methods,
 	};
 	named.underlying = iface;
-	methods.set("slice", func([INT, INT], [named]));
+	methods.set("slice", optLast([INT, INT], [named]));
 	return named;
 }
 
@@ -126,20 +145,20 @@ function buildDataViewType(arrayBufferType) {
 	const methods = new Map([
 		["getInt8", func([INT], [INT8])],
 		["getUint8", func([INT], [UINT8])],
-		["getInt16", func([INT, BOOL], [INT16])],
-		["getUint16", func([INT, BOOL], [UINT16])],
-		["getInt32", func([INT, BOOL], [INT32])],
-		["getUint32", func([INT, BOOL], [UINT32])],
-		["getFloat32", func([INT, BOOL], [FLOAT32])],
-		["getFloat64", func([INT, BOOL], [FLOAT64])],
+		["getInt16", optLast([INT, BOOL], [INT16])],
+		["getUint16", optLast([INT, BOOL], [UINT16])],
+		["getInt32", optLast([INT, BOOL], [INT32])],
+		["getUint32", optLast([INT, BOOL], [UINT32])],
+		["getFloat32", optLast([INT, BOOL], [FLOAT32])],
+		["getFloat64", optLast([INT, BOOL], [FLOAT64])],
 		["setInt8", func([INT, INT8])],
 		["setUint8", func([INT, UINT8])],
-		["setInt16", func([INT, INT16, BOOL])],
-		["setUint16", func([INT, UINT16, BOOL])],
-		["setInt32", func([INT, INT32, BOOL])],
-		["setUint32", func([INT, UINT32, BOOL])],
-		["setFloat32", func([INT, FLOAT32, BOOL])],
-		["setFloat64", func([INT, FLOAT64, BOOL])],
+		["setInt16", optLast([INT, INT16, BOOL])],
+		["setUint16", optLast([INT, UINT16, BOOL])],
+		["setInt32", optLast([INT, INT32, BOOL])],
+		["setUint32", optLast([INT, UINT32, BOOL])],
+		["setFloat32", optLast([INT, FLOAT32, BOOL])],
+		["setFloat64", optLast([INT, FLOAT64, BOOL])],
 	]);
 	const named = { kind: "named", name: "DataView", underlying: null };
 	named.underlying = { kind: "interface", name: "DataView", fields, methods };
@@ -164,15 +183,16 @@ function buildTypedArrayType(name, elemType, arrayBufferType) {
 		_isTypedArray: true,
 	};
 	named.underlying = iface;
-	methods.set("subarray", func([INT, INT], [named]));
-	methods.set("slice", func([INT, INT], [named]));
-	methods.set("set", func([ANY, INT], [VOID]));
+	methods.set("subarray", optLast([INT, INT], [named]));
+	methods.set("slice", optLast([INT, INT], [named]));
+	methods.set("set", optLast([ANY, INT], [VOID]));
 	return named;
 }
 
-function createWebGLMethods() {
+function createWebGLMethods(isWebGL2) {
 	const methods = new Map();
 	const add = (name, fn) => {
+		if (!isWebGL2 && WEBGL2_ONLY_METHODS.has(name)) return;
 		methods.set(name, fn);
 		const camel = name[0].toLowerCase() + name.slice(1);
 		if (camel !== name) methods.set(camel, fn);
@@ -296,7 +316,7 @@ function createWebGPUMethods() {
 	addDev("CreateShaderModule", func([ANY], [ANY]));
 	addDev("CreateRenderPipeline", func([ANY], [ANY]));
 	addDev("CreateComputePipeline", func([ANY], [ANY]));
-	addDev("CreateCommandEncoder", func([ANY], [ANY]));
+	addDev("CreateCommandEncoder", optLast([ANY], [ANY]));
 	addDev("CreateBindGroup", func([ANY], [ANY]));
 	addDev("CreateBindGroupLayout", func([ANY], [ANY]));
 	addDev("CreatePipelineLayout", func([ANY], [ANY]));
@@ -307,7 +327,7 @@ function createWebGPUMethods() {
 		const camel = name[0].toLowerCase() + name.slice(1);
 		if (camel !== name) adapterMethods.set(camel, fn);
 	};
-	addAdapt("RequestDevice", func([ANY], [ANY]));
+	addAdapt("RequestDevice", optLast([ANY], [ANY]));
 
 	return { queueMethods, deviceMethods, adapterMethods };
 }
@@ -339,21 +359,29 @@ export function setupWebGlobals(globals, types) {
 	}
 
 	// WebGL constants map
-	const constFields = new Map();
+	const constFields2 = new Map();
 	for (const [k] of Object.entries(WEBGL_CONSTANTS_LIST)) {
-		constFields.set(k, INT);
+		constFields2.set(k, INT);
+	}
+	const constFields1 = new Map(
+		[...constFields2].filter(([k]) => !WEBGL2_ONLY_CONSTANTS.has(k)),
+	);
+	const webgl2Only = new Set(WEBGL2_ONLY_CONSTANTS);
+	for (const m of WEBGL2_ONLY_METHODS) {
+		webgl2Only.add(m);
+		webgl2Only.add(m[0].toLowerCase() + m.slice(1));
 	}
 
-	const webglMethods = createWebGLMethods();
 	const webglContext = {
 		kind: "named",
 		name: "WebGLRenderingContext",
 		underlying: {
 			kind: "interface",
 			name: "WebGLRenderingContext",
-			fields: constFields,
-			methods: webglMethods,
+			fields: constFields1,
+			methods: createWebGLMethods(false),
 			_isOpen: true,
+			_excluded: webgl2Only,
 		},
 	};
 	const webgl2Context = {
@@ -362,8 +390,8 @@ export function setupWebGlobals(globals, types) {
 		underlying: {
 			kind: "interface",
 			name: "WebGL2RenderingContext",
-			fields: constFields,
-			methods: webglMethods,
+			fields: constFields2,
+			methods: createWebGLMethods(true),
 			_isOpen: true,
 		},
 	};

package/src/typechecker/types.js

@@ -55,7 +55,7 @@ export const UINT16 = { kind: "basic", name: "uint16" };
 export const UINT32 = { kind: "basic", name: "uint32" };
 export const UINT64 = { kind: "basic", name: "uint64" };
 export const UINTPTR = { kind: "basic", name: "uintptr" };
-export const RUNE = INT;
+export const RUNE = INT32;
 export const FLOAT32 = { kind: "basic", name: "float32" };
 export const FLOAT64 = { kind: "basic", name: "float64" };
 export const STRING = { kind: "basic", name: "string" };
@@ -149,9 +149,9 @@ export const isString = makeBasicPredicate("string");
 export const isBool = makeBasicPredicate("bool");
 
 // ── TypedArray mappings ──────────────────────────────────────
+// []float64 deliberately stays a plain Array for JSON / JS-library interop.
 export const TYPED_ARRAY_CONSTRUCTORS = {
 	float32: "Float32Array",
-	float64: "Float64Array",
 	uint8: "Uint8Array",
 	byte: "Uint8Array",
 	int8: "Int8Array",
@@ -159,6 +159,7 @@ export const TYPED_ARRAY_CONSTRUCTORS = {
 	int16: "Int16Array",
 	uint32: "Uint32Array",
 	int32: "Int32Array",
+	rune: "Int32Array",
 };
 
 export function typedArrayConstructorForElem(elemType) {

package/src/vendor.js

@@ -227,9 +227,12 @@ export async function loadNodePolyfillsPlugin(projectRoot, customPlugin) {
 	if (!info) return null;
 	try {
 		const mod = await import(pathToFileURL(info.path).href);
-		const fn =
-			mod.nodePolyfills || mod.default?.nodePolyfills || mod.default || mod;
-		return typeof fn === "function" ? fn() : mod;
+		const fn = [
+			mod.nodePolyfills,
+			mod.default?.nodePolyfills,
+			mod.default,
+		].find((f) => typeof f === "function");
+		return fn ? fn() : null;
 	} catch {
 		return null;
 	}
@@ -339,10 +342,12 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 		options.nodePolyfillsPlugin ??
 		bundlerInfo.nodePolyfillsPlugin ??
 		(options.nodePolyfills === false ? null : undefined);
-	const polyfillPlugin = await loadNodePolyfillsPlugin(
-		projectRoot,
-		customPlugin,
-	);
+	// The polyfill plugin is a Rolldown plugin; esbuild cannot use it.
+	const supportsPlugins =
+		typeof bundlerInfo.bundle === "function" || bundlerInfo.name === "rolldown";
+	const polyfillPlugin = supportsPlugins
+		? await loadNodePolyfillsPlugin(projectRoot, customPlugin)
+		: null;
 
 	if (typeof bundlerInfo.bundle === "function") {
 		try {