gofront 1.5.1 → 1.6.1

package/src/backend/js/source-map.js

@@ -57,3 +57,35 @@ export function buildSourceMap(sources, mappings, sourcesContent) {
 	if (sourcesContent) map.sourcesContent = sourcesContent;
 	return JSON.stringify(map);
 }
+
+// WASM source maps use the convention "generated line 0, generated column =
+// byte offset into the module".  `mappings` is Array<{ offset, srcFileIdx,
+// srcLine }> (0-based line), one segment per function body (function-level
+// granularity); DevTools shows the Go file/line for each wasm function.
+export function buildWasmSourceMap(sources, mappings, sourcesContent) {
+	const sorted = [...mappings].sort((a, b) => a.offset - b.offset);
+	const segments = [];
+	let prevOffset = 0;
+	let prevSrcFile = 0;
+	let prevSrcLine = 0;
+	for (const m of sorted) {
+		const fileIdx = m.srcFileIdx ?? 0;
+		segments.push(
+			vlqEncode(m.offset - prevOffset) +
+				vlqEncode(fileIdx - prevSrcFile) +
+				vlqEncode(m.srcLine - prevSrcLine) +
+				vlqEncode(0),
+		);
+		prevOffset = m.offset;
+		prevSrcFile = fileIdx;
+		prevSrcLine = m.srcLine;
+	}
+	const map = {
+		version: 3,
+		sources: sources.map((s) => s.replace(/\\/g, "/")),
+		names: [],
+		mappings: segments.join(","),
+	};
+	if (sourcesContent) map.sourcesContent = sourcesContent;
+	return JSON.stringify(map);
+}

package/src/backend/js/statements.js

@@ -31,27 +31,35 @@ export const statementGenMethods = {
 	},
 
 	// Shared helper for comma-ok map index in both DefineStmt and AssignStmt.
-	// isDefine=true  → emit `let v = m[k]; let ok = k in m;`
-	// isDefine=false → emit `v = k in m ? m[k] : zero; ok = k in m;`
 	_genCommaOkMapIndex(stmt, rhsNode, isDefine) {
 		const mapExpr = this.genExpr(rhsNode.expr);
 		const keyExpr = this.genExpr(rhsNode.index);
 		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
 		const decl = isDefine ? "let " : "";
-		if (vName !== "_") {
-			if (isDefine) {
+		if (isDefine && !this.strict) {
+			if (vName !== "_") {
 				this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
-			} else {
-				const zero = rhsNode._mapValueType
-					? this.zeroValueForType(rhsNode._mapValueType)
-					: "undefined";
-				this.line(
-					`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
-				);
 			}
+			if (okName !== "_") {
+				this.line(`let ${okName} = (${keyExpr}) in ${mapExpr};`);
+			}
+			return;
+		}
+		const zero = rhsNode._mapValueType
+			? this.zeroValueForType(rhsNode._mapValueType)
+			: "undefined";
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const mTmp = `__m${this._tmpCounter}`;
+		const kTmp = `__k${this._tmpCounter}`;
+		this.line(`const ${mTmp} = ${mapExpr}, ${kTmp} = ${keyExpr};`);
+		if (vName !== "_") {
+			this.line(
+				`${decl}${vName} = (${mTmp} && (${kTmp} in ${mTmp})) ? ${mTmp}[${kTmp}] : ${zero};`,
+			);
+		}
+		if (okName !== "_") {
+			this.line(`${decl}${okName} = Boolean(${mTmp} && (${kTmp} in ${mTmp}));`);
 		}
-		if (okName !== "_")
-			this.line(`${decl}${okName} = (${keyExpr}) in ${mapExpr};`);
 	},
 
 	genStmt(stmt) {
@@ -63,6 +71,33 @@ export const statementGenMethods = {
 				this.genTypeDeclWithMethods(stmt, []);
 				break;
 			case "IncDecStmt": {
+				if (stmt.expr.kind === "IndexExpr" && stmt.expr._mapValueType) {
+					const zero = this.zeroValueForType(stmt.expr._mapValueType);
+					const wrapField = this._namedWrapperField(
+						stmt.expr.expr._type,
+						stmt.expr.expr,
+					);
+					const base = wrapField
+						? `${this.genExpr(stmt.expr.expr)}.${wrapField}`
+						: this.genExpr(stmt.expr.expr);
+					const idx = this.genExpr(stmt.expr.index);
+					const op = stmt.op === "++" ? "+" : "-";
+					if (
+						this._hasCallExpr(stmt.expr.expr) ||
+						this._hasCallExpr(stmt.expr.index)
+					) {
+						this.line(
+							`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${op} 1; })(${base}, ${idx});`,
+							srcLine,
+						);
+					} else {
+						this.line(
+							`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${op} 1;`,
+							srcLine,
+						);
+					}
+					break;
+				}
 				if (
 					this.strict &&
 					this._genStrictCompound(
@@ -266,6 +301,35 @@ export const statementGenMethods = {
 		if (active.length === 0) {
 			if (rhs.length > 0) this.line(`${rhs[0]};`);
 		} else if (lhs.length === 1) {
+			if (
+				stmt.op !== "=" &&
+				stmt.lhs[0].kind === "IndexExpr" &&
+				stmt.lhs[0]._mapValueType
+			) {
+				const zero = this.zeroValueForType(stmt.lhs[0]._mapValueType);
+				const wrapField = this._namedWrapperField(
+					stmt.lhs[0].expr._type,
+					stmt.lhs[0].expr,
+				);
+				const base = wrapField
+					? `${this.genExpr(stmt.lhs[0].expr)}.${wrapField}`
+					: this.genExpr(stmt.lhs[0].expr);
+				const idx = this.genExpr(stmt.lhs[0].index);
+				const binOp = stmt.op.slice(0, -1);
+				if (
+					this._hasCallExpr(stmt.lhs[0].expr) ||
+					this._hasCallExpr(stmt.lhs[0].index)
+				) {
+					this.line(
+						`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${binOp} (${active[0].r}); })(${base}, ${idx});`,
+					);
+				} else {
+					this.line(
+						`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${binOp} (${active[0].r});`,
+					);
+				}
+				return;
+			}
 			if (
 				this.strict &&
 				stmt.op !== "=" &&
@@ -333,11 +397,11 @@ export const statementGenMethods = {
 				result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
 				break;
 			case "*":
-				this._usesCmul = true;
+				this.useHelper("cmul");
 				result = `__cmul(${lhsStr}, ${rhsExpr})`;
 				break;
 			case "/":
-				this._usesCdiv = true;
+				this.useHelper("cdiv");
 				result = `__cdiv(${lhsStr}, ${rhsExpr})`;
 				break;
 			default:
@@ -379,6 +443,22 @@ export const statementGenMethods = {
 			} else {
 				this.line("return;");
 			}
+		} else if (this.namedReturnVars?.length > 0) {
+			const vars = this.namedReturnVars;
+			if (stmt.values.length === 1 && vars.length === 1) {
+				this.line(`${vars[0]} = ${this._genReturnValue(stmt.values[0])};`);
+			} else if (stmt.values.length === 1 && vars.length > 1) {
+				const val = this._genReturnValue(stmt.values[0]);
+				this.line(`[${vars.join(", ")}] = ${val};`);
+			} else if (stmt.values.length > 1 && stmt.values.length === vars.length) {
+				const temps = stmt.values.map((v) => this._genReturnValue(v));
+				this.line(`[${vars.join(", ")}] = [${temps.join(", ")}];`);
+			}
+			this.line(
+				vars.length === 1
+					? `return ${vars[0]};`
+					: `return [${vars.join(", ")}];`,
+			);
 		} else if (stmt.values.length === 1) {
 			this.line(`return ${this._genReturnValue(stmt.values[0])};`);
 		} else {
@@ -616,6 +696,39 @@ export const statementGenMethods = {
 		return nodeAssigns(node, name);
 	},
 
+	_genStringRangeFor(stmt, iteree, isAssign) {
+		this._loopDepth = this._loopDepth ?? 0;
+		const d = this._loopDepth++;
+		const [idxNode, valNode] = stmt.init.lhs;
+		const s = `__s${d}`;
+		const i = `__i${d}`;
+		const cp = `__cp${d}`;
+		this.line(
+			`for (let ${i} = 0, ${s} = Array.from(${iteree} ?? ""); ${i} < ${s}.length; ${i}++) {`,
+		);
+		this.indented(() => {
+			this._emitRangeVar(idxNode, i, isAssign);
+			if (valNode && valNode.name !== "_") {
+				this.line(`const ${cp} = ${s}[${i}].codePointAt(0);`);
+				this._emitRangeVar(valNode, cp, isAssign);
+			}
+			const declared = isAssign
+				? []
+				: [idxNode, valNode]
+						.filter((e) => e?.kind === "Ident" && e.name !== "_")
+						.map((e) => e.name);
+			if (this._bodyRedeclares(stmt.body, declared)) {
+				this.line("{");
+				this.indented(() => this.genBlock(stmt.body));
+				this.line("}");
+			} else {
+				this.genBlock(stmt.body);
+			}
+		});
+		this.line("}");
+		this._loopDepth--;
+	},
+
 	_genIterFor(init, iterType, iteree, lhs, body) {
 		const iterExpr = this._genRangeIterExpr(iterType, iteree, lhs);
 		const binding =
@@ -645,12 +758,17 @@ export const statementGenMethods = {
 			return;
 		}
 
-		if (!this._isMapRangeType(iterType) && !this._isStringRangeType(iterType)) {
-			this._genSliceRangeFor(stmt, iteree, init.kind === "AssignStmt");
+		if (this._isStringRangeType(iterType)) {
+			this._genStringRangeFor(stmt, iteree, init.kind === "AssignStmt");
+			return;
+		}
+
+		if (this._isMapRangeType(iterType)) {
+			this._genIterFor(init, iterType, iteree, lhs, stmt.body);
 			return;
 		}
 
-		this._genIterFor(init, iterType, iteree, lhs, stmt.body);
+		this._genSliceRangeFor(stmt, iteree, init.kind === "AssignStmt");
 	},
 
 	_genRangeIterExpr(iterType, iteree, lhs) {
@@ -658,23 +776,14 @@ export const statementGenMethods = {
 			if (lhs.length === 1) return `Object.keys(${iteree})`;
 			return `Object.entries(${iteree})`;
 		}
-		if (this._isStringRangeType(iterType)) {
-			if (lhs.length === 1) return `Array.from(${iteree}).keys()`;
-			return `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;
-		}
-		this._usesSliceGuard = true;
+		this.useHelper("sliceGuard");
 		if (lhs.length === 1) return `__s(${iteree}).keys()`;
 		return `__s(${iteree}).entries()`;
 	},
 
-	genIteratorFor(stmt) {
-		const range = stmt.init.rhs[0];
-		const lhs = stmt.init.lhs.map((e) => e.name ?? this.genExpr(e));
-		let iteree = this.genExpr(range.expr);
-		const yieldParams = range._yieldParams;
-
-		// Wrap bare function expressions to avoid "Function statements require a name"
-		if (range.expr.kind === "FuncLit") {
+	_genIteratorLoop(itereeExpr, paramsStr, body) {
+		let iteree = this.genExpr(itereeExpr);
+		if (itereeExpr.kind === "FuncLit") {
 			iteree = `(${iteree})`;
 		}
 
@@ -683,17 +792,13 @@ export const statementGenMethods = {
 		const retFlag = `__returned${d}`;
 		const retVar = `__retVal${d}`;
 
-		// Yield callback param names (blank vars get _$N to avoid JS syntax error)
-		const cbParams = lhs.map((n, i) => (n === "_" ? `_$${i}` : n));
-
 		this.line("{");
 		this.indented(() => {
 			this.line(`let ${breakFlag} = false;`);
 			this.line(`let ${retFlag} = false;`);
 			this.line(`let ${retVar};`);
 
-			const params = yieldParams.length === 0 ? "" : cbParams.join(", ");
-			this.line(`${iteree}(function(${params}) {`);
+			this.line(`${iteree}(function(${paramsStr}) {`);
 			this.indented(() => {
 				this.line(`if (${breakFlag}) return false;`);
 				const prev = {
@@ -707,7 +812,7 @@ export const statementGenMethods = {
 				this._iterReturnFlag = retFlag;
 				this._iterReturnVar = retVar;
 
-				this.genBlock(stmt.body);
+				this.genBlock(body);
 
 				this._inIteratorBody = prev.in;
 				this._iterBreakFlag = prev.break;
@@ -723,54 +828,17 @@ export const statementGenMethods = {
 		this._iterDepth--;
 	},
 
+	genIteratorFor(stmt) {
+		const range = stmt.init.rhs[0];
+		const lhs = stmt.init.lhs.map((e) => e.name ?? this.genExpr(e));
+		const cbParams = lhs.map((n, i) => (n === "_" ? `_$${i}` : n));
+		const params = range._yieldParams.length === 0 ? "" : cbParams.join(", ");
+		this._genIteratorLoop(range.expr, params, stmt.body);
+	},
+
 	// 0-param iterator: for range iter { body }
 	genIteratorForCond(stmt) {
-		const range = stmt.cond;
-		let iteree = this.genExpr(range.expr);
-
-		if (range.expr.kind === "FuncLit") {
-			iteree = `(${iteree})`;
-		}
-
-		const d = this._iterDepth++;
-		const breakFlag = `__broke${d}`;
-		const retFlag = `__returned${d}`;
-		const retVar = `__retVal${d}`;
-
-		this.line("{");
-		this.indented(() => {
-			this.line(`let ${breakFlag} = false;`);
-			this.line(`let ${retFlag} = false;`);
-			this.line(`let ${retVar};`);
-
-			this.line(`${iteree}(function() {`);
-			this.indented(() => {
-				this.line(`if (${breakFlag}) return false;`);
-				const prev = {
-					in: this._inIteratorBody,
-					break: this._iterBreakFlag,
-					ret: this._iterReturnFlag,
-					retVar: this._iterReturnVar,
-				};
-				this._inIteratorBody = true;
-				this._iterBreakFlag = breakFlag;
-				this._iterReturnFlag = retFlag;
-				this._iterReturnVar = retVar;
-
-				this.genBlock(stmt.body);
-
-				this._inIteratorBody = prev.in;
-				this._iterBreakFlag = prev.break;
-				this._iterReturnFlag = prev.ret;
-				this._iterReturnVar = prev.retVar;
-
-				this.line("return true;");
-			});
-			this.line("});");
-			this.line(`if (${retFlag}) return ${retVar};`);
-		});
-		this.line("}");
-		this._iterDepth--;
+		this._genIteratorLoop(stmt.cond.expr, "", stmt.body);
 	},
 
 	// Inline a statement as a for-init/post string (no semicolon)

package/src/backend/js/stdlib/base64.js

@@ -0,0 +1,12 @@
+// src/backend/js/stdlib/base64.js
+// CodeGen for Go encoding/base64 package.
+
+export const base64Methods = {
+	_genBase64(fn, a) {
+		this.useHelper("base64");
+		this.useHelper("error");
+		const args = a();
+		if (fn === "NewEncoding") return `__base64_make(${args[0]}, "=")`;
+		return undefined;
+	},
+};

package/src/backend/js/stdlib/binary.js

@@ -0,0 +1,102 @@
+// src/backend/js/stdlib/binary.js
+// CodeGen for Go encoding/binary package.
+
+function sizeOfGoType(gt) {
+	if (!gt) return -1;
+	if (gt.kind === "basic") {
+		switch (gt.name) {
+			case "bool":
+			case "int8":
+			case "uint8":
+			case "byte":
+				return 1;
+			case "int16":
+			case "uint16":
+				return 2;
+			case "int32":
+			case "uint32":
+			case "float32":
+			case "rune":
+				return 4;
+			case "int64":
+			case "uint64":
+			case "float64":
+			case "int":
+			case "uint":
+			case "uintptr":
+				return 8;
+			default:
+				return -1;
+		}
+	}
+	if (gt.kind === "array" || gt.kind === "ArrayType") {
+		const es = sizeOfGoType(gt.elem);
+		const len = gt.len ?? gt.size ?? 0;
+		return es > 0 ? es * len : -1;
+	}
+	if (
+		gt.kind === "pointer" ||
+		gt.kind === "PointerType" ||
+		gt.kind === "StarExpr"
+	) {
+		return sizeOfGoType(gt.base ?? gt.expr ?? gt.operand);
+	}
+	if (gt.kind === "struct" || gt.kind === "StructType") {
+		let total = 0;
+		if (gt.fields instanceof Map) {
+			for (const fType of gt.fields.values()) {
+				const s = sizeOfGoType(fType);
+				if (s < 0) return -1;
+				total += s;
+			}
+			return total;
+		}
+	}
+	return -1;
+}
+
+export const binaryMethods = {
+	_genBinary(fn, a, expr) {
+		this.useHelper("binary");
+		this.useHelper("error");
+		const args = a();
+		if (fn === "Read") {
+			const targetType = expr?.args?.[2]?._type;
+			const baseType = targetType?.base ?? targetType;
+			const resolved =
+				baseType?.kind === "named"
+					? (baseType.underlying ?? baseType)
+					: baseType;
+			const sz = sizeOfGoType(resolved);
+			const typeTag =
+				resolved?.name ??
+				(resolved?.kind === "basic" ? resolved.name : (baseType?.name ?? ""));
+			return `__binary_read(${args[0]}, ${args[1]}, ${args[2]}${sz > 0 ? `, ${sz}` : ", 0"}, "${typeTag}")`;
+		}
+		if (fn === "Write") {
+			const targetType = expr?.args?.[2]?._type;
+			const baseType = targetType?.base ?? targetType;
+			const resolved =
+				baseType?.kind === "named"
+					? (baseType.underlying ?? baseType)
+					: baseType;
+			const sz = sizeOfGoType(resolved);
+			const typeTag =
+				resolved?.name ??
+				(resolved?.kind === "basic" ? resolved.name : (baseType?.name ?? ""));
+			return `__binary_write(${args[0]}, ${args[1]}, ${args[2]}${sz > 0 ? `, ${sz}` : ", 0"}, "${typeTag}")`;
+		}
+		if (fn === "Size") {
+			const sz = sizeOfGoType(expr?.args?.[0]?._type);
+			if (sz >= 0) return `${sz}`;
+			return `__binary_size(${args[0]})`;
+		}
+		if (fn === "AppendUint16")
+			return `__binary_le.AppendUint16(${args[0]}, ${args[1]})`;
+		if (fn === "AppendUint32")
+			return `__binary_le.AppendUint32(${args[0]}, ${args[1]})`;
+		if (fn === "AppendUint64")
+			return `__binary_le.AppendUint64(${args[0]}, ${args[1]})`;
+		return undefined;
+	},
+};

package/src/backend/js/stdlib/bits.js

@@ -19,7 +19,21 @@ const BITS_MAP = {
 	OnesCount64: ([x]) =>
 		`((() => { let v = BigInt.asUintN(64, BigInt(${x})); let c = 0; while (v > 0n) { if (v & 1n) c++; v >>= 1n; } return c; })())`,
 	RotateLeft64: ([x, k]) =>
-		`((() => { const s = BigInt(${k}) & 63n; const v = BigInt.asUintN(64, BigInt(${x})); return BigInt.asUintN(64, (v << s) | (v >> ((64n - s) & 63n))); })())`,
+		`((() => { const s = BigInt(${k}) & 63n; const v = BigInt.asUintN(64, BigInt(${x})); return Number(BigInt.asUintN(64, (v << s) | (v >> ((64n - s) & 63n)))); })())`,
+
+	Len32: ([x]) => `((v => 32 - Math.clz32(v >>> 0))(${x}))`,
+	Len64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); if (v === 0n) return 0; const hi = Number(v >> 32n); return hi !== 0 ? 64 - Math.clz32(hi) : 32 - Math.clz32(Number(v & 0xffffffffn)); })())`,
+	ReverseBytes16: ([x]) =>
+		`((v => ((v & 0xff) << 8) | ((v >>> 8) & 0xff))((${x}) & 0xffff))`,
+	ReverseBytes32: ([x]) =>
+		`((v => (((v & 0xff) << 24) | ((v & 0xff00) << 8) | ((v >>> 8) & 0xff00) | ((v >>> 24) & 0xff)) >>> 0)((${x}) >>> 0))`,
+	ReverseBytes64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); let r = 0n; for (let i = 0n; i < 8n; i++) r = (r << 8n) | ((v >> (i * 8n)) & 0xffn); return Number(r); })())`,
+	Reverse32: ([x]) =>
+		`((() => { let v = (${x}) >>> 0; v = ((v >>> 1) & 0x55555555) | ((v & 0x55555555) << 1); v = ((v >>> 2) & 0x33333333) | ((v & 0x33333333) << 2); v = ((v >>> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4); v = ((v >>> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8); return ((v >>> 16) | (v << 16)) >>> 0; })())`,
+	Reverse64: ([x]) =>
+		`((() => { const rev32 = (v) => { v = ((v >>> 1) & 0x55555555) | ((v & 0x55555555) << 1); v = ((v >>> 2) & 0x33333333) | ((v & 0x33333333) << 2); v = ((v >>> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4); v = ((v >>> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8); return ((v >>> 16) | (v << 16)) >>> 0; }; const v = BigInt.asUintN(64, BigInt(${x})); const lo = Number(v & 0xffffffffn); const hi = Number((v >> 32n) & 0xffffffffn); return Number((BigInt(rev32(lo)) << 32n) | BigInt(rev32(hi))); })())`,
 };
 
 /** @type {ThisType<CodeGen>} */

package/src/backend/js/stdlib/builder.js

@@ -3,25 +3,40 @@
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 const BUILDER_STR = {
-	WriteString: (b, a) => `(${b}._buf += ${a[0]}, [${a[0]}.length, null])`,
-	WriteByte: (b, a) => `(${b}._buf += String.fromCodePoint(${a[0]}))`,
-	Write: (b, a) => `(${b}._buf += String.fromCharCode(...${a[0]}))`,
+	WriteString: (b, a) =>
+		`((__s) => { ${b}._buf += __s; return [new TextEncoder().encode(__s).length, null]; })(${a[0]})`,
+	WriteByte: (b, a) => `(${b}._buf += String.fromCodePoint(${a[0]}), null)`,
+	WriteRune: (b, a) =>
+		`((cp) => { const r = (cp < 0 || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) ? 0xfffd : cp; const s = String.fromCodePoint(r); ${b}._buf += s; return [new TextEncoder().encode(s).length, null]; })(${a[0]})`,
+	Write: (b, a) =>
+		`(${b}._buf += new TextDecoder().decode(new Uint8Array(${a[0]})), [${a[0]}.length, null])`,
 	String: (b) => `${b}._buf`,
 	Reset: (b) => `(${b}._buf = "")`,
+	Len: (b) => `new TextEncoder().encode(${b}._buf).length`,
+	Cap: (b) =>
+		`Math.max(${b}._cap ?? 0, new TextEncoder().encode(${b}._buf).length)`,
+	Grow: (b, a) =>
+		`((n) => { if (n < 0) throw new Error("strings.Builder.Grow: negative count"); ${b}._cap = Math.max(${b}._cap ?? 0, new TextEncoder().encode(${b}._buf).length) + n; })(${a[0]})`,
 };
 const BUILDER_BYTES = {
 	WriteString: (b, a) =>
-		`(${b}._buf.push(...new TextEncoder().encode(${a[0]})), [${a[0]}.length, null])`,
-	WriteByte: (b, a) => `${b}._buf.push(${a[0]})`,
-	Write: (b, a) => `(${b}._buf.push(...${a[0]}), [${a[0]}.length, null])`,
+		`((buf, s) => { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) buf._buf.push(bytes[i]); return [bytes.length, null]; })(${b}, ${a[0]})`,
+	WriteByte: (b, a) => `(${b}._buf.push(${a[0]}), null)`,
+	WriteRune: (b, a) =>
+		`((buf, cp) => { const r = (cp < 0 || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) ? 0xfffd : cp; const bytes = new TextEncoder().encode(String.fromCodePoint(r)); for (let i = 0; i < bytes.length; i++) buf._buf.push(bytes[i]); return [bytes.length, null]; })(${b}, ${a[0]})`,
+	Write: (b, a) =>
+		`((buf, d) => { for (let i = 0; i < d.length; i++) buf._buf.push(d[i]); return [d.length, null]; })(${b}, ${a[0]})`,
 	String: (b) => `new TextDecoder().decode(new Uint8Array(${b}._buf))`,
 	Reset: (b) => `(${b}._buf = [])`,
+	Read: (b, a) =>
+		`((buf, p) => { if (buf._buf.length === 0) return [0, __io_eof]; const n = Math.min(p.length, buf._buf.length); for (let i = 0; i < n; i++) p[i] = buf._buf.shift(); return [n, null]; })(${b}, ${a[0]})`,
 };
 const BUILDER_COMMON = {
-	WriteRune: (b, a) => `(${b}._buf += String.fromCodePoint(${a[0]}))`,
-	Bytes: (b) => `${b}._buf.slice()`,
+	Bytes: (b) => `new Uint8Array(${b}._buf)`,
 	Len: (b) => `${b}._buf.length`,
-	Grow: () => "undefined",
+	Cap: (b) => `Math.max(${b}._cap ?? 0, ${b}._buf.length)`,
+	Grow: (b, a) =>
+		`((n) => { if (n < 0) throw new Error("bytes.Buffer.Grow: negative count"); ${b}._cap = Math.max(${b}._cap ?? 0, ${b}._buf.length) + n; })(${a[0]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
@@ -30,6 +45,10 @@ export const builderMethods = {
 		const recv = expr.func.expr;
 		const base = this._unboxWriter(this.genExpr(recv));
 		const args = expr.args.map((a) => this.genExpr(a));
+		if (method === "Read") {
+			this.useHelper("ioEOF");
+			this.useHelper("error");
+		}
 		const isStr = typeName === "strings.Builder";
 		const table = isStr ? BUILDER_STR : BUILDER_BYTES;
 		const gen = table[method] ?? BUILDER_COMMON[method];