gofront 1.6.0 → 1.7.0

package/src/backend/js/statements.js

@@ -184,8 +184,7 @@ export const statementGenMethods = {
 			this.line(`const ${tmp} = ${rhs[0]};`);
 			for (let i = 0; i < lhs.length; i++) {
 				if (lhs[i] === "_") continue;
-				const prefix = redecls[i] ? "" : "let ";
-				this.line(`${prefix}${lhs[i]} = ${tmp}[${i}];`);
+				this._genDefineSingleVar([lhs[i]], [`${tmp}[${i}]`], [redecls[i]]);
 			}
 		} else {
 			for (let i = 0; i < lhs.length; i++) {
@@ -193,12 +192,20 @@ export const statementGenMethods = {
 					this.line(`${rhs[i]};`);
 					continue;
 				}
-				const prefix = redecls[i] ? "" : "let ";
-				this.line(`${prefix}${lhs[i]} = ${rhs[i]};`);
+				this._genDefineSingleVar([lhs[i]], [rhs[i]], [redecls[i]]);
 			}
 		}
 	},
 
+	// Address-taken variables introduced by a destructuring declaration are
+	// re-bound to their { value } box.
+	_boxDeclaredNames(names) {
+		for (const n of names) {
+			if (n && n !== "_" && this._boxedVars.has(n))
+				this.line(`${n} = { value: ${n} };`);
+		}
+	},
+
 	_genDefineStmt(stmt) {
 		const rhsNode = stmt.rhs[0];
 		if (this._isCommaOkMapExpr(stmt, rhsNode)) {
@@ -221,6 +228,7 @@ export const statementGenMethods = {
 			const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
 			const names = lhs.map((n) => (n === "_" ? "" : n));
 			this.line(`let [${names.join(", ")}] = ${rhsStr};`);
+			this._boxDeclaredNames(names);
 		} else {
 			this._genDefineMixedRedecl(lhs, rhs, redecls);
 		}
@@ -696,6 +704,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 =
@@ -725,12 +766,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) {
@@ -738,23 +784,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.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})`;
 		}
 
@@ -763,17 +800,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 = {
@@ -787,7 +820,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;
@@ -803,54 +836,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)
@@ -875,14 +871,29 @@ export const statementGenMethods = {
 		}
 	},
 
+	// Interface-typed tags may hold boxed named values; cases compare with __ifeq.
+	_switchTagAndCases(stmt) {
+		const tag = stmt.tag ? this.genExpr(stmt.tag) : "true";
+		if (!stmt.tag || !this._isIfaceType(stmt.tag._type))
+			return { tag, caseExpr: (e) => this.genExpr(e) };
+		this.useHelper("ifeq");
+		this._swCounter = (this._swCounter ?? 0) + 1;
+		const tmp = `__sw${this._swCounter}`;
+		this.line(`const ${tmp} = ${tag};`);
+		return {
+			tag: "true",
+			caseExpr: (e) => `__ifeq(${tmp}, ${this._genIfaceOperand(e)})`,
+		};
+	},
+
 	genSwitch(stmt) {
 		const genBody = () => {
-			const tag = stmt.tag ? this.genExpr(stmt.tag) : "true";
+			const { tag, caseExpr } = this._switchTagAndCases(stmt);
 			this.line(`switch (${tag}) {`);
 			this.indented(() => {
 				for (const c of stmt.cases) {
 					if (c.list) {
-						for (const e of c.list) this.line(`case ${this.genExpr(e)}:`);
+						for (const e of c.list) this.line(`case ${caseExpr(e)}:`);
 					} else {
 						this.line("default:");
 					}
@@ -938,6 +949,13 @@ export const statementGenMethods = {
 					.join(" || ");
 				this.line(`${first ? "if" : "else if"} (${cond}) {`);
 				this.indented(() => {
+					// A single named non-struct case binds the unboxed value.
+					if (
+						stmt.assign &&
+						c.types.length === 1 &&
+						this._isNamedBoxTypeNode(c.types[0])
+					)
+						this.line(`const ${stmt.assign} = __tsw.__gfUnbox();`);
 					for (const s of c.stmts) this.genStmt(s);
 				});
 				this.line("}");

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];

package/src/backend/js/stdlib/bytes.js

@@ -2,8 +2,8 @@
 
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
-const __bs = `(b => String.fromCharCode(...b))`;
-const __sb = `(s => [...s].map(c => c.charCodeAt(0)))`;
+const __bs = `(b => typeof TextDecoder !== "undefined" ? new TextDecoder().decode(b instanceof Uint8Array ? b : new Uint8Array(b)) : String.fromCharCode.apply(null, b))`;
+const __sb = `(s => typeof TextEncoder !== "undefined" ? new TextEncoder().encode(s) : new Uint8Array([...s].map(c => c.charCodeAt(0))))`;
 
 const BYTES_DISPATCH = {
 	Contains: (a) => `${__bs}(${a[0]}).includes(${__bs}(${a[1]}))`,
@@ -16,49 +16,106 @@ const BYTES_DISPATCH = {
 		`((b, sep) => sep.length === 0 ? b.length + 1 : ${__bs}(b).split(${__bs}(sep)).length - 1)(${a[0]}, ${a[1]})`,
 	Repeat: (a) => `${__sb}(${__bs}(${a[0]}).repeat(${a[1]}))`,
 	Replace: (a) =>
-		`((b, o, n, cnt) => { let s = ${__bs}(b), os = ${__bs}(o), ns = ${__bs}(n); if (cnt < 0) return ${__sb}(s.replaceAll(os, ns)); for (let i = 0; i < cnt; i++) s = s.replace(os, ns); return ${__sb}(s); })(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`,
-	ToUpper: (a) => `${__sb}(${__bs}(${a[0]}).toUpperCase())`,
-	ToLower: (a) => `${__sb}(${__bs}(${a[0]}).toLowerCase())`,
-	TrimSpace: (a) => `${__sb}(${__bs}(${a[0]}).trim())`,
+		`((b, o, n, cnt) => { let str = ${__bs}(b), os = ${__bs}(o), nw = ${__bs}(n); if (cnt < 0) return ${__sb}(str.replaceAll(os, () => nw)); let r = ""; let i = 0; for (; cnt > 0; cnt--) { const j = str.indexOf(os, i); if (j < 0) break; r += str.slice(i, j) + nw; i = j + os.length; if (os.length === 0) { if (i >= str.length) break; r += str[i]; i++; } } return ${__sb}(r + str.slice(i)); })(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`,
+	ToUpper: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).toUpperCase())`,
+	ToLower: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).toLowerCase())`,
+	ToTitle: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).toUpperCase())`,
+	TrimSpace: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).trim())`,
 	Trim: (a) =>
-		`${__sb}(${__bs}(${a[0]}).replace(new RegExp(\`^[\${${a[1]}}]+|[\${${a[1]}}]+$\`, "g"), ""))`,
+		`((b, c) => { const s = new TextDecoder().decode(new Uint8Array(b)); const cs = new Set(Array.from(c)); const chars = Array.from(s); let l = 0, r = chars.length; while (l < r && cs.has(chars[l])) l++; while (r > l && cs.has(chars[r - 1])) r--; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${a[0]}, ${a[1]})`,
 	Equal: (a) =>
 		`((a, b) => { if (a.length !== b.length) return false; for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false; return true; })(${a[0]}, ${a[1]})`,
 	Split: (a) => `${__bs}(${a[0]}).split(${__bs}(${a[1]})).map(p => ${__sb}(p))`,
 	Join: (a) => `${__sb}(${a[0]}.map(p => ${__bs}(p)).join(${__bs}(${a[1]})))`,
 	ReplaceAll: (a) =>
-		`((b, o, n) => { const r = []; let i = 0; while (i <= b.length - o.length) { if (o.length > 0 && o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else { r.push(b[i++]); } } for (; i < b.length; i++) r.push(b[i]); return ArrayBuffer.isView(b) ? new Uint8Array(r) : r; })(${a[0]}, ${a[1]}, ${a[2]})`,
+		`((b, o, n) => { const r = []; let i = 0; while (i <= b.length - o.length) { if (o.length > 0 && o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else { r.push(b[i++]); } } for (; i < b.length; i++) r.push(b[i]); return new Uint8Array(r); })(${a[0]}, ${a[1]}, ${a[2]})`,
 	TrimPrefix: (a) =>
 		`((b, p) => p.every((v, i) => b[i] === v) ? b.slice(p.length) : b.slice())(${a[0]}, ${a[1]})`,
 	TrimSuffix: (a) =>
 		`((b, s) => s.length && s.every((v, i) => b[b.length - s.length + i] === v) ? b.slice(0, -s.length) : b.slice())(${a[0]}, ${a[1]})`,
 	TrimLeft: (a) =>
-		`((b, c) => { let i = 0; while (i < b.length && c.includes(String.fromCharCode(b[i]))) i++; return b.slice(i); })(${a[0]}, ${a[1]})`,
+		`((b, c) => { const s = new TextDecoder().decode(new Uint8Array(b)); const cs = new Set(Array.from(c)); const chars = Array.from(s); let l = 0, r = chars.length; while (l < r && cs.has(chars[l])) l++; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${a[0]}, ${a[1]})`,
 	TrimRight: (a) =>
-		`((b, c) => { let i = b.length; while (i > 0 && c.includes(String.fromCharCode(b[i - 1]))) i--; return b.slice(0, i); })(${a[0]}, ${a[1]})`,
+		`((b, c) => { const s = new TextDecoder().decode(new Uint8Array(b)); const cs = new Set(Array.from(c)); const chars = Array.from(s); let l = 0, r = chars.length; while (r > l && cs.has(chars[r - 1])) r--; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${a[0]}, ${a[1]})`,
 	TrimFunc: (a) =>
-		`((b, f) => { let l = 0, r = b.length; while (l < r && f(b[l])) l++; while (r > l && f(b[r - 1])) r--; return b.slice(l, r); })(${a[0]}, ${a[1]})`,
+		`((b, f) => { const s = new TextDecoder().decode(new Uint8Array(b)); const chars = Array.from(s); let l = 0, r = chars.length; while (l < r && f(chars[l].codePointAt(0))) l++; while (r > l && f(chars[r - 1].codePointAt(0))) r--; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${a[0]}, ${a[1]})`,
 	IndexByte: (a) => `(${a[0]}).indexOf(${a[1]})`,
 	LastIndex: (a) =>
 		`((b, s) => { for (let i = b.length - s.length; i >= 0; i--) if (s.every((v, j) => b[i + j] === v)) return i; return -1; })(${a[0]}, ${a[1]})`,
 	LastIndexByte: (a) => `(${a[0]}).lastIndexOf(${a[1]})`,
 	Fields: (a) =>
-		`((b) => { const s = String.fromCharCode(...b).trim(); return s === '' ? [] : s.split(/\\s+/).map(w => [...w].map(c => c.charCodeAt(0))); })(${a[0]})`,
+		`((b) => { const s = new TextDecoder().decode(new Uint8Array(b ?? [])).trim(); return s === '' ? [] : s.split(/\\s+/).map(w => new TextEncoder().encode(w)); })(${a[0]})`,
+	FieldsFunc: (a) =>
+		`((b, fn) => { const s = new TextDecoder().decode(new Uint8Array(b ?? [])); const res = []; let cur = ""; for (const ch of s) { const cp = ch.codePointAt(0); if (fn(cp)) { if (cur.length > 0) { res.push(new TextEncoder().encode(cur)); cur = ""; } } else { cur += ch; } } if (cur.length > 0) res.push(new TextEncoder().encode(cur)); return res; })(${a[0]}, ${a[1]})`,
+	Clone: (a) =>
+		`(${a[0]} ? (${a[0]}.slice ? ${a[0]}.slice() : Array.from(${a[0]})) : null)`,
 	Cut: (a) =>
-		`((b, sep) => { for (let i = 0; i <= b.length - sep.length; i++) if (sep.every((v, j) => b[i + j] === v)) return [b.slice(0, i), b.slice(i + sep.length), true]; return [b.slice(), [], false]; })(${a[0]}, ${a[1]})`,
+		`((b, sep) => { for (let i = 0; i <= b.length - sep.length; i++) if (sep.every((v, j) => b[i + j] === v)) return [b.slice(0, i), b.slice(i + sep.length), true]; return [b.slice(), new Uint8Array(0), false]; })(${a[0]}, ${a[1]})`,
 	ContainsAny: (a) =>
-		`[...(${a[1]})].some(c => (${a[0]}).includes(c.charCodeAt(0)))`,
-	ContainsRune: (a) => `(${a[0]}).includes(${a[1]})`,
-	Map: (a) => `(${a[1]}).map(v => (${a[0]})(v))`,
+		`((b, chars) => { const s = new TextDecoder().decode(new Uint8Array(b)); for (const c of chars) if (s.includes(c)) return true; return false; })(${a[0]}, ${a[1]})`,
+	ContainsRune: (a) =>
+		`((b, r) => { const s = new TextDecoder().decode(new Uint8Array(b)); return s.includes(String.fromCodePoint(r < 0 || r > 0x10ffff || (r >= 0xd800 && r <= 0xdfff) ? 0xfffd : r)); })(${a[0]}, ${a[1]})`,
+	Map: (a) =>
+		`((f, b) => { const s = new TextDecoder().decode(new Uint8Array(b)); let res = ""; for (const c of s) { const r = f(c.codePointAt(0)); if (r >= 0) res += String.fromCodePoint(r); } return new TextEncoder().encode(res); })(${a[0]}, ${a[1]})`,
 	SplitN: (a) =>
-		`((b, sep, n) => { if (n === 0) return []; if (n < 0) return ((b, sep) => { const r = []; let i = 0; while (i <= b.length) { const j = b.findIndex((_, k) => k >= i && sep.every((v, l) => b[k + l] === sep[l])); if (j < 0 || j >= b.length) break; r.push(b.slice(i, j)); i = j + sep.length; } r.push(b.slice(i)); return r; })(b, sep); const r = []; let i = 0; for (let c = 1; c < n; c++) { const j = b.findIndex((_, k) => k >= i && sep.every((v, l) => b[k + l] === sep[l])); if (j < 0) break; r.push(b.slice(i, j)); i = j + sep.length; } r.push(b.slice(i)); return r; })(${a[0]}, ${a[1]}, ${a[2]})`,
+		`((b, sep, n) => {
+			if (n === 0) return null;
+			if (sep.length === 0) {
+				if (n < 0 || b.length <= n) {
+					const r = [];
+					for (let k = 0; k < b.length; k++) r.push(b.slice(k, k + 1));
+					return r;
+				}
+				const r = [];
+				for (let k = 0; k < n - 1; k++) r.push(b.slice(k, k + 1));
+				r.push(b.slice(n - 1));
+				return r;
+			}
+			const findNext = (start) => {
+				for (let k = start; k <= b.length - sep.length; k++) {
+					let match = true;
+					for (let l = 0; l < sep.length; l++) {
+						if (b[k + l] !== sep[l]) { match = false; break; }
+					}
+					if (match) return k;
+				}
+				return -1;
+			};
+			if (n < 0) {
+				const r = [];
+				let i = 0;
+				while (i <= b.length) {
+					const j = findNext(i);
+					if (j < 0) break;
+					r.push(b.slice(i, j));
+					i = j + sep.length;
+				}
+				r.push(b.slice(i));
+				return r;
+			}
+			const r = [];
+			let i = 0;
+			for (let c = 1; c < n; c++) {
+				const j = findNext(i);
+				if (j < 0) break;
+				r.push(b.slice(i, j));
+				i = j + sep.length;
+			}
+			r.push(b.slice(i));
+			return r;
+		})(${a[0]}, ${a[1]}, ${a[2]})`,
 	NewReader: (a) =>
-		`{_src: ${a[0]}, _pos: 0, Read(p) { const n = Math.min(p.length, this._src.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._src[this._pos + i]; this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(b) { this._src = b; this._pos = 0; }}`,
+		`((b) => ({ _src: b, _pos: 0, Read(p) { if (this._pos >= this._src.length) return [0, __io_eof]; const n = Math.min(p.length, this._src.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._src[this._pos + i]; this._pos += n; return [n, null]; }, Len() { return Math.max(0, this._src.length - this._pos); }, Reset(b2) { this._src = b2; this._pos = 0; } }))(${a[0]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
 export const bytesMethods = {
 	_genBytes(fn, a) {
+		if (fn === "NewReader") this.useHelper("ioEOF");
 		const gen = BYTES_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;
 	},

package/src/backend/js/stdlib/errors.js

@@ -4,7 +4,7 @@
 
 /** @type {ThisType<CodeGen>} */
 export const errorsMethods = {
-	_genErrors(fn, a) {
+	_genErrors(fn, a, expr) {
 		const args = a();
 		if (fn === "New") {
 			this.useHelper("error");
@@ -15,6 +15,30 @@ export const errorsMethods = {
 			return `__errorIs(${args[0]}, ${args[1]})`;
 		}
 		if (fn === "Unwrap") return `(${args[0]}?._cause ?? null)`;
+		if (fn === "As") {
+			this.useHelper("errorAs");
+			const targetGoType = expr?.args?.[1]?._type;
+			const baseGoType = targetGoType?.base ?? targetGoType;
+			const concreteGoType = baseGoType?.base ?? baseGoType;
+			const typeName = concreteGoType?.name;
+			if (concreteGoType?.kind === "interface" || typeName === "error") {
+				return `__errorAs(${args[0]}, ${args[1]}, (x) => x !== null && (typeof x === "object" ? typeof x.Error === "function" : true))`;
+			}
+			// Named non-struct error types sit in interfaces as boxes; store the raw value.
+			const namedBox = this._namedBoxInfo(concreteGoType);
+			if (namedBox) {
+				return `__errorAs(${args[0]}, ${args[1]}, (x) => x instanceof ${namedBox.cls}, (x) => x.__gfUnbox())`;
+			}
+			if (typeName) {
+				return `__errorAs(${args[0]}, ${args[1]}, (x) => (typeof ${typeName} === "function" && x instanceof ${typeName}) || x?.constructor?.name === "${typeName}" || x?.__struct === "${typeName}")`;
+			}
+			return `__errorAs(${args[0]}, ${args[1]})`;
+		}
+		if (fn === "Join") {
+			this.useHelper("error");
+			this.useHelper("errorJoin");
+			return `__errorJoin(${args.join(", ")})`;
+		}
 		return undefined;
 	},
 };