gofront 1.7.0 → 1.9.0

package/src/backend/js/expressions.js

@@ -2,19 +2,89 @@ import {
 	closureMutates,
 	fnMutates,
 	nodeMutatesVar,
-	nodeWritesVar,
 	rootIdentName,
+	someChild,
 } from "../../lower/index.js";
+import { hasCallOrReceive } from "../../lower/walk.js";
+import { constIntValue } from "../../typechecker/const-fold.js";
 import {
+	BROWSER_GLOBALS,
+	compositeLitIndices,
 	ERROR,
+	embeddedFieldName,
+	is64BitInt,
+	is64BitUnsigned,
 	isAny,
 	isComplex,
 	isTypedArraySlice,
 	typedArrayConstructorForElem,
+	typeStr,
 } from "../../typechecker/types.js";
+import { goTypeName } from "../shared/fmt-types.js";
+import { jsNativeCall, NATIVE_HELPERS } from "./natives.js";
+
+// True when `node` compares the identifier `name` with nil (`l == nil`): a
+// pointer-receiver method that does so is meant to run on a nil receiver.
+export function comparesToNil(node, name) {
+	if (Array.isArray(node)) return node.some((n) => comparesToNil(n, name));
+	if (!node || typeof node !== "object") return false;
+	if (node.kind === "BinaryExpr" && (node.op === "==" || node.op === "!=")) {
+		const isRecv = (e) => e?.kind === "Ident" && e.name === name;
+		const isNil = (e) =>
+			(e?.kind === "Ident" && e.name === "nil") ||
+			(e?.kind === "BasicLit" && e.litKind === "NIL");
+		if (
+			(isRecv(node.left) && isNil(node.right)) ||
+			(isRecv(node.right) && isNil(node.left))
+		)
+			return true;
+	}
+	return someChild(node, (c) => comparesToNil(c, name));
+}
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
+// True when type `t` mentions a type parameter anywhere.
+export function mentionsTypeParam(t, depth = 0) {
+	if (!t || depth > 16) return false;
+	switch (t.kind) {
+		case "typeParam":
+			return true;
+		case "slice":
+		case "array":
+			return mentionsTypeParam(t.elem, depth + 1);
+		case "pointer":
+			return mentionsTypeParam(t.base, depth + 1);
+		case "map":
+			return (
+				mentionsTypeParam(t.key, depth + 1) ||
+				mentionsTypeParam(t.value, depth + 1)
+			);
+		case "func":
+			return [...t.params, ...t.returns].some((x) =>
+				mentionsTypeParam(x, depth + 1),
+			);
+		case "named":
+			return (t.typeArgs ?? []).some((x) => mentionsTypeParam(x, depth + 1));
+		default:
+			return false;
+	}
+}
+
+// How an instance of a generic struct is identified at run time: the type
+// arguments' printed form, kept after the zero-value factories in the
+// instance's `__tz` array.  Null when an argument is a type parameter (the
+// instantiation is not known inside erased generic code).
+export function instanceId(typeArgs) {
+	if (!typeArgs?.length || typeArgs.some((t) => mentionsTypeParam(t)))
+		return null;
+	return typeArgs.map(typeStr).join(",");
+}
+
+// Array literals longer than this that leave most slots zero are emitted as
+// the zero array plus assignments (_genSparseArrayLit).
+const SPARSE_ARRAY_MIN = 32;
+
 const STRICT_NUMERIC_TYPES = new Set([
 	"float32",
 	"int8",
@@ -27,6 +97,25 @@ const STRICT_NUMERIC_TYPES = new Set([
 	"uint32",
 ]);
 
+// Unsigned types narrower than 64 bits: `-x` and `^x` wrap back into range.
+const SMALL_UNSIGNED_WRAP = {
+	uint8: "& 0xFF",
+	byte: "& 0xFF",
+	uint16: "& 0xFFFF",
+	uint32: ">>> 0",
+};
+
+// Signed types narrower than 64 bits: `-x` wraps back into range.
+const SIGNED_NEG_WRAP = {
+	int8: "<< 24 >> 24",
+	int16: "<< 16 >> 16",
+	int32: "| 0",
+	rune: "| 0",
+};
+
+// Integer types whose JS shifts must follow Go's 64-bit semantics.
+const WIDE_INT_NAMES = new Set(["int", "int64", "uint", "uint64", "uintptr"]);
+
 const STRICT_OPS = new Set([
 	"+",
 	"-",
@@ -41,23 +130,66 @@ const STRICT_OPS = new Set([
 	">>",
 ]);
 
+function collectFunctionLabels(node, labels = new Set()) {
+	if (!node || typeof node !== "object") return labels;
+	if (Array.isArray(node)) {
+		for (const item of node) collectFunctionLabels(item, labels);
+		return labels;
+	}
+	if (node.kind === "LabeledStmt" && node.label) labels.add(node.label);
+	if (node.kind === "ForStmt" && node.label) labels.add(node.label);
+	for (const k of Object.keys(node)) {
+		if (k.startsWith("_")) continue;
+		collectFunctionLabels(node[k], labels);
+	}
+	return labels;
+}
+
 const NAMED_ZERO_TABLE = {
-	"time.Time": [null, "{ _d: new Date(0), _isZero: true }"],
-	"strings.Builder": [null, '{ _buf: "" }'],
-	"bytes.Buffer": [null, "{ _buf: [] }"],
-	"strings.Replacer": [null, "{ _p: [], Replace(s) { return s; } }"],
-	"sync.Mutex": ["sync", "__sync_mutex()"],
-	"sync.RWMutex": ["sync", "__sync_rwmutex()"],
-	"sync.Once": ["sync", "__sync_once()"],
-	"sync.WaitGroup": ["sync", "__sync_waitgroup()"],
-	"binary.LittleEndian": ["binary", "__binary_le"],
-	"encoding/binary.LittleEndian": ["binary", "__binary_le"],
-	"binary.BigEndian": ["binary", "__binary_be"],
-	"encoding/binary.BigEndian": ["binary", "__binary_be"],
-	"base64.Encoding": ["base64", "__base64_std"],
-	"encoding/base64.Encoding": ["base64", "__base64_std"],
 	"simd.F32x4": [null, "Object.freeze([0, 0, 0, 0])"],
 	F32x4: [null, "Object.freeze([0, 0, 0, 0])"],
+	"simd.Mask32x4": [null, "Object.freeze([false, false, false, false])"],
+	Mask32x4: [null, "Object.freeze([false, false, false, false])"],
+};
+
+// gofront/simd receiver methods -> runtime helper; the receiver is passed first.
+const SIMD_VECTOR_HELPERS = {
+	Add: "__simd_add",
+	Sub: "__simd_sub",
+	Mul: "__simd_mul",
+	Div: "__simd_div",
+	Min: "__simd_min",
+	Max: "__simd_max",
+	MulAdd: "__simd_muladd",
+	Neg: "__simd_neg",
+	Abs: "__simd_abs",
+	Sqrt: "__simd_sqrt",
+	Floor: "__simd_floor",
+	Ceil: "__simd_ceil",
+	Trunc: "__simd_trunc",
+	RoundToEven: "__simd_nearest",
+	Dot3: "__simd_dot3",
+	Dot4: "__simd_dot4",
+	Sum: "__simd_sum",
+	WithLane: "__simd_with_lane",
+	Swizzle: "__simd_swizzle",
+	Equal: "__simd_eq",
+	NotEqual: "__simd_ne",
+	Less: "__simd_lt",
+	LessEqual: "__simd_le",
+	Greater: "__simd_gt",
+	GreaterEqual: "__simd_ge",
+};
+
+const SIMD_MASK_HELPERS = {
+	And: "__simd_mask_and",
+	Or: "__simd_mask_or",
+	Xor: "__simd_mask_xor",
+	AndNot: "__simd_mask_andnot",
+	Not: "__simd_mask_not",
+	Any: "__simd_mask_any",
+	All: "__simd_mask_all",
+	Bits: "__simd_mask_bits",
 };
 
 // Splits a generated JS lvalue at its outermost trailing access:
@@ -95,83 +227,13 @@ function splitLastAccess(js) {
 
 // Namespace constants: pkg.Field → JS literal
 const NS_CONSTANTS = {
-	math: {
-		Pi: "Math.PI",
-		E: "Math.E",
-		Phi: "1.618033988749895",
-		Sqrt2: "Math.SQRT2",
-		SqrtE: "1.6487212707001282",
-		SqrtPi: "1.7724538509055159",
-		SqrtPhi: "1.272019649514069",
-		Ln2: "Math.LN2",
-		Log2E: "Math.LOG2E",
-		Ln10: "Math.LN10",
-		Log10E: "Math.LOG10E",
-		MaxFloat32: "3.4028234663852886e38",
-		SmallestNonzeroFloat32: "1.401298464324817e-45",
-		MaxFloat64: "Number.MAX_VALUE",
-		SmallestNonzeroFloat64: "Number.MIN_VALUE",
-		MaxInt: "Number.MAX_SAFE_INTEGER",
-		MinInt: "Number.MIN_SAFE_INTEGER",
-		MaxInt8: "127",
-		MinInt8: "-128",
-		MaxInt16: "32767",
-		MinInt16: "-32768",
-		MaxInt32: "2147483647",
-		MinInt32: "-2147483648",
-		MaxInt64: "9223372036854775807",
-		MinInt64: "-9223372036854775808",
-		MaxUint8: "255",
-		MaxUint16: "65535",
-		MaxUint32: "4294967295",
-		MaxUint: "18446744073709551615",
-		MaxUint64: "18446744073709551615",
-	},
-	strconv: {
-		ErrSyntax: "__strconv_err_syntax",
-		ErrRange: "__strconv_err_range",
-	},
-	path: {
-		ErrBadPattern: "__path_err_bad_pattern",
-	},
-	filepath: {
-		ErrBadPattern: "__path_err_bad_pattern",
-	},
-	io: {
-		EOF: "__io_eof",
-		Discard:
-			"{ WriteString(s) { return [s.length, null]; }, Write(b) { return [b.length, null]; } }",
-	},
-	sha256: {
-		Size: "32",
-		BlockSize: "64",
-	},
-	hex: {
-		ErrLength: '__error("encoding/hex: odd length hex string")',
-	},
-	base64: {
-		StdPadding: "61",
-		NoPadding: "-1",
-		StdEncoding: "__base64_std",
-		URLEncoding: "__base64_url",
-		RawStdEncoding: "__base64_raw_std",
-		RawURLEncoding: "__base64_raw_url",
-	},
-	binary: {
-		LittleEndian: "__binary_le",
-		BigEndian: "__binary_be",
-	},
-	rand: {
-		Reader: "__crypto_rand_reader",
-	},
-	os: { Args: "process.argv" },
 	time: {
-		Nanosecond: "1",
-		Microsecond: "1000",
-		Millisecond: "1000000",
-		Second: "1000000000",
-		Minute: "60000000000",
-		Hour: "3600000000000",
+		Nanosecond: "1n",
+		Microsecond: "1000n",
+		Millisecond: "1000000n",
+		Second: "1000000000n",
+		Minute: "60000000000n",
+		Hour: "3600000000000n",
 		RFC3339: '"2006-01-02T15:04:05Z07:00"',
 		RFC3339Nano: '"2006-01-02T15:04:05.999999999Z07:00"',
 		DateOnly: '"2006-01-02"',
@@ -199,7 +261,6 @@ const NS_CONSTANTS = {
 		Friday: "5",
 		Saturday: "6",
 	},
-	utf8: { RuneError: "0xFFFD", MaxRune: "0x10FFFF", UTFMax: "4" },
 };
 
 // JavaScript precedence of the operators emitted for Go binary expressions.
@@ -258,6 +319,15 @@ const INT_TYPE_NAMES = new Set([
 	"rune",
 ]);
 
+// Zero values with a shared factory in HELPER_GENERICS.
+const SHARED_ZERO_FACTORIES = {
+	null: "__zn",
+	0: "__z0",
+	'""': "__zs",
+	false: "__zf",
+	"0n": "__z64",
+};
+
 // Zero-value JS literals for basic Go types.
 const ZERO_FOR_BASIC = {
 	int: "0",
@@ -265,11 +335,11 @@ const ZERO_FOR_BASIC = {
 	int8: "0",
 	int16: "0",
 	int32: "0",
-	int64: "0",
+	int64: "0n",
 	uint8: "0",
 	uint16: "0",
 	uint32: "0",
-	uint64: "0",
+	uint64: "0n",
 	uintptr: "0",
 	float32: "0",
 	float64: "0",
@@ -282,24 +352,47 @@ const ZERO_FOR_BASIC = {
 };
 
 // Set of all numeric type names (for type-assertion codegen).
-const TYPEOF_NUMBER_NAMES = new Set([...INT_TYPE_NAMES, "float32", "float64"]);
+const TYPEOF_NUMBER_NAMES = new Set([
+	...[...INT_TYPE_NAMES].filter((n) => n !== "int64" && n !== "uint64"),
+	"float32",
+	"float64",
+]);
 
 // Builtin function codegen — keyed by builtin name, value is (self, expr) => string.
 const BUILTIN_GEN = {
 	append: (s, e) => s.genAppend(e),
 	len: (s, e) => s._genBuiltinLen(e),
-	cap: (s, e) => `(${s.genExpr(e.args[0])}?.length ?? 0)`,
+	cap: (s, e) => {
+		if (e._constLen != null) return s._genConstLen(e);
+		s.useHelper("slice");
+		return `__cap(${s.genExpr(e.args[0])})`;
+	},
 	make: (s, e) => s.genMake(e),
 	delete: (s, e) => {
 		const [m, k] = e.args.map((a) => s.genExpr(a));
 		return `(delete ${m}[${k}])`;
 	},
 	copy: (s, e) => {
-		const [dst, src] = e.args.map((a) => s.genExpr(a));
-		return `((__cd, __cs) => { if (!__cd || !__cs) return 0; const n = Math.min(__cd.length, __cs.length); if (__cd.set) { __cd.set(__cs.length === n ? __cs : (__cs.subarray ? __cs.subarray(0, n) : __cs.slice(0, n))); } else { __cd.splice(0, n, ...(__cs.slice ? __cs.slice(0, n) : __cs.subarray(0, n))); } return n; })(${dst}, ${src})`;
+		const dst = s.genExpr(e.args[0]);
+		const src = s._genSliceSource(e.args[1]);
+		// Array and struct elements are values: the copied elements must not
+		// alias src.
+		const t = e.args[1]._type;
+		const elem = (t?.kind === "named" ? t.underlying : t)?.elem;
+		const clone = s._aggregateBase(elem) ? s._cloneJs(elem, "__e") : "__e";
+		const items =
+			clone === "__e"
+				? "(__cs.slice ? __cs.slice(0, n) : __cs.subarray(0, n))"
+				: `__cs.slice(0, n).map((__e) => ${clone})`;
+		return `((__cd, __cs) => { if (!__cd || !__cs) return 0; const n = Math.min(__cd.length, __cs.length); if (__cd.set) { __cd.set(__cs.length === n ? __cs : (__cs.subarray ? __cs.subarray(0, n) : __cs.slice(0, n))); } else { __cd.splice(0, n, ...${items}); } return n; })(${dst}, ${src})`;
 	},
 	new: (s, e) => {
 		const arg = e.args[0];
+		const base = e._type?.kind === "pointer" ? e._type.base : null;
+		if (base?.kind === "named" && base.typeArgs?.length) {
+			const inst = s._genericStructNew(base.name, base.typeArgs);
+			if (inst) return inst;
+		}
 		const typeName = arg.name ?? s.getTypeName(arg);
 		if (typeName && s.structNames.has(typeName)) {
 			return `new ${typeName}()`;
@@ -309,25 +402,36 @@ const BUILTIN_GEN = {
 			const name = t.name ?? (t.kind === "named" ? t.name : null);
 			if (name) return `new ${name}()`;
 		}
-		return `{ value: ${s.zeroValueForExpr(arg)} }`;
+		// `new([4]byte)`: the type argument is wrapped in a TypeExpr node.
+		const zero = s.zeroValueForExpr(arg.kind === "TypeExpr" ? arg.type : arg);
+		// Erased type parameter: a struct instantiation is its own pointer.
+		if (base?.kind === "typeParam")
+			return `((__v) => (${s._typeParamIsStructJs(base.name)} ? __v : { value: __v }))(${zero})`;
+		return `{ value: ${zero} }`;
 	},
 	// `print` writes without a trailing newline (Go semantics); the wasm glue
 	// buffers the same way, so output parity holds across backends.
 	print: (s, e) =>
-		`((__s) => (typeof process !== "undefined" && process?.stdout?.write ? process.stdout.write(__s) : console.log(__s)))([${e.args.map((a) => s.genExpr(a)).join(", ")}].map(String).join(" "))`,
+		`((__s) => (typeof process !== "undefined" && process?.stdout?.write ? process.stdout.write(__s) : console.log(__s)))([${e.args.map((a) => s.genExpr(a)).join(", ")}].map(String).join(""))`,
 	println: (s, e) =>
 		`console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
-	panic: (s, e) => `(() => { throw new Error(${s.genExpr(e.args[0])}); })()`,
+	panic: (s, e) => {
+		const arg = s.genExpr(e.args[0]);
+		s.useHelper("panicRt");
+		return `__gopanicv(${arg})`;
+	},
 	recover: (s) => {
 		s.useHelper("panicRt");
 		return `__recover(${s._recoverOkInScope ? "__recoverOk" : "false"})`;
 	},
 	error: (s, e) => {
+		// `error(x)` of an error (or nil) is the conversion: x itself.
+		if (!s._isStringExprType(e.args[0]?._type)) return s.genExpr(e.args[0]);
 		s.useHelper("error");
 		return `__error(${s.genExpr(e.args[0])})`;
 	},
-	min: (s, e) => `Math.min(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
-	max: (s, e) => `Math.max(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
+	min: (s, e) => genMinMax(s, e, "min", "<"),
+	max: (s, e) => genMinMax(s, e, "max", ">"),
 	clear: (s, e) => s._genBuiltinClear(e),
 	complex: (s, e) =>
 		`{ re: ${s.genExpr(e.args[0])}, im: ${s.genExpr(e.args[1])} }`,
@@ -335,6 +439,65 @@ const BUILTIN_GEN = {
 	imag: (s, e) => `(${s.genExpr(e.args[0])}).im`,
 };
 
+// Math.min/max coerce strings to NaN, so string operands fold with `<`/`>`.
+// A type parameter may be a string or a number: pick the form at run time
+// (Math.min/max keeps NaN propagation and -0 for floats).
+function genMinMax(s, e, fn, cmp) {
+	const is64 = s._is64BitInt(e._type);
+	const args = e.args.map((a) => {
+		const js = s.genExpr(a);
+		if (
+			is64 &&
+			a._type?.kind === "untyped" &&
+			!js.endsWith("n") &&
+			/^-?\d+$/.test(js)
+		) {
+			return `${js}n`;
+		}
+		return js;
+	});
+	const fold = (xs) => `${xs}.reduce((a, b) => (b ${cmp} a ? b : a))`;
+	if (args.length === 1) return args[0];
+	if (e._type?.kind === "typeParam")
+		return `((...v) => (typeof v[0] === "string" || typeof v[0] === "bigint" ? ${fold("v")} : Math.${fn}(...v)))(${args.join(", ")})`;
+	if (is64 || s._isStringExprType(e._type)) return fold(`[${args.join(", ")}]`);
+	return `Math.${fn}(${args.join(", ")})`;
+}
+
+// Expression kinds whose folded constant value (`_const`, attached by the
+// checker — see typechecker/const-fold.js) is emitted as a literal.  Literals
+// and constant names already emit their value.
+const FOLDED_CONST_KINDS = new Set([
+	"UnaryExpr",
+	"BinaryExpr",
+	"ParenExpr",
+	"CallExpr",
+	"TypeConversion",
+]);
+
+const JS_SAFE_INT = 2n ** 53n;
+
+// `-1.0` already emits its exact value; keep it as written.
+const isSignedLit = (e) =>
+	e.kind === "UnaryExpr" &&
+	(e.op === "-" || e.op === "+") &&
+	e.operand?.kind === "BasicLit";
+
+// Negative literals are parenthesised so they splice safely into operators.
+const signed = (n, text) => (n < 0 || Object.is(n, -0) ? `(${text})` : text);
+
+// JS literal per folded constant kind; null when JS cannot represent it.
+const CONST_LITS = {
+	STRING: (v) => JSON.stringify(v),
+	BOOL: (v) => (v ? "true" : "false"),
+	FLOAT: (v) =>
+		Number.isFinite(v) ? signed(v, Object.is(v, -0) ? "-0" : String(v)) : null,
+	INT: (v) => {
+		const n = Number(v);
+		return Number.isFinite(n) ? signed(n, BigInt(n).toString()) : null;
+	},
+};
+
 // Method-name dispatch for genExpr — string values add no static call edges.
 const EXPR_GEN_DELEGATE = {
 	UnaryExpr: "_genUnaryExpr",
@@ -350,46 +513,159 @@ const EXPR_GEN_DELEGATE = {
 };
 
 /** @type {ThisType<CodeGen>} */
+const stdIdent = (name, type) => ({ kind: "Ident", name, _type: type });
+
+// True when a func type mentions a type parameter (a generic stdlib function).
+function hasTypeParamType(t) {
+	return JSON.stringify([t.params, t.returns], (k, v) =>
+		k.startsWith("_") || k === "underlying" ? undefined : v,
+	).includes('"typeParam"');
+}
+
 export const expressionGenMethods = {
 	genExpr(expr) {
+		if (expr._asComplex && !expr._complexWrapping) {
+			expr._complexWrapping = true;
+			try {
+				return `{ re: ${this.genExpr(expr)}, im: 0 }`;
+			} finally {
+				expr._complexWrapping = false;
+			}
+		}
+		if (expr._ifaceKeyDyn && !expr._ifaceKeying) {
+			// A key typed by a type parameter: encode it for the instantiated type.
+			const f = this._typeParamZeroFactory(expr._ifaceKeyParam);
+			if (f) {
+				expr._ifaceKeying = true;
+				try {
+					this.useHelper("structKey");
+					const box = expr._ifaceKeyDyn === "box" ? ", true" : "";
+					return `__ikt(${f}, ${this.genExpr(expr)}${box})`;
+				} finally {
+					expr._ifaceKeying = false;
+				}
+			}
+		}
+		if (expr._ifaceKey && !expr._ifaceKeying) {
+			// A string key is its own property key; any other dynamic value is
+			// encoded with its type (see HELPER_STRUCT_KEY).
+			const plain =
+				!this._isNamedBoxKind(expr) && this._isStringExprType(expr._type);
+			if (!plain) {
+				expr._ifaceKeying = true;
+				try {
+					this.useHelper("structKey");
+					const tag = this._ifaceKeyTag(expr._ifaceKeyType);
+					return `__ik(${this.genExpr(expr)}${tag ? `, ${JSON.stringify(tag)}` : ""})`;
+				} finally {
+					expr._ifaceKeying = false;
+				}
+			}
+		}
+		if (expr._mapKeyEnc && !expr._mapKeying) {
+			// Array, anonymous struct and pointer keys: see HELPER_STRUCT_KEY.
+			expr._mapKeying = true;
+			try {
+				this.useHelper("structKey");
+				const enc = expr._mapKeyEnc === "pk" ? "__pk" : "__sk";
+				return `${enc}(${this.genExpr(expr)})`;
+			} finally {
+				expr._mapKeying = false;
+			}
+		}
+		if (
+			expr._ifaceSrc?.kind === "pointer" &&
+			expr._ifaceSrc.base?.kind === "typeParam" &&
+			!expr._pbsWrapping
+		) {
+			// `&v` of a type parameter's variable is a box; a struct behind it
+			// is its own pointer.
+			expr._pbsWrapping = true;
+			try {
+				this.useHelper("ifaceBox");
+				return `__pbs(${this.genExpr(expr)})`;
+			} finally {
+				expr._pbsWrapping = false;
+			}
+		}
+		if (
+			expr._ifaceSrc?.kind === "typeParam" &&
+			!expr._tpBoxing &&
+			!expr._ifaceKeyDyn &&
+			this._typeParamZeroFactory(expr._ifaceSrc.name)
+		) {
+			// A type parameter's value entering an interface is boxed and
+			// tagged by the instantiated type (see `__ti`).
+			expr._tpBoxing = true;
+			try {
+				const f = this._typeParamZeroFactory(expr._ifaceSrc.name);
+				return `(${f}.b ?? ${f}.fb ?? ((__v) => __v))(${this.genExpr(expr)})`;
+			} finally {
+				expr._tpBoxing = false;
+			}
+		}
 		if (this._isNamedIfaceBox(expr)) return this._genNamedIfaceBoxExpr(expr);
+		if (expr._ifaceSrc && !expr._ityTagging && !this._isNamedBoxKind(expr)) {
+			const tag = this._dynTypeTag(expr._ifaceSrc);
+			if (tag) {
+				this.useHelper("ifaceBox");
+				expr._ityTagging = true;
+				try {
+					const ptr = expr._ifaceSrc.kind === "pointer" ? ", true" : "";
+					return `__ity(${this.genExpr(expr)}, ${JSON.stringify(tag)}${ptr})`;
+				} finally {
+					expr._ityTagging = false;
+				}
+			}
+		}
 		if (expr._ifaceBox && !expr._ifaceBoxing && !this._isNamedBoxKind(expr)) {
 			expr._ifaceBoxing = true;
 			try {
 				this.useHelper("ifaceBox");
-				const fn =
-					expr._ifaceBox === "ptr"
-						? "__ifp"
-						: expr._ifaceBox === "ptr_slice"
-							? "__ifps"
-							: expr._ifaceBox === "ptr_map"
-								? "__ifpm"
-								: expr._ifaceBox === "map"
-									? "__ifm"
-									: expr._ifaceBox === "slice"
-										? "__ifs"
-										: "__ifv";
-				const extra = expr._ifacePtrFields?.length
-					? `, ${JSON.stringify(expr._ifacePtrFields)}`
-					: "";
-				return `${fn}(${this.genExpr(expr)}${extra})`;
+				const boxed = this._ifaceBoxWrap(
+					this.genExpr(expr),
+					expr._ifaceBox,
+					expr._ifacePtrFields,
+					expr.kind === "CompositeLit",
+				);
+				return this._typedNilWrap(boxed, expr);
 			} finally {
 				expr._ifaceBoxing = false;
 			}
 		}
+		const folded = this._genFoldedConst(expr);
+		if (folded !== null) return folded;
 		switch (expr.kind) {
 			case "BasicLit":
 				if (expr.litKind === "STRING") return JSON.stringify(expr.value);
+				if (
+					(this._is64BitInt(expr._type) || expr._is64Bit) &&
+					(expr.litKind === "INT" || expr._const?.k === "INT")
+				) {
+					return `${expr.value}n`;
+				}
+				if (expr._const?.k === "INT")
+					this._warnConstPrecision(expr._const, expr);
 				return expr.value; // int, float, bool, nil(null)
 			case "ImagLit":
 				return `{ re: 0, im: ${expr.value} }`;
-			case "Ident":
+			case "Ident": {
 				if (this._boxedVars.has(expr.name) && !expr._isAddressOf)
 					return `${expr.name}.value`;
-				return expr.name;
+				// A named untyped constant used as an int64 operand: its
+				// declaration holds a Number, so emit the exact BigInt.
+				const lit64 =
+					expr._is64Bit &&
+					expr._const &&
+					(expr._type?.kind === "untyped" || this._is64BitInt(expr._type))
+						? this._gen64BitFoldedConst(expr, expr._const)
+						: null;
+				return lit64 ?? expr.name;
+			}
 			case "AwaitExpr":
 				return `await ${this.genExpr(expr.expr)}`;
 			case "InstantiationExpr":
+				return this._genInstantiationExpr(expr);
 			case "RangeExpr":
 				return this.genExpr(expr.expr);
 			default: {
@@ -400,6 +676,82 @@ export const expressionGenMethods = {
 		}
 	},
 
+	_gen64BitFoldedConst(expr, val) {
+		if (
+			(this._is64BitInt(expr._type) || expr._is64Bit) &&
+			(val.k === "INT" || expr._intConst)
+		) {
+			const n = constIntValue(val);
+			if (n !== null) return n < 0n ? `(${n}n)` : `${n}n`;
+		}
+		return null;
+	},
+
+	// The literal for a folded constant expression (`1 << 40` →
+	// `1099511627776`), or null.  Integers outside ±2⁵³ emit the nearest
+	// Number and a precision warning.
+	_genFoldedConst(expr) {
+		const val = expr._const;
+		if (!val) return null;
+		// Constant names emit themselves, but an integer use of one still warns
+		// (an integer constant declared in this package warned at its declaration).
+		if (expr.kind === "Ident" || expr.kind === "SelectorExpr") {
+			const declared = expr.kind === "Ident" && val.k === "INT";
+			if (expr._intConst && !declared) this._warnConstPrecision(val, expr);
+			return null;
+		}
+		if (!FOLDED_CONST_KINDS.has(expr.kind) || isSignedLit(expr)) return null;
+		const lit64 = this._gen64BitFoldedConst(expr, val);
+		if (lit64 !== null) return lit64;
+		if (val.k === "INT" || expr._intConst) this._warnConstPrecision(val, expr);
+		return CONST_LITS[val.k]?.(val.v) ?? null;
+	},
+
+	// Warns when an integer constant outside ±2⁵³ has no exact Number (once
+	// per node per generate run: some forms generate the same node more than
+	// once, and cached ASTs are generated again by later compiles).
+	_warnConstPrecision(val, expr) {
+		if (this._is64BitInt(expr?._type) || expr?._is64Bit || expr?._floatConst)
+			return;
+		const i = constIntValue(val);
+		if (i === null || (i <= JS_SAFE_INT && i >= -JS_SAFE_INT)) return;
+		if (BigInt(Number(i)) !== i && !this._precisionWarned.has(expr)) {
+			this._precisionWarned.add(expr);
+			this._warn(`constant ${i} exceeds JS Number precision`, expr);
+		}
+	},
+
+	// `js` boxed as `box` (a checker _ifaceBoxMeta kind) for an interface.
+	// `fresh` marks a value nothing else refers to (a composite literal), which
+	// a struct box then takes over instead of copying.
+	_ifaceBoxWrap(js, box, ptrFields, fresh = false) {
+		this.useHelper("ifaceBox");
+		const fn =
+			{
+				ptr: "__ifp",
+				ptr_slice: "__ifps",
+				ptr_map: "__ifpm",
+				map: "__ifm",
+				slice: "__ifs",
+			}[box] ?? "__ifv";
+		const fields = ptrFields?.length ? JSON.stringify(ptrFields) : "";
+		if (fn === "__ifv" && fresh)
+			return `${fn}(${js}, ${fields || "null"}, true)`;
+		return `${fn}(${js}${fields ? `, ${fields}` : ""})`;
+	},
+
+	// A nil `*T` entering an interface is a typed nil: it keeps T's methods
+	// (callable with a nil receiver) and differs from the nil interface.
+	_typedNilWrap(js, expr) {
+		if (expr._ifaceBox !== "ptr") return js;
+		const src = expr._ifaceSrc;
+		const base = src?.kind === "pointer" ? src.base : null;
+		if (base?.kind !== "named" || base.underlying?.kind !== "struct") return js;
+		const cls = this._dequalify(base.name).replace(/\[.*$/, "");
+		if (!this.structNames.has(cls)) return js;
+		return `__ifn(${js}, ${cls})`;
+	},
+
 	_isNamedBoxKind(expr) {
 		return expr._ifaceBox === "named" || expr._ifaceBox === "named_ptr";
 	},
@@ -444,6 +796,29 @@ export const expressionGenMethods = {
 		return this._isStructType(pt.base);
 	},
 
+	_isScalarPointerType(t) {
+		if (!t) return false;
+		const pt =
+			t.kind === "named"
+				? (t.underlying ?? this.checker?.types.get(t.name)?.underlying)
+				: t;
+		if (pt?.kind !== "pointer") return false;
+		return !this._isStructType(pt.base);
+	},
+
+	_genPointerEquality(expr) {
+		if (expr.op !== "==" && expr.op !== "!=") return null;
+		if (
+			!this._isScalarPointerType(expr.left._type) &&
+			!this._isScalarPointerType(expr.right._type)
+		) {
+			return null;
+		}
+		this.useHelper("ptreq");
+		const cmp = `__ptreq(${this.genExpr(expr.left)}, ${this.genExpr(expr.right)})`;
+		return expr.op === "==" ? cmp : `!${cmp}`;
+	},
+
 	_isStructExpr(expr) {
 		if (!expr) return false;
 		if (expr.kind === "CompositeLit") {
@@ -473,14 +848,31 @@ export const expressionGenMethods = {
 	// Pseudo type object for an AST type node (used where no checker type is available).
 	_typeFromNode(node) {
 		if (!node) return null;
-		if (node.kind === "TypeName" && this.structNames.has(node.name))
-			return { kind: "named", name: node.name, underlying: { kind: "struct" } };
+		if (node.kind === "TypeName" || node.kind === "SelectorExpr") {
+			// `pkg.S` of a bundled package names the class `S`.
+			const name = this.getTypeName(node);
+			if (name && this.structNames.has(name))
+				return { kind: "named", name, underlying: { kind: "struct" } };
+		}
 		if (node.kind === "ArrayType")
 			return { kind: "array", elem: this._typeFromNode(node.elem) };
 		return null;
 	},
 
+	// A value of type-parameter type is copied at run time when its type
+	// argument is a struct or array (decision: runtime check on the zero-value
+	// factory, so one erased function body serves every instantiation).
+	_typeParamClone(t, js) {
+		if (t?.kind !== "typeParam") return null;
+		const factory = this._typeParamZeroFactory(t.name);
+		if (!factory) return null;
+		this.useHelper("vclone");
+		return `__vclone(${factory}, ${js})`;
+	},
+
 	_cloneJs(t, js) {
+		const tp = this._typeParamClone(t, js);
+		if (tp) return tp;
 		const base = this._aggregateBase(t);
 		if (!base) return js;
 		if (base.kind === "struct") {
@@ -498,7 +890,9 @@ export const expressionGenMethods = {
 	_isAddressableExpr(e) {
 		switch (e?.kind) {
 			case "Ident":
-				return e.name !== "_" && !e._isTypeRef;
+				return (
+					e.name !== "_" && (!e._isTypeRef || e._type?.kind === "typeParam")
+				);
 			case "SelectorExpr":
 				return !e._isMethodValue && !e._isMethodExpr;
 			case "IndexExpr":
@@ -516,7 +910,12 @@ export const expressionGenMethods = {
 	genValueExpr(expr) {
 		const js = this.genExpr(expr);
 		if (expr._ifaceBox) return js;
-		if (!this._aggregateBase(expr._type) || !this._isAddressableExpr(expr))
+		if (
+			!(
+				this._aggregateBase(expr._type) || this._typeParamClone(expr._type, js)
+			) ||
+			!this._isAddressableExpr(expr)
+		)
 			return js;
 		return this._cloneJs(expr._type, js);
 	},
@@ -525,11 +924,6 @@ export const expressionGenMethods = {
 		return rootIdentName(e);
 	},
 
-	// True when `node` itself (not its children) writes to variable `name`.
-	_nodeWritesVar(node, name) {
-		return nodeWritesVar(node, name);
-	},
-
 	// True when `node` may modify (or take the address of) the value held by variable `name`.
 	_nodeMutatesVar(node, name, addrOnly = false) {
 		return nodeMutatesVar(node, name, addrOnly);
@@ -541,16 +935,26 @@ export const expressionGenMethods = {
 
 	_withFnCtx(body, fn) {
 		const prev = this._fnCtx;
+		const prevLabels = this._functionLabels;
+		const labels = collectFunctionLabels(
+			body,
+			new Set(this._functionLabels ?? []),
+		);
+		this._functionLabels = Array.from(labels);
 		this._fnCtx = {
 			body,
 			mut: new Map(),
 			owned: new Set(),
 			borrowed: new Set(),
+			// Parameters, receivers and named results, including the enclosing
+			// functions' (closures): `x = x[lo:hi]` on them must not copy.
+			params: new Set(prev?.params),
 		};
 		try {
 			fn();
 		} finally {
 			this._fnCtx = prev;
+			this._functionLabels = prevLabels;
 		}
 	},
 
@@ -568,6 +972,15 @@ export const expressionGenMethods = {
 	// Copies aggregate params/receivers that the function body mutates.
 	_emitParamCopies(params) {
 		for (const p of params) {
+			if (p.name) this._fnCtx?.params.add(p.name);
+			if (p.variadic && p.name && p.name !== "_") {
+				this.useHelper("va");
+				// Only a function that tests the parameter against nil needs an
+				// empty call to be nil; others keep an empty slice so stdlib
+				// helpers and printing see `[]`.
+				const nilTested = comparesToNil(this._fnCtx?.body, p.name);
+				this.line(`${p.name} = __va(${p.name}${nilTested ? ", true" : ""});`);
+			}
 			if (p.variadic || !p.name || p.name === "_") continue;
 			if (this._boxedVars.has(p.name)) {
 				// Address-taken parameter: rebind it to a { value } box.
@@ -621,12 +1034,26 @@ export const expressionGenMethods = {
 			) {
 				return this.genExpr(expr.operand);
 			}
-			if (
-				expr.operand.kind === "SelectorExpr" ||
-				expr.operand.kind === "IndexExpr"
-			) {
-				const inner = this.genExpr(expr.operand);
-				return `{ get value() { return ${inner}; }, set value(v) { ${inner} = v; } }`;
+			if (expr.operand.kind === "IndexExpr") {
+				const obj = this.genExpr(expr.operand.expr);
+				const idx = this.genExpr(expr.operand.index);
+				const check = this._genStrictIndex(
+					{ ...expr.operand, _lvalue: false },
+					"__o",
+					"__i",
+				);
+				// Erased generic element: a struct instantiation is its own
+				// pointer, anything else gets the get/set wrapper.
+				if (expr.operand._type?.kind === "typeParam")
+					return `((__o, __i) => { ${check ? `${check}; ` : ""}if (${this._typeParamIsStructJs(expr.operand._type.name)}) return __o[__i]; return Object.defineProperties({ get value() { return __o[__i]; }, set value(v) { __o[__i] = v; } }, { __target: { value: __o }, __index: { value: __i } }); })(${obj}, ${idx})`;
+				if (check)
+					return `((__o, __i) => (${check}, Object.defineProperties({ get value() { return __o[__i]; }, set value(v) { __o[__i] = v; } }, { __target: { value: __o }, __index: { value: __i } })))(${obj}, ${idx})`;
+				return `((__o, __i) => Object.defineProperties({ get value() { return __o[__i]; }, set value(v) { __o[__i] = v; } }, { __target: { value: __o }, __index: { value: __i } }))(${obj}, ${idx})`;
+			}
+			if (expr.operand.kind === "SelectorExpr") {
+				const obj = this.genExpr(expr.operand.expr);
+				const field = expr.operand.field;
+				return `((__o) => Object.defineProperties({ get value() { return __o.${field}; }, set value(v) { __o.${field} = v; } }, { __target: { value: __o }, __index: { value: "${field}" } }))(${obj})`;
 			}
 			// For non-boxed vars (primitives, etc.), wrap in { value: x }
 			return `{ value: ${this.genExpr(expr.operand)} }`;
@@ -634,7 +1061,13 @@ export const expressionGenMethods = {
 		// Dereference: *p
 		if (op === "*") {
 			if (this._isStructPointerType(expr.operand._type)) {
-				return this.genExpr(expr.operand);
+				return expr._nonNil
+					? this.genExpr(expr.operand)
+					: this._genNilChecked(this.genExpr(expr.operand));
+			}
+			if (expr.operand._type?.base?.kind === "typeParam") {
+				if (expr._derefOpTarget) return `${this.genExpr(expr.operand)}.value`;
+				return `((__p) => (${this._typeParamIsStructJs(expr.operand._type.base.name)} ? __p : __p.value))(${this.genExpr(expr.operand)})`;
 			}
 			return `${this.genExpr(expr.operand)}.value`;
 		}
@@ -645,6 +1078,27 @@ export const expressionGenMethods = {
 			return inner;
 		}
 		const code = this.genExpr(expr.operand);
+		if (this._is64BitInt(expr._type) || expr._is64Bit) {
+			let operandCode = code;
+			if (!operandCode.endsWith("n") && /^-?\d+$/.test(operandCode)) {
+				operandCode = `${operandCode}n`;
+			}
+			if (op === "+") return operandCode;
+			const wrap = this._is64BitUnsigned(expr._type)
+				? "BigInt.asUintN"
+				: "BigInt.asIntN";
+			if (op === "-" || op === "~") return `${wrap}(64, ${op}(${operandCode}))`;
+		}
+		const wrap = this.strict
+			? SMALL_UNSIGNED_WRAP[this._typeName(expr._type)]
+			: null;
+		if (wrap && (op === "-" || op === "~")) return `(${op}(${code}) ${wrap})`;
+		// -MinInt wraps back to itself for signed narrow integers.
+		const signedWrap =
+			this.strict && op === "-"
+				? SIGNED_NEG_WRAP[this._typeName(expr._type)]
+				: null;
+		if (signedWrap) return `(-(${code}) ${signedWrap})`;
 		const needsParens =
 			this._emittedBinaryOp(expr.operand) !== null ||
 			((op === "-" || op === "+") && /^[-+]/.test(code));
@@ -652,9 +1106,24 @@ export const expressionGenMethods = {
 	},
 
 	_genSelectorExpr(expr) {
+		// Go-source stdlib member: bundled under its mangled top-level name.
+		if (expr._stdName) {
+			// An untyped constant used as an int64 operand: its declaration
+			// holds a Number, so emit the exact BigInt (as for an Ident).
+			const lit64 =
+				expr._is64Bit && expr._type?.kind === "untyped" && expr._const
+					? this._gen64BitFoldedConst(expr, expr._const)
+					: null;
+			return lit64 ?? expr._stdName;
+		}
+		if (this._isStdlibFuncValue(expr)) return this._genStdlibFuncValue(expr);
 		if (expr._isMethodExpr) {
 			const namedExpr = this._namedMethodExprInfo(expr);
 			if (namedExpr) return `${namedExpr.cls}.$${expr.field}`;
+			const rt = expr._methodExprRecv;
+			const protoCls = this._ptrMethodProtoClass(rt, expr.field);
+			if (protoCls)
+				return `((recv, ...args) => ${protoCls}.prototype.${expr.field}.call(recv, ...args))`;
 			return `((recv, ...args) => recv.${expr.field}(...args))`;
 		}
 		const namedValue = this._genNamedMethodValue(expr);
@@ -662,36 +1131,101 @@ export const expressionGenMethods = {
 		if (expr.expr.kind === "Ident") {
 			const nsConst = NS_CONSTANTS[expr.expr.name]?.[expr.field];
 			if (nsConst !== undefined) {
-				if (expr.expr.name === "strconv") {
-					this.useHelper("strconvError");
-				} else if (expr.expr.name === "path" || expr.expr.name === "filepath") {
-					if (expr.field === "ErrBadPattern") this.useHelper("pathError");
-				} else if (expr.expr.name === "io" && expr.field === "EOF") {
-					this.useHelper("ioEOF");
-				} else if (expr.expr.name === "binary") {
-					this.useHelper("binary");
-				} else if (expr.expr.name === "hex") {
-					this.useHelper("hex");
-					this.useHelper("error");
-				} else if (expr.expr.name === "base64") {
-					this.useHelper("base64");
-				} else if (expr.expr.name === "rand" && expr.field === "Reader") {
-					this.useHelper("cryptoRand");
-				} else if (expr.expr.name === "sha256") {
-					this.useHelper("sha256");
-				}
 				return nsConst;
 			}
 		}
 		const base = this.genExpr(expr.expr);
-		if (this.bundledPackages.has(base)) return expr.field;
+		// Bundled GoFront package member; browser-global names carry the `$`
+		// suffix of their declaration (see jsBindingName).
+		if (this.bundledPackages.has(base))
+			return BROWSER_GLOBALS.has(expr.field) ? `${expr.field}$` : expr.field;
 		if (expr.expr._type?.kind === "pointer" && expr.field !== "value")
 			return this._genPointerSelectorField(expr, base);
-		const sel = `${base}.${this._jsMemberName(expr)}`;
-		if (expr._isMethodValue && !expr._callee) return `${sel}.bind(${base})`;
+		const sel = `${base}${this._promotedPath(expr)}.${this._jsMemberName(expr)}`;
+		if (expr._isMethodValue && !expr._callee) {
+			// A value receiver is copied when the method value is evaluated.
+			const t = expr.expr._type;
+			if (!expr._type?._ptrRecv && this._aggregateBase(t))
+				return `((__r) => __r.${this._jsMemberName(expr)}.bind(__r))(${this._cloneJs(t, base)})`;
+			return `${sel}.bind(${base})`;
+		}
 		return sel;
 	},
 
+	// `pkg.Fn` used as a value (not called): a stdlib function is inlined at
+	// its call sites, so a value is an arrow function that makes that call.
+	_isStdlibFuncValue(expr) {
+		const t = expr._type;
+		if (expr._callee || t?.kind !== "func" || expr._isMethodExpr) return false;
+		const ns = expr.expr;
+		if (ns?.kind !== "Ident" || ns._type?.kind !== "namespace") return false;
+		return !this.bundledPackages.has(ns.name) && !hasTypeParamType(t);
+	},
+
+	_genStdlibFuncValue(expr) {
+		const t = expr._type;
+		const ps = t.params ?? [];
+		const nFixed = t.variadic && ps.length > 0 ? ps.length - 1 : ps.length;
+		const fixed = ps.slice(0, nFixed).map((p, i) => stdIdent(`__a${i}`, p));
+		const names = fixed.map((a) => a.name);
+		const callJs = (args) =>
+			this.genExpr({
+				kind: "CallExpr",
+				func: { ...expr, _callee: true },
+				args,
+				_type: t.returns?.[0] ?? { kind: "basic", name: "void" },
+			});
+		if (nFixed === ps.length)
+			return `((${names.join(", ")}) => ${callJs(fixed)})`;
+		// Stdlib calls are inlined per operand count, so dispatch on it.
+		const rest = `__a${nFixed}`;
+		let body = `(() => { throw new Error("too many arguments in call to ${expr.expr.name}.${expr.field}"); })()`;
+		for (let k = 8; k >= 0; k--) {
+			const extra = Array.from({ length: k }, (_, i) =>
+				stdIdent(`${rest}[${i}]`, ps[nFixed]),
+			);
+			body = `${rest}.length === ${k} ? ${callJs([...fixed, ...extra])} : ${body}`;
+		}
+		return `((${[...names, `...${rest}`].join(", ")}) => ${body})`;
+	},
+
+	// A promoted field (`o.A` with embedded `In`) lives on the embedded value:
+	// the class also carries a flattened copy, so reads and writes go through
+	// the embedded path (`.In`) to stay in sync.  Returns "" for direct fields.
+	_promotedPath(expr) {
+		if (expr._isMethodValue || expr._isMethodExpr) return "";
+		let t = expr.expr._type;
+		if (t?.kind === "pointer") t = t.base;
+		const path = this._embedPath(t, expr.field, 0);
+		return path ? path.map((n) => `.${n}`).join("") : "";
+	},
+
+	_embedPath(t, field, depth) {
+		const st = t?.kind === "named" ? t.underlying : t;
+		if (st?.kind !== "struct" || !st.fields?.has(field) || depth > 8)
+			return null;
+		const direct = (st._structFields ?? []).some(
+			(sf) => !sf.embedded && sf.names?.includes(field),
+		);
+		if (direct) return null;
+		for (const sf of st._structFields ?? []) {
+			if (!sf.embedded) continue;
+			const inner = sf.type?.kind === "pointer" ? sf.type.base : sf.type;
+			if (inner?.kind !== "named" || !this.structNames.has(inner.name))
+				continue;
+			const name = embeddedFieldName(sf);
+			if (name === field) return null;
+			const ist = inner.underlying;
+			if (!ist?.fields?.has(field)) continue;
+			const sub = this._embedPath(inner, field, depth + 1);
+			const idirect = (ist._structFields ?? []).some(
+				(x) => !x.embedded && x.names?.includes(field),
+			);
+			return idirect ? [name] : sub ? [name, ...sub] : null;
+		}
+		return null;
+	},
+
 	// PascalCase aliases of Web API methods (gl.ClearColor) map to the real camelCase member.
 	_jsMemberName(expr) {
 		const f = expr.field;
@@ -733,7 +1267,12 @@ export const expressionGenMethods = {
 				? `${this.genExpr(sel.expr)}.value`
 				: this.genExpr(sel.expr);
 		}
-		return { cls: info.cls, recv };
+		return {
+			cls: info.cls,
+			recv,
+			byValue: !method._ptrRecv,
+			recvType: viaPtr ? recvType.base : recvType,
+		};
 	},
 
 	// `x.M` used as a value: binds the receiver now, as Go does.
@@ -741,7 +1280,11 @@ export const expressionGenMethods = {
 		if (!expr._isMethodValue || expr._callee) return undefined;
 		const target = this._namedMethodTarget(expr);
 		if (!target) return undefined;
-		return `((__r) => (...__a) => ${target.cls}.$${expr.field}(__r, ...__a))(${target.recv})`;
+		// A value receiver (a named array) is copied when the value is evaluated.
+		const recv = target.byValue
+			? this._cloneJs(target.recvType, target.recv)
+			: target.recv;
+		return `((__r) => (...__a) => ${target.cls}.$${expr.field}(__r, ...__a))(${recv})`;
 	},
 
 	_genAddressOfExpr(operand) {
@@ -776,17 +1319,134 @@ export const expressionGenMethods = {
 		return `${target.cls}.$${sel.field}(${args ? `${target.recv}, ${args}` : target.recv})`;
 	},
 
+	// `F[int]` as a value is a function that passes F its zero-value factories.
+	_genInstantiationExpr(expr) {
+		const fn = this.genExpr(expr.expr);
+		if (!expr._genericFnType || expr._callee) return fn;
+		const { typeParams } = expr._genericFnType;
+		const zeros = this._typeArgFactories(
+			typeParams,
+			expr._typeArgs,
+			this._genericFnNeedsTypeInfo(expr._genericFnType),
+		);
+		return `((...a) => ${fn}(${zeros.join(", ")}, ...a))`;
+	},
+
 	_genCallArgs(expr) {
 		if (expr._multiForward) return `...${this.genExpr(expr.args[0])}`;
-		return expr.args
-			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
-			.join(", ");
+		return this._genCallArgList(expr).join(", ");
+	},
+
+	_genCallArgList(expr) {
+		return expr.args.map((a, i) =>
+			a._spread
+				? this._genSpreadArg(expr, a)
+				: a._boxTypeParam
+					? this._genTypeParamBox(a)
+					: this._callerCopiesArg(expr, i)
+						? this.genValueExpr(a)
+						: this.genExpr(a),
+		);
+	},
+
+	// A type parameter operand of a Print-family fmt call (see
+	// src/lower/fmt-formatters.js): a JS value does not know its Go type, so
+	// the type argument boxes it as converting it to an `any` does.
+	_genTypeParamBox(a) {
+		// Boxed below: skip the boxing of a value entering an interface.
+		const wasBoxing = a._tpBoxing;
+		a._tpBoxing = true;
+		const js = this.genExpr(a);
+		a._tpBoxing = wasBoxing;
+		const tpf = this._typeParamZeroFactory(a._type.name);
+		return tpf ? `(${tpf}.b ?? ${tpf}.fb ?? ((__v) => __v))(${js})` : js;
+	},
+
+	// A direct call of a `//gofront:native` function: host code from the
+	// registry, or null (declined, natives off, spread arguments) to call the
+	// Go body.
+	_genNativeCall(expr) {
+		if (!this.natives || !expr._native) return null;
+		if (expr._multiForward || expr.args.some((a) => a._spread)) return null;
+		const typeArgs = expr._typeArgs ?? expr.func._typeArgs ?? [];
+		const js = jsNativeCall(expr._native, this._genCallArgList(expr), typeArgs);
+		if (js !== null && NATIVE_HELPERS.has(expr._native))
+			this.useHelper(NATIVE_HELPERS.get(expr._native));
+		return js;
+	},
+
+	// `f(xs...)`: a Go-compiled variadic callee receives the slice itself in a
+	// marker (its prologue unwraps it); other callees get a JS spread.
+	_genSpreadArg(call, arg) {
+		const js = this.genExpr(arg);
+		// A variadic function of a Go-source package (`fmt.Println`): a nil
+		// slice spreads to no operands.
+		if (call.func._stdName) return `...(${js} ?? [])`;
+		return this._calleeIsGoVariadic(call) ? `{ __sp: ${js} }` : `...${js}`;
+	},
+
+	_calleeIsGoVariadic(call) {
+		const f = call.func;
+		if (f.kind === "Ident") {
+			if (this.variadicFns?.has(f.name)) return true;
+			// A local func value (closure or parameter) compiled from Go source.
+			const imported =
+				this.checker?._externalNames?.has(f.name) ||
+				BROWSER_GLOBALS.has(f.name) ||
+				[...(this.jsImports?.values() ?? [])].some((names) =>
+					names.includes(f.name),
+				);
+			return !imported && f._type?.kind === "func" && !!f._type.variadic;
+		}
+		if (f.kind !== "SelectorExpr" || f._isMethodExpr) return false;
+		const recv = this._resolveRecvName(f.expr._type);
+		return !!recv && !!this.variadicFns?.has(`${recv}.${f.field}`);
+	},
+
+	// A callee copies its mutated array and struct parameters on entry, except
+	// when the parameter is a type parameter (generics are erased in JS) or
+	// part of a variadic rest array.  For those the caller passes aggregate
+	// (array and struct) arguments as copies.
+	_callerCopiesArg(expr, i) {
+		const argT = expr.args[i]._type;
+		if (!this._aggregateBase(argT) && !this._typeParamClone(argT, ""))
+			return false;
+		let ft = expr.func?._type ?? expr.func?.expr?._type;
+		if (ft?.kind === "generic") ft = ft.underlying;
+		if (ft?.kind !== "func") return false;
+		const params = ft.params ?? [];
+		if (ft.variadic && i >= params.length - 1) return true;
+		return params[i]?.kind === "typeParam";
 	},
 
 	_genPointerSelectorField(expr, base) {
 		if (this._isStructPointerType(expr.expr._type)) {
-			const sel = `${base}.${expr.field}`;
-			if (expr._isMethodValue && !expr._callee) return `${sel}.bind(${base})`;
+			// Strict mode: a field of a nil struct pointer panics as in Go.
+			const recv =
+				this.strict && !expr._isMethodValue && !expr._nonNil
+					? this._genNilChecked(base)
+					: base;
+			const sel = `${recv}${this._promotedPath(expr)}.${expr.field}`;
+			if (expr._isMethodValue && !expr._callee) {
+				// `p.M` with a value receiver binds a copy of `*p` now.
+				if (expr._derefRecv) {
+					const copy = this._cloneJs(
+						expr.expr._type.base,
+						this.strict ? this._genNilChecked(base) : base,
+					);
+					return `((__r) => __r.${expr.field}.bind(__r))(${copy})`;
+				}
+				// A pointer receiver may be nil: bind through the prototype so
+				// `s.M` on a nil pointer does not read `.M` off null.
+				const protoCls = this._ptrMethodProtoClass(
+					expr.expr._type,
+					expr.field,
+					expr,
+				);
+				if (protoCls)
+					return `${protoCls}.prototype.${expr.field}.bind(${base})`;
+				return `${sel}.bind(${base})`;
+			}
 			return sel;
 		}
 		const sel = `${base}.value.${expr.field}`;
@@ -801,19 +1461,55 @@ export const expressionGenMethods = {
 		const base = wrapField
 			? `${this.genExpr(expr.expr)}.${wrapField}`
 			: this.genExpr(expr.expr);
-		const idx = this.genExpr(expr.index);
-		if (expr._mapValueType && !expr._lvalue)
-			return this._genMapIndexExpr(expr, base, idx);
+		let idx = this.genExpr(expr.index);
+		if (expr._mapValueType) {
+			if (!expr._lvalue) return this._genMapIndexExpr(expr, base, idx);
+			return `${this._genMapWriteBase(base)}[${idx}]`;
+		}
+		if (this._is64BitInt(expr.index?._type)) idx = `Number(${idx})`;
+		const checked = this._genStrictIndex(expr, base, idx);
+		if (checked) return checked;
 		if (this._isStringExprType(exprType) && !expr._lvalue)
 			return `${base}.charCodeAt(${idx})`;
 		return `${base}[${idx}]`;
 	},
 
+	// `p` for a field access `p.F`, panicking with Go's message when nil.
+	_genNilChecked(base) {
+		this.useHelper("nilCall");
+		return `__nilcall(${base})`;
+	},
+
+	// The map of a write `m[k] = v`: strict mode panics on a nil map.
+	_genMapWriteBase(base) {
+		if (!this.strict) return base;
+		this.useHelper("nilMap");
+		return `__mw(${base})`;
+	},
+
+	// Strict mode: `xs[i]` on a slice, array or string with Go's bounds check
+	// (null when no check applies).  Reads of slices and arrays use `__at`;
+	// lvalues and string reads use `base[__ix(base, i)]`, binding `base` to
+	// `__lv` first when evaluating it twice could repeat a call.
+	_genStrictIndex(expr, base, idx) {
+		if (!this.strict || expr._inBounds) return null;
+		const t = expr.expr._type;
+		const u = t?.kind === "named" ? t.underlying : t;
+		const isStr = this._isStringExprType(t);
+		if (!isStr && u?.kind !== "slice" && u?.kind !== "array") return null;
+		this.useHelper("bounds");
+		if (!expr._lvalue && !isStr) return `__at(${base}, ${idx})`;
+		const once = this._hasCallExpr(expr.expr);
+		const obj = once ? `(__lv = ${base})` : base;
+		const at = `__ix(${once ? "__lv" : base}, ${idx})`;
+		return expr._lvalue ? `${obj}[${at}]` : `${obj}.charCodeAt(${at})`;
+	},
+
 	_genMapIndexExpr(expr, base, idx) {
 		const zero = this.zeroValueForType(expr._mapValueType);
 		if (this._hasCallExpr(expr.expr) || this._hasCallExpr(expr.index))
-			return `((__m, __k) => __m[__k] ?? ${zero})(${base}, ${idx})`;
-		return `(${base}[${idx}] ?? ${zero})`;
+			return `((__m, __k) => __m?.[__k] ?? ${zero})(${base}, ${idx})`;
+		return `(${base}?.[${idx}] ?? ${zero})`;
 	},
 
 	_isStringExprType(exprType) {
@@ -826,17 +1522,36 @@ export const expressionGenMethods = {
 
 	_genSliceExpr(expr) {
 		const base = this.genExpr(expr.expr);
-		const lo = expr.low ? this.genExpr(expr.low) : "";
-		const hi = expr.high ? this.genExpr(expr.high) : "";
-		const method = isTypedArraySlice(expr.expr._type) ? "subarray" : "slice";
-		if (!lo && !hi) return `${base}.${method}()`;
-		if (!hi) return `${base}.${method}(${lo})`;
-		if (!lo) return `${base}.${method}(0, ${hi})`;
-		return `${base}.${method}(${lo}, ${hi})`;
+		const lo = expr.low
+			? this._is64BitInt(expr.low._type)
+				? `Number(${this.genExpr(expr.low)})`
+				: this.genExpr(expr.low)
+			: "0";
+		const hi = expr.high
+			? this._is64BitInt(expr.high._type)
+				? `Number(${this.genExpr(expr.high)})`
+				: this.genExpr(expr.high)
+			: "undefined";
+		if (this._isStringExprType(expr.expr._type))
+			return expr.high ? `${base}.slice(${lo}, ${hi})` : `${base}.slice(${lo})`;
+		// `b[:]`, `b[0:]` and `a[:]` have the operand's length and capacity:
+		// the result is the operand itself.  Other bounds make a view sharing
+		// the backing store (`__slice`, which checks the bounds against cap).
+		const zeroLow = !expr.low || Number(expr.low._const?.v) === 0;
+		if (zeroLow && !expr.high && !expr.max) return base;
+		this.useHelper("slice");
+		// `x = x[lo:hi]` (see `_markSelfReslice`) copies a plain array when
+		// the result stays within `len(x)`; typed arrays always share.
+		if (expr._selfReslice && !isTypedArraySlice(expr.expr._type))
+			return `__reslice(${base}, ${lo}, ${hi})`;
+		const max = expr.max
+			? `, ${this._is64BitInt(expr.max._type) ? `Number(${this.genExpr(expr.max)})` : this.genExpr(expr.max)}`
+			: "";
+		return `__slice(${base}, ${lo}, ${hi}${max})`;
 	},
 
 	_genFuncLit(expr) {
-		const params = expr.params.map((p) => p.name).join(", ");
+		const params = this._paramNames(expr.params).join(", ");
 		const asyncPrefix = expr.async ? "async " : "";
 		const saved = this.out;
 		const prevBoxed = this._boxedVars;
@@ -846,7 +1561,7 @@ export const expressionGenMethods = {
 		this._withFnCtx(expr.body, () =>
 			this.indented(() => {
 				this._emitParamCopies(expr.params);
-				this._genBody(expr.body, expr);
+				this._withNamedReturns(expr, () => this._genBody(expr.body, expr));
 			}),
 		);
 		const body = this.out.join("\n");
@@ -864,26 +1579,80 @@ export const expressionGenMethods = {
 		const check = this._typeCheckExpr(expr.type, val);
 		const wrap = (body) => (hoist ? `((__v) => ${body})(${src})` : body);
 		// Named non-struct values sit in interfaces as boxes; the asserted value is raw.
-		const out = this._isNamedBoxTypeNode(expr.type)
-			? `${val}.__gfUnbox()`
-			: val;
+		const out = this._assertedValueJs(expr.type, val);
 		if (!expr._commaOk) {
 			// plain assertion: panic if check fails (matches Go behavior)
 			if (check === "true") return src; // can't check at runtime — pass through
+			this.useHelper("ifaceBox");
 			return wrap(
-				`(${check} ? ${out} : (() => { throw new Error("interface conversion: type assertion failed"); })())`,
+				`(${check} ? ${out} : (() => { throw ${this._typeAssertFailJs(expr, val)}; })())`,
 			);
 		}
-		// comma-ok: emit [value-or-zero, runtimeTypeCheck]
+		// comma-ok: emit [value-or-zero, runtimeTypeCheck]; an asserted struct
+		// or array is a copy of the boxed value.
 		const zero = this.zeroValueForTypeNode(expr.type);
-		return wrap(`(${check} ? [${out}, true] : [${zero}, false])`);
+		const valT = this._typeFromNode(expr.type);
+		const okOut = this._aggregateBase(valT) ? this._cloneJs(valT, out) : out;
+		return wrap(`(${check} ? [${okOut}, true] : [${zero}, false])`);
+	},
+
+	// The error a failed `x.(T)` throws: Go's `interface conversion: ...` text
+	// naming the static interface type, the dynamic type and the target.
+	_typeAssertFailJs(expr, val) {
+		const target = expr._type;
+		const u = this._underlyingOf(target);
+		const methods =
+			u?.kind === "interface" ? [...(u.methods?.keys() ?? [])] : [];
+		const tName = this._assertTypeName(target) ?? goTypeName(expr.type);
+		const src = this._assertTypeName(expr.expr?._type) ?? "interface {}";
+		return `__tafail(${JSON.stringify(src)}, ${val}, ${JSON.stringify(tName)}, ${methods.length ? JSON.stringify(methods.sort()) : "null"})`;
+	},
+
+	// Go's spelling of the static type in a failed assertion message; null for
+	// `any` (`interface {}`).
+	_assertTypeName(t) {
+		if (!t || isAny(t)) return null;
+		return t.name === "error" ? "error" : goTypeName(t);
+	},
+
+	// `csv.ParseError` names the class of the bundled Go-source package type.
+	_qualifiedStructName(name) {
+		if (!name.includes(".") || this.structNames.has(name)) return name;
+		const cls = this.checker?.types.get(name)?.name;
+		return cls && this.structNames.has(cls) ? cls : name;
+	},
+
+	_simdCheckExpr(name, val) {
+		if (name === "simd.F32x4" || name === "F32x4")
+			return `(Array.isArray(${val}) && ${val}.length === 4 && typeof ${val}[0] === "number")`;
+		if (name === "simd.Mask32x4" || name === "Mask32x4")
+			return `(Array.isArray(${val}) && ${val}.length === 4 && typeof ${val}[0] === "boolean")`;
+		return null;
 	},
 
-	_typeNameCheckExpr(name, val) {
+	_typeNameCheckExpr(typeName, val) {
+		// A type parameter: the instantiated type's test travels with its factory.
+		const factory = this._typeParamZeroFactory(typeName);
+		if (factory) return `(${factory}?.is?.(${val}) ?? true)`;
+		const name = this._qualifiedStructName(typeName);
+		// int64 and uint64 share the BigInt: a value out of int64's range can
+		// only be a uint64.
+		if (name === "int64")
+			return `(typeof ${val} === "bigint" && ${val} >= -9223372036854775808n && ${val} <= 9223372036854775807n)`;
+		if (name === "uint64")
+			return `(typeof ${val} === "bigint" && ${val} >= 0n)`;
+		// Integer types share the JS number with the floats: only a whole
+		// number is one, so a fraction or -0 in an `any` falls through to float64.
+		if (INT_TYPE_NAMES.has(name))
+			return `(Number.isSafeInteger(${val}) && !Object.is(${val}, -0))`;
 		if (TYPEOF_NUMBER_NAMES.has(name)) return `typeof ${val} === "number"`;
+		if (name === "complex128" || name === "complex64")
+			return `(typeof ${val} === "object" && ${val} !== null && typeof ${val}.re === "number" && typeof ${val}.im === "number")`;
 		if (name === "string") return `typeof ${val} === "string"`;
 		if (name === "bool") return `typeof ${val} === "boolean"`;
 		if (name === "nil") return `${val} === null`;
+		const simd = this._simdCheckExpr(name, val);
+		if (simd) return simd;
 		if (name === "error")
 			return `(typeof ${val} === "object" && ${val} !== null && typeof ${val}.Error === "function")`;
 		if (this.structNames.has(name))
@@ -892,8 +1661,16 @@ export const expressionGenMethods = {
 		const namedInfo = this._namedBoxInfo(named);
 		if (namedInfo) return `(${val} instanceof ${namedInfo.cls})`;
 		// User-declared interfaces: check the dynamic value has every method.
-		if (!name.includes(".") && named?.underlying?.kind === "interface")
-			return this._ifaceMethodCheck(val, [...named.underlying.methods.keys()]);
+		if (named?.underlying?.kind === "interface")
+			return this._ifaceMethodCheck(
+				val,
+				[...named.underlying.methods.keys()],
+				this._unwrapIsMulti(named.underlying.methods.get("Unwrap")),
+			);
+		if (this._isNamedComposite(named)) {
+			this.useHelper("ifaceBox");
+			return `__isty(${val}, ${JSON.stringify(name)}, "named")`;
+		}
 		return "true"; // unknown type — can't check at runtime
 	},
 
@@ -903,6 +1680,9 @@ export const expressionGenMethods = {
 			return this._ifaceMethodCheck(
 				val,
 				(typeNode.methods ?? []).map((m) => m.name),
+				this._unwrapIsMulti(
+					(typeNode.methods ?? []).find((m) => m.name === "Unwrap"),
+				),
 			);
 		if (typeNode.kind === "PointerType" && typeNode.base?.kind === "TypeName") {
 			const info = this._namedBoxInfo(
@@ -913,11 +1693,65 @@ export const expressionGenMethods = {
 		return null;
 	},
 
-	_ifaceMethodCheck(val, methodNames) {
-		const checks = methodNames.map((m) => `typeof ${val}.${m} === "function"`);
+	// `Unwrap() []error` (errors.Join) and `Unwrap() error` share a name: the
+	// JS function of a multi-error `Unwrap` is tagged `__multi`.  `method` is
+	// a func type or an interface method AST; null when there is no `Unwrap`.
+	_unwrapIsMulti(method) {
+		if (!method) return null;
+		const ret = method.returnType ?? method.returns?.[0];
+		const u = ret?.kind === "named" ? ret.underlying : ret;
+		return u?.kind === "slice" || u?.kind === "SliceType";
+	},
+
+	_ifaceMethodCheck(val, methodNames, multiUnwrap = null) {
+		const checks = methodNames.map((m) => {
+			const base =
+				m === "Unwrap" && multiUnwrap !== null
+					? `typeof ${val}.${m} === "function" && (${val}.${m}.__multi === true) === ${multiUnwrap}`
+					: `typeof ${val}.${m} === "function"`;
+			// A struct value's method set lacks the pointer-receiver methods.
+			return `${base} && !(${val}.__v === true && ${val}.constructor.__pm?.includes(${JSON.stringify(m)}))`;
+		});
 		return `(${[`${val} != null`, ...checks].join(" && ")})`;
 	},
 
+	// The value an assertion to `typeNode` yields: raw, unboxed from the
+	// interface's box for a named non-struct type (known only at run time
+	// for a type parameter).
+	_assertedValueJs(typeNode, val) {
+		if (this._isNamedBoxTypeNode(typeNode)) return `${val}.__gfUnbox()`;
+		if (
+			this._isStructPtrTypeNode(typeNode) ||
+			(typeNode?.kind === "PointerType" && typeNode._assertType)
+		) {
+			this.useHelper("ifaceBox");
+			return `__unnil(${val})`;
+		}
+		if (typeNode?._assertType?.kind === "slice") {
+			// A nil slice in an interface is a tagged empty array.
+			this.useHelper("ifaceBox");
+			return `__unnil(${val})`;
+		}
+		const factory =
+			typeNode?.kind === "TypeName"
+				? this._typeParamZeroFactory(typeNode.name)
+				: null;
+		return factory ? `(${factory}?.u ? ${val}.__gfUnbox() : ${val})` : val;
+	},
+
+	_isStructPtrTypeNode(typeNode) {
+		const base = typeNode?.kind === "PointerType" ? typeNode.base : null;
+		const name =
+			base?.kind === "TypeName"
+				? base.name
+				: base?.kind === "GenericTypeName"
+					? this._dequalify(base.name)
+					: null;
+		return (
+			name !== null && this.structNames.has(this._qualifiedStructName(name))
+		);
+	},
+
 	_isNamedBoxTypeNode(typeNode) {
 		if (typeNode?.kind === "TypeName")
 			return Boolean(
@@ -930,14 +1764,35 @@ export const expressionGenMethods = {
 		return false;
 	},
 
+	// Converting a struct to a different defined struct type builds a copy in
+	// the target's class (so its methods exist); null when not applicable.
+	_genStructClassConversion(targetName, srcType, inner) {
+		if (!targetName || targetName.includes("[")) return null;
+		const target = this.checker?.types.get(targetName);
+		if (target?.kind !== "named" || target.underlying?.kind !== "struct")
+			return null;
+		if (srcType?.name === targetName) return null;
+		const srcU = srcType?.kind === "named" ? srcType.underlying : srcType;
+		if (srcU?.kind !== "struct") return null;
+		const cls = this._dequalify(targetName);
+		return `Object.assign(new ${cls}(), ${this._cloneJs(srcType, inner)})`;
+	},
+
 	_genTypeConversionCall(expr) {
 		const targetType = expr._conversionTargetType;
 		const arg = this.genExpr(expr.args[0]);
-		const isRaw =
-			targetType?.name === "json.RawMessage" ||
-			targetType?.name === "encoding/json.RawMessage";
+		const viaParam = this._genTypeParamConversion(targetType?.name, arg);
+		if (targetType?.kind === "typeParam" && viaParam) return viaParam;
+		const structConv = this._genStructClassConversion(
+			targetType?.kind === "named" ? targetType.name : undefined,
+			expr.args[0]?._type,
+			arg,
+		);
+		if (structConv) return structConv;
 		const base =
 			targetType?.kind === "named" ? targetType.underlying : targetType;
+		if (base?.kind === "map" && this._isNilLiteral(expr.args[0]))
+			return this._nilMapZero();
 		if (
 			targetType?.kind === "named" &&
 			base?.kind === "basic" &&
@@ -954,19 +1809,29 @@ export const expressionGenMethods = {
 				(elem === "byte" || elem === "uint8") &&
 				this._isStringExprType(expr.args[0]?._type)
 			) {
-				const enc = `new TextEncoder().encode(${arg})`;
-				return isRaw ? `((u) => { u.__raw = true; return u; })(${enc})` : enc;
-			}
-			if (isRaw) {
-				return `((u) => { u.__raw = true; return u; })(${arg})`;
+				this.useHelper("u8enc");
+				return `__u8enc(${arg})`;
 			}
 		}
 		return arg;
 	},
 
+	// `json.Marshal(v)` / `enc.Encode(v)` call the generated codec entry
+	// (see src/lower/json-codecs.js); a stream method takes its receiver first.
+	_jsonEntryCall(expr) {
+		const sel = expr.func;
+		const func = { kind: "Ident", name: sel._genEntry, _type: sel._type };
+		const args = sel._jsonStream ? [sel.expr, ...expr.args] : expr.args;
+		return { ...expr, func, args };
+	},
+
 	genCall(expr) {
+		if (expr.func._genEntry) return this.genCall(this._jsonEntryCall(expr));
 		if (expr._isTypeConversion) return this._genTypeConversionCall(expr);
 
+		const native = this._genNativeCall(expr);
+		if (native !== null) return native;
+
 		const funcExpr =
 			expr.func.kind === "InstantiationExpr" ? expr.func.expr : expr.func;
 		if (funcExpr.kind === "Ident") {
@@ -974,19 +1839,113 @@ export const expressionGenMethods = {
 			if (builtin !== undefined) return builtin;
 		}
 
+		const viaBox = this._genTypeParamMethodCall(expr);
+		if (viaBox !== null) return viaBox;
+
 		if (expr.func.kind === "SelectorExpr") {
 			const result = this._genSelectorCall(expr);
 			if (result !== undefined) return result;
 		}
 
+		const converted = this._convertedPointerMethodCall(expr);
+		if (converted) return converted;
+
+		const nilSafe = this._nilSafeMethodClass(expr.func);
+		if (nilSafe) {
+			// The method tests its receiver for nil: call it through the
+			// prototype so a nil `this` reaches it instead of a TypeError.
+			const recv = this.genExpr(expr.func.expr);
+			const rest = this._genCallArgs(expr);
+			return `${nilSafe}.prototype.${expr.func.field}.call(${rest ? `${recv}, ${rest}` : recv})`;
+		}
+
 		expr.func._callee = true;
 		const rawFn = this.genExpr(expr.func);
 		const fn = expr.func.kind === "FuncLit" ? `(${rawFn})` : rawFn;
-		if (expr._multiForward) return `${fn}(...${this.genExpr(expr.args[0])})`;
-		const args = expr.args
-			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
-			.join(", ");
-		return `${fn}(${args})`;
+		const args = this._genCallArgs(expr);
+		const zeros = this._genericCallZeros(expr);
+		if (!zeros) return `${fn}(${args})`;
+		return `${fn}(${args ? `${zeros}, ${args}` : zeros})`;
+	},
+
+	// `x.M(...)` on a type-parameter value: a raw value of a named non-struct
+	// type argument is boxed (by the type's factory) to reach its methods.
+	_genTypeParamMethodCall(expr) {
+		if (!this._isTypeParamMethodCall(expr)) return null;
+		const factory = this._typeParamZeroFactory(expr.func.expr._type.name);
+		if (!factory) return null;
+		this.useHelper("generics");
+		const recv = `__tbox(${factory}, ${this.genExpr(expr.func.expr)})`;
+		const args = this._genCallArgs(expr);
+		return `${recv}.${expr.func.field}(${args})`;
+	},
+
+	// `(*S)(p).M()` where `p` points at another struct type: the JS object keeps
+	// its own class, so call S's prototype method on it.
+	_convertedPointerMethodCall(expr) {
+		const sel = expr.func;
+		if (sel?.kind !== "SelectorExpr" || sel._isMethodExpr) return null;
+		let recv = sel.expr;
+		while (recv?.kind === "ParenExpr") recv = recv.expr;
+		if (recv?._isTypeConversion !== true) return null;
+		const target = recv._conversionTargetType;
+		const from = recv.args?.[0]?._type;
+		if (target?.kind !== "pointer" || target.base?.kind !== "named")
+			return null;
+		if (from?.kind !== "pointer" || from.base === target.base) return null;
+		if (target.base.underlying?.kind !== "struct") return null;
+		const cls = target.base.name;
+		if (!target.base.methods?.has(sel.field)) return null;
+		const rest = this._genCallArgs(expr);
+		const obj = this.genExpr(recv.args[0]);
+		return `${cls}.prototype.${sel.field}.call(${rest ? `${obj}, ${rest}` : obj})`;
+	},
+
+	// The class whose prototype holds pointer-receiver method `field`, for a
+	// pointer to a struct type that declares it directly (not promoted), so a
+	// method value or expression can reach it with a nil receiver; else null.
+	_ptrMethodProtoClass(ptr, field, sel) {
+		if (ptr?.kind !== "pointer" || ptr.base?.kind !== "named") return null;
+		if (ptr.base.underlying?.kind !== "struct") return null;
+		if (sel && this._promotedPath(sel)) return null;
+		if (!ptr.base.methods?.has(field)) return null;
+		return ptr.base.name;
+	},
+
+	// The class of a pointer-receiver struct method that accepts a nil receiver
+	// when `func` selects it on a pointer of exactly that struct, else null.
+	_nilSafeMethodClass(func) {
+		if (func?.kind !== "SelectorExpr" || func._isMethodExpr) return null;
+		const t = func.expr?._type;
+		if (t?.kind !== "pointer" || t.base?.kind !== "named") return null;
+		const cls = t.base.name;
+		if (t.base.typeArgs?.length) return null;
+		if (this.nilSafeMethods?.has(`${cls}.${func.field}`)) return cls;
+		// A Go-source stdlib type (`Buffer$$bytes`) is declared outside this
+		// package: its method decl tells whether it tests the receiver for nil.
+		const decl = cls.includes("$$")
+			? t.base.methods?.get(func.field)?._methodDecl
+			: null;
+		return decl?.recvPointer && comparesToNil(decl.body, decl.recvName)
+			? cls
+			: null;
+	},
+
+	// The leading zero-value factories of a call to a generic function
+	// (`F(x)` with inferred, `F[int](x)` with explicit type arguments), or null.
+	_genericCallZeros(expr) {
+		const site = expr._genericFnType
+			? expr
+			: expr.func.kind === "InstantiationExpr" && expr.func._genericFnType
+				? expr.func
+				: null;
+		if (!site) return null;
+		const { typeParams } = site._genericFnType;
+		return this._typeArgFactories(
+			typeParams,
+			site._typeArgs,
+			this._genericFnNeedsTypeInfo(site._genericFnType),
+		).join(", ");
 	},
 
 	_isErrorInterfaceType(t) {
@@ -1009,31 +1968,17 @@ export const expressionGenMethods = {
 	},
 
 	_genReceiverTypeCall(recvName, expr) {
-		if (recvName === "strings.Builder" || recvName === "bytes.Buffer")
-			return this._genBuilderCall(recvName, expr.func.field, expr);
-		if (recvName === "regexp.Regexp")
-			return this._genRegexpMethodCall(expr.func.field, expr);
-		if (recvName === "time.Time")
-			return this._genTimeMethodCall(expr.func.field, expr);
-		if (recvName === "time.Duration")
-			return this._genDurationMethodCall(expr.func.field, expr);
-		if (recvName === "testing.T")
-			return this._genTestingMethodCall(expr.func.field, expr);
-		if (recvName === "strings.Replacer") {
-			const recv = this.genExpr(expr.func.expr);
-			const arg = this.genExpr(expr.args[0]);
-			return `(${recv} ? ${recv}.Replace(${arg}) : ${arg})`;
-		}
 		if (recvName?.startsWith("shared.") && expr.func.field === "Subarray") {
 			const args = expr.args.map((a) => this.genExpr(a)).join(", ");
 			return `${this.genExpr(expr.func.expr)}.subarray(${args})`;
 		}
-		if (recvName === "simd.F32x4" || recvName === "F32x4") {
-			return this._genSimdReceiverCall(expr);
+		if (/^(simd\.)?(F32x4|Mask32x4)$/.test(recvName ?? "")) {
+			return this._genSimdReceiverCall(expr, recvName.endsWith("Mask32x4"));
 		}
 		if (recvName === "sync.Mutex" || recvName === "sync.RWMutex") {
 			if (expr.func.field === "TryLock" || expr.func.field === "TryRLock")
 				return "true";
+			if (expr.func.field === "RLocker") return "({ Lock() {}, Unlock() {} })";
 			return "(void 0)";
 		}
 		if (recvName === "sync.Once" && expr.func.field === "Do") {
@@ -1051,58 +1996,18 @@ export const expressionGenMethods = {
 			}
 			if (expr.func.field === "Wait") return "(void 0)";
 		}
-		if (
-			recvName === "binary.LittleEndian" ||
-			recvName === "binary.BigEndian" ||
-			recvName === "encoding/binary.LittleEndian" ||
-			recvName === "encoding/binary.BigEndian" ||
-			recvName === "binary.ByteOrder" ||
-			recvName === "encoding/binary.ByteOrder"
-		) {
-			this.useHelper("binary");
-			const recv = this.genExpr(expr.func.expr);
-			const args = expr.args.map((a) => this.genExpr(a)).join(", ");
-			return `${recv}.${expr.func.field}(${args})`;
-		}
-		if (
-			recvName === "base64.Encoding" ||
-			recvName === "encoding/base64.Encoding"
-		) {
-			this.useHelper("base64");
-			const recv = this.genExpr(expr.func.expr);
-			const args = expr.args.map((a) => this.genExpr(a)).join(", ");
-			return `${recv}.${expr.func.field}(${args})`;
-		}
 		return undefined;
 	},
 
-	_genSimdReceiverCall(expr) {
+	_genSimdReceiverCall(expr, isMask = false) {
 		this.useHelper("simd");
 		const method = expr.func.field;
 		const recv = this.genExpr(expr.func.expr);
-		const helpers = {
-			Add: "__simd_add",
-			Sub: "__simd_sub",
-			Mul: "__simd_mul",
-			Div: "__simd_div",
-			Min: "__simd_min",
-			Max: "__simd_max",
-			Dot3: "__simd_dot3",
-			Dot4: "__simd_dot4",
-		};
-		if (helpers[method]) {
-			return `${helpers[method]}(${recv}, ${this.genExpr(expr.args[0])})`;
-		}
-		if (method === "Lane") {
-			return `${recv}[${this.genExpr(expr.args[0])}]`;
-		}
-		if (method === "WithLane") {
-			return `__simd_with_lane(${recv}, ${this.genExpr(expr.args[0])}, ${this.genExpr(expr.args[1])})`;
-		}
-		if (method === "Splat") {
-			return `__simd_splat(${this.genExpr(expr.args[0])})`;
-		}
-		return undefined;
+		const args = expr.args.map((a) => this.genExpr(a));
+		if (method === "Lane") return `${recv}[${args[0]}]`;
+		if (method === "Splat" && !isMask) return `__simd_splat(${args[0]})`;
+		const helper = (isMask ? SIMD_MASK_HELPERS : SIMD_VECTOR_HELPERS)[method];
+		return helper ? `${helper}(${[recv, ...args].join(", ")})` : undefined;
 	},
 
 	_genSelectorCall(expr) {
@@ -1116,12 +2021,44 @@ export const expressionGenMethods = {
 			const ns = expr.func.expr.name;
 			const fn = expr.func.field;
 			const result = this._genStdlibCall(ns, fn, expr);
-			if (result !== undefined) return result;
+			if (result !== undefined) {
+				if (this._is64BitInt(expr._type)) {
+					return `((__r) => typeof __r === "number" ? BigInt(__r) : __r)(${result})`;
+				}
+				if (
+					expr._type?.kind === "tuple" &&
+					expr._type.types.some((t) => this._is64BitInt(t))
+				) {
+					const casts = expr._type.types.map((t, i) =>
+						this._is64BitInt(t)
+							? `typeof __r[${i}] === "number" ? BigInt(__r[${i}]) : __r[${i}]`
+							: `__r[${i}]`,
+					);
+					return `((__r) => [${casts.join(", ")}])(${result})`;
+				}
+				return result;
+			}
 		}
 		const recvType = expr.func.expr._type;
 		const recvName = this._resolveRecvName(recvType);
 		const typed = this._genReceiverTypeCall(recvName, expr);
-		if (typed !== undefined) return typed;
+		if (typed !== undefined) {
+			if (this._is64BitInt(expr._type)) {
+				return `((__r) => typeof __r === "number" ? BigInt(__r) : __r)(${typed})`;
+			}
+			if (
+				expr._type?.kind === "tuple" &&
+				expr._type.types.some((t) => this._is64BitInt(t))
+			) {
+				const casts = expr._type.types.map((t, i) =>
+					this._is64BitInt(t)
+						? `typeof __r[${i}] === "number" ? BigInt(__r[${i}]) : __r[${i}]`
+						: `__r[${i}]`,
+				);
+				return `((__r) => [${casts.join(", ")}])(${typed})`;
+			}
+			return typed;
+		}
 		const namedCall = this._genNamedMethodCall(expr);
 		if (namedCall !== undefined) return namedCall;
 		if (this.strict && this._isInterfaceType(recvType)) {
@@ -1137,6 +2074,16 @@ export const expressionGenMethods = {
 		return undefined;
 	},
 
+	// `len`/`cap` of an array or array pointer is a constant, but an operand
+	// containing a call or receive is still evaluated (and a nil pointer is
+	// not dereferenced).
+	_genConstLen(expr) {
+		const arg = expr.args[0];
+		if (arg && hasCallOrReceive(arg))
+			return `(${this.genExpr(arg)}, ${expr._constLen})`;
+		return String(expr._constLen);
+	},
+
 	_isInterfaceType(t) {
 		if (!t) return false;
 		if (t.kind === "interface") return true;
@@ -1144,13 +2091,13 @@ export const expressionGenMethods = {
 	},
 
 	_genBuiltinLen(expr) {
-		if (expr._constLen != null) return String(expr._constLen);
+		if (expr._constLen != null) return this._genConstLen(expr);
 		const arg = expr.args[0];
 		const t = arg?._type;
 		const wrapField = this._namedWrapperField(t, arg);
 		if (wrapField) return `${this.genExpr(arg)}.${wrapField}.length`;
 		const js = this.genExpr(arg);
-		if (t?.kind === "map") return `Object.keys(${js}).length`;
+		if (t?.kind === "map") return `Object.keys(${js} ?? {}).length`;
 		this.useHelper("len");
 		return `__len(${js})`;
 	},
@@ -1164,7 +2111,12 @@ export const expressionGenMethods = {
 			(t?.kind === "named" && t.underlying?.kind === "map")
 		)
 			return `((__m) => { for (const __k in __m) delete __m[__k]; })(${js})`;
-		return `(${js}).length = 0`;
+		// A slice: every element goes back to its zero value (the length stays).
+		const st = t?.kind === "named" ? t.underlying : t;
+		const zero = this.zeroValueForType(st?.elem);
+		if (/^(new |\{|\[|Array|__nm\()|\$z_/.test(zero))
+			return `((__s) => { if (__s) for (let __i = 0; __i < __s.length; __i++) __s[__i] = ${zero}; })(${js})`;
+		return `(${js})?.fill(${zero})`;
 	},
 
 	_genBuiltinIdent(name, expr) {
@@ -1172,6 +2124,15 @@ export const expressionGenMethods = {
 		return gen ? gen(this, expr) : undefined;
 	},
 
+	// The source operand of `append(b, x...)` / `copy(b, x)`: a string
+	// contributes its UTF-8 bytes.
+	_genSliceSource(node) {
+		const js = this.genExpr(node);
+		if (!this._isStringExprType(node._type)) return js;
+		this.useHelper("u8enc");
+		return `__u8enc(${js})`;
+	},
+
 	genAppend(expr) {
 		const retType = expr._type;
 		const wrapField = this._namedWrapperField(retType, expr.args[0]);
@@ -1181,16 +2142,36 @@ export const expressionGenMethods = {
 			const elems = expr.args
 				.slice(1)
 				.map((a) =>
-					a._spread ? `...${this.genExpr(a)}` : this.genValueExpr(a),
+					a._spread
+						? `...(${this._genSliceSource(a)} ?? [])`
+						: this.genValueExpr(a),
 				);
 			if (elems.length === 0) return this.genExpr(expr.args[0]);
 			this.useHelper("append");
 			return `new ${retType.name}(__append(${sliceJS}, ${elems.join(", ")}))`;
 		}
 		const slice = this.genExpr(expr.args[0]);
-		const elems = expr.args
-			.slice(1)
-			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genValueExpr(a)));
+		// Spread elements of array type are values: append copies them.
+		const st = expr._type ?? expr.args[0]._type;
+		const elemT = (st?.kind === "named" ? st.underlying : st)?.elem;
+		const spreadOf = (a) =>
+			this._aggregateBase(elemT)
+				? `...(${this.genExpr(a)} ?? []).map((__e) => ${this._cloneJs(elemT, "__e")})`
+				: `...(${this._genSliceSource(a)} ?? [])`;
+		const is64Elem = this._is64BitInt(elemT);
+		const elems = expr.args.slice(1).map((a) => {
+			if (a._spread) return spreadOf(a);
+			const val = this.genValueExpr(a);
+			if (
+				is64Elem &&
+				a._type?.kind === "untyped" &&
+				!val.endsWith("n") &&
+				/^-?\d+$/.test(val)
+			) {
+				return `${val}n`;
+			}
+			return val;
+		});
 		if (elems.length === 0) return slice;
 		this.useHelper("append");
 		const sliceType = expr._type ?? expr.args[0]._type;
@@ -1199,22 +2180,55 @@ export const expressionGenMethods = {
 					(sliceType.kind === "named" ? sliceType.underlying : sliceType).elem,
 				)
 			: null;
-		if (typedCtor)
-			return `__append((${slice}) ?? new ${typedCtor}(0), ${elems.join(", ")})`;
+		if (typedCtor) {
+			const single = expr.args.length === 2 && expr.args[1]._spread;
+			// One source slice or string: append it as it is, not spread.
+			if (single)
+				return `__appendv((${slice}) ?? __tn(${typedCtor}), ${this._genSliceSource(expr.args[1])} ?? [])`;
+			return `__append((${slice}) ?? __tn(${typedCtor}), ${elems.join(", ")})`;
+		}
+		// A json codec grows a slice it has just made and no one else holds:
+		// pushing in place is O(1), where __append copies the whole slice.
+		if (
+			this._inJsonCodecFile() &&
+			expr.args.length === 2 &&
+			expr.args[0].kind === "Ident" &&
+			!expr.args[1]._spread
+		) {
+			this.useHelper("pushs");
+			return `__pushs(${slice}, ${elems[0]})`;
+		}
 		return `__append(${slice}, ${elems.join(", ")})`;
 	},
 
+	// A `make` length or capacity expression wrapped in its negative-value
+	// check (a literal needs none).
+	_guardMakeSize(code, guard) {
+		if (/^\d+$/.test(code)) return code;
+		this.useHelper("mklen");
+		return `${guard}(${code})`;
+	},
+
 	genMake(expr) {
 		// make([]T, n) or make([]T, n, cap) → new Array(n).fill(zero)
 		// make(map[K]V) → {}
 		const typeArg = expr.args[0];
 		const typeNode = typeArg.kind === "TypeExpr" ? typeArg.type : typeArg;
-		const resolvedKind = typeArg._type?.kind;
+		// A defined type (`type S []int`) makes like its underlying type.
+		const madeType =
+			typeArg._coreType ??
+			(typeArg._type?.kind === "named"
+				? typeArg._type.underlying
+				: typeArg._type);
+		const resolvedKind = madeType?.kind;
 		if (typeNode.kind === "SliceType" || resolvedKind === "slice") {
-			const n = expr.args[1] ? this.genExpr(expr.args[1]) : "0";
+			let n = expr.args[1] ? this.genExpr(expr.args[1]) : "0";
+			if (expr.args[1] && this._is64BitInt(expr.args[1]._type))
+				n = `Number(${n})`;
+			// A negative length or capacity panics with Go's message.
+			n = this._guardMakeSize(n, "__mkn");
 			const elemNode = typeNode.kind === "SliceType" ? typeNode.elem : null;
-			const elemResolved =
-				typeArg._type?.kind === "slice" ? typeArg._type.elem : null;
+			const elemResolved = madeType?.kind === "slice" ? madeType.elem : null;
 			const typedCtor =
 				typedArrayConstructorForElem(elemResolved) ??
 				(elemNode?.name
@@ -1223,8 +2237,19 @@ export const expressionGenMethods = {
 							name: elemNode.name,
 						})
 					: null);
+			// make([]T, n, cap) allocates cap elements and returns a view of
+			// the first n (`__mkslice`), so append within cap shares them.
+			let capArg = expr.args[2] ? this.genExpr(expr.args[2]) : null;
+			if (capArg && expr.args[2] && this._is64BitInt(expr.args[2]._type))
+				capArg = `Number(${capArg})`;
+			if (capArg) {
+				this.useHelper("slice");
+				capArg = this._guardMakeSize(capArg, "__mkc");
+			}
+			const withCap = (alloc) =>
+				capArg ? `__mkslice(${n}, ${alloc(capArg)})` : alloc(n);
 			if (typedCtor) {
-				return `new ${typedCtor}(${n})`;
+				return withCap((k) => `new ${typedCtor}(${k})`);
 			}
 			// Use the proper zero value for the element type (e.g. new Point() not 0)
 			let zero = "null";
@@ -1234,29 +2259,23 @@ export const expressionGenMethods = {
 				zero = this.zeroValueForTypeNode(elemNode);
 			}
 			// If zero value is a constructor call, use a factory function so each element is distinct
-			if (zero.startsWith("new ")) {
-				return `Array.from({length: ${n}}, () => ${zero})`;
+			if (zero.startsWith("new ") || zero.includes("$z_")) {
+				return withCap((k) => `Array.from({length: ${k}}, () => ${zero})`);
 			}
-			return `new Array(${n}).fill(${zero})`;
+			return withCap((k) => `new Array(${k}).fill(${zero})`);
 		}
-		// map or fallback
+		// map or fallback.  The json codecs' maps hold decoded keys, among them
+		// "__proto__": without a prototype that is an ordinary key.
+		if (
+			this._inJsonCodecFile() &&
+			(resolvedKind === "map" || typeNode.kind === "MapType")
+		)
+			return "Object.create(null)";
 		return "{}";
 	},
 
-	// Render struct elements as a JS field list string.
-	// Handles positional (_positionalField), embedded-spread (_isEmbedInit), and keyed (KeyValueExpr).
-	_genStructFields(elems) {
-		return elems
-			.map((e) => {
-				if (e._positionalField) {
-					return `${e._positionalField}: ${this.genExpr(e)}`;
-				}
-				if (e.kind !== "KeyValueExpr") return null;
-				if (e._isEmbedInit) return `...${this.genExpr(e.value)}`;
-				return `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`;
-			})
-			.filter((s) => s !== null)
-			.join(", ");
+	_inJsonCodecFile() {
+		return this._jsonCodecFileIdx === (this._currentSrcFileIdx ?? 0);
 	},
 
 	_isSliceOrArrayType(t) {
@@ -1267,22 +2286,42 @@ export const expressionGenMethods = {
 		return t?.kind === "MapType";
 	},
 
+	// The one place a map literal key becomes a JS property name: a plain
+	// string literal stays as is, any other key is computed so that the key
+	// encoding of `genExpr` (`__ik`, struct keys) applies.
+	_genMapLitKey(key) {
+		return key.litKind === "STRING"
+			? JSON.stringify(key.value)
+			: `[${this.genExpr(key)}]`;
+	},
+
 	_genMapLitEntries(elems) {
 		return elems
-			.map((e) => {
-				if (e.kind === "KeyValueExpr") {
-					const k =
-						e.key.litKind === "STRING"
-							? JSON.stringify(e.key.value)
-							: `[${this.genExpr(e.key)}]`;
-					return `${k}: ${this.genValueExpr(e.value)}`;
-				}
-				return this.genValueExpr(e);
-			})
+			.map((e) =>
+				e.kind === "KeyValueExpr"
+					? `${this._genMapLitKey(e.key)}: ${this.genValueExpr(e.value)}`
+					: this.genValueExpr(e),
+			)
 			.join(", ");
 	},
 
+	// A literal whose (possibly elided or named) type is a map type.
+	_isMapLit(expr) {
+		let t = expr._type;
+		for (let i = 0; t?.kind === "named" && i < 32; i++) t = t.underlying;
+		return t?.kind === "map";
+	},
+
 	_genFallbackCompositeLit(expr) {
+		if (this._isMapLit(expr))
+			return `{ ${this._genMapLitEntries(expr.elems)} }`;
+		const at = this._litArrayType(expr);
+		if (at) {
+			// A named array type without methods (`type V [3]int; V{1}`).
+			const elems = this._genArrayLitElems(at, expr);
+			const ctor = typedArrayConstructorForElem(at.elem);
+			return ctor ? `new ${ctor}([${elems}])` : `[${elems}]`;
+		}
 		if (expr.elems.length > 0 && expr.elems[0]?.kind === "KeyValueExpr") {
 			const fields = expr.elems
 				.map(
@@ -1323,7 +2362,7 @@ export const expressionGenMethods = {
 				(ce) => (ce._positionalField ?? ce.key?.name) === ef,
 			);
 			values[idx] = match
-				? this.genValueExpr(match.value ?? match)
+				? this.genValueExpr(match.kind === "KeyValueExpr" ? match.value : match)
 				: fields[idx].zero;
 		} else {
 			const valExpr = this.genExpr(e.value);
@@ -1364,6 +2403,8 @@ export const expressionGenMethods = {
 
 	_genPositionalStructLit(typeName, expr) {
 		const fields = this.getStructFields(typeName);
+		const generic = this._genGenericStructLit(fields, expr);
+		if (generic) return generic;
 		if (!fields || fields.length === 0 || expr.elems.length === 0) {
 			return `new ${typeName}()`;
 		}
@@ -1381,10 +2422,95 @@ export const expressionGenMethods = {
 		return inst;
 	},
 
-	_genSliceOrArrayLit(t, expr) {
-		const elems = expr.elems
+	// `Box[int]{…}`: every field is passed (unset ones as undefined, so the
+	// constructor starts them at their zero value) followed by the factories.
+	_genGenericStructLit(fields, expr) {
+		const t = expr._type;
+		if (t?.kind !== "named" || !t.typeArgs?.length) return null;
+		const values = fields.map(() => undefined);
+		if (expr.elems.length > 0) {
+			const hasPositional = expr.elems.some(
+				(e) => e._positionalField || e.kind !== "KeyValueExpr",
+			);
+			if (hasPositional) this._fillPositionalStructElems(fields, expr, values);
+			else this._fillKeyedStructElems(fields, expr, values);
+		}
+		return this._genericStructNew(t.name, t.typeArgs, values);
+	},
+
+	// The array type of a literal (through named types), or null.
+	_litArrayType(expr) {
+		let t = expr._type;
+		while (t?.kind === "named") t = t.underlying;
+		return t?.kind === "array" && typeof t.size === "number" ? t : null;
+	},
+
+	// Elements of a literal of array type `at` (or `{ size, elem }` for a
+	// slice), placed at their (keyed) indices, with every other slot the
+	// element zero value: `[3]int{1}` is `[1, 0, 0]` and `[5]int{2: 7}` is
+	// `[0, 0, 7, 0, 0]`, as in Go.  Keys out of ascending order would
+	// evaluate the elements out of source order, so the values are then
+	// computed first and spread into place.
+	_genArrayLitElems(at, expr) {
+		const values = new Array(at.size).fill(null);
+		const indices = compositeLitIndices(expr.elems);
+		const src = expr.elems.map((e) =>
+			this.genValueExpr(e.kind === "KeyValueExpr" ? e.value : e),
+		);
+		const ascending = indices.every((v, i) => i === 0 || v > indices[i - 1]);
+		indices.forEach((idx, i) => {
+			values[idx] = ascending ? src[i] : `v$[${i}]`;
+		});
+		for (let i = 0; i < values.length; i++)
+			values[i] ??= this.zeroValueForType(at.elem);
+		if (ascending) return values.join(", ");
+		return `...((v$) => [${values.join(", ")}])([${src.join(", ")}])`;
+	},
+
+	// `{ size, elem }` for a slice or array literal (through named types).
+	_litIndexedShape(expr) {
+		const at = this._litArrayType(expr);
+		if (at) return at;
+		let t = expr._type;
+		while (t?.kind === "named") t = t.underlying;
+		if (t?.kind !== "slice") return null;
+		// A loop, not a spread: huge literals would overflow the call stack.
+		let max = -1;
+		for (const i of compositeLitIndices(expr.elems)) if (i > max) max = i;
+		const size = max + 1;
+		return { size, elem: t.elem };
+	},
+
+	// A large array literal that leaves most slots zero (`[100000]byte{}`,
+	// `[65536]int{1: 2}`) starts from the zero array, as `var a [N]T` does,
+	// and assigns only the given elements instead of spelling out every
+	// slot.  Small or mostly-filled literals stay inline (null).
+	_genSparseArrayLit(expr) {
+		const at = this._litArrayType(expr);
+		if (!at || at.size <= SPARSE_ARRAY_MIN) return null;
+		if (expr.elems.length * 2 >= at.size) return null;
+		const zero = this.zeroValueForType(at);
+		if (expr.elems.length === 0) return zero;
+		const indices = compositeLitIndices(expr.elems);
+		const sets = expr.elems.map((e, i) => {
+			const v = this.genValueExpr(e.kind === "KeyValueExpr" ? e.value : e);
+			return `a$[${indices[i]}] = (${v})`;
+		});
+		return `((a$) => (${sets.join(", ")}, a$))(${zero})`;
+	},
+
+	_genLitElems(expr) {
+		const at = this._litIndexedShape(expr);
+		if (at) return this._genArrayLitElems(at, expr);
+		return expr.elems
 			.map((e) => this.genValueExpr(e.kind === "KeyValueExpr" ? e.value : e))
 			.join(", ");
+	},
+
+	_genSliceOrArrayLit(t, expr) {
+		const sparse = this._genSparseArrayLit(expr);
+		if (sparse) return sparse;
+		const elems = this._genLitElems(expr);
 		const elemNode =
 			t.kind === "SliceType" || t.kind === "ArrayType" ? t.elem : null;
 		const elemResolved =
@@ -1409,10 +2535,8 @@ export const expressionGenMethods = {
 		const t = expr.typeExpr;
 		if (t === null) return this._genImplicitCompositeLit(expr);
 		const typeName = this.getTypeName(t);
-		if (typeName === "bytes.Buffer" || typeName === "Buffer")
-			return "{ _buf: [] }";
-		if (typeName === "strings.Builder" || typeName === "Builder")
-			return '{ _buf: "" }';
+		if (typeName === "simd.Mask32x4" || typeName === "Mask32x4")
+			return "Object.freeze([false, false, false, false])";
 		if (typeName === "simd.F32x4" || typeName === "F32x4") {
 			this.useHelper("simd");
 			const a = expr.elems[0] ? this.genExpr(expr.elems[0]) : "0";
@@ -1421,6 +2545,8 @@ export const expressionGenMethods = {
 			const d = expr.elems[3] ? this.genExpr(expr.elems[3]) : "0";
 			return `__simd_f32x4(${a}, ${b}, ${c}, ${d})`;
 		}
+		const aliasLit = this._genAliasLit(t, typeName, expr);
+		if (aliasLit !== null) return aliasLit;
 		if (typeName && this.structNames.has(typeName))
 			return this._genPositionalStructLit(typeName, expr);
 		if (typeName && this.namedWrapperNames.has(typeName))
@@ -1434,14 +2560,68 @@ export const expressionGenMethods = {
 		return this._genFallbackCompositeLit(expr);
 	},
 
+	// Literals whose type expression is not the class to construct: a generic
+	// alias `A[X]{…}`, an anonymous `struct{…}{…}`, or `P{…}` for
+	// `type P = struct{…}`. Null for every other literal.
+	_genAliasLit(t, typeName, expr) {
+		if (t.kind === "GenericTypeName" || t.kind === "InstantiationExpr")
+			return this._genGenericAliasLit(typeName, expr);
+		const anon =
+			t.kind === "StructType" ||
+			((t.kind === "TypeName" || t.kind === "Ident") &&
+				this.checker?.types.get(t.name)?.kind === "struct");
+		return anon ? this._genAnonStructLit(expr) : null;
+	},
+
+	// `A[X]{…}` for a generic alias `type A[P any] = T`: the literal has the
+	// aliased type (expr._type), so dispatch on that instead of on `A`.
+	_genGenericAliasLit(typeName, expr) {
+		if (!this.checker?.types.get(typeName)?._generic?.isAlias) return null;
+		const rt = expr._type;
+		const base = rt?.kind === "named" ? rt.underlying : rt;
+		if (rt?.kind === "named" && this.structNames.has(rt.name))
+			return this._genPositionalStructLit(rt.name, expr);
+		if (base?.kind === "map")
+			return `{ ${this._genMapLitEntries(expr.elems)} }`;
+		if (base?.kind === "struct") return this._genAnonStructLit(expr);
+		return this._genImplicitCompositeLit(expr);
+	},
+
+	// A literal of an anonymous struct type: a plain object with every field,
+	// the omitted ones set to their zero value.
+	_genAnonStructLit(expr) {
+		const st =
+			expr._type?.kind === "named" ? expr._type.underlying : expr._type;
+		if (st?.kind !== "struct" || !(st.fields instanceof Map))
+			return this._genFallbackCompositeLit(expr);
+		const values = new Map();
+		for (const e of expr.elems) {
+			if (e._positionalField)
+				values.set(e._positionalField, this.genValueExpr(e));
+			else if (e.kind === "KeyValueExpr")
+				values.set(e.key.name, this.genValueExpr(e.value));
+		}
+		const fields = [...st.fields].map(
+			([name, ft]) =>
+				`${name}: ${values.get(name) ?? this.zeroValueForType(ft)}`,
+		);
+		return `{ ${fields.join(", ")} }`;
+	},
+
 	_genImplicitCompositeLit(expr) {
-		const typeName = expr._type?.name ?? expr._type?.underlying?.name;
+		// An elided `&T` (`[]*T{{1}}`) builds the struct; a struct pointer is the object.
+		const lit = expr._type?.kind === "pointer" ? expr._type.base : expr._type;
+		const typeName = lit?.name ?? lit?.underlying?.name;
 		if (typeName && this.structNames.has(typeName)) {
 			return this._genPositionalStructLit(typeName, expr);
 		}
+		if (this._isMapLit(expr))
+			return `{ ${this._genMapLitEntries(expr.elems)} }`;
 		const hasPositional = expr.elems.some((e) => e._positionalField);
 		const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
-		if (hasPositional || hasKeyed) {
+		// `{2: 5}` inside `[2][3]int{…}` is an array, not an object.
+		const indexed = this._litIndexedShape(expr) !== null;
+		if (hasPositional || (hasKeyed && !indexed)) {
 			const fields = expr.elems
 				.map((e) => {
 					if (e._positionalField)
@@ -1451,7 +2631,9 @@ export const expressionGenMethods = {
 				.join(", ");
 			return `{ ${fields} }`;
 		}
-		const elems = expr.elems.map((e) => this.genValueExpr(e)).join(", ");
+		const sparse = this._genSparseArrayLit(expr);
+		if (sparse) return sparse;
+		const elems = this._genLitElems(expr);
 		if (isTypedArraySlice(expr._type)) {
 			const typedCtor = typedArrayConstructorForElem(expr._type.elem);
 			if (typedCtor) return `new ${typedCtor}([${elems}])`;
@@ -1465,35 +2647,51 @@ export const expressionGenMethods = {
 		if (u?.kind === "map") {
 			return `{ ${this._genMapLitEntries(expr.elems)} }`;
 		}
-		// Default: slice
-		const elems = expr.elems
-			.map((e) => this.genValueExpr(e.kind === "KeyValueExpr" ? e.value : e))
-			.join(", ");
-		return `[${elems}]`;
+		// Default: slice or array
+		return `[${this._genLitElems(expr)}]`;
 	},
 
 	// ── Helpers ───────────────────────────────────────────────────
 
 	_genComplexOperand(expr) {
-		if (isComplex(expr._type)) return this.genExpr(expr);
+		if (isComplex(expr._type) || expr._asComplex) return this.genExpr(expr);
 		return `{ re: ${this.genExpr(expr)}, im: 0 }`;
 	},
 
 	getTypeName(typeNode) {
 		if (!typeNode) return null;
-		if (typeNode.kind === "TypeName") return this._dequalify(typeNode.name);
+		if (typeNode._stdName) return typeNode._stdName;
+		if (typeNode.kind === "TypeName")
+			return this._aliasTarget(this._dequalify(typeNode.name));
 		if (typeNode.kind === "GenericTypeName") return typeNode.name;
-		if (typeNode.kind === "Ident") return typeNode.name;
+		if (typeNode.kind === "Ident") return this._aliasTarget(typeNode.name);
 		if (typeNode.kind === "InstantiationExpr")
 			return this.getTypeName(typeNode.expr);
 		if (typeNode.kind === "SelectorExpr") {
 			const base = this.getTypeName(typeNode.expr);
-			if (this.bundledPackages.has(base)) return typeNode.field;
+			if (this.bundledPackages.has(base)) {
+				// `p.A` for `type A = Base` in p: no class is emitted for A.
+				const t = this.checker?.types.get(`${base}.${typeNode.field}`);
+				return t?.kind === "named" && t.name && !t.name.includes("$$")
+					? t.name
+					: typeNode.field;
+			}
 			return `${base}.${typeNode.field}`;
 		}
 		return null;
 	},
 
+	// `type A = Base`: no class is emitted for A, so it names Base's.
+	_aliasTarget(name) {
+		const t = this.checker?.types.get(name);
+		return t?.kind === "named" &&
+			t.name &&
+			t.name !== name &&
+			!name.includes(".")
+			? t.name
+			: name;
+	},
+
 	// Bundled GoFront packages are inlined, so `pkg.T` names the class `T`.
 	_dequalify(name) {
 		const dot = name.indexOf(".");
@@ -1523,6 +2721,104 @@ export const expressionGenMethods = {
 		return false;
 	},
 
+	// ── Generic zero values (see HELPER_GENERICS) ─────────────────
+
+	// JS condition: type parameter `name` was instantiated with a struct (its
+	// zero value is a struct object, which is its own pointer when erased; a
+	// map's zero is a bare `{}`, so only a class instance or a populated
+	// object counts).
+	_typeParamIsStructJs(name) {
+		const f = this._typeParamZeroFactory(name);
+		return f
+			? `((__z) => __z !== null && typeof __z === "object" && !Array.isArray(__z) && !ArrayBuffer.isView(__z) && (Object.getPrototypeOf(Object.getPrototypeOf(__z)) !== null || Object.keys(__z).length > 0))(${f}())`
+			: "false";
+	},
+
+	// The zero-value factory bound to type parameter `name` in the code being
+	// emitted (`$z_T`), or null outside a generic body.
+	_typeParamZeroFactory(name) {
+		return this._typeParamZeros?.get(name) ?? null;
+	},
+
+	// Runs `fn` with type parameters `names` bound to the factories `$z_<name>`.
+	_withoutNatives(fn) {
+		const saved = this.natives;
+		this.natives = false;
+		try {
+			return fn();
+		} finally {
+			this.natives = saved;
+		}
+	},
+
+	_withTypeParamZeros(names, fn) {
+		const prev = this._typeParamZeros;
+		this._typeParamZeros = names
+			? new Map(names.map((n) => [n, `$z_${n}`]))
+			: null;
+		try {
+			return fn();
+		} finally {
+			this._typeParamZeros = prev;
+		}
+	},
+
+	// A factory `() => zero` for type `t`: what a generic callee receives for
+	// one of its type parameters.
+	zeroFactoryFor(t) {
+		if (t?.kind === "typeParam") {
+			const bound = this._typeParamZeroFactory(t.name);
+			if (bound) return bound;
+		}
+		this.useHelper("generics");
+		if (this._is64BitUnsigned(t)) return "__zu64";
+		const zero = this.zeroValueForType(t);
+		return Object.hasOwn(SHARED_ZERO_FACTORIES, zero)
+			? SHARED_ZERO_FACTORIES[zero]
+			: `() => (${zero})`;
+	},
+
+	// One factory per type parameter of generic function or type `generic`.
+	// `withInfo`: the callee needs the instantiated types (see type-info.js).
+	_typeArgFactories(typeParams, typeArgs, withInfo = false) {
+		return typeParams.map((_, i) =>
+			withInfo
+				? this._typeInfoFactory(typeArgs?.[i])
+				: this.zeroFactoryFor(typeArgs?.[i]),
+		);
+	},
+
+	// `new Box(args…, [factories])` for an instance of generic struct `name`
+	// with `typeArgs`; fields without an argument start at their zero value.
+	// Null when `name` is not a generic struct.
+	_genericStructNew(name, typeArgs, args = []) {
+		const generic = this.checker?.types.get(name);
+		const st = generic?.underlying;
+		const cls = this._dequalify(name);
+		if (!generic?._generic || generic._generic.isAlias) return null;
+		if (st?.kind !== "struct") return null;
+		if (!this.structNames.has(cls)) return null;
+		const tps = generic._generic.typeParams;
+		const vals = Array.from(
+			{ length: st.fields.size },
+			(_, i) => args[i] ?? "undefined",
+		);
+		const tz = this._typeArgFactories(
+			tps,
+			typeArgs,
+			this._genericTypeNeedsTypeInfo(generic) ||
+				typeArgs?.some((t) => mentionsTypeParam(t)),
+		);
+		const id = instanceId(typeArgs);
+		if (id !== null) tz.push(JSON.stringify(id));
+		else {
+			const runtimeId = this._runtimeInstanceId(typeArgs);
+			if (runtimeId) tz.push(runtimeId);
+		}
+		vals.push(`[${tz.join(", ")}]`);
+		return `new ${cls}(${vals.join(", ")})`;
+	},
+
 	// Returns the JS zero-value literal for a basic type name, or null if not a basic type.
 	_zeroForBasicName(name) {
 		return Object.hasOwn(ZERO_FOR_BASIC, name) ? ZERO_FOR_BASIC[name] : null;
@@ -1543,6 +2839,10 @@ export const expressionGenMethods = {
 			u.kind !== "named"
 		)
 			return this.zeroValueForType(u);
+		if (named?.kind === "named" && u?.kind === "struct") {
+			const clsName = named.name ?? this._dequalify(name);
+			if (this.structNames.has(clsName)) return `new ${clsName}()`;
+		}
 		name = this._dequalify(name);
 		if (this.structNames.has(name)) return `new ${name}()`;
 		return "null";
@@ -1551,7 +2851,10 @@ export const expressionGenMethods = {
 	zeroValueForTypeNode(typeNode) {
 		if (!typeNode) return "null";
 		switch (typeNode.kind) {
+			case "Ident":
 			case "TypeName": {
+				const factory = this._typeParamZeroFactory(typeNode.name);
+				if (factory) return `${factory}()`;
 				const basic = this._zeroForBasicName(typeNode.name);
 				if (basic !== null) return basic;
 				return this._zeroForNamedType(typeNode.name);
@@ -1573,7 +2876,7 @@ export const expressionGenMethods = {
 				);
 			}
 			case "MapType":
-				return "{}";
+				return this._nilMapZero();
 			case "PointerType":
 				return "null";
 			case "StructType": {
@@ -1586,16 +2889,31 @@ export const expressionGenMethods = {
 					.join(", ");
 				return `{ ${fields} }`;
 			}
+			case "GenericTypeName":
+			case "InstantiationExpr":
+				return (
+					this._genericStructNew(
+						this.getTypeName(typeNode),
+						typeNode._typeArgs,
+					) ?? "null"
+				);
 			default:
 				return "null";
 		}
 	},
 
+	// A nil map: a fresh tagged `{}` in js packages (`m == nil` holds while it
+	// stays empty); in strict mode the frozen `__nilmap`, which panics on write.
+	_nilMapZero() {
+		this.useHelper(this.strict ? "nilMap" : "nm");
+		return this.strict ? "__nilmap" : "__nm()";
+	},
+
 	_arrayZero(n, ctor, elemZero) {
 		if (ctor) return `new ${ctor}(${n})`;
 		if (n === 0) return "[]";
-		if (/^(new |\{|\[|Array)/.test(elemZero))
-			return `Array.from({ length: ${n} }, () => ${elemZero})`;
+		if (/^(new |\{|\[|Array|__nm\()|\$z_/.test(elemZero))
+			return `Array.from({ length: ${n} }, () => (${elemZero}))`;
 		return `new Array(${n}).fill(${elemZero})`;
 	},
 
@@ -1614,7 +2932,7 @@ export const expressionGenMethods = {
 					this.zeroValueForType(t.elem),
 				);
 			case "map":
-				return "{}";
+				return this._nilMapZero();
 			case "struct": {
 				const fields = [...t.fields.entries()]
 					.map(([name, ft]) => `${name}: ${this.zeroValueForType(ft)}`)
@@ -1622,7 +2940,14 @@ export const expressionGenMethods = {
 				return `{ ${fields} }`;
 			}
 			case "named":
-				return this._zeroForNamedType(t.name);
+				return (
+					this._genericStructNew(t.name, t.typeArgs) ??
+					this._zeroForNamedType(t.name)
+				);
+			case "typeParam": {
+				const factory = this._typeParamZeroFactory(t.name);
+				return factory ? `${factory}()` : "null";
+			}
 			default:
 				return "null";
 		}
@@ -1633,35 +2958,59 @@ export const expressionGenMethods = {
 		if (!typeNode) return "true";
 		if (typeNode.kind === "TypeName")
 			return this._typeNameCheckExpr(typeNode.name, val);
+		const generic = this._genericInstanceCheck(typeNode, val);
+		if (generic) return generic;
+		const dynamic = this._dynTypeCheck(typeNode, val);
+		if (dynamic) return dynamic;
 		const extended = this._namedOrIfaceCheckExpr(typeNode, val);
 		if (extended) return extended;
 		if (
 			typeNode.kind === "PointerType" &&
 			typeNode.base?.kind === "TypeName" &&
-			this.structNames.has(typeNode.base.name)
+			this.structNames.has(this._qualifiedStructName(typeNode.base.name))
 		) {
-			const name = typeNode.base.name;
+			const name = this._qualifiedStructName(typeNode.base.name);
 			return `(${val} instanceof ${name} && ${val}.__v !== true)`;
 		}
 		return "true";
 	},
 
-	zeroValueForExpr(expr) {
-		// For new(T) calls
-		if (expr.kind === "Ident") {
-			switch (expr.name) {
-				case "int":
-				case "float64":
-					return "0";
-				case "string":
-					return '""';
-				case "bool":
-					return "false";
-				default:
-					if (this.structNames.has(expr.name)) return `new ${expr.name}()`;
-			}
+	// `Stack[int]` / `*Stack[int]`: the class test plus the instantiation
+	// recorded on the instance (an instance without one matches any).
+	_genericInstanceCheck(typeNode, val) {
+		const isPtr = typeNode.kind === "PointerType";
+		const base = isPtr ? typeNode.base : typeNode;
+		if (base?.kind !== "GenericTypeName" || !base._typeArgs) return null;
+		const cls = this._dequalify(base.name);
+		if (!this.structNames.has(cls)) return null;
+		const generic = this.checker?.types.get(base.name)?._generic;
+		const id = instanceId(base._typeArgs);
+		let check = isPtr
+			? `${val} instanceof ${cls} && ${val}.__v !== true`
+			: `${val} instanceof ${cls} && ${val}.__p !== true`;
+		if (id !== null && generic) {
+			this.useHelper("generics");
+			const at = generic.typeParams.length;
+			check += ` && (${val}[__tz]?.[${at}] ?? ${JSON.stringify(id)}) === ${JSON.stringify(id)}`;
 		}
-		return "null";
+		return `(${check})`;
+	},
+
+	zeroValueForExpr(expr) {
+		return this.zeroValueForTypeNode(expr);
+	},
+
+	_genSimdEquality(expr) {
+		if (expr.op !== "==" && expr.op !== "!=") return null;
+		if (!this._isSimdValueType(expr.left._type)) return null;
+		this.useHelper("simd");
+		const cmp = `__simd_equal(${this.genExpr(expr.left)}, ${this.genExpr(expr.right)})`;
+		return expr.op === "==" ? cmp : `!${cmp}`;
+	},
+
+	_isSimdValueType(t) {
+		const base = t?.kind === "named" ? t.underlying : t;
+		return base?.kind === "simd";
 	},
 
 	// Returns true if the type is a struct or array (uses value comparison with __equal).
@@ -1700,24 +3049,112 @@ export const expressionGenMethods = {
 		)
 			return this._genComplexBinary(expr);
 
+		const simdEq = this._genSimdEquality(expr);
+		if (simdEq !== null) return simdEq;
+
 		if (this._isStructEquality(expr)) {
 			this.useHelper("equal");
 			const cmp = `__equal(${this.genExpr(expr.left)}, ${this.genExpr(expr.right)})`;
 			return expr.op === "==" ? cmp : `!${cmp}`;
 		}
 
+		const nilMap = this._genNilMapCompare(expr);
+		if (nilMap) return nilMap;
+
+		const anyNil = this._genAnyNilCompare(expr);
+		if (anyNil) return anyNil;
+
+		const tpEq = this._genTypeParamEquality(expr);
+		if (tpEq) return tpEq;
+
 		if (this._isIfaceEquality(expr)) {
 			this.useHelper("ifeq");
 			const cmp = `__ifeq(${this._genIfaceOperand(expr.left)}, ${this._genIfaceOperand(expr.right)})`;
 			return expr.op === "==" ? cmp : `!${cmp}`;
 		}
 
-		if (this.strict && this._needsStrictOp(expr.op, expr._type)) {
+		const ptrCmp = this._genPointerEquality(expr);
+		if (ptrCmp !== null) return ptrCmp;
+
+		if (this._is64BitInt(expr._type)) return this._gen64BitBinaryExpr(expr);
+
+		if (
+			(this.strict || this._isFloat32(expr._type)) &&
+			this._needsStrictOp(expr.op, expr._type)
+		) {
 			const l = this.genExpr(expr.left);
 			const r = this.genExpr(expr.right);
-			return this._genStrictBinary(expr.op, l, r, expr._type);
+			return this._genStrictBinary(expr.op, l, r, expr._type, expr.right._type);
+		}
+
+		return this._genStandardBinaryExpr(expr);
+	},
+
+	_gen64BitBinaryExpr(expr) {
+		let l = this.genExpr(expr.left);
+		let r = this.genExpr(expr.right);
+		// An untyped operand is a literal (`3` -> `3n`) or a named constant,
+		// which holds a Number.
+		const lit = (js) => (/^-?\d+$/.test(js) ? `${js}n` : `BigInt(${js})`);
+		if (expr.left._type?.kind === "untyped" && !l.endsWith("n")) l = lit(l);
+		else if (!this._is64BitInt(expr.left?._type)) l = `BigInt(${l})`;
+		if (expr.right._type?.kind === "untyped" && !r.endsWith("n")) r = lit(r);
+		else if (!this._is64BitInt(expr.right?._type)) r = `BigInt(${r})`;
+		return this._gen64BitBinary(expr.op, l, r, expr._type);
+	},
+
+	_tconvBinaryOperands(expr, l, r) {
+		if (
+			expr.left._type?.kind === "typeParam" &&
+			expr.right._type?.kind === "untyped"
+		) {
+			const factory = this._typeParamZeroFactory(expr.left._type.name);
+			if (factory) {
+				this.useHelper("generics");
+				r = `__tconv(${factory}, ${r})`;
+			}
+		} else if (
+			expr.right._type?.kind === "typeParam" &&
+			expr.left._type?.kind === "untyped"
+		) {
+			const factory = this._typeParamZeroFactory(expr.right._type.name);
+			if (factory) {
+				this.useHelper("generics");
+				l = `__tconv(${factory}, ${l})`;
+			}
 		}
+		return [l, r];
+	},
+
+	_coerceUntyped64(expr, l, r, isLeft64, isRight64) {
+		if (isLeft64 && expr.right?._type?.kind === "untyped") {
+			if (!r.endsWith("n") && /^-?\d+$/.test(r)) return [l, `${r}n`];
+		} else if (isRight64 && expr.left?._type?.kind === "untyped") {
+			if (!l.endsWith("n") && /^-?\d+$/.test(l)) return [`${l}n`, r];
+		}
+		return [l, r];
+	},
+
+	_coerceMixed64(expr, l, r, isLeft64, isRight64) {
+		const isShift = expr.op === "<<" || expr.op === ">>";
+		if (isLeft64 && !isRight64 && !isShift) r = `BigInt(${r})`;
+		else if (isRight64 && !isLeft64 && !isShift) l = `BigInt(${l})`;
+		if (isShift && isRight64) r = `Number(${r})`;
+		return [l, r];
+	},
+
+	_wrapBinaryResult(expr, res, isLeft64, isRight64) {
+		const isCmp =
+			expr.op === "==" ||
+			expr.op === "!=" ||
+			expr.op === "<" ||
+			expr.op === "<=" ||
+			expr.op === ">" ||
+			expr.op === ">=";
+		return (isLeft64 || isRight64) && !isCmp ? `Number(${res})` : res;
+	},
 
+	_genStandardBinaryExpr(expr) {
 		const jsOp = this._emittedBinaryOp(expr) ?? "/";
 		const operand = (child, isRight) =>
 			wrapForJsOp(
@@ -1726,17 +3163,66 @@ export const expressionGenMethods = {
 				jsOp,
 				isRight,
 			);
-		const l = operand(expr.left, false);
+		let [l, r] = this._tconvBinaryOperands(
+			expr,
+			operand(expr.left, false),
+			operand(expr.right, true),
+		);
+		const isLeft64 = this._is64BitInt(expr.left?._type);
+		const isRight64 = this._is64BitInt(expr.right?._type);
+		[l, r] = this._coerceUntyped64(expr, l, r, isLeft64, isRight64);
+		[l, r] = this._coerceMixed64(expr, l, r, isLeft64, isRight64);
 
 		if (expr.op === "&^") {
 			const rCode = this.genExpr(expr.right);
-			const r =
+			const rP =
 				this._emittedBinaryOp(expr.right) !== null ? `(${rCode})` : rCode;
-			return `${l} & ~${r}`;
+			return this._wrapBinaryResult(expr, `${l} & ~${rP}`, isLeft64, isRight64);
 		}
-		const r = operand(expr.right, true);
 		if (this._isIntDivision(expr)) return `Math.trunc(${l} / ${r})`;
-		return `${l} ${jsOp} ${r}`;
+		return this._wrapBinaryResult(
+			expr,
+			`${l} ${jsOp} ${r}`,
+			isLeft64,
+			isRight64,
+		);
+	},
+
+	// `m == nil` / `m != nil` on a map: true for a nil map (null, the strict
+	// sentinel, or an untouched js-package zero map), false for `map[K]V{}`.
+	_nilMapOperand(expr) {
+		if (expr.op !== "==" && expr.op !== "!=") return null;
+		const other = this._isNilLiteral(expr.right)
+			? expr.left
+			: this._isNilLiteral(expr.left)
+				? expr.right
+				: null;
+		if (!other) return null;
+		const t =
+			other._type?.kind === "named" ? other._type.underlying : other._type;
+		return t?.kind === "map" || other._coreType?.kind === "map" ? other : null;
+	},
+
+	_genNilMapCompare(expr) {
+		const operand = this._nilMapOperand(expr);
+		if (!operand) return null;
+		this.useHelper(this.strict ? "nilMap" : "nm");
+		const cmp = `__isnm(${this.genExpr(operand)})`;
+		return expr.op === "==" ? cmp : `!${cmp}`;
+	},
+
+	// `a == b` on type-parameter operands: __geq compares structs and arrays by value.
+	_genTypeParamEquality(expr) {
+		if (expr.op !== "==" && expr.op !== "!=") return null;
+		const t = expr.left._type;
+		if (t?.kind !== "typeParam" || expr.right._type?.kind !== "typeParam")
+			return null;
+		const factory = this._typeParamZeroFactory(t.name);
+		if (!factory) return null;
+		this.useHelper("equal");
+		this.useHelper("geq");
+		const cmp = `__geq(${factory}, ${this.genExpr(expr.left)}, ${this.genExpr(expr.right)})`;
+		return expr.op === "==" ? cmp : `!${cmp}`;
 	},
 
 	_isStructEquality(expr) {
@@ -1779,10 +3265,29 @@ export const expressionGenMethods = {
 		);
 	},
 
+	// The `any` operand of `x == nil` / `x != nil` (JS documents a nil slice
+	// stored in an `any` as equal to nil, though it keeps a type tag), or null.
+	_anyNilOperand(expr) {
+		if (expr.op !== "==" && expr.op !== "!=") return null;
+		const operand = this._isNilLiteral(expr.right)
+			? expr.left
+			: this._isNilLiteral(expr.left)
+				? expr.right
+				: null;
+		return operand && this._isIfaceType(operand._type) ? operand : null;
+	},
+
+	_genAnyNilCompare(expr) {
+		const operand = this._anyNilOperand(expr);
+		if (!operand) return null;
+		const test = `((__a) => __a == null || __a.__nils === true)(${this.genExpr(operand)})`;
+		return expr.op === "==" ? test : `!${test}`;
+	},
+
 	_isNilLiteral(expr) {
 		return (
 			(expr.kind === "Ident" && expr.name === "nil") ||
-			(expr.kind === "BasicLit" && expr.value === "null")
+			(expr.kind === "BasicLit" && expr.litKind === "NIL")
 		);
 	},
 
@@ -1796,6 +3301,8 @@ export const expressionGenMethods = {
 		)
 			return null;
 		if (this._isStructEquality(expr) || this._isIntDivision(expr)) return null;
+		if (this._nilMapOperand(expr)) return null;
+		if (this._anyNilOperand(expr)) return null;
 		if (this._isIfaceEquality(expr)) return null;
 		if (expr.op === "&^") return "&";
 		if (expr.op === "==" || expr.op === "!=") {
@@ -1806,9 +3313,19 @@ export const expressionGenMethods = {
 		return expr.op;
 	},
 
+	// `T(x)` with T a type parameter: converts by the instantiated type.
+	_genTypeParamConversion(name, inner) {
+		const factory = name ? this._typeParamZeroFactory(name) : null;
+		if (!factory) return null;
+		this.useHelper("generics");
+		return `__tconv(${factory}, ${inner})`;
+	},
+
 	_genTypeConversion(expr) {
 		const inner = this.genExpr(expr.expr);
 		const t = expr.targetType;
+		const viaParam = this._genTypeParamConversion(t?.name, inner);
+		if (viaParam) return viaParam;
 		if (t?.name === "complex128" || t?.name === "complex64") {
 			return isComplex(expr.expr._type) ? inner : `{ re: ${inner}, im: 0 }`;
 		}
@@ -1816,8 +3333,21 @@ export const expressionGenMethods = {
 			return this._genArrayTypeConversion(expr, inner, t);
 		if (t?.kind === "SliceType")
 			return this._genSliceTypeConversion(expr, inner, t);
+		// `map[K]V(nil)` is a nil map value, which stays distinct from the nil
+		// interface once boxed in an `any`.
+		if (t?.kind === "MapType" && this._isNilLiteral(expr.expr))
+			return this._nilMapZero();
 		const target = t?.name;
+		const structConv = this._genStructClassConversion(
+			target,
+			expr.expr._type,
+			inner,
+		);
+		if (structConv) return structConv;
 		if (target === "error") {
+			// A boxed named value that implements error is already an error.
+			if (this._isNamedBoxKind(expr.expr)) return inner;
+			if (!this._isStringExprType(expr.expr._type)) return inner;
 			this.useHelper("error");
 			return `__error(${inner})`;
 		}
@@ -1840,16 +3370,33 @@ export const expressionGenMethods = {
 			const size = t.size?.value !== undefined ? Number(t.size.value) : t.size;
 			return `${inner}.slice(0, ${size})`;
 		}
-		return inner;
+		// Array-to-array conversion yields a new array value.
+		return this._cloneJs(expr.expr._type, inner);
 	},
 
 	_genSliceTypeConversion(expr, inner, t) {
+		// `[]T(nil)` is the nil slice, not a copy of anything.
+		if (this._isNilLiteral(expr.expr)) return "null";
 		const elem = t.elem?.name;
+		// Converting a nil slice yields a nil slice.
+		const src = this._underlyingOf(expr.expr._type);
+		if (src?.kind === "slice" && !this._sliceConvNilSafe) {
+			this._sliceConvNilSafe = true;
+			try {
+				return `((__s) => __s == null ? null : ${this._genSliceTypeConversion(expr, "__s", t)})(${inner})`;
+			} finally {
+				this._sliceConvNilSafe = false;
+			}
+		}
 		if (elem === "byte" || elem === "uint8") {
-			if (this._isStringExprType(expr.expr._type))
-				return `new TextEncoder().encode(${inner})`;
-			if (isAny(expr.expr._type) || !expr.expr._type)
-				return `(typeof ${inner} === "string" ? new TextEncoder().encode(${inner}) : new Uint8Array(${inner}))`;
+			if (this._isStringExprType(expr.expr._type)) {
+				this.useHelper("u8enc");
+				return `__u8enc(${inner})`;
+			}
+			if (isAny(expr.expr._type) || !expr.expr._type) {
+				this.useHelper("u8enc");
+				return `(typeof ${inner} === "string" ? __u8enc(${inner}) : new Uint8Array(${inner}))`;
+			}
 			return `new Uint8Array(${inner})`;
 		}
 		const typedCtor = typedArrayConstructorForElem(
@@ -1868,41 +3415,71 @@ export const expressionGenMethods = {
 
 	_genStringConversion(srcType, inner) {
 		const base = srcType?.kind === "named" ? srcType.underlying : srcType;
-		if (base && this.isIntType(base)) return `String.fromCodePoint(${inner})`;
+		if (base && this.isIntType(base)) {
+			this.useHelper("runestr");
+			return `__rstr(${inner})`;
+		}
 		if (base?.kind === "slice") {
 			const elem = base.elem?.name;
-			if (elem === "byte" || elem === "uint8")
-				return `new TextDecoder().decode(new Uint8Array(${inner}))`;
-			if (elem === "rune" || elem === "int" || elem === "int32")
-				return `Array.from(${inner}, c => String.fromCodePoint(c)).join("")`;
+			if (elem === "byte" || elem === "uint8") {
+				this.useHelper("u8dec");
+				return `__u8dec(${inner})`;
+			}
+			if (elem === "rune" || elem === "int" || elem === "int32") {
+				this.useHelper("runestr");
+				return `Array.from(${inner}, c => __rstr(c)).join("")`;
+			}
 		}
 		return `String(${inner})`;
 	},
 
 	_genPrimitiveConversion(expr, inner, target) {
+		const srcType = expr.expr?._type;
+		const isSrc64 = this._is64BitInt(srcType);
 		switch (target) {
 			case "string":
-				return this._genStringConversion(expr.expr._type, inner);
+				return this._genStringConversion(
+					srcType,
+					isSrc64 ? `Number(${inner})` : inner,
+				);
+			case "int64": {
+				this.useHelper("to64");
+				return `__to_i64(${inner})`;
+			}
+			case "uint64": {
+				this.useHelper("to64");
+				return `__to_u64(${inner})`;
+			}
 			case "int":
-			case "int64":
 			case "uint":
-			case "uint64":
 			case "uintptr":
-				return `Math.trunc(Number(${inner}))`;
+				return isSrc64 ? `Number(${inner})` : `Math.trunc(Number(${inner}))`;
 			case "int8":
-				return `(Number(${inner}) << 24 >> 24)`;
+				return isSrc64
+					? `Number(BigInt.asIntN(8, ${inner}))`
+					: `(Number(${inner}) << 24 >> 24)`;
 			case "int16":
-				return `(Number(${inner}) << 16 >> 16)`;
+				return isSrc64
+					? `Number(BigInt.asIntN(16, ${inner}))`
+					: `(Number(${inner}) << 16 >> 16)`;
 			case "int32":
 			case "rune":
-				return `(Number(${inner}) | 0)`;
+				return isSrc64
+					? `Number(BigInt.asIntN(32, ${inner}))`
+					: `(Number(${inner}) | 0)`;
 			case "uint8":
 			case "byte":
-				return `(Number(${inner}) & 0xFF)`;
+				return isSrc64
+					? `Number(BigInt.asUintN(8, ${inner}))`
+					: `(Number(${inner}) & 0xFF)`;
 			case "uint16":
-				return `(Number(${inner}) & 0xFFFF)`;
+				return isSrc64
+					? `Number(BigInt.asUintN(16, ${inner}))`
+					: `(Number(${inner}) & 0xFFFF)`;
 			case "uint32":
-				return `(Number(${inner}) >>> 0)`;
+				return isSrc64
+					? `Number(BigInt.asUintN(32, ${inner}))`
+					: `(Number(${inner}) >>> 0)`;
 			case "float32":
 				return `Math.fround(Number(${inner}))`;
 			case "float64":
@@ -1926,15 +3503,77 @@ export const expressionGenMethods = {
 		return STRICT_NUMERIC_TYPES.has(typeName);
 	},
 
+	_is64BitInt(t) {
+		return is64BitInt(t);
+	},
+
+	// float32 arithmetic rounds through Math.fround and arithmetic on a type
+	// parameter wraps for the instantiated type (`__tar`) in every package kind.
+	_isFloat32(t) {
+		return (
+			this._typeName(t) === "float32" ||
+			(t?.kind === "typeParam" && this._typeParamZeroFactory(t.name) != null)
+		);
+	},
+
+	_is64BitUnsigned(t) {
+		return is64BitUnsigned(t);
+	},
+
+	_gen64BitBinary(op, l, r, type) {
+		const unsigned = this._is64BitUnsigned(type);
+		const wrap = unsigned ? "BigInt.asUintN" : "BigInt.asIntN";
+		const divZero =
+			'(() => { throw new Error("runtime error: integer divide by zero"); })()';
+		if (op === "/" || op === "%") {
+			// The divisor is read twice (zero check, division): bind both
+			// operands once, left first, unless they are plain names or literals.
+			const simple = /^[A-Za-z_$][\w$.]*$|^-?\d+n$/;
+			if ((simple.test(l) && simple.test(r)) || /\b(await|yield)\b/.test(l + r))
+				return `((${r}) === 0n ? ${divZero} : ${wrap}(64, (${l}) ${op} (${r})))`;
+			return `((__a, __b) => __b === 0n ? ${divZero} : ${wrap}(64, __a ${op} __b))(${l}, ${r})`;
+		}
+		if (op === "<<" || op === ">>") {
+			this.useHelper("shift");
+			return op === "<<"
+				? `__shl64(${l}, ${r}, ${unsigned})`
+				: `__shr64(${l}, ${r}, ${unsigned})`;
+		}
+		if (op === "&^") return `${wrap}(64, (${l}) & ~(${r}))`;
+		return `${wrap}(64, (${l}) ${op} (${r}))`;
+	},
+
+	// `uint` / `uintptr`: 64-bit unsigned values held as JS numbers.
+	_isUintWord(type) {
+		const name = this._typeName(type);
+		return name === "uint" || name === "uintptr";
+	},
+
 	_needsStrictOp(op, type) {
+		if (type?.kind === "typeParam")
+			return (
+				STRICT_OPS.has(op) && this._typeParamZeroFactory(type.name) != null
+			);
+		if (this._is64BitInt(type))
+			return STRICT_OPS.has(op) || op === "<<" || op === ">>" || op === "&^";
 		if (!STRICT_OPS.has(op)) return false;
 		if (this._isStrictAtomicOp(op, this._typeName(type))) return true;
+		if (op === "-" && this._isUintWord(type)) return true;
+		if (op === "<<" || op === ">>")
+			return WIDE_INT_NAMES.has(this._typeName(type));
 		return this.isIntType(type) && (op === "/" || op === "%");
 	},
 
 	// Emits `lhs = strict(lhs op rhs)` for any lvalue shape; returns false when not applicable.
 	// Indexed / nested targets are split into object + key temps so sub-expressions run once.
-	_genStrictCompound(lhsNode, op, rhsJs, srcLine = null, lhsJs = null) {
+	_genStrictCompound(
+		lhsNode,
+		op,
+		rhsJs,
+		srcLine = null,
+		lhsJs = null,
+		countType = null,
+	) {
 		const type = lhsNode._type;
 		if (!this._needsStrictOp(op, type)) return false;
 		if (lhsNode.kind === "IndexExpr" && lhsNode.expr?._type?.kind === "map")
@@ -1942,7 +3581,7 @@ export const expressionGenMethods = {
 		const l = lhsJs ?? this._genAssignLhsExpr(lhsNode);
 		if (/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(l)) {
 			this.line(
-				`${l} = ${this._genStrictBinary(op, l, rhsJs, type)};`,
+				`${l} = ${this._genStrictBinary(op, l, rhsJs, type, countType)};`,
 				srcLine,
 			);
 			return true;
@@ -1955,21 +3594,40 @@ export const expressionGenMethods = {
 			const k = `__k${this._tmpCounter}`;
 			const target = `${o}[${k}]`;
 			this.line(
-				`{ const ${o} = ${split.obj}, ${k} = ${split.key}; ${target} = ${this._genStrictBinary(op, target, rhsJs, type)}; }`,
+				`{ const ${o} = ${split.obj}, ${k} = ${split.key}; ${target} = ${this._genStrictBinary(op, target, rhsJs, type, countType)}; }`,
 				srcLine,
 			);
 		} else {
 			const target = `${o}.${split.prop}`;
 			this.line(
-				`{ const ${o} = ${split.obj}; ${target} = ${this._genStrictBinary(op, target, rhsJs, type)}; }`,
+				`{ const ${o} = ${split.obj}; ${target} = ${this._genStrictBinary(op, target, rhsJs, type, countType)}; }`,
 				srcLine,
 			);
 		}
 		return true;
 	},
 
-	_genStrictBinary(op, l, r, type) {
+	// A non-constant signed shift count on a narrow integer is checked for a
+	// negative value (Go panics); 64-bit counts arrive as BigInt.
+	_guardShiftCount(r, countType) {
+		if (!countType || countType.kind === "untyped") return r;
+		const name = this._typeName(countType);
+		if (!name || name.startsWith("u")) return r;
+		this.useHelper("shift");
+		return `__shc(${this._is64BitInt(countType) ? `Number(${r})` : r})`;
+	},
+
+	_genStrictBinary(op, l, r, type, countType = null) {
+		if (type?.kind === "typeParam") {
+			this.useHelper("generics");
+			return `__tar(${this._typeParamZeroFactory(type.name)}, "${op}", ${l}, ${r})`;
+		}
+		if (this._is64BitInt(type)) {
+			return this._gen64BitBinary(op, l, r, type);
+		}
 		const tName = this._typeName(type);
+		const isShift = op === "<<" || op === ">>";
+		const rc = isShift ? this._guardShiftCount(r, countType) : r;
 		if (tName === "float32") {
 			return `Math.fround(${l} ${op} ${r})`;
 		}
@@ -1978,7 +3636,10 @@ export const expressionGenMethods = {
 		if (tName === "int32" || tName === "rune" || tName === "uint32") {
 			const signed = tName !== "uint32";
 			const cast = signed ? "| 0" : ">>> 0";
-			if (signed && op === "*") return `Math.imul(${l}, ${r})`;
+			if (op === "*")
+				return signed
+					? `Math.imul(${l}, ${r})`
+					: `(Math.imul(${l}, ${r}) >>> 0)`;
 			if (op === "/")
 				return `((${r}) === 0 ? ${divZero} : (Math.trunc((${l}) / (${r})) ${cast}))`;
 			if (op === "%")
@@ -1986,9 +3647,9 @@ export const expressionGenMethods = {
 			if (op === "<<" || op === ">>") {
 				const ovf = signed && op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0";
 				const jsOp = !signed && op === ">>" ? ">>>" : op;
-				return `((${r}) >= 32 ? ${ovf} : ((${l}) ${jsOp} (${r}))) ${cast}`;
+				return `(((${rc}) >= 32 ? ${ovf} : ((${l}) ${jsOp} (${r}))) ${cast})`;
 			}
-			if (op === "&^") return `((${l}) & ~(${r})) ${cast}`;
+			if (op === "&^") return `(((${l}) & ~(${r})) ${cast})`;
 			return `((${l} ${op} ${r}) ${cast})`;
 		}
 		if (tName === "int8" || tName === "int16") {
@@ -1999,7 +3660,7 @@ export const expressionGenMethods = {
 			if (op === "%")
 				return `((${r}) === 0 ? ${divZero} : (((((${l}) % (${r})) << ${sh}) >> ${sh})))`;
 			if (op === "<<" || op === ">>") {
-				return `((${r}) >= ${bits} ? (${op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0"}) : (((${l}) ${op} (${r})) << ${sh} >> ${sh}))`;
+				return `((${rc}) >= ${bits} ? (${op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0"}) : (((${l}) ${op} (${r})) << ${sh} >> ${sh}))`;
 			}
 			if (op === "&^") return `((((${l}) & ~(${r})) << ${sh}) >> ${sh})`;
 			return `((((${l} ${op} ${r})) << ${sh}) >> ${sh})`;
@@ -2013,11 +3674,21 @@ export const expressionGenMethods = {
 				return `((${r}) === 0 ? ${divZero} : (((${l}) % (${r})) & ${mask}))`;
 			if (op === "<<" || op === ">>") {
 				const jsOp = op === ">>" ? ">>>" : "<<";
-				return `((${r}) >= ${bits} ? 0 : (((${l}) ${jsOp} (${r})) & ${mask}))`;
+				return `((${rc}) >= ${bits} ? 0 : (((${l}) ${jsOp} (${r})) & ${mask}))`;
 			}
 			if (op === "&^") return `(((${l}) & ~(${r})) & ${mask})`;
 			return `((${l} ${op} ${r}) & ${mask})`;
 		}
+		if (op === "-" && this._isUintWord(type))
+			return `((__d) => __d < 0 ? __d + 2 ** 64 : __d)((${l}) - (${r}))`;
+		if (op === "<<" || op === ">>") {
+			// 64-bit semantics: operand first, then count (Go order); a negative
+			// count panics and the result wraps to 64 bits.
+			this.useHelper("shift");
+			const unsigned = this._typeName(type).startsWith("u");
+			if (op === "<<") return `__shl64(${l}, ${r}, ${unsigned})`;
+			return `__shr64(${l}, ${r}, ${unsigned})`;
+		}
 		if (this.isIntType(type)) {
 			if (op === "/")
 				return `((${r}) === 0 ? ${divZero} : Math.trunc((${l}) / (${r})))`;