gofront 1.8.0 → 1.9.1

package/src/backend/js/expressions.js

@@ -2,21 +2,27 @@ 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,
+	isComplex64,
 	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.
@@ -37,8 +43,92 @@ export function comparesToNil(node, name) {
 	return someChild(node, (c) => comparesToNil(c, name));
 }
 
+// True when evaluating `node` reads through the receiver `name` (`r.f`,
+// `r[i]`, `*r`), which panics on a nil receiver anyway. Calling a method of
+// `safe` on it is not a read: that method accepts a nil receiver. A func
+// literal's body is not evaluated where it appears, so it is not searched.
+export function derefsReceiver(node, name, safe) {
+	if (Array.isArray(node))
+		return node.some((n) => derefsReceiver(n, name, safe));
+	if (!node || typeof node !== "object" || node.kind === "FuncLit")
+		return false;
+	const isRecv = (e) => e?.kind === "Ident" && e.name === name;
+	if (node.kind === "SelectorExpr" && isRecv(node.expr))
+		return !safe.has(node.field);
+	if (
+		(node.kind === "IndexExpr" || node.kind === "SliceExpr") &&
+		isRecv(node.expr)
+	)
+		return true;
+	if (node.kind === "UnaryExpr" && node.op === "*" && isRecv(node.operand))
+		return true;
+	return someChild(node, (c) => derefsReceiver(c, name, safe));
+}
+
+// True when `stmts` (a method body) reads through the receiver `name` before
+// anything could skip the read: only the statements that always run first
+// count, up to the first branch, loop, return or rebinding of `name`. A
+// method that does so panics on a nil receiver either way.
+export function derefsReceiverFirst(stmts, name, safe) {
+	return receiverPrefix(stmts, name, safe) === "deref";
+}
+
+// What one statement of a method body's unconditional prefix does with the
+// receiver: "deref" reads through it, "stop" may skip the rest (a branch,
+// loop, return, panic or rebinding of the name), "next" runs on.
+const binds = (lhs, name) =>
+	lhs.some((e) => e?.kind === "Ident" && e.name === name);
+const branches = (reads, ...parts) => (parts.some(reads) ? "deref" : "stop");
+const RECEIVER_STEP = {
+	Block: (s, _reads, name, safe) => receiverPrefix(s.stmts, name, safe),
+	IfStmt: (s, reads) => branches(reads, s.init, s.cond),
+	ForStmt: (s, reads) => branches(reads, s.init, s.cond),
+	SwitchStmt: (s, reads) => branches(reads, s.init, s.tag),
+	TypeSwitchStmt: (s, reads) => branches(reads, s.expr),
+	ReturnStmt: (s, reads) => branches(reads, s.values),
+	ExprStmt: (s, reads) => {
+		if (reads(s.expr)) return "deref";
+		const panics = s.expr?.kind === "CallExpr" && s.expr.func?.name === "panic";
+		return panics ? "stop" : "next";
+	},
+	DefineStmt: (s, reads, name) => {
+		if (reads(s.rhs) || reads(s.lhs.filter((e) => e?.kind !== "Ident")))
+			return "deref";
+		return binds(s.lhs, name) ? "stop" : "next";
+	},
+	IncDecStmt: (s, reads) => (reads(s.expr) ? "deref" : "next"),
+	VarDecl: (s, reads, name) => {
+		if (s.decls.some((d) => reads(d.value))) return "deref";
+		const named = (d) => d.names.some((n) => (n?.name ?? n) === name);
+		return s.decls.some(named) ? "stop" : "next";
+	},
+};
+RECEIVER_STEP.AssignStmt = RECEIVER_STEP.DefineStmt;
+
+// "deref" when the unconditional prefix of `stmts` reads through the
+// receiver, "stop" when something may skip the rest, else "next".
+function receiverPrefix(stmts, name, safe) {
+	const reads = (n) => derefsReceiver(n, name, safe);
+	for (const s of stmts ?? []) {
+		const step = RECEIVER_STEP[s?.kind];
+		const r = step ? step(s, reads, name, safe) : "stop";
+		if (r !== "next") return r;
+	}
+	return "next";
+}
+
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
+// True for a map, slice or array type that mentions a type parameter: one
+// that generic code boxes into an interface is tagged by its instantiated
+// type.
+export function isGenericComposite(t) {
+	return (
+		(t?.kind === "map" || t?.kind === "slice" || t?.kind === "array") &&
+		mentionsTypeParam(t)
+	);
+}
+
 // True when type `t` mentions a type parameter anywhere.
 export function mentionsTypeParam(t, depth = 0) {
 	if (!t || depth > 16) return false;
@@ -125,36 +215,7 @@ 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])"],
@@ -236,91 +297,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",
-	},
-	bits: {
-		UintSize: "64",
-	},
-	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",
-		Stdout: "__os_stdout",
-		Stderr: "__os_stderr",
-		Stdin: "__os_stdin",
-	},
 	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"',
@@ -348,7 +331,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.
@@ -413,6 +395,7 @@ const SHARED_ZERO_FACTORIES = {
 	0: "__z0",
 	'""': "__zs",
 	false: "__zf",
+	"0n": "__z64",
 };
 
 // Zero-value JS literals for basic Go types.
@@ -422,11 +405,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",
@@ -439,13 +422,18 @@ 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) => {
+		if (e._constLen != null) return s._genConstLen(e);
 		s.useHelper("slice");
 		return `__cap(${s.genExpr(e.args[0])})`;
 	},
@@ -457,13 +445,11 @@ const BUILTIN_GEN = {
 	copy: (s, e) => {
 		const dst = s.genExpr(e.args[0]);
 		const src = s._genSliceSource(e.args[1]);
-		// Array elements are values: the copied elements must not alias src.
+		// 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)?.kind === "array"
-				? s._cloneJs(elem, "__e")
-				: "__e";
+		const clone = s._aggregateBase(elem) ? s._cloneJs(elem, "__e") : "__e";
 		const items =
 			clone === "__e"
 				? "(__cs.slice ? __cs.slice(0, n) : __cs.subarray(0, n))"
@@ -496,15 +482,21 @@ const BUILTIN_GEN = {
 	// `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])})`;
 	},
@@ -521,13 +513,25 @@ const BUILTIN_GEN = {
 // 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 args = e.args.map((a) => s.genExpr(a));
+	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" ? ${fold("v")} : Math.${fn}(...v)))(${args.join(", ")})`;
-	if (!s._isStringExprType(e._type)) return `Math.${fn}(${args.join(", ")})`;
-	return fold(`[${args.join(", ")}]`);
+		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
@@ -588,8 +592,51 @@ function hasTypeParamType(t) {
 	).includes('"typeParam"');
 }
 
+// Complex constant arithmetic on [re, im] pairs.
+const COMPLEX_CONST_OPS = {
+	"+": (a, b) => [a[0] + b[0], a[1] + b[1]],
+	"-": (a, b) => [a[0] - b[0], a[1] - b[1]],
+	"*": (a, b) => [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]],
+	"/": (a, b) => {
+		const d = b[0] * b[0] + b[1] * b[1];
+		if (d === 0) return null;
+		return [(a[0] * b[0] + a[1] * b[1]) / d, (a[1] * b[0] - a[0] * b[1]) / d];
+	},
+};
+
+// The [re, im] value of an untyped complex constant expression built from
+// literals and named constants, or null.
+function complexConstParts(e, depth = 0) {
+	if (!e || typeof e !== "object" || depth > 32) return null;
+	if (e.kind === "ParenExpr") return complexConstParts(e.expr, depth + 1);
+	// A named complex constant has no folded value: fold its initializer.
+	if (e._complexInit) return complexConstParts(e._complexInit, depth + 1);
+	if (e.kind === "ImagLit") return [0, Number(e.value)];
+	const val = e._const;
+	if (val && (val.k === "FLOAT" || val.k === "INT")) return [Number(val.v), 0];
+	if (e.kind === "UnaryExpr") return complexConstNeg(e, depth);
+	const op = e.kind === "BinaryExpr" ? COMPLEX_CONST_OPS[e.op] : null;
+	const a = op && complexConstParts(e.left, depth + 1);
+	const b = a && complexConstParts(e.right, depth + 1);
+	return b ? op(a, b) : null;
+}
+
+function complexConstNeg(e, depth) {
+	if (e.op !== "-" && e.op !== "+") return null;
+	const c = complexConstParts(e.operand, depth + 1);
+	return c && e.op === "-" ? [-c[0], -c[1]] : c;
+}
+
 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);
@@ -613,21 +660,96 @@ export const expressionGenMethods = {
 				expr._ifaceKeying = true;
 				try {
 					this.useHelper("structKey");
-					return `__ik(${this.genExpr(expr)})`;
+					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._fmtDescing && !this._isNamedBoxKind(expr)) {
-			const desc = this._fmtDesc(expr._ifaceSrc);
-			if (desc) {
-				expr._fmtDescing = true;
+		if (
+			expr._ifaceSrc &&
+			!expr._tfnTagging &&
+			this._isTaggedFuncType(expr._ifaceSrc)
+		) {
+			// A value of a defined func type keeps that type in an interface.
+			expr._tfnTagging = true;
+			try {
+				this.useHelper("ifaceBox");
+				return `__tfn(${this.genExpr(expr)}, ${JSON.stringify(expr._ifaceSrc.name)})`;
+			} finally {
+				expr._tfnTagging = false;
+			}
+		}
+		if (isGenericComposite(expr._ifaceSrc) && !expr._gmapTagging) {
+			const tag = this._genericMapTag(expr._ifaceSrc);
+			if (tag) {
+				this.useHelper("ifaceBox");
+				expr._gmapTagging = true;
+				try {
+					// An array is copied before it is tagged: a copy made after
+					// `__ity` (`.map`) would drop the tag.
+					return `__ity(${this.genValueExpr(expr)}, ${tag})`;
+				} finally {
+					expr._gmapTagging = false;
+				}
+			}
+		}
+		{
+			const tag = this._ityTag(expr);
+			if (tag) {
+				this.useHelper("ifaceBox");
+				expr._ityTagging = true;
 				try {
-					return this._fmtDescWrap(this.genExpr(expr), desc);
+					const ptr = this._dynTagFlags(expr._ifaceSrc);
+					// An array is copied before it is tagged: the copy is the value
+					// the interface holds, and it must keep the tag.
+					return `__ity(${this.genValueExpr(expr)}, ${JSON.stringify(tag)}${ptr})`;
 				} finally {
-					expr._fmtDescing = false;
+					expr._ityTagging = false;
 				}
 			}
 		}
@@ -635,29 +757,50 @@ export const expressionGenMethods = {
 			expr._ifaceBoxing = true;
 			try {
 				this.useHelper("ifaceBox");
-				return this._ifaceBoxWrap(
+				const boxed = this._ifaceBoxWrap(
 					this.genExpr(expr),
 					expr._ifaceBox,
 					expr._ifacePtrFields,
+					expr.kind === "CompositeLit",
 				);
+				return this._typedNilWrap(boxed, expr);
 			} finally {
 				expr._ifaceBoxing = false;
 			}
 		}
+		const f32 = this._genFloat32Const(expr);
+		if (f32 !== null) return f32;
+		const c64 = this._genComplex64Const(expr);
+		if (c64 !== null) return c64;
 		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":
@@ -672,6 +815,42 @@ 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;
+	},
+
+	// An untyped constant converted to float32 (`var c float32 = 0.01`) is
+	// emitted as its float32 value, or null when that changes nothing.
+	_genFloat32Const(expr) {
+		const val = expr._const;
+		if (!expr._f32Const || !val || (val.k !== "FLOAT" && val.k !== "INT"))
+			return null;
+		const n = Number(val.v);
+		if (!Number.isFinite(n)) return null;
+		const r = Math.fround(n);
+		if (r === n) return null;
+		return CONST_LITS.FLOAT(r);
+	},
+
+	// An untyped complex constant that takes type complex64
+	// (`var c complex64 = 1 + 0.01i`) is emitted as its folded value with
+	// float32 components, or null when it cannot be folded here.
+	_genComplex64Const(expr) {
+		if (!expr._c64Const) return null;
+		const c = complexConstParts(expr);
+		if (!c) return null;
+		const re = CONST_LITS.FLOAT(Math.fround(c[0]));
+		const im = CONST_LITS.FLOAT(Math.fround(c[1]));
+		return re === null || im === null ? null : `{ re: ${re}, im: ${im} }`;
+	},
+
 	// The literal for a folded constant expression (`1 << 40` →
 	// `1099511627776`), or null.  Integers outside ±2⁵³ emit the nearest
 	// Number and a precision warning.
@@ -686,6 +865,8 @@ export const expressionGenMethods = {
 			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;
 	},
@@ -694,6 +875,8 @@ export const expressionGenMethods = {
 	// 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)) {
@@ -703,7 +886,9 @@ export const expressionGenMethods = {
 	},
 
 	// `js` boxed as `box` (a checker _ifaceBoxMeta kind) for an interface.
-	_ifaceBoxWrap(js, box, ptrFields) {
+	// `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 =
 			{
@@ -713,14 +898,22 @@ export const expressionGenMethods = {
 				map: "__ifm",
 				slice: "__ifs",
 			}[box] ?? "__ifv";
-		const extra = ptrFields?.length ? `, ${JSON.stringify(ptrFields)}` : "";
-		return `${fn}(${js}${extra})`;
+		const fields = ptrFields?.length ? JSON.stringify(ptrFields) : "";
+		if (fn === "__ifv" && fresh)
+			return `${fn}(${js}, ${fields || "null"}, true)`;
+		return `${fn}(${js}${fields ? `, ${fields}` : ""})`;
 	},
 
-	// `js` tagged with the fmt descriptor source `desc` (see _fmtDesc).
-	_fmtDescWrap(js, desc) {
-		this.useHelper("ifd");
-		return `__ifd(${js}, ${desc})`;
+	// 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) {
@@ -819,8 +1012,12 @@ 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;
@@ -857,7 +1054,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":
@@ -871,10 +1070,22 @@ export const expressionGenMethods = {
 		}
 	},
 
+	// The type tag `expr` takes on entering an interface, or null.
+	_ityTag(expr) {
+		if (!expr._ifaceSrc || expr._ityTagging || this._isNamedBoxKind(expr))
+			return null;
+		return this._dynTypeTag(expr._ifaceSrc);
+	},
+
 	// Emits `expr` as a Go value: struct/array operands that alias existing storage are copied.
 	genValueExpr(expr) {
+		const tagged =
+			Boolean(this._ityTag(expr)) ||
+			(isGenericComposite(expr._ifaceSrc) &&
+				!expr._gmapTagging &&
+				Boolean(this._genericMapTag(expr._ifaceSrc)));
 		const js = this.genExpr(expr);
-		if (expr._ifaceBox) return js;
+		if (expr._ifaceBox || tagged) return js;
 		if (
 			!(
 				this._aggregateBase(expr._type) || this._typeParamClone(expr._type, js)
@@ -889,11 +1100,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);
@@ -905,12 +1111,10 @@ 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);
+		// A function starts with no JS labels in scope (see
+		// `_emitIterTargetDispatch`).
+		const prevLabels = this._jsLabels;
+		this._jsLabels = [];
 		this._fnCtx = {
 			body,
 			mut: new Map(),
@@ -924,7 +1128,7 @@ export const expressionGenMethods = {
 			fn();
 		} finally {
 			this._fnCtx = prev;
-			this._functionLabels = prevLabels;
+			this._jsLabels = prevLabels;
 		}
 	},
 
@@ -1031,7 +1235,9 @@ export const expressionGenMethods = {
 		// Dereference: *p
 		if (op === "*") {
 			if (this._isStructPointerType(expr.operand._type)) {
-				return this._genNilChecked(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`;
@@ -1046,6 +1252,17 @@ 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;
@@ -1064,11 +1281,38 @@ export const expressionGenMethods = {
 
 	_genSelectorExpr(expr) {
 		// Go-source stdlib member: bundled under its mangled top-level name.
-		if (expr._stdName) return expr._stdName;
+		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;
+			// `(*MyInt).M` for a pointer-receiver method of a named non-struct
+			// type: the static method takes the pointer, nil included.
+			if (rt?.kind === "pointer") {
+				const info = this._namedBoxInfo(rt.base);
+				const decl = rt.base?.methods?.get(expr.field)?._methodDecl;
+				if (info?.methods.has(expr.field) && decl?.recvPointer)
+					return `${info.cls}.$${expr.field}`;
+			}
+			const protoCls = this._ptrMethodProtoClass(rt, expr.field);
+			if (protoCls) {
+				// A value-receiver method reads `*recv`, which panics on nil.
+				let recv = "recv";
+				if (rt.base.methods.get(expr.field)?._ptrRecv === false) {
+					this.useHelper("nilCall");
+					recv = "__nilcall(recv)";
+				}
+				return `((recv, ...args) => ${protoCls}.prototype.${expr.field}.call(${recv}, ...args))`;
+			}
 			return `((recv, ...args) => recv.${expr.field}(...args))`;
 		}
 		const namedValue = this._genNamedMethodValue(expr);
@@ -1076,26 +1320,6 @@ 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");
-				} else if (expr.expr.name === "os") {
-					this.useHelper("os");
-				}
 				return nsConst;
 			}
 		}
@@ -1178,7 +1402,7 @@ export const expressionGenMethods = {
 			const inner = sf.type?.kind === "pointer" ? sf.type.base : sf.type;
 			if (inner?.kind !== "named" || !this.structNames.has(inner.name))
 				continue;
-			const name = inner.name;
+			const name = embeddedFieldName(sf);
 			if (name === field) return null;
 			const ist = inner.underlying;
 			if (!ist?.fields?.has(field)) continue;
@@ -1299,21 +1523,54 @@ export const expressionGenMethods = {
 
 	_genCallArgs(expr) {
 		if (expr._multiForward) return `...${this.genExpr(expr.args[0])}`;
-		return expr.args
-			.map((a, i) =>
-				a._spread
-					? this._genSpreadArg(expr, a)
+		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),
-			)
-			.join(", ");
+		);
+	},
+
+	// 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}`;
 	},
 
@@ -1355,7 +1612,9 @@ export const expressionGenMethods = {
 		if (this._isStructPointerType(expr.expr._type)) {
 			// Strict mode: a field of a nil struct pointer panics as in Go.
 			const recv =
-				this.strict && !expr._isMethodValue ? this._genNilChecked(base) : base;
+				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.
@@ -1366,6 +1625,15 @@ export const expressionGenMethods = {
 					);
 					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;
@@ -1382,11 +1650,12 @@ export const expressionGenMethods = {
 		const base = wrapField
 			? `${this.genExpr(expr.expr)}.${wrapField}`
 			: this.genExpr(expr.expr);
-		const idx = this.genExpr(expr.index);
+		let idx = this.genExpr(expr.index);
 		if (expr._mapValueType) {
 			if (!expr._lvalue) return this._genMapIndexExpr(expr, base, idx);
 			return `${this._genMapWriteBase(base)}[${idx}]`;
 		}
+		idx = this._asIndexNumber(idx, expr.index?._type);
 		const checked = this._genStrictIndex(expr, base, idx);
 		if (checked) return checked;
 		if (this._isStringExprType(exprType) && !expr._lvalue)
@@ -1428,8 +1697,8 @@ export const expressionGenMethods = {
 	_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) {
@@ -1442,8 +1711,12 @@ export const expressionGenMethods = {
 
 	_genSliceExpr(expr) {
 		const base = this.genExpr(expr.expr);
-		const lo = expr.low ? this.genExpr(expr.low) : "0";
-		const hi = expr.high ? this.genExpr(expr.high) : "undefined";
+		const lo = expr.low
+			? this._asIndexNumber(this.genExpr(expr.low), expr.low._type)
+			: "0";
+		const hi = expr.high
+			? this._asIndexNumber(this.genExpr(expr.high), expr.high._type)
+			: "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:
@@ -1456,7 +1729,9 @@ export const expressionGenMethods = {
 		// 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.genExpr(expr.max)}` : "";
+		const max = expr.max
+			? `, ${this._asIndexNumber(this.genExpr(expr.max), expr.max._type)}`
+			: "";
 		return `__slice(${base}, ${lo}, ${hi}${max})`;
 	},
 
@@ -1471,7 +1746,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");
@@ -1493,18 +1768,38 @@ export const expressionGenMethods = {
 		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]; an asserted array
-		// is a copy of the boxed value.
+		// 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);
-		const arrT = this._typeFromNode(expr.type);
-		const okOut = arrT?.kind === "array" ? this._cloneJs(arrT, out) : out;
+		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;
@@ -1512,20 +1807,37 @@ export const expressionGenMethods = {
 		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(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`;
-		// F32x4 and Mask32x4 are both frozen 4-element arrays; lanes tell them apart.
-		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")`;
+		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))
@@ -1534,12 +1846,20 @@ 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")
+		if (named?.underlying?.kind === "interface")
 			return this._ifaceMethodCheck(
 				val,
 				[...named.underlying.methods.keys()],
 				this._unwrapIsMulti(named.underlying.methods.get("Unwrap")),
 			);
+		if (this._isTaggedFuncType(named)) {
+			this.useHelper("ifaceBox");
+			return `__isty(${val}, ${JSON.stringify(name)}, "namedfunc")`;
+		}
+		if (this._isNamedComposite(named)) {
+			this.useHelper("ifaceBox");
+			return `__isty(${val}, ${JSON.stringify(name)}, "named")`;
+		}
 		return "true"; // unknown type — can't check at runtime
 	},
 
@@ -1573,11 +1893,14 @@ export const expressionGenMethods = {
 	},
 
 	_ifaceMethodCheck(val, methodNames, multiUnwrap = null) {
-		const checks = methodNames.map((m) =>
-			m === "Unwrap" && multiUnwrap !== null
-				? `typeof ${val}.${m} === "function" && (${val}.${m}.__multi === true) === ${multiUnwrap}`
-				: `typeof ${val}.${m} === "function"`,
-		);
+		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(" && ")})`;
 	},
 
@@ -1586,6 +1909,21 @@ export const expressionGenMethods = {
 	// 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" ||
+			this._isNamedSliceTypeNode(typeNode)
+		) {
+			// 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)
@@ -1593,6 +1931,29 @@ export const expressionGenMethods = {
 		return factory ? `(${factory}?.u ? ${val}.__gfUnbox() : ${val})` : val;
 	},
 
+	// A type name that denotes a defined slice type (`type S []int`).
+	_isNamedSliceTypeNode(typeNode) {
+		if (typeNode?.kind !== "TypeName") return false;
+		const named = this.checker?.types.get(typeNode.name);
+		return (
+			this._isNamedComposite(named) &&
+			this._underlyingOf(named)?.kind === "slice"
+		);
+	},
+
+	_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(
@@ -1630,11 +1991,14 @@ export const expressionGenMethods = {
 			arg,
 		);
 		if (structConv) return structConv;
-		const isRaw =
-			targetType?.name === "json.RawMessage" ||
-			targetType?.name === "encoding/json.RawMessage";
 		const base =
 			targetType?.kind === "named" ? targetType.underlying : targetType;
+		if (base?.kind === "map" && this._isNilLiteral(expr.args[0]))
+			return this._nilMapZero();
+		if (this._isTaggedFuncType(targetType)) {
+			this.useHelper("ifaceBox");
+			return `__tfn(${arg}, ${JSON.stringify(targetType.name)})`;
+		}
 		if (
 			targetType?.kind === "named" &&
 			base?.kind === "basic" &&
@@ -1651,19 +2015,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") {
@@ -1671,18 +2045,30 @@ 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})`;
+			const m = expr.func.field;
+			const viaProto = (r) =>
+				`${nilSafe}.prototype.${m}.call(${rest ? `${r}, ${rest}` : r})`;
+			// A non-nil variable keeps the direct (faster) call.
+			if (/^[\w$]+$/.test(recv))
+				return `(${recv} != null ? ${recv}.${m}(${rest}) : ${viaProto(recv)})`;
+			return viaProto(recv);
 		}
 
 		expr.func._callee = true;
@@ -1694,15 +2080,91 @@ export const expressionGenMethods = {
 		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");
+		let recv = `__tbox(${factory}, ${this.genExpr(expr.func.expr)})`;
+		// `P(&v).M()` with `P interface{ *T; M() }`: a pointer to a boxed
+		// type-parameter variable is the box, so reach the value it holds.
+		if (this._hasPointerTypeSet(expr.func.expr._type))
+			recv = `((__r) => typeof __r?.${expr.func.field} === "function" ? __r : __r?.value)(${recv})`;
+		const args = this._genCallArgs(expr);
+		return `${recv}.${expr.func.field}(${args})`;
+	},
+
+	// Whether type parameter `tp` is constrained to a single `*T` type-set term.
+	_hasPointerTypeSet(tp) {
+		const c = tp.constraint;
+		const iface = c?.kind === "named" ? c.underlying : c;
+		const terms = iface?.unionConstraint?.terms;
+		return (
+			terms?.length === 1 &&
+			(terms[0].resolved?.kind === "pointer" ||
+				terms[0].type?.kind === "PointerType")
+		);
+	},
+
+	// `(*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;
-		return this.nilSafeMethods?.has(`${cls}.${func.field}`) ? cls : null;
+		// An instance of a generic struct (`Gen[int]`) shares its class.
+		const cls = t.base.typeArgs?.length
+			? this._structClassName(t.base)
+			: t.base.name;
+		if (!cls) return null;
+		if (
+			t.base.underlying?.kind === "struct" &&
+			!this._promotedPath(func) &&
+			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
@@ -1741,79 +2203,7 @@ export const expressionGenMethods = {
 		return recvType?.name ?? recvType?.base?.name;
 	},
 
-	_genJsonStreamCall(recvName, expr) {
-		const isEnc = this._isJsonEncoderName(recvName);
-		if (isEnc && expr.func.field === "Encode") {
-			this.useHelper("json");
-			const enc = this.genExpr(expr.func.expr);
-			this._markJsonAnyEncoders();
-			const argType = expr.args[0]?._type;
-			const codec = this._getJsonEncoder(argType);
-			const arg = this.genExpr(expr.args[0]);
-			return `__json_encoder_encode(${enc}, ${codec}, ${arg})`;
-		}
-		const isDec =
-			recvName === "json.Decoder" ||
-			recvName === "encoding/json.Decoder" ||
-			recvName?.startsWith("Decoder$$");
-		if (isDec && expr.func.field === "Decode") {
-			this.useHelper("json");
-			const dec = this.genExpr(expr.func.expr);
-			const targetType = expr.args[0]?._type;
-			const codec = this._getJsonDecoder(targetType);
-			const arg = this.genExpr(expr.args[0]);
-			return `__json_decoder_decode(${dec}, ${codec}, ${arg}, ${this._jsonTargetArgs(targetType)})`;
-		}
-		return undefined;
-	},
-
 	_genReceiverTypeCall(recvName, expr) {
-		const jsonStream = this._genJsonStreamCall(recvName, expr);
-		if (jsonStream !== undefined) return jsonStream;
-		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 === "time.Month") {
-			this.useHelper("duration");
-			return `__monthString(${this.genExpr(expr.func.expr)})`;
-		}
-		if (recvName === "time.Weekday") {
-			this.useHelper("duration");
-			return `__weekdayString(${this.genExpr(expr.func.expr)})`;
-		}
-		if (recvName === "time.Location") {
-			const recv = this.genExpr(expr.func.expr);
-			return `(${recv} ? ${recv}.String() : "UTC")`;
-		}
-		if (recvName === "time.Timer") {
-			const recv = this.genExpr(expr.func.expr);
-			if (expr.func.field === "Stop")
-				return `(${recv} ? ${recv}.Stop() : false)`;
-			if (expr.func.field === "Reset")
-				return `(${recv} ? ${recv}.Reset(${this.genExpr(expr.args[0])}) : false)`;
-		}
-		if (
-			recvName === "testing.T" ||
-			recvName === "testing.B" ||
-			recvName === "testing.M" ||
-			recvName === "testing.TB"
-		)
-			return this._genTestingMethodCall(expr.func.field, expr);
-		if (recvName === "strings.Replacer") {
-			const recv = this.genExpr(expr.func.expr);
-			if (expr.func.field === "WriteString") {
-				const w = this.genExpr(expr.args[0]);
-				const s = this.genExpr(expr.args[1]);
-				return `((r,w,s) => { s = r ? r.Replace(s) : s; const x = w?.value ?? w; if (typeof x.WriteString === "function") return x.WriteString(s); if (typeof x._buf === "string") { x._buf += s; return [s.length, null]; } if (Array.isArray(x._buf)) { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) x._buf.push(bytes[i]); return [bytes.length, null]; } if (typeof x.Write === "function") return x.Write(new TextEncoder().encode(s)); return [0, "strings.Replacer.WriteString: unsupported writer"]; })(${recv}, ${w}, ${s})`;
-			}
-			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})`;
@@ -1842,28 +2232,6 @@ 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;
 	},
 
@@ -1889,12 +2257,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)) {
@@ -1902,14 +2302,22 @@ export const expressionGenMethods = {
 			// TypeError with a different message.
 			this.useHelper("nilCall");
 			const recv = this.genExpr(expr.func.expr);
-			const args = expr.args
-				.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
-				.join(", ");
+			const args = this._genCallArgs(expr);
 			return `__nilcall(${recv}).${expr.func.field}(${args})`;
 		}
 		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;
@@ -1917,13 +2325,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})`;
 	},
@@ -1954,9 +2362,9 @@ export const expressionGenMethods = {
 	// contributes its UTF-8 bytes.
 	_genSliceSource(node) {
 		const js = this.genExpr(node);
-		return this._isStringExprType(node._type)
-			? `new TextEncoder().encode(${js})`
-			: js;
+		if (!this._isStringExprType(node._type)) return js;
+		this.useHelper("u8enc");
+		return `__u8enc(${js})`;
 	},
 
 	genAppend(expr) {
@@ -1981,12 +2389,23 @@ export const expressionGenMethods = {
 		const st = expr._type ?? expr.args[0]._type;
 		const elemT = (st?.kind === "named" ? st.underlying : st)?.elem;
 		const spreadOf = (a) =>
-			this._aggregateBase(elemT)?.kind === "array"
+			this._aggregateBase(elemT)
 				? `...(${this.genExpr(a)} ?? []).map((__e) => ${this._cloneJs(elemT, "__e")})`
 				: `...(${this._genSliceSource(a)} ?? [])`;
-		const elems = expr.args
-			.slice(1)
-			.map((a) => (a._spread ? spreadOf(a) : this.genValueExpr(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;
@@ -1995,11 +2414,35 @@ 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) → {}
@@ -2007,12 +2450,16 @@ export const expressionGenMethods = {
 		const typeNode = typeArg.kind === "TypeExpr" ? typeArg.type : typeArg;
 		// A defined type (`type S []int`) makes like its underlying type.
 		const madeType =
-			typeArg._type?.kind === "named"
+			typeArg._coreType ??
+			(typeArg._type?.kind === "named"
 				? typeArg._type.underlying
-				: typeArg._type;
+				: 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]) n = this._asIndexNumber(n, expr.args[1]._type);
+			// 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 = madeType?.kind === "slice" ? madeType.elem : null;
 			const typedCtor =
@@ -2025,8 +2472,13 @@ export const expressionGenMethods = {
 					: null);
 			// make([]T, n, cap) allocates cap elements and returns a view of
 			// the first n (`__mkslice`), so append within cap shares them.
-			const capArg = expr.args[2] ? this.genExpr(expr.args[2]) : null;
-			if (capArg) this.useHelper("slice");
+			let capArg = expr.args[2] ? this.genExpr(expr.args[2]) : null;
+			if (capArg && expr.args[2])
+				capArg = this._asIndexNumber(capArg, expr.args[2]._type);
+			if (capArg) {
+				this.useHelper("slice");
+				capArg = this._guardMakeSize(capArg, "__mkc");
+			}
 			const withCap = (alloc) =>
 				capArg ? `__mkslice(${n}, ${alloc(capArg)})` : alloc(n);
 			if (typedCtor) {
@@ -2045,24 +2497,18 @@ export const expressionGenMethods = {
 			}
 			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) {
@@ -2322,10 +2768,6 @@ 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") {
@@ -2445,26 +2887,44 @@ export const expressionGenMethods = {
 	// ── 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._stdName) return typeNode._stdName;
-		if (typeNode.kind === "TypeName") return this._dequalify(typeNode.name);
+		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(".");
@@ -2514,6 +2974,16 @@ export const expressionGenMethods = {
 	},
 
 	// 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
@@ -2534,6 +3004,7 @@ export const expressionGenMethods = {
 			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]
@@ -2722,6 +3193,8 @@ export const expressionGenMethods = {
 			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 (
@@ -2785,20 +3258,45 @@ export const expressionGenMethods = {
 		const r = this._genComplexOperand(expr.right);
 		switch (expr.op) {
 			case "+":
-				return `{ re: ${l}.re + ${r}.re, im: ${l}.im + ${r}.im }`;
 			case "-":
-				return `{ re: ${l}.re - ${r}.re, im: ${l}.im - ${r}.im }`;
 			case "*":
-				this.useHelper("cmul");
-				return `__cmul(${l}, ${r})`;
 			case "/":
-				this.useHelper("cdiv");
-				return `__cdiv(${l}, ${r})`;
+				return this._genComplexArith(expr.op, l, r, isComplex64(expr._type));
 			case "==":
-				return `(${l}.re === ${r}.re && ${l}.im === ${r}.im)`;
+				return this._genComplexEquality("===", "&&", l, r);
 			case "!=":
-				return `(${l}.re !== ${r}.re || ${l}.im !== ${r}.im)`;
+				return this._genComplexEquality("!==", "||", l, r);
+		}
+	},
+
+	// `l == r` / `l != r` on complex operands: each component reads both
+	// operands, so an operand that calls a function is bound once first.
+	_genComplexEquality(cmp, join, l, r) {
+		const pure = (js) => !js.includes("(");
+		if (pure(l) && pure(r))
+			return `(${l}.re ${cmp} ${r}.re ${join} ${l}.im ${cmp} ${r}.im)`;
+		return `((__a, __b) => __a.re ${cmp} __b.re ${join} __a.im ${cmp} __b.im)(${l}, ${r})`;
+	},
+
+	// `l op r` for complex operands.  A complex64 result has float32
+	// components, as in Go (where the arithmetic runs in float64 and the
+	// result is narrowed).
+	_genComplexArith(op, l, r, is64) {
+		let re;
+		let im;
+		let call = null;
+		if (op === "+" || op === "-") {
+			re = `${l}.re ${op} ${r}.re`;
+			im = `${l}.im ${op} ${r}.im`;
+		} else {
+			const helper = op === "*" ? "cmul" : "cdiv";
+			this.useHelper(helper);
+			call = `__${helper}(${l}, ${r})`;
 		}
+		if (!is64) return call ?? `{ re: ${re}, im: ${im} }`;
+		if (call)
+			return `((__z) => ({ re: Math.fround(__z.re), im: Math.fround(__z.im) }))(${call})`;
+		return `{ re: Math.fround(${re}), im: Math.fround(${im}) }`;
 	},
 
 	_genBinaryExpr(expr) {
@@ -2821,6 +3319,9 @@ export const expressionGenMethods = {
 		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;
 
@@ -2833,12 +3334,85 @@ export const expressionGenMethods = {
 		const ptrCmp = this._genPointerEquality(expr);
 		if (ptrCmp !== null) return ptrCmp;
 
-		if (this.strict && this._needsStrictOp(expr.op, expr._type)) {
+		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(
@@ -2847,17 +3421,29 @@ 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
@@ -2872,7 +3458,7 @@ export const expressionGenMethods = {
 		if (!other) return null;
 		const t =
 			other._type?.kind === "named" ? other._type.underlying : other._type;
-		return t?.kind === "map" ? other : null;
+		return t?.kind === "map" || other._coreType?.kind === "map" ? other : null;
 	},
 
 	_genNilMapCompare(expr) {
@@ -2937,6 +3523,25 @@ 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") ||
@@ -2955,6 +3560,7 @@ 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 === "!=") {
@@ -2985,6 +3591,10 @@ 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,
@@ -2995,6 +3605,7 @@ export const expressionGenMethods = {
 		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})`;
 		}
@@ -3025,11 +3636,25 @@ export const expressionGenMethods = {
 		// `[]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(
@@ -3048,41 +3673,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":
@@ -3106,9 +3761,75 @@ export const expressionGenMethods = {
 		return STRICT_NUMERIC_TYPES.has(typeName);
 	},
 
+	_is64BitInt(t) {
+		return is64BitInt(t);
+	},
+
+	// Whether a value of type `t` can be a BigInt at run time: a 64-bit
+	// integer, or a type parameter whose type set holds one (`~int | ~int64`).
+	_mayBeBigInt(t) {
+		if (t?.kind !== "typeParam") return is64BitInt(t);
+		const terms = this.checker?._constraintTerms(t.constraint, new Set());
+		return terms?.some(is64BitInt) === true;
+	},
+
+	// `code` as a JS number for an index, slice bound or `make` size.
+	_asIndexNumber(code, t) {
+		return this._mayBeBigInt(t) ? `Number(${code})` : code;
+	},
+
+	// 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 === "%");
@@ -3116,7 +3837,14 @@ export const expressionGenMethods = {
 
 	// 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")
@@ -3124,7 +3852,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;
@@ -3137,21 +3865,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})`;
 		}
@@ -3171,7 +3918,7 @@ 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})`;
 			return `((${l} ${op} ${r}) ${cast})`;
@@ -3184,7 +3931,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})`;
@@ -3198,11 +3945,13 @@ 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.