gofront 1.6.0 → 1.6.1

package/src/backend/js/stdlib/fmt.js

@@ -3,16 +3,30 @@
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 const _SSCAN_LOOP =
-	`let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { ` +
-	`const t = tokens[i]; const p = ptrs[i]; ` +
-	`if (typeof p.value === "number") p.value = Number(t); ` +
-	`else if (typeof p.value === "boolean") p.value = t === "true"; ` +
+	`let n = 0, err = null; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { ` +
+	`const item = tokens[i]; const t = typeof item === "object" && item !== null ? item.t : item; const verb = item?.verb; const p = ptrs[i]; ` +
+	`if (verb === "%c") { p.value = t.codePointAt ? t.codePointAt(0) : t; } ` +
+	`else if (verb === "%x" || verb === "%X") { const clean = t.replace(/^0[xX]/, ""); const v = parseInt(clean, 16); if (isNaN(v)) { err = __error("expected hex number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0x" + clean) : v; } ` +
+	`else if (verb === "%o") { const clean = t.replace(/^0[oO]?/, ""); const v = parseInt(clean, 8); if (isNaN(v)) { err = __error("expected octal number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0o" + clean) : v; } ` +
+	`else if (verb === "%b") { const clean = t.replace(/^0[bB]/, ""); const v = parseInt(clean, 2); if (isNaN(v)) { err = __error("expected binary number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0b" + clean) : v; } ` +
+	`else if (typeof p.value === "number") { const v = Number(t); if (Number.isNaN(v) || !/^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?$/.test(t)) { err = __error("expected number"); break; } p.value = v; } ` +
+	`else if (typeof p.value === "bigint") { try { if (!/^[+-]?\\d+$/.test(t)) throw 1; p.value = BigInt(t); } catch { err = __error("expected integer"); break; } } ` +
+	`else if (typeof p.value === "boolean") { const tl = String(t).toLowerCase(); if (tl === "true" || tl === "1" || tl === "t") p.value = true; else if (tl === "false" || tl === "0" || tl === "f") p.value = false; else { err = __error("expected boolean"); break; } } ` +
 	`else p.value = t; n++; }`;
 
 /** @type {ThisType<CodeGen>} */
 export const fmtMethods = {
+	_fmtArgJs(e) {
+		const js = this.genExpr(e);
+		const base =
+			e?._type?.kind === "named" ? (e._type.underlying ?? e._type) : e?._type;
+		return base?.kind === "slice" ? `(${js} ?? [])` : js;
+	},
+
 	_genFmt(fn, _a, expr) {
-		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
+		const fmtArgs = expr.args
+			.map((e, idx) => (idx === 0 ? this.genExpr(e) : this._fmtArgJs(e)))
+			.join(", ");
 		switch (fn) {
 			case "Sprintf":
 				this.useHelper("sprintf");
@@ -42,29 +56,72 @@ export const fmtMethods = {
 			case "Fprint":
 				return this._genFmtFprint(fn, expr);
 			case "Sscan": {
+				this.useHelper("error");
 				const strArg = this.genExpr(expr.args[0]);
 				const restArgs = expr.args
 					.slice(1)
 					.map((e) => this.genExpr(e))
 					.join(", ");
-				return `((str, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
+				return `((str, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, err ? err : (n < ptrs.length ? __error("unexpected EOF") : null)]; })(${strArg}, ${restArgs})`;
 			}
 			case "Sscanln": {
+				this.useHelper("error");
 				const strArg = this.genExpr(expr.args[0]);
 				const restArgs = expr.args
 					.slice(1)
 					.map((e) => this.genExpr(e))
 					.join(", ");
-				return `((str, ...ptrs) => { const tokens = str.split("\\n")[0].trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
+				return `((str, ...ptrs) => { const tokens = str.split("\\n")[0].trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, err ? err : (n < ptrs.length ? __error("unexpected EOF") : null)]; })(${strArg}, ${restArgs})`;
 			}
 			case "Sscanf": {
+				this.useHelper("error");
 				const strArg = this.genExpr(expr.args[0]);
 				const fmtArg = this.genExpr(expr.args[1]);
 				const restArgs = expr.args
 					.slice(2)
 					.map((e) => this.genExpr(e))
 					.join(", ");
-				return `((str, _fmt, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, n < ptrs.length ? "input does not match format" : null]; })(${strArg}, ${fmtArg}, ${restArgs})`;
+				return (
+					`((str, fmt, ...ptrs) => { ` +
+					`const s = String(str); const f = String(fmt); ` +
+					`let si = 0, fi = 0; const tokens = []; let parseErr = null; ` +
+					`while (fi < f.length) { ` +
+					`if (/\\s/.test(f[fi])) { ` +
+					`while (fi < f.length && /\\s/.test(f[fi])) fi++; ` +
+					`while (si < s.length && /\\s/.test(s[si])) si++; ` +
+					`continue; ` +
+					`} ` +
+					`if (f[fi] === "%") { ` +
+					`if (fi + 1 < f.length && f[fi + 1] === "%") { ` +
+					`if (s[si] !== "%") { parseErr = __error("input does not match format"); break; } ` +
+					`si++; fi += 2; continue; ` +
+					`} ` +
+					`const vm = f.slice(fi).match(/^%[vdsfqtxXbcoeEfFgG]/); ` +
+					`if (vm) { ` +
+					`const verb = vm[0]; fi += verb.length; ` +
+					`if (verb !== "%c") { while (si < s.length && /\\s/.test(s[si])) si++; } ` +
+					`if (si >= s.length) break; ` +
+					`let tokRe = /^\\S+/; ` +
+					`if (verb === "%d" || verb === "%i") tokRe = /^[+-]?\\d+/; ` +
+					`else if (verb === "%o") tokRe = /^[+-]?(?:0[oO])?[0-7]+/; ` +
+					`else if (verb === "%b") tokRe = /^[+-]?(?:0[bB])?[01]+/; ` +
+					`else if (verb === "%f" || verb === "%F" || verb === "%e" || verb === "%E" || verb === "%g" || verb === "%G") tokRe = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?/; ` +
+					`else if (verb === "%t") tokRe = /^(?:true|false|1|0|t|f|T|F|TRUE|FALSE)/; ` +
+					`else if (verb === "%x" || verb === "%X") tokRe = /^[+-]?(?:0x)?[0-9a-fA-F]+/; ` +
+					`else if (verb === "%c") tokRe = /^[\\s\\S]/; ` +
+					`const m = s.slice(si).match(tokRe); ` +
+					`if (!m) { parseErr = __error("input does not match format"); break; } ` +
+					`tokens.push({ t: m[0], verb }); si += m[0].length; continue; ` +
+					`} ` +
+					`} ` +
+					`if (si >= s.length) break; ` +
+					`if (s[si] !== f[fi]) { parseErr = __error("input does not match format"); break; } ` +
+					`si++; fi++; ` +
+					`} ` +
+					`${_SSCAN_LOOP} ` +
+					`return [n, parseErr || err || (n < ptrs.length ? __error("unexpected EOF") : null)]; ` +
+					`})(${strArg}, ${fmtArg}, ${restArgs})`
+				);
 			}
 			default:
 				return undefined;
@@ -75,7 +132,7 @@ export const fmtMethods = {
 		this.useHelper("sprintf");
 		const writerArg = expr.args[0];
 		const rest = expr.args.slice(1);
-		const restJs = rest.map((e) => this.genExpr(e)).join(", ");
+		const restJs = rest.map((e) => this._fmtArgJs(e)).join(", ");
 		const writerType = writerArg._type;
 		const targetTypeName =
 			writerType?.name ??
@@ -84,16 +141,16 @@ export const fmtMethods = {
 		if (targetTypeName === "strings.Builder") {
 			const w = this.genExpr(writerArg);
 			const base = this._unboxWriter(w);
-			return `(${base}._buf += ${sprintfCall})`;
+			return `((__b, __s) => { __b._buf += __s; return [__s.length, null]; })(${base}, ${sprintfCall})`;
 		}
 		if (targetTypeName === "bytes.Buffer") {
 			const w = this.genExpr(writerArg);
 			const base = this._unboxWriter(w);
-			return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${sprintfCall})`;
+			return `((__b, __s) => { const __bytes = new TextEncoder().encode(__s); for (let i = 0; i < __bytes.length; i++) __b._buf.push(__bytes[i]); return [__bytes.length, null]; })(${base}, ${sprintfCall})`;
 		}
 		// Generic io.Writer fallback — call .WriteString if available
 		const w = this.genExpr(writerArg);
-		return `${w}.WriteString(${sprintfCall})`;
+		return `((__w, __s) => typeof __w.WriteString === "function" ? __w.WriteString(__s) : __w.Write(new TextEncoder().encode(__s)))(${w}, ${sprintfCall})`;
 	},
 
 	_genStdoutWrite(strJs) {
@@ -106,7 +163,7 @@ export const fmtMethods = {
 		const argc = expr.args.length;
 		if (argc === 0) return JSON.stringify(suffix);
 		const fmt = Array(argc).fill("%v").join(sep) + suffix;
-		const args = expr.args.map((e) => this.genExpr(e)).join(", ");
+		const args = expr.args.map((e) => this._fmtArgJs(e)).join(", ");
 		return `__sprintf(${JSON.stringify(fmt)}, ${args})`;
 	},
 

package/src/backend/js/stdlib/hex.js

@@ -0,0 +1,17 @@
+// src/backend/js/stdlib/hex.js
+// CodeGen for Go encoding/hex package.
+
+export const hexMethods = {
+	_genHex(fn, a) {
+		this.useHelper("hex");
+		this.useHelper("error");
+		const args = a();
+		if (fn === "EncodeToString") return `__hex_encode_to_string(${args[0]})`;
+		if (fn === "DecodeString") return `__hex_decode_string(${args[0]})`;
+		if (fn === "Encode") return `__hex_encode(${args[0]}, ${args[1]})`;
+		if (fn === "Decode") return `__hex_decode(${args[0]}, ${args[1]})`;
+		if (fn === "EncodedLen") return `(${args[0]} * 2)`;
+		if (fn === "DecodedLen") return `Math.floor(${args[0]} / 2)`;
+		return undefined;
+	},
+};

package/src/backend/js/stdlib/html.js

@@ -12,7 +12,7 @@ export const htmlMethods = {
 			}
 			case "UnescapeString": {
 				const [s] = a();
-				return `${s}.replace(/&#39;/g,"'").replace(/&#34;/g,'"').replace(/&gt;/g,">").replace(/&lt;/g,"<").replace(/&amp;/g,"&")`;
+				return `(${s}).replace(/&(?:quot|apos|#39|#34|gt|lt|amp|#(?:[0-9]+|[xX][0-9a-fA-F]+));/g, m => { switch (m) { case "&quot;": case "&#34;": return '"'; case "&apos;": case "&#39;": return "'"; case "&gt;": return ">"; case "&lt;": return "<"; case "&amp;": return "&"; default: { if (m.startsWith("&#")) { const raw = m.slice(2, -1); const cp = (raw.startsWith("x") || raw.startsWith("X")) ? parseInt(raw.slice(1), 16) : parseInt(raw, 10); return (cp >= 0 && cp <= 0x10FFFF && !(cp >= 0xD800 && cp <= 0xDFFF)) ? String.fromCodePoint(cp) : "\\uFFFD"; } return m; } } })`;
 			}
 		}
 		return undefined;

package/src/backend/js/stdlib/index.js

@@ -1,12 +1,15 @@
 // CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
 // One file per Go package under ./stdlib/. This index merges them.
 
+import { base64Methods } from "./base64.js";
+import { binaryMethods } from "./binary.js";
 import { bitsMethods } from "./bits.js";
 import { builderMethods } from "./builder.js";
 import { bytesMethods } from "./bytes.js";
 import { errorsMethods } from "./errors.js";
 import { fmtMethods } from "./fmt.js";
 import { gomMethods } from "./gom.js";
+import { hexMethods } from "./hex.js";
 import { htmlMethods } from "./html.js";
 import { ioMethods } from "./io.js";
 import { mapsMethods } from "./maps.js";
@@ -15,11 +18,13 @@ import { osMethods } from "./os.js";
 import { pathMethods } from "./path.js";
 import { randMethods } from "./rand.js";
 import { regexpMethods } from "./regexp.js";
+import { sha256Methods } from "./sha256.js";
 import { sharedMethods } from "./shared.js";
 import { slicesMethods } from "./slices.js";
 import { sortMethods } from "./sort.js";
 import { strconvMethods } from "./strconv.js";
 import { stringsMethods } from "./strings.js";
+import { syncMethods } from "./sync.js";
 import { testingMethods } from "./testing.js";
 import { timeMethods } from "./time.js";
 import { unicodeMethods } from "./unicode.js";
@@ -49,8 +54,14 @@ const STDLIB_METHOD_MAP = {
 	rand: "_genRand",
 	utf8: "_genUtf8",
 	path: "_genPath",
+	filepath: "_genPath",
 	testing: "_genTesting",
 	shared: "_genShared",
+	sync: "_genSync",
+	sha256: "_genSha256",
+	binary: "_genBinary",
+	hex: "_genHex",
+	base64: "_genBase64",
 };
 
 const dispatchMethods = {
@@ -103,5 +114,10 @@ export const stdlibGenMethods = {
 	...unicodeMethods,
 	...utf8Methods,
 	...testingMethods,
+	...syncMethods,
+	...sha256Methods,
+	...binaryMethods,
+	...hexMethods,
+	...base64Methods,
 	...dispatchMethods,
 };

package/src/backend/js/stdlib/io.js

@@ -5,6 +5,7 @@
 /** @type {ThisType<CodeGen>} */
 export const ioMethods = {
 	_genIo(fn, _a, expr) {
+		if (fn === "ReadAll") this.useHelper("error");
 		switch (fn) {
 			case "WriteString": {
 				const writerArg = expr.args[0];
@@ -19,15 +20,116 @@ export const ioMethods = {
 					return `((b,s) => { b._buf += s; return [s.length, null]; })(${base}, ${s})`;
 				}
 				if (typeName === "bytes.Buffer") {
-					return `((b,s) => { b._buf.push(...new TextEncoder().encode(s)); return [s.length, null]; })(${base}, ${s})`;
+					return `((b,s) => { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) b._buf.push(bytes[i]); return [bytes.length, null]; })(${base}, ${s})`;
 				}
 				// Generic: auto-dereference pointer, then dispatch on concrete writer type.
 				// strings.Builder has { _buf: string }, bytes.Buffer has { _buf: [] }.
-				return `((b,s) => { const w = b?.value ?? b; if (typeof w.WriteString === "function") return [w.WriteString(s), null]; if (typeof w._buf === "string") { w._buf += s; return [s.length, null]; } if (Array.isArray(w._buf)) { w._buf.push(...new TextEncoder().encode(s)); return [s.length, null]; } return [0, "io.WriteString: unsupported writer"]; })(${w}, ${s})`;
+				return `((b,s) => { const w = b?.value ?? b; if (typeof w.WriteString === "function") return w.WriteString(s); if (typeof w._buf === "string") { w._buf += s; return [s.length, null]; } if (Array.isArray(w._buf)) { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) w._buf.push(bytes[i]); return [bytes.length, null]; } if (typeof w.Write === "function") return w.Write(new TextEncoder().encode(s)); return [0, "io.WriteString: unsupported writer"]; })(${w}, ${s})`;
 			}
 			case "ReadAll": {
+				this.useHelper("ioEOF");
 				const r = this.genExpr(expr.args[0]);
-				return `((r) => { const w = r?.value ?? r; if (typeof w._src === "string") { const s = w._src.slice(w._pos); w._pos = w._src.length; return [[...s].map(c => c.charCodeAt(0)), null]; } if (Array.isArray(w._src)) { const b = w._src.slice(w._pos); w._pos = w._src.length; return [b, null]; } const chunks = []; const buf = new Array(4096); let err = null; while (!err) { const [n, e] = w.Read(buf); if (n > 0) chunks.push(...buf.slice(0, n)); err = e; } return [chunks, err === "EOF" ? null : err]; })(${r})`;
+				return `((r) => { const w = r?.value ?? r; const chunks = []; const buf = new Uint8Array(512); let err = null; while (!err) { const [n, e] = w.Read(buf); if (n > 0) { for (let i = 0; i < n; i++) chunks.push(buf[i]); } if (n === 0 && !e) break; err = e; } return [new Uint8Array(chunks), (err === "EOF" || err === __io_eof || err?._msg === "EOF") ? null : err]; })(${r})`;
+			}
+			case "LimitReader": {
+				this.useHelper("ioEOF");
+				const r = this.genExpr(expr.args[0]);
+				const n = this.genExpr(expr.args[1]);
+				return `((r, n) => {
+					let rem = typeof n === "bigint" ? Number(n) : Number(n);
+					const reader = r?.value ?? r;
+					return {
+						Read(buf) {
+							if (rem <= 0) return [0, __io_eof];
+							const max = buf.length > rem ? rem : buf.length;
+							const slice = buf.subarray ? buf.subarray(0, max) : buf.slice(0, max);
+							const [readN, err] = reader.Read(slice);
+							if (readN > 0) {
+								if (buf.set && slice !== buf) buf.set(slice.subarray(0, readN), 0);
+								rem -= readN;
+							}
+							return [readN, err];
+						}
+					};
+				})(${r}, ${n})`;
+			}
+			case "Copy": {
+				this.useHelper("ioEOF");
+				const dst = this.genExpr(expr.args[0]);
+				const src = this.genExpr(expr.args[1]);
+				return `((dst, src) => {
+					const w = dst?.value ?? dst;
+					const r = src?.value ?? src;
+					const writeChunk = (chunk) => {
+						if (typeof w?.Write === "function") return w.Write(chunk);
+						if (Array.isArray(w?._buf)) {
+							for (let i = 0; i < chunk.length; i++) w._buf.push(chunk[i]);
+							return [chunk.length, null];
+						}
+						if (typeof w?._buf === "string") {
+							w._buf += new TextDecoder().decode(chunk);
+							return [chunk.length, null];
+						}
+						return [0, "unsupported writer"];
+					};
+					const buf = new Uint8Array(32 * 1024);
+					let total = 0;
+					while (true) {
+						const [n, rerr] = r.Read(buf);
+						if (n > 0) {
+							const chunk = buf.subarray(0, n);
+							const [wn, werr] = writeChunk(chunk);
+							total += wn;
+							if (werr) return [total, werr];
+						}
+						if (rerr) {
+							if (rerr === "EOF" || rerr === __io_eof || rerr?._msg === "EOF") return [total, null];
+							return [total, rerr];
+						}
+					}
+				})(${dst}, ${src})`;
+			}
+			case "CopyN": {
+				this.useHelper("ioEOF");
+				const dst = this.genExpr(expr.args[0]);
+				const src = this.genExpr(expr.args[1]);
+				const n = this.genExpr(expr.args[2]);
+				return `((dst, src, n) => {
+					const w = dst?.value ?? dst;
+					const r = src?.value ?? src;
+					const writeChunk = (chunk) => {
+						if (typeof w?.Write === "function") return w.Write(chunk);
+						if (Array.isArray(w?._buf)) {
+							for (let i = 0; i < chunk.length; i++) w._buf.push(chunk[i]);
+							return [chunk.length, null];
+						}
+						if (typeof w?._buf === "string") {
+							w._buf += new TextDecoder().decode(chunk);
+							return [chunk.length, null];
+						}
+						return [0, "unsupported writer"];
+					};
+					let rem = typeof n === "bigint" ? Number(n) : Number(n);
+					let total = 0;
+					const buf = new Uint8Array(32 * 1024);
+					while (rem > 0) {
+						const toRead = rem < buf.length ? rem : buf.length;
+						const [rn, rerr] = r.Read(buf.subarray(0, toRead));
+						if (rn > 0) {
+							const [wn, werr] = writeChunk(buf.subarray(0, rn));
+							total += wn;
+							rem -= wn;
+							if (werr) return [total, werr];
+						}
+						if (rerr) {
+							if ((rerr === "EOF" || rerr === __io_eof || rerr?._msg === "EOF") && rem === 0) {
+								return [total, null];
+							}
+							return [total, rerr];
+						}
+					}
+					return [total, null];
+				})(${dst}, ${src}, ${n})`;
 			}
 		}
 		return undefined;

package/src/backend/js/stdlib/math.js

@@ -19,6 +19,9 @@ const MATH1 = {
 	Acos: "acos",
 	Exp: "exp",
 	Trunc: "trunc",
+	Sinh: "sinh",
+	Cosh: "cosh",
+	Tanh: "tanh",
 };
 const MATH2 = {
 	Pow: "pow",
@@ -41,7 +44,16 @@ const MATH_EXTRA = {
 	Copysign: ([x, y]) =>
 		`(Math.abs(${x}) * (${y} < 0 || Object.is(${y}, -0) ? -1 : 1))`,
 	Dim: ([x, y]) => `Math.max(${x} - ${y}, 0)`,
-	Remainder: ([x, y]) => `(${x} - Math.round(${x} / ${y}) * ${y})`,
+	Remainder: ([x, y]) =>
+		`((x, y) => { if (isNaN(x) || isNaN(y) || y === 0 || !isFinite(x)) return NaN; if (!isFinite(y)) return x; const q = x / y; const r = Math.round(q); const diff = Math.abs(q - r); const n = (diff === 0.5 && (r % 2 !== 0)) ? (r < q ? r + 1 : r - 1) : r; return x - n * y; })(${x}, ${y})`,
+	Float64bits: ([x]) =>
+		`((f) => { const b = new ArrayBuffer(8); new Float64Array(b)[0] = f; return Number(new BigUint64Array(b)[0]); })(${x})`,
+	Float64frombits: ([b]) =>
+		`((u) => { const buf = new ArrayBuffer(8); new BigUint64Array(buf)[0] = BigInt(u); return new Float64Array(buf)[0]; })(${b})`,
+	Float32bits: ([x]) =>
+		`((f) => { const b = new ArrayBuffer(4); new Float32Array(b)[0] = f; return new Uint32Array(b)[0]; })(${x})`,
+	Float32frombits: ([b]) =>
+		`((u) => { const buf = new ArrayBuffer(4); new Uint32Array(buf)[0] = Number(u) >>> 0; return new Float32Array(buf)[0]; })(${b})`,
 };
 
 /** @type {ThisType<CodeGen>} */

package/src/backend/js/stdlib/path.js

@@ -6,23 +6,37 @@ const PATH_DISPATCH = {
 	Base: (a) =>
 		`((p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; })(${a[0]})`,
 	Dir: (a) =>
-		`((p) => { const i = p.lastIndexOf("/"); if (i < 0) return "."; if (i === 0) return "/"; return p.slice(0, i); })(${a[0]})`,
+		`((p) => { const i = p.lastIndexOf("/"); if (i < 0) return "."; const res = p.slice(0, i); return res === "" ? "/" : __pathClean(res); })(${a[0]})`,
 	Ext: (a) =>
 		`((p) => { const b = p.slice(p.lastIndexOf("/") + 1); const i = b.lastIndexOf("."); return i <= 0 ? "" : b.slice(i); })(${a[0]})`,
 	IsAbs: (a) => `(${a[0]}).startsWith("/")`,
 	Split: (a) =>
 		`((p) => { const i = p.lastIndexOf("/"); return i < 0 ? ["", p] : [p.slice(0, i + 1), p.slice(i + 1)]; })(${a[0]})`,
 	Match: (a) =>
-		`((pat, name) => { try { const sp=/[.+^$()|[\\]\\\\]/g; const re = new RegExp("^" + pat.replace(sp, "\\\\$&").replace(/\\*/g, "[^/]*").replace(/\\?/g, "[^/]") + "$"); return [re.test(name), null]; } catch(e) { return [false, "syntax error in pattern"]; } })(${a[0]}, ${a[1]})`,
+		`((pat, name) => { const [m, err] = __pathMatch(pat, name); return [m, err ? __path_err_bad_pattern : null]; })(${a[0]}, ${a[1]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
 export const pathMethods = {
 	_genPath(fn, a, expr) {
+		if (fn === "Match") {
+			this.useHelper("error");
+			this.useHelper("pathError");
+			this.useHelper("pathClean");
+		}
+		if (fn === "Dir") {
+			this.useHelper("pathClean");
+		}
 		if (fn === "Join") {
 			this.useHelper("pathClean");
-			const allArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
-			return `__pathClean([${allArgs}].filter(x => x !== "").join("/"))`;
+			const allArgs = expr.args
+				.map((e) =>
+					e._spread || expr.ellipsis
+						? `...(${this.genExpr(e)})`
+						: this.genExpr(e),
+				)
+				.join(", ");
+			return `((arr) => arr.length === 0 ? "" : __pathClean(arr.join("/")))([${allArgs}].filter(x => x !== ""))`;
 		}
 		if (fn === "Clean") {
 			this.useHelper("pathClean");

package/src/backend/js/stdlib/rand.js

@@ -3,9 +3,12 @@
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 const RAND_DISPATCH = {
-	Intn: (a) => `Math.floor(Math.random() * ${a[0]})`,
-	Int63n: (a) => `Math.floor(Math.random() * ${a[0]})`,
-	Int31n: (a) => `Math.floor(Math.random() * ${a[0]})`,
+	Intn: (a) =>
+		`((n) => { if (n <= 0) throw new Error("invalid argument to Intn"); return Math.floor(Math.random() * n); })(${a[0]})`,
+	Int63n: (a) =>
+		`((n) => { if (n <= 0) throw new Error("invalid argument to Int63n"); return Math.floor(Math.random() * n); })(${a[0]})`,
+	Int31n: (a) =>
+		`((n) => { if (n <= 0) throw new Error("invalid argument to Int31n"); return Math.floor(Math.random() * n); })(${a[0]})`,
 	Float64: () => "Math.random()",
 	Float32: () => "Math.random()",
 	Int: () => "Math.floor(Math.random() * 2147483647)",
@@ -13,14 +16,16 @@ const RAND_DISPATCH = {
 	Int63: () => "Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)",
 	Seed: () => "(void 0)",
 	Shuffle: (a) =>
-		`((n, f) => { for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); f(i, j); } })(${a[0]}, ${a[1]})`,
+		`((n, f) => { if (n < 0) throw new Error("invalid argument to Shuffle"); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); f(i, j); } })(${a[0]}, ${a[1]})`,
 	Perm: (a) =>
-		`((n) => { const a = Array.from({length: n}, (_, i) => i); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; })(${a[0]})`,
+		`((n) => { if (n < 0) throw new Error("invalid argument to Perm"); const a = Array.from({length: n}, (_, i) => i); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; })(${a[0]})`,
+	Read: (a) => `__crypto_rand_read(${a[0]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
 export const randMethods = {
 	_genRand(fn, a) {
+		if (fn === "Read") this.useHelper("cryptoRand");
 		const gen = RAND_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;
 	},

package/src/backend/js/stdlib/sha256.js

@@ -0,0 +1,12 @@
+// src/backend/js/stdlib/sha256.js
+// CodeGen for Go crypto/sha256 package.
+
+export const sha256Methods = {
+	_genSha256(fn, a) {
+		this.useHelper("sha256");
+		const args = a();
+		if (fn === "Sum256") return `__sha256.Sum256(${args[0]})`;
+		if (fn === "New") return "__sha256.New()";
+		return undefined;
+	},
+};

package/src/backend/js/stdlib/slices.js

@@ -1,51 +1,77 @@
-// CodeGen for Go `slices` package.
+import { isTypedArraySlice } from "../../../typechecker/types.js";
 
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 const SLICES_DISPATCH = {
 	Contains: (a) => `${a[0]}.includes(${a[1]})`,
+	ContainsFunc: (a) =>
+		`((s, f) => { s = s || []; for (let i = 0; i < s.length; i++) { if (f(s[i])) return true; } return false; })(${a[0]}, ${a[1]})`,
 	Index: (a) => `${a[0]}.indexOf(${a[1]})`,
+	IndexFunc: (a) =>
+		`((s, f) => { s = s || []; for (let i = 0; i < s.length; i++) { if (f(s[i])) return i; } return -1; })(${a[0]}, ${a[1]})`,
+	BinarySearch: (a) =>
+		`((s, target) => { s = s || []; let i = 0, j = s.length; while (i < j) { const h = (i + j) >>> 1; if (s[h] < target) i = h + 1; else j = h; } return [i, i < s.length && s[i] === target]; })(${a[0]}, ${a[1]})`,
+	BinarySearchFunc: (a) =>
+		`((s, target, cmp) => { s = s || []; let i = 0, j = s.length; while (i < j) { const h = (i + j) >>> 1; if (cmp(s[h], target) < 0) i = h + 1; else j = h; } return [i, i < s.length && cmp(s[i], target) === 0]; })(${a[0]}, ${a[1]}, ${a[2]})`,
 	Compare: (a) =>
-		`((a, b) => { for (let i = 0; i < a.length && i < b.length; i++) { if (a[i] < b[i]) return -1; if (a[i] > b[i]) return 1; } return a.length - b.length; })(${a[0]}, ${a[1]})`,
-	Sort: (a) => `${a[0]}.sort((a, b) => a < b ? -1 : a > b ? 1 : 0)`,
-	SortFunc: (a) => `${a[0]}.sort(${a[1]})`,
-	SortStableFunc: (a) => `${a[0]}.sort(${a[1]})`,
+		`((a, b) => { a = a || []; b = b || []; for (let i = 0; i < a.length && i < b.length; i++) { const x = a[i], y = b[i]; const xN = typeof x === "number" && isNaN(x), yN = typeof y === "number" && isNaN(y); if (xN && yN) continue; if (xN) return -1; if (yN) return 1; if (x < y) return -1; if (x > y) return 1; } return a.length < b.length ? -1 : a.length > b.length ? 1 : 0; })(${a[0]}, ${a[1]})`,
+	Sort: (a) =>
+		`((s) => s ? s.sort((a, b) => a < b ? -1 : a > b ? 1 : 0) : null)(${a[0]})`,
+	SortFunc: (a) => `((s, f) => s ? s.sort(f) : null)(${a[0]}, ${a[1]})`,
+	SortStableFunc: (a) => `((s, f) => s ? s.sort(f) : null)(${a[0]}, ${a[1]})`,
 	IsSorted: (a) =>
-		`((s) => { for (let i = 1; i < s.length; i++) { if (s[i] < s[i-1]) return false; } return true; })(${a[0]})`,
+		`((s) => { s = s || []; for (let i = 0; i < s.length; i++) { if (typeof s[i] === "number" && isNaN(s[i])) return false; if (i > 0 && s[i] < s[i-1]) return false; } return true; })(${a[0]})`,
 	IsSortedFunc: (a) =>
-		`((s, f) => { for (let i = 1; i < s.length; i++) { if (f(s[i], s[i-1]) < 0) return false; } return true; })(${a[0]}, ${a[1]})`,
-	Reverse: (a) => `${a[0]}.reverse()`,
-	Max: (a) => `Math.max(...${a[0]})`,
-	Min: (a) => `Math.min(...${a[0]})`,
+		`((s, f) => { s = s || []; for (let i = 1; i < s.length; i++) { if (f(s[i], s[i-1]) < 0) return false; } return true; })(${a[0]}, ${a[1]})`,
+	Reverse: (a) => `((s) => s ? s.reverse() : null)(${a[0]})`,
+	Max: (a) =>
+		`((s) => { if (!s || s.length === 0) throw new Error("slices.Max: empty list"); let m = s[0]; for (let i = 1; i < s.length; i++) { const x = s[i]; if ((typeof x === "number" && isNaN(x)) || x > m || (x === 0 && m === 0 && Object.is(m, -0) && !Object.is(x, -0))) m = x; } return m; })(${a[0]})`,
+	Min: (a) =>
+		`((s) => { if (!s || s.length === 0) throw new Error("slices.Min: empty list"); let m = s[0]; for (let i = 1; i < s.length; i++) { const x = s[i]; if ((typeof x === "number" && isNaN(x)) || x < m || (x === 0 && m === 0 && Object.is(x, -0))) m = x; } return m; })(${a[0]})`,
 	MaxFunc: (a) =>
-		`((s, f) => s.reduce((m, x) => f(x, m) > 0 ? x : m))(${a[0]}, ${a[1]})`,
+		`((s, f) => { if (!s || s.length === 0) throw new Error("slices.MaxFunc: empty list"); return s.reduce((m, x) => f(x, m) > 0 ? x : m); })(${a[0]}, ${a[1]})`,
 	MinFunc: (a) =>
-		`((s, f) => s.reduce((m, x) => f(x, m) < 0 ? x : m))(${a[0]}, ${a[1]})`,
-	Clone: (a) => `${a[0]}.slice()`,
+		`((s, f) => { if (!s || s.length === 0) throw new Error("slices.MinFunc: empty list"); return s.reduce((m, x) => f(x, m) < 0 ? x : m); })(${a[0]}, ${a[1]})`,
+	Clone: (a) => `((s) => s ? s.slice() : null)(${a[0]})`,
 	Compact: (a) =>
-		`((s) => s.filter((v, i) => i === 0 || v !== s[i-1]))(${a[0]})`,
+		`((s) => { if (!s || s.length === 0) return s; let k = 1; for (let i = 1; i < s.length; i++) { if (s[i] !== s[k - 1]) s[k++] = s[i]; } return ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]})`,
 	CompactFunc: (a) =>
-		`((s, f) => s.filter((v, i) => i === 0 || !f(v, s[i-1])))(${a[0]}, ${a[1]})`,
-	Concat: (a) => `[].concat(${a.join(", ")})`,
-	Delete: (a) => `[...${a[0]}.slice(0, ${a[1]}), ...${a[0]}.slice(${a[2]})]`,
-	DeleteFunc: (a) => `${a[0]}.filter((v) => !${a[1]}(v))`,
-	Insert: (a) =>
-		`[...${a[0]}.slice(0, ${a[1]}), ${a.slice(2).join(", ")}, ...${a[0]}.slice(${a[1]})]`,
-	Replace: (a) =>
-		`[...${a[0]}.slice(0, ${a[1]}), ${a.slice(3).join(", ")}, ...${a[0]}.slice(${a[2]})]`,
-	Grow: (a) => `${a[0]}.slice()`,
-	Clip: (a) => `${a[0]}.slice()`,
+		`((s, f) => { if (!s || s.length === 0) return s; let k = 1; for (let i = 1; i < s.length; i++) { if (!f(s[i], s[k - 1])) s[k++] = s[i]; } return ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]}, ${a[1]})`,
+	Concat: (a) =>
+		a.length === 0
+			? "null"
+			: `((...slices) => { const nonNull = slices.filter(Boolean); if (nonNull.length === 0) return slices[0] === null ? null : []; if (ArrayBuffer.isView(nonNull[0])) { const totalLen = nonNull.reduce((sum, s) => sum + s.length, 0); const out = new nonNull[0].constructor(totalLen); let off = 0; for (const s of nonNull) { out.set(s, off); off += s.length; } return out; } return [].concat(...slices.map(s => s ? (ArrayBuffer.isView(s) ? Array.from(s) : s) : [])); })(${a.map((x) => `(${x})`).join(", ")})`,
+	Delete: (a) =>
+		`((s, i, j) => { if (!s && i === 0 && j === 0) return s; s = s || []; if (i < 0 || j < i || j > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { s.copyWithin(i, j); return s.subarray(0, s.length - (j - i)); } s.splice(i, j - i); return s; })(${a[0]}, ${a[1]}, ${a[2]})`,
+	DeleteFunc: (a) =>
+		`((s, f) => { if (!s || s.length === 0) return s; let k = 0; for (let i = 0; i < s.length; i++) { if (!f(s[i])) s[k++] = s[i]; } return ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]}, ${a[1]})`,
+	Insert: (a, isTyped) => {
+		const items = a.slice(2);
+		const nilInit = isTyped ? "new Uint8Array(0)" : "[]";
+		return `((s, i, ...v) => { if (!s && i === 0) s = ${nilInit}; if (!s || i < 0 || i > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { const res = new s.constructor(s.length + v.length); res.set(s.subarray(0, i), 0); res.set(v, i); res.set(s.subarray(i), i + v.length); return res; } s.splice(i, 0, ...v); return s; })(${a[0]}, ${a[1]}${items.length ? `, ${items.join(", ")}` : ""})`;
+	},
+	Replace: (a, isTyped) => {
+		const items = a.slice(3);
+		const nilInit = isTyped ? "new Uint8Array(0)" : "[]";
+		return `((s, i, j, ...v) => { if (!s && i === 0 && j === 0) s = ${nilInit}; if (!s || i < 0 || j < i || j > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { const res = new s.constructor(s.length - (j - i) + v.length); res.set(s.subarray(0, i), 0); res.set(v, i); res.set(s.subarray(j), i + v.length); return res; } s.splice(i, j - i, ...v); return s; })(${a[0]}, ${a[1]}, ${a[2]}${items.length ? `, ${items.join(", ")}` : ""})`;
+	},
+	Grow: (a, isTyped) => {
+		const nilInit = isTyped ? "new Uint8Array(0)" : "[]";
+		return `((s, n) => { if (n < 0) throw new Error("runtime error: makeslice: len out of range"); if (!s) return ${nilInit}; return s.slice(); })(${a[0]}, ${a[1]})`;
+	},
+	Clip: (a) => `((s) => s ? s.slice() : null)(${a[0]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
 export const slicesMethods = {
-	_genSlices(fn, a) {
+	_genSlices(fn, a, expr) {
 		if (fn === "Equal") {
 			this.useHelper("equal");
 			const [a1, b1] = a();
 			return `__equal(${a1}, ${b1})`;
 		}
+		const isTyped = isTypedArraySlice(expr?.args?.[0]?._type);
 		const gen = SLICES_DISPATCH[fn];
-		return gen ? gen(a()) : undefined;
+		return gen ? gen(a(), isTyped) : undefined;
 	},
 };