gofront 1.6.1 → 1.8.0

package/src/backend/js/stdlib/json.js

@@ -0,0 +1,1167 @@
+// src/backend/js/stdlib/json.js
+// CodeGen for Go encoding/json package with compile-time static encoders and decoders.
+
+import { someChild } from "../../../lower/walk.js";
+import { typedArrayConstructorForElem } from "../../../typechecker/types.js";
+
+function safeIdent(name) {
+	return String(name || "").replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+
+function declareCodec(fnName, params, body) {
+	return `var ${fnName} = typeof ${fnName} !== "undefined" ? ${fnName} : function ${fnName}(${params}) {\n${body}\n};`;
+}
+
+function typeCodecName(t, fallback = "val") {
+	if (!t) return fallback;
+	if (t.kind === "pointer" && t.base) {
+		return `${typeCodecName(t.base, fallback)}_ptr`;
+	}
+	if (t.name) return t.name;
+	if (t.kind === "slice") return `slice_${typeCodecName(t.elem, "elem")}`;
+	if (t.kind === "map")
+		return `map_${typeCodecName(t.value ?? t.elem, "elem")}`;
+	return fallback;
+}
+
+function unwrapNamed(t) {
+	return t?.kind === "named" ? t.underlying : t;
+}
+
+function isRawMessageType(t) {
+	return (
+		t?.name === "json.RawMessage" || t?.name === "encoding/json.RawMessage"
+	);
+}
+
+const NUMBER_NAMES = new Set(["json.Number", "encoding/json.Number"]);
+
+function isNumberType(t) {
+	if (!t) return false;
+	const name = t.name ?? "";
+	if (NUMBER_NAMES.has(name)) return true;
+	if (name.startsWith("Number$$") || name.endsWith(".Number")) return true;
+	return (
+		t.kind === "named" && name === "Number" && unwrapNamed(t)?.name === "string"
+	);
+}
+
+function isByteSliceType(t) {
+	const base = unwrapNamed(t);
+	return (
+		base?.kind === "slice" &&
+		(base.elem?.name === "byte" || base.elem?.name === "uint8") &&
+		!isRawMessageType(t)
+	);
+}
+
+function isJsonNullAssignable(type) {
+	const base = unwrapNamed(type);
+	return (
+		base?.kind === "pointer" ||
+		base?.kind === "slice" ||
+		base?.kind === "map" ||
+		base?.kind === "interface" ||
+		(base?.kind === "basic" && base.name === "any")
+	);
+}
+
+// Field kinds the `,string` tag option applies to (Go: bool, ints, uints, floats, string).
+const QUOTABLE_KINDS = new Set([
+	"string",
+	"bool",
+	"int",
+	"int8",
+	"int16",
+	"int32",
+	"int64",
+	"uint",
+	"uint8",
+	"uint16",
+	"uint32",
+	"uint64",
+	"uintptr",
+	"byte",
+	"rune",
+	"float32",
+	"float64",
+]);
+
+// reflect's names for GoFront's basic aliases, used in decode error messages.
+const BASIC_DISPLAY = { any: "interface {}", byte: "uint8", rune: "int32" };
+
+// Unmarshal targets whose argument errors depend on the static type alone:
+// pointers can be nil, interfaces are judged by their dynamic value.
+// Only statically concrete non-pointer kinds are rejected up front; anything
+// else (type parameters, unknown kinds) is judged by its dynamic value.
+const TARGET_KIND = { pointer: "ptr" };
+const VALUE_TARGET_KINDS = new Set([
+	"slice",
+	"array",
+	"map",
+	"struct",
+	"func",
+	"chan",
+]);
+
+const COMPOSITE_KINDS = new Set(["slice", "array", "map"]);
+const COMPOSITE_DECODERS = {
+	slice: "_getSliceDecoder",
+	array: "_getArrayDecoder",
+	map: "_getMapDecoder",
+};
+
+// Basic kinds decoded by the typed scalar decoders.
+const SCALAR_KINDS = QUOTABLE_KINDS;
+
+// Methods live on the named type, or on its underlying struct for struct types.
+function lookupMethod(type, name) {
+	if (type?.kind !== "named") return null;
+	return type.methods?.get(name) ?? type.underlying?.methods?.get(name) ?? null;
+}
+
+export const jsonMethods = {
+	_genJson(fn, a, expr) {
+		this.useHelper("json");
+		this.useHelper("base64");
+		this.useHelper("error");
+		this._markJsonPtrRecvMarshalers();
+		const args = a();
+		if (fn === "Marshal") {
+			this._markJsonAnyEncoders();
+			const argType = expr.args[0]?._type;
+			const enc = this._getJsonEncoder(argType);
+			return `__json_marshal(${enc}, ${args[0]})`;
+		}
+		if (fn === "MarshalIndent") {
+			this._markJsonAnyEncoders();
+			const argType = expr.args[0]?._type;
+			const enc = this._getJsonEncoder(argType);
+			return `__json_marshal_indent(${enc}, ${args[0]}, ${args[1]}, ${args[2]})`;
+		}
+		if (fn === "Unmarshal") {
+			const targetType = expr.args[1]?._type;
+			const dec = this._getJsonDecoder(targetType);
+			return `__json_unmarshal(${dec}, ${args[0]}, ${args[1]}, ${this._jsonTargetArgs(targetType)})`;
+		}
+		if (fn === "Valid") {
+			return `__json_valid(${args[0]})`;
+		}
+		return undefined;
+	},
+
+	// Name and static kind of an Unmarshal/Decode target, for the argument
+	// errors Go reports from the type alone ("ptr", "val" or none for interfaces).
+	_jsonTargetArgs(targetType) {
+		const base = unwrapNamed(targetType);
+		const key = base?.kind === "basic" ? base.name : base?.kind;
+		if (!targetType || key === "nil") return '"", ""';
+		const isValue =
+			base?.kind === "basic" ? key !== "any" : VALUE_TARGET_KINDS.has(key);
+		const kind = TARGET_KIND[key] ?? (isValue ? "val" : "");
+		return `${JSON.stringify(this._jsonDisplayType(targetType))}, ${JSON.stringify(kind)}`;
+	},
+
+	_getJsonEncoder(type, addr = false) {
+		if (!type) return "__json_enc_any";
+		if (isNumberType(type)) return "__json_enc_number";
+		if (isRawMessageType(type)) {
+			const fnName = "__json_enc_RawMessage";
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(
+					fnName,
+					declareCodec(fnName, "v", `  return __json_enc_raw(v);`),
+				);
+			}
+			return fnName;
+		}
+
+		// Go calls a pointer-receiver MarshalJSON only on addressable values.
+		const marshaler = this._jsonMarshalerInfo(type);
+		if (marshaler && (!marshaler.ptrRecv || addr)) {
+			return this._getMarshalerEncoder(type, marshaler);
+		}
+
+		const base = unwrapNamed(type);
+		if (isByteSliceType(type)) return "__json_b64";
+
+		if (base?.kind === "struct") {
+			const needsAddr = addr && this._jsonNeedsAddr(type);
+			const typeName = safeIdent((type.name ?? "AnonStruct").split(".").pop());
+			const fnName = `__json_enc_${typeName}${needsAddr ? "_addr" : ""}`;
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(fnName, "");
+				const code = this._buildStructEncoder(type, fnName, needsAddr);
+				this._jsonCodecs.set(fnName, code);
+			}
+			return fnName;
+		}
+
+		if (type.kind === "pointer" && type.base) {
+			const innerEnc = this._getJsonEncoder(type.base, true);
+			// Pointers to structs are the struct object; other pointers are { value } boxes.
+			const deref = unwrapNamed(type.base)?.kind === "struct" ? "v" : "v.value";
+			const fnName = `__json_enc_ptr_${safeIdent(typeCodecName(type.base, "val").split(".").pop())}`;
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(
+					fnName,
+					declareCodec(
+						fnName,
+						"v",
+						`  return (v === null || v === undefined) ? "null" : ${innerEnc}(${deref});`,
+					),
+				);
+			}
+			return fnName;
+		}
+
+		if (base?.kind === "slice" || base?.kind === "array") {
+			const elemEnc = this._getJsonEncoder(base.elem, true);
+			const fnName = `__json_enc_slice_${safeIdent(typeCodecName(base.elem, "elem").split(".").pop())}`;
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(
+					fnName,
+					declareCodec(
+						fnName,
+						"v",
+						`  return __json_enc_slice(v, ${elemEnc});`,
+					),
+				);
+			}
+			return fnName;
+		}
+
+		if (base?.kind === "map") {
+			const valType = base.value ?? base.elem;
+			const valEnc = this._getJsonEncoder(valType, false);
+			const fnName = `__json_enc_map_${safeIdent(typeCodecName(valType, "val").split(".").pop())}`;
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(
+					fnName,
+					declareCodec(fnName, "v", `  return __json_enc_map(v, ${valEnc});`),
+				);
+			}
+			return fnName;
+		}
+
+		if (base?.kind === "basic") {
+			return this._getBasicEncoder(base.name);
+		}
+
+		return "__json_enc_any";
+	},
+
+	// Tags pointer-receiver MarshalJSON methods so the dynamic `any` encoder can skip
+	// them for non-addressable values, as Go does.
+	_markJsonPtrRecvMarshalers() {
+		if (this._jsonPtrRecvMarked) return;
+		this._jsonPtrRecvMarked = true;
+		for (const [name, type] of this.checker?.types ?? []) {
+			if (name.includes(".") || type?.kind !== "named") continue;
+			if (!lookupMethod(type, "MarshalJSON")?._ptrRecv) continue;
+			const cls = safeIdent(name);
+			this._jsonCodecs.set(
+				`__json_ptrrecv_${cls}`,
+				`if (typeof ${cls} === "function" && ${cls}.prototype.MarshalJSON) ${cls}.prototype.MarshalJSON.__ptrRecv = true;`,
+			);
+		}
+	},
+
+	// Structs reach the dynamic `any` encoder as bare instances, so each package
+	// struct without a MarshalJSON method gets a hidden hook that runs its static
+	// encoder (tags, omitempty, promoted fields) instead of listing its properties.
+	// A non-generic struct declared in this package that has no MarshalJSON.
+	_isPlainPackageStruct(name, type) {
+		const isStruct =
+			type?.kind === "named" && type.underlying?.kind === "struct";
+		const generic = type?.typeArgs?.length || type?._genericOf;
+		if (!isStruct || generic || /[.$[]/.test(name) || type.name !== name)
+			return false;
+		return !this._jsonMarshalerInfo(type) && this.structNames?.has(name);
+	},
+
+	_markJsonAnyEncoders() {
+		this._jsonAnyMarked = true;
+	},
+
+	_isJsonEncoderName(recvName) {
+		return (
+			recvName === "json.Encoder" ||
+			recvName === "encoding/json.Encoder" ||
+			recvName?.startsWith("Encoder$$")
+		);
+	},
+
+	// True when `node` contains a call that marks the any-encoders when
+	// generated (`json.Marshal`, `json.MarshalIndent`, `Encoder.Encode`).
+	// Decided before any body is generated, so a function-local struct can get
+	// its hook right after its class even when the call comes later.
+	_usesJsonAnyMarshal(node) {
+		if (Array.isArray(node))
+			return node.some((n) => this._usesJsonAnyMarshal(n));
+		if (!node || typeof node !== "object") return false;
+		if (node.kind === "CallExpr" && node.func?.kind === "SelectorExpr") {
+			const { expr, field } = node.func;
+			if (
+				expr?.kind === "Ident" &&
+				expr.name === "json" &&
+				(field === "Marshal" || field === "MarshalIndent")
+			)
+				return true;
+			if (
+				field === "Encode" &&
+				this._isJsonEncoderName(this._resolveRecvName(expr?._type))
+			)
+				return true;
+		}
+		return someChild(node, (n) => this._usesJsonAnyMarshal(n));
+	},
+
+	_jsonAnyHook(cls, enc) {
+		return `Object.defineProperty(${cls}.prototype, "__json_enc", { value: function() { return ${enc}(this); }, configurable: true, writable: true });`;
+	},
+
+	// Runs once all function bodies are generated; package-level structs get
+	// their hook at top level (function-local ones get it in _noteLocalTypeDecl).
+	_emitJsonAnyHooks() {
+		if (!this._jsonAnyMarked || this._jsonAnyHooked) return;
+		this._jsonAnyHooked = true;
+		const local = this._localTypeNames;
+		for (const [name, type] of this.checker?.types ?? []) {
+			if (local.has(name) || !this._isPlainPackageStruct(name, type)) continue;
+			const cls = safeIdent(name);
+			this._jsonCodecs.set(
+				`__json_anyenc_${cls}`,
+				this._jsonAnyHook(cls, this._getJsonEncoder(type, false)),
+			);
+		}
+	},
+
+	// A function-local struct class is only in scope inside its function, so
+	// its hook goes right after the class, and only when the program marshals.
+	_noteLocalTypeDecl(stmt) {
+		this._localTypeNames.add(stmt.name);
+		if (!this._jsonAnyUsed || stmt.type.kind !== "StructType") return;
+		const type = this.checker?.types.get(stmt.name);
+		if (!this._isPlainPackageStruct(stmt.name, type)) return;
+		const enc = this._getJsonEncoder(type, false);
+		this.line(this._jsonAnyHook(safeIdent(stmt.name), enc));
+	},
+
+	_jsonTypeName(type) {
+		const name = type?.name ?? "value";
+		const at = name.indexOf("$$");
+		if (at >= 0) {
+			const orig = name.slice(0, at);
+			const modPath = name.slice(at + 2).replaceAll("$", "/");
+			return `${modPath}.${orig}`;
+		}
+		if (name.includes(".")) return name;
+		const pkg = this.checker?.pkgName;
+		return pkg ? `${pkg}.${name}` : name;
+	},
+
+	_jsonClassName(type) {
+		return String(type?.name ?? "Object")
+			.split(".")
+			.pop();
+	},
+
+	// How to call `name` (MarshalJSON / UnmarshalJSON) on values of `type`, or null.
+	// Struct types dispatch on the instance; named non-struct types (raw values)
+	// call the static `T.$name(recv, ...)` with a { value } box for pointer receivers.
+	_jsonMethodInfo(type, name) {
+		const method = lookupMethod(type, name);
+		if (!method || isRawMessageType(type)) return null;
+		const isStruct = type.underlying?.kind === "struct";
+		if (!isStruct && !this._namedBoxInfo(type)) return null;
+		return {
+			ptrRecv: Boolean(method._ptrRecv),
+			isStruct,
+			cls: this._jsonClassName(type),
+		};
+	},
+
+	_jsonMarshalerInfo(type) {
+		return this._jsonMethodInfo(type, "MarshalJSON");
+	},
+
+	_jsonUnmarshalerInfo(type) {
+		return this._jsonMethodInfo(type, "UnmarshalJSON");
+	},
+
+	// UnmarshalJSON call for a target reachable through `addrExpr`: the struct
+	// instance for struct types, a { value } box otherwise.
+	_jsonUnmarshalCall(info, addrExpr, bytesExpr) {
+		if (info.isStruct) return `${addrExpr}.UnmarshalJSON(${bytesExpr})`;
+		const recv = info.ptrRecv ? addrExpr : `${addrExpr}.value`;
+		return `${info.cls}.$UnmarshalJSON(${recv}, ${bytesExpr})`;
+	},
+
+	// True when encoding an addressable `type` differs from a non-addressable one,
+	// i.e. it (or a value field inside it) has a pointer-receiver MarshalJSON.
+	_jsonNeedsAddr(type, seen = new Set()) {
+		if (!type || seen.has(type)) return false;
+		seen.add(type);
+		const marshaler = this._jsonMarshalerInfo(type);
+		if (marshaler) return marshaler.ptrRecv;
+		const base = unwrapNamed(type);
+		if (base?.kind !== "struct") return false;
+		const fields = this.checker?.resolveJsonFields(base) ?? [];
+		return fields.some((f) => this._jsonNeedsAddr(f.type, seen));
+	},
+
+	_getMarshalerEncoder(type, info) {
+		const fnName = `__json_enc_${safeIdent(info.cls)}_marshal`;
+		if (!this._jsonCodecs.has(fnName)) {
+			let call;
+			if (info.isStruct) {
+				call = `  if (v === null || v === undefined) return "null";\n  var res = v.MarshalJSON();`;
+			} else {
+				const recv = info.ptrRecv ? "{ value: v }" : "v";
+				call = `  var res = ${info.cls}.$MarshalJSON(${recv});`;
+			}
+			this._jsonCodecs.set(
+				fnName,
+				declareCodec(
+					fnName,
+					"v",
+					`${call}\n  return __json_marshaler_out(res, ${JSON.stringify(this._jsonTypeName(type))});`,
+				),
+			);
+		}
+		return fnName;
+	},
+
+	_getUnmarshalerDecoder(type) {
+		const info = this._jsonUnmarshalerInfo(type);
+		const fnName = `__json_dec_${safeIdent(info.cls)}_unmarshal`;
+		if (!this._jsonCodecs.has(fnName)) {
+			const bytes =
+				"__json_raw_bytes(rawStr !== undefined ? rawStr : JSON.stringify(parsed))";
+			const body = info.isStruct
+				? `  var inst = target && typeof target === "object" ? target : new ${info.cls}();\n  var err = ${this._jsonUnmarshalCall(info, "inst", bytes)};\n  if (err) return __json_user_err(err);\n  if (box) box.value = inst;\n  return null;`
+				: `  var addr = box || { value: target };\n  var err = ${this._jsonUnmarshalCall(info, "addr", bytes)};\n  if (err) return __json_user_err(err);\n  return null;`;
+			this._jsonCodecs.set(
+				fnName,
+				declareCodec(fnName, "parsed, target, box, rawData, rawStr", body),
+			);
+		}
+		return fnName;
+	},
+
+	_unmarshalerElemDecoder(elemType) {
+		const isPtr = elemType?.kind === "pointer";
+		const valueType = isPtr ? elemType.base : elemType;
+		const info = this._jsonUnmarshalerInfo(valueType);
+		if (!info) return null;
+		let make;
+		if (info.isStruct) {
+			make = (rawExpr) =>
+				`(() => { var inst = new ${info.cls}(); var uerr = ${this._jsonUnmarshalCall(info, "inst", `__json_raw_bytes(${rawExpr})`)}; return uerr ? __json_user_err(uerr) : inst; })()`;
+		} else {
+			// Pointer elements are the { value } box itself; value elements its value.
+			const zero = this.zeroValueForType(valueType);
+			const result = isPtr ? "__b" : "__b.value";
+			make = (rawExpr) =>
+				`(() => { var __b = { value: ${zero} }; var uerr = ${this._jsonUnmarshalCall(info, "__b", `__json_raw_bytes(${rawExpr})`)}; return uerr ? __json_user_err(uerr) : ${result}; })()`;
+		}
+		if (isPtr)
+			return (v, rawExpr) => `(${v} === null ? null : ${make(rawExpr)})`;
+		return (_v, rawExpr) => make(rawExpr);
+	},
+
+	// Returns the basic kind a `,string` field is quoted as, or null if the option does not apply.
+	_jsonQuotedKind(f) {
+		if (!f.quoted) return null;
+		const t = f.type?.kind === "pointer" ? f.type.base : f.type;
+		if (this._jsonMarshalerInfo(t)) return null;
+		const base = unwrapNamed(t);
+		return base?.kind === "basic" && QUOTABLE_KINDS.has(base.name)
+			? base.name
+			: null;
+	},
+
+	_genQuotedFieldEncoderExpr(f, kind) {
+		const isPtr = f.type?.kind === "pointer";
+		const basic = this._genBasicFieldExpr(kind);
+		const quote = (x) => {
+			const inner = basic(x);
+			return kind === "string"
+				? `__json_esc_noh(${inner})`
+				: `('"' + ${inner} + '"')`;
+		};
+		if (!isPtr) return quote;
+		return (v) =>
+			`(${v} === null || ${v} === undefined ? "null" : ${quote(`${v}.value`)})`;
+	},
+
+	_getBasicEncoder(basicName) {
+		switch (basicName) {
+			case "string":
+				return "__json_esc";
+			case "bool":
+				return "(v => v ? 'true' : 'false')";
+			case "int":
+			case "int8":
+			case "int16":
+			case "int32":
+			case "uint":
+			case "uint8":
+			case "uint16":
+			case "uint32":
+			case "byte":
+			case "rune":
+				return "(v => String(Math.trunc(v)))";
+			case "int64":
+			case "uint64":
+				return "(v => typeof v === 'bigint' ? v.toString() : String(v))";
+			case "float32":
+				return "__json_float32";
+			case "float64":
+				return "__json_float64";
+			default:
+				return "__json_enc_any";
+		}
+	},
+
+	_buildStructEncoder(structType, fnName, addr = false) {
+		const underlying = unwrapNamed(structType);
+		const fields = this.checker?.resolveJsonFields(underlying) ?? [];
+		const lines = [];
+		lines.push(
+			`var ${fnName} = typeof ${fnName} !== "undefined" ? ${fnName} : function ${fnName}(v) {`,
+		);
+		lines.push(`  if (v === null || v === undefined) return "null";`);
+		lines.push(`  var parts = [];`);
+
+		for (const f of fields) {
+			const keyLiteral = JSON.stringify(`${JSON.stringify(f.jsonKey)}:`);
+			const encodeVal = this._genFieldEncoderExpr(f, addr);
+			const isStruct = unwrapNamed(f.type)?.kind === "struct";
+			const isMap = unwrapNamed(f.type)?.kind === "map";
+
+			this._emitFieldEncoderAccess(f, lines, (valName) => {
+				const encoded = encodeVal(valName);
+				if (f.omitempty) {
+					return `if (!__json_is_zero(${valName}, ${isStruct}, ${isMap})) parts.push(${keyLiteral} + ${encoded});`;
+				}
+				return `parts.push(${keyLiteral} + ${encoded});`;
+			});
+		}
+
+		lines.push(`  return "{" + parts.join(",") + "}";`);
+		lines.push(`};`);
+		return lines.join("\n");
+	},
+
+	_emitFieldEncoderAccess(f, lines, onVal) {
+		const path = f.path ?? [{ name: f.goName, isPtr: false }];
+		if (f.isEmbedded && f.tagged) {
+			lines.push(
+				`  { var val = (v.${f.goName} !== undefined ? v.${f.goName} : v); ${onVal("val")} }`,
+			);
+			return;
+		}
+		if (path.length === 1) {
+			lines.push(`  { var val = v.${path[0].name}; ${onVal("val")} }`);
+			return;
+		}
+
+		// Promoted fields from embedded struct
+		const ptrSegs = path.slice(0, -1).filter((s) => s.isPtr);
+		const nilChecks = ptrSegs.map((s) => `v.${s.name} === null`);
+
+		let cur = "v";
+		const conds = [];
+		for (let i = 0; i < path.length - 1; i++) {
+			const seg = path[i];
+			conds.push(`${cur}.${seg.name} != null`);
+			cur = `${cur}.${seg.name}`;
+		}
+		const leaf = `${cur}.${path[path.length - 1].name}`;
+
+		if (nilChecks.length > 0) {
+			lines.push(`  if (!(${nilChecks.join(" || ")})) {`);
+			lines.push(
+				`    var val = (${conds.join(" && ")} ? ${leaf} : v.${f.goName});`,
+			);
+			lines.push(`    if (val !== undefined) { ${onVal("val")} }`);
+			lines.push(`  }`);
+		} else {
+			lines.push(
+				`  { var val = (${conds.join(" && ")} ? ${leaf} : v.${f.goName}); if (val !== undefined) { ${onVal("val")} } }`,
+			);
+		}
+	},
+
+	_genFieldEncoderExpr(f, addr = false) {
+		const quotedKind = this._jsonQuotedKind(f);
+		if (quotedKind) return this._genQuotedFieldEncoderExpr(f, quotedKind);
+		if (isNumberType(f.type)) return (v) => `__json_enc_number(${v})`;
+		if (isRawMessageType(f.type)) {
+			return (v) => `__json_enc_raw(${v})`;
+		}
+		// Marshalers and pointers go through the shared encoders.
+		const special =
+			f.type?.kind === "pointer" ||
+			(f.type?.kind === "named" && this._jsonMarshalerInfo(f.type));
+		if (special) {
+			const enc = this._getJsonEncoder(f.type, addr);
+			return (v) => `${enc}(${v})`;
+		}
+		if (isByteSliceType(f.type)) {
+			return (v) => `__json_b64(${v})`;
+		}
+		const base = unwrapNamed(f.type);
+		if (base?.kind === "basic") {
+			return this._genBasicFieldExpr(base.name);
+		}
+		if (base?.kind === "struct") {
+			const enc = this._getJsonEncoder(f.type, addr);
+			return (v) => `${enc}(${v})`;
+		}
+		if (base?.kind === "slice" || base?.kind === "array") {
+			const enc = this._getJsonEncoder(base.elem, true);
+			return (v) => `__json_enc_slice(${v}, ${enc})`;
+		}
+		if (base?.kind === "map") {
+			const enc = this._getJsonEncoder(base.value ?? base.elem, false);
+			return (v) => `__json_enc_map(${v}, ${enc})`;
+		}
+		return (v) => `__json_enc_any(${v})`;
+	},
+
+	_genBasicFieldExpr(name) {
+		switch (name) {
+			case "string":
+				return (v) => `__json_esc(${v})`;
+			case "bool":
+				return (v) => `(${v} ? "true" : "false")`;
+			case "int":
+			case "int8":
+			case "int16":
+			case "int32":
+			case "uint":
+			case "uint8":
+			case "uint16":
+			case "uint32":
+			case "byte":
+			case "rune":
+				return (v) => `String(Math.trunc(${v}))`;
+			case "int64":
+			case "uint64":
+				return (v) =>
+					`(typeof ${v} === "bigint" ? ${v}.toString() : String(${v}))`;
+			case "float32":
+				return (v) => `__json_float32(${v})`;
+			case "float64":
+				return (v) => `__json_float64(${v})`;
+			default:
+				return (v) => `__json_enc_any(${v})`;
+		}
+	},
+
+	_getJsonDecoder(targetType) {
+		if (!targetType) return "__json_dec_any_target";
+		const baseType =
+			targetType.kind === "pointer" ? targetType.base : targetType;
+		if (!baseType) return "__json_dec_any_target";
+
+		if (isNumberType(baseType)) {
+			return "__json_dec_number";
+		}
+
+		if (this._jsonUnmarshalerInfo(baseType)) {
+			return this._getUnmarshalerDecoder(baseType);
+		}
+
+		if (isRawMessageType(baseType)) {
+			const fnName = "__json_dec_RawMessage";
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(
+					fnName,
+					declareCodec(
+						fnName,
+						"parsed, target, box, rawData",
+						`  var u8 = rawData instanceof Uint8Array ? rawData : new Uint8Array(rawData);\n  u8.__raw = true;\n  if (box) box.value = u8;\n  return null;`,
+					),
+				);
+			}
+			return fnName;
+		}
+
+		if (isByteSliceType(baseType)) {
+			const fnName = "__json_dec_byte_slice";
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(
+					fnName,
+					declareCodec(
+						fnName,
+						"parsed, target, box",
+						`  if (parsed === null) { if (box) box.value = null; return null; }\n  var u8 = __json_bytes_decode(parsed);\n  if (u8 && u8._msg) return u8;\n  if (box) box.value = u8;\n  return null;`,
+					),
+				);
+			}
+			return fnName;
+		}
+
+		const base = unwrapNamed(baseType);
+		if (base?.kind === "struct") {
+			const typeName = safeIdent(
+				(baseType.name ?? "AnonStruct").split(".").pop(),
+			);
+			const fnName = `__json_dec_${typeName}`;
+			if (!this._jsonCodecs.has(fnName)) {
+				this._jsonCodecs.set(fnName, "");
+				const code = this._buildStructDecoder(baseType, fnName);
+				this._jsonCodecs.set(fnName, code);
+			}
+			return fnName;
+		}
+
+		const composite = COMPOSITE_DECODERS[base?.kind];
+		if (composite) return this[composite](base);
+		// Top-level scalar targets (`json.Unmarshal(b, &n)`) are type-checked too.
+		if (base?.kind === "basic" && SCALAR_KINDS.has(base.name))
+			return this._getScalarDecoder(baseType, base);
+
+		return "__json_dec_any_target";
+	},
+
+	_getSliceDecoder(base) {
+		const elemTypeName = typeCodecName(base.elem, "elem");
+		const fnName = `__json_dec_slice_${safeIdent(elemTypeName.split(".").pop())}`;
+		if (!this._jsonCodecs.has(fnName)) {
+			const elemDec = this._genElemDecoder(base.elem);
+			const typedCtor = typedArrayConstructorForElem(base.elem);
+			const initOut = typedCtor ? `new ${typedCtor}(parsed.length)` : `[]`;
+			const setElem = typedCtor ? `out[i] = item;` : `out.push(item);`;
+			const display = JSON.stringify(`[]${this._jsonDisplayType(base.elem)}`);
+			this._jsonCodecs.set(
+				fnName,
+				declareCodec(
+					fnName,
+					"parsed, target, box",
+					`  if (parsed === null) { if (box) box.value = null; return null; }\n  if (!Array.isArray(parsed)) return __json_err("cannot unmarshal " + __json_type(parsed) + " into " + __json_ctx(${display}));\n  var out = ${initOut};\n  for (var i = 0; i < parsed.length; i++) {\n    var item = ${elemDec("parsed[i]", "__json_raw_child(parsed, i)")};\n    if (item && item._msg) return item;\n    ${setElem}\n  }\n  if (box) box.value = out;\n  return null;`,
+				),
+			);
+		}
+		return fnName;
+	},
+
+	// Arrays decode into a fresh array of the fixed length: surplus JSON elements
+	// are dropped and missing ones are zero. JSON null leaves the array alone.
+	_getArrayDecoder(base) {
+		const elemTypeName = typeCodecName(base.elem, "elem");
+		const fnName = `__json_dec_array${base.size}_${safeIdent(elemTypeName.split(".").pop())}`;
+		if (!this._jsonCodecs.has(fnName)) {
+			this._jsonCodecs.set(
+				fnName,
+				declareCodec(
+					fnName,
+					"parsed, target, box",
+					this._arrayDecoderBody(base),
+				),
+			);
+		}
+		return fnName;
+	},
+
+	_arrayDecoderBody(base) {
+		const elemDec = this._genElemDecoder(base.elem);
+		const typedCtor = typedArrayConstructorForElem(base.elem);
+		const display = JSON.stringify(this._jsonDisplayType(base));
+		const init = `new ${typedCtor ?? "Array"}(${base.size})`;
+		// Typed arrays start zeroed; plain arrays need their zero values filled in.
+		const zero = this.zeroValueForType(base.elem);
+		const fill = typedCtor
+			? ""
+			: `\n  for (var z = parsed.length; z < ${base.size}; z++) out[z] = ${zero};`;
+		return `  if (parsed === null) return null;\n  if (!Array.isArray(parsed)) return __json_err("cannot unmarshal " + __json_type(parsed) + " into " + __json_ctx(${display}));\n  var out = ${init};\n  for (var i = 0; i < parsed.length && i < ${base.size}; i++) {\n    var item = ${elemDec("parsed[i]", "__json_raw_child(parsed, i)")};\n    if (item && item._msg) return item;\n    out[i] = item;\n  }${fill}\n  if (box) box.value = out;\n  return null;`;
+	},
+
+	_getMapDecoder(base) {
+		const valType = base.value ?? base.elem;
+		const valTypeName = typeCodecName(valType, "val");
+		const fnName = `__json_dec_map_${safeIdent(valTypeName.split(".").pop())}`;
+		if (!this._jsonCodecs.has(fnName)) {
+			const valDec = this._genElemDecoder(valType);
+			const display = JSON.stringify(
+				`map[string]${this._jsonDisplayType(valType)}`,
+			);
+			this._jsonCodecs.set(
+				fnName,
+				declareCodec(
+					fnName,
+					"parsed, target, box",
+					`  if (parsed === null) { if (box) box.value = null; return null; }\n  if (typeof parsed !== "object" || Array.isArray(parsed)) return __json_err("cannot unmarshal " + __json_type(parsed) + " into " + __json_ctx(${display}));\n  var out = __json_newmap();\n  for (var k in parsed) {\n    if (Object.prototype.hasOwnProperty.call(parsed, k)) {\n      var item = ${valDec("parsed[k]", "__json_raw_child(parsed, k)")};\n      if (item && item._msg) return item;\n      out[k] = item;\n    }\n  }\n  if (box) box.value = out;\n  return null;`,
+				),
+			);
+		}
+		return fnName;
+	},
+
+	_getScalarDecoder(baseType, base) {
+		const display = this._jsonDisplayType(baseType);
+		const fnName = `__json_dec_scalar_${safeIdent(display)}`;
+		if (!this._jsonCodecs.has(fnName)) {
+			this._jsonCodecs.set(
+				fnName,
+				declareCodec(
+					fnName,
+					"parsed, target, box, rawData, rawStr",
+					`  if (parsed === null) return null;\n  var dv = ${this._jsonScalarDecodeExpr(base.name, display, "parsed", "rawStr")};\n  if (dv && dv._msg) return dv;\n  if (box) box.value = dv;\n  return null;`,
+				),
+			);
+		}
+		return fnName;
+	},
+
+	// Go-style display of a type in decode error messages (reflect's Type.String()).
+	_jsonDisplayType(t) {
+		const show = (x) => this._jsonDisplayType(x);
+		const byKind = {
+			pointer: () => `*${show(t.base)}`,
+			named: () => this._jsonTypeName(t),
+			basic: () => BASIC_DISPLAY[t.name] ?? t.name,
+			slice: () => `[]${show(t.elem)}`,
+			array: () => `[${t.size}]${show(t.elem)}`,
+			map: () => `map[${show(t.key)}]${show(t.value ?? t.elem)}`,
+		};
+		return byKind[t?.kind]?.() ?? "interface {}";
+	},
+
+	// Decodes one parsed JSON scalar into `kind`; yields the value or an error (`_msg`).
+	_jsonScalarDecodeExpr(kind, display, v, rawExpr) {
+		const d = JSON.stringify(display);
+		const raw = rawExpr ?? "undefined";
+		switch (kind) {
+			case "string":
+				return `(typeof ${v} === "string" && !${v}.endsWith("__bigint") ? ${v} : __json_err("cannot unmarshal " + __json_type(${v}) + " into " + __json_ctx(${d})))`;
+			case "bool":
+				return `(typeof ${v} === "boolean" ? ${v} : __json_err("cannot unmarshal " + __json_type(${v}) + " into " + __json_ctx(${d})))`;
+			case "float32":
+				return `__json_float_decode(${v}, 32, ${d}, ${raw})`;
+			case "float64":
+				return `__json_float_decode(${v}, 64, ${d}, ${raw})`;
+			default:
+				return `__json_int_decode(${v}, ${JSON.stringify(kind)}, ${d}, ${raw})`;
+		}
+	},
+
+	_genElemDecoder(elemType) {
+		if (!elemType) return (v) => `__json_dec_any(${v})`;
+		if (isNumberType(elemType))
+			return (v, rawExpr) =>
+				`__json_number_decode(${v}, "json.Number", ${rawExpr})`;
+		const unmarshaler = this._unmarshalerElemDecoder(elemType);
+		if (unmarshaler) return unmarshaler;
+		if (isRawMessageType(elemType)) {
+			return (_v, rawExpr) => `__json_raw_bytes(${rawExpr})`;
+		}
+		if (isByteSliceType(elemType)) {
+			return (v) => `(${v} === null ? null : __json_bytes_decode(${v}))`;
+		}
+		const base = unwrapNamed(elemType);
+		if (base?.kind === "basic" && SCALAR_KINDS.has(base.name)) {
+			const display = this._jsonDisplayType(elemType);
+			return (v, rawExpr) =>
+				this._jsonScalarDecodeExpr(base.name, display, v, rawExpr);
+		}
+		const ptrElem = this._pointerElemDecoder(elemType);
+		if (ptrElem) return ptrElem;
+		if (base?.kind === "struct") {
+			const dec = this._getJsonDecoder(elemType);
+			const structName = elemType.name?.split(".").pop() ?? "Object";
+			return (v) =>
+				`(() => { var inst = new ${structName}(); var err = ${dec}(${v}, inst); return err || inst; })()`;
+		}
+		return this._compositeElemDecoder(elemType, base);
+	},
+
+	// `*Struct` and `*scalar` elements; null stays nil.
+	_pointerElemDecoder(elemType) {
+		if (elemType?.kind !== "pointer" || !elemType.base) return null;
+		const innerBase = unwrapNamed(elemType.base);
+		if (innerBase?.kind === "struct") {
+			const dec = this._getJsonDecoder(elemType.base);
+			const structName = elemType.base.name?.split(".").pop() ?? "Object";
+			return (v) =>
+				`(${v} === null ? null : (() => { var inst = new ${structName}(); var err = ${dec}(${v}, inst); return err || inst; })())`;
+		}
+		if (innerBase?.kind !== "basic") return null;
+		const basicDec = this._genElemDecoder(elemType.base);
+		return (v, rawExpr) =>
+			`(${v} === null ? null : (() => { var item = ${basicDec(v, rawExpr)}; return item && item._msg ? item : { value: item, __p: true }; })())`;
+	},
+
+	// Slices, arrays and maps decode through their own codec into a fresh box.
+	_compositeElemDecoder(elemType, base) {
+		if (!COMPOSITE_KINDS.has(base?.kind)) return (v) => `__json_dec_any(${v})`;
+		const dec = this._getJsonDecoder(elemType);
+		return (v) =>
+			`(() => { var b = { value: null }; var err = ${dec}(${v}, null, b); return err || b.value; })()`;
+	},
+
+	_buildStructDecoder(structType, fnName) {
+		const underlying = unwrapNamed(structType);
+		const fields = this.checker?.resolveJsonFields(underlying) ?? [];
+		const structName = structType.name?.split(".").pop() ?? "T";
+		const lines = [];
+		lines.push(
+			`var ${fnName} = typeof ${fnName} !== "undefined" ? ${fnName} : function ${fnName}(parsed, target, box) {`,
+		);
+		lines.push(
+			`  if (parsed === null) { if (box) box.value = null; return null; }`,
+		);
+		lines.push(`  if (typeof parsed !== "object" || Array.isArray(parsed)) {`);
+		lines.push(
+			`    return __json_err("cannot unmarshal " + __json_type(parsed) + " into " + __json_ctx(${JSON.stringify(this._jsonDisplayType(structType))}));`,
+		);
+		lines.push(`  }`);
+		const knownKeys = fields.flatMap((f) => [f.jsonKey, f.goName]);
+		lines.push(
+			`  var disallowErr = __json_check_unknown(parsed, ${JSON.stringify(knownKeys)});`,
+		);
+		lines.push(`  if (disallowErr) return disallowErr;`);
+		// Go reports errors as "Go struct field <innermost struct>.<json key path>".
+		lines.push(`  __json_structs.push(${JSON.stringify(structName)});`);
+		lines.push(`  try {`);
+
+		for (const f of fields) {
+			const key = JSON.stringify(f.jsonKey);
+			const goName = JSON.stringify(f.goName);
+			lines.push(
+				`  { var fieldKey = __json_match_field(parsed, ${key}, ${goName}); if (fieldKey !== null) {`,
+			);
+			lines.push(`    __json_path.push(${key});`);
+			lines.push(`    try {`);
+			lines.push(`    var val = parsed[fieldKey];`);
+			lines.push(`    var raw = __json_raw_child(parsed, fieldKey);`);
+			lines.push(
+				`    __json_current_offset = __json_raw_end(parsed, fieldKey) || 0;`,
+			);
+			const quotedKind = this._jsonQuotedKind(f);
+			if (quotedKind) {
+				const valueType = f.type?.kind === "pointer" ? f.type.base : f.type;
+				const typeStr = this._jsonDisplayType(valueType);
+				lines.push(
+					`    var q = __json_unquote(val, ${JSON.stringify(quotedKind)}, ${JSON.stringify(typeStr)}); if (q && q._msg) return q; val = q.v; raw = q.lit;`,
+				);
+			}
+			lines.push(`    if (val !== null) {`);
+			this._emitFieldDecoder(f, structName, lines, "raw");
+			lines.push(`    } else {`);
+			this._emitFieldNull(f, lines, "raw");
+			lines.push(`    }`);
+			lines.push(`    } finally { __json_path.pop(); }`);
+			lines.push(`  }`);
+			lines.push(`  }`);
+		}
+
+		lines.push(`  } finally { __json_structs.pop(); }`);
+		lines.push(`  return null;`);
+		lines.push(`};`);
+		return lines.join("\n");
+	},
+
+	_emitUnmarshalerField(f, lines, rawExpr) {
+		const isPtr = f.type?.kind === "pointer";
+		const valueType = isPtr ? f.type.base : f.type;
+		const info = this._jsonUnmarshalerInfo(valueType);
+		const bytes = `__json_raw_bytes(${rawExpr})`;
+		if (info.isStruct) {
+			lines.push(`      var sub = target.${f.goName};`);
+			lines.push(
+				`      if (!sub) { sub = new ${info.cls}(); target.${f.goName} = sub; }`,
+			);
+			lines.push(
+				`      var uerr = ${this._jsonUnmarshalCall(info, "sub", bytes)};`,
+			);
+		} else if (isPtr) {
+			lines.push(`      var sub = target.${f.goName};`);
+			lines.push(
+				`      if (!sub) { sub = { value: ${this.zeroValueForType(valueType)} }; target.${f.goName} = sub; }`,
+			);
+			lines.push(
+				`      var uerr = ${this._jsonUnmarshalCall(info, "sub", bytes)};`,
+			);
+		} else {
+			lines.push(
+				`      var addr = { get value() { return target.${f.goName}; }, set value(__v) { target.${f.goName} = __v; } };`,
+			);
+			lines.push(
+				`      var uerr = ${this._jsonUnmarshalCall(info, "addr", bytes)};`,
+			);
+		}
+		lines.push(`      if (uerr) return __json_user_err(uerr);`);
+		if (f.isEmbedded && info.isStruct) {
+			lines.push(`      Object.assign(target, sub);`);
+		}
+	},
+
+	_emitNumberFieldDecoder(f, lines, rawExpr) {
+		lines.push(
+			`      var nv = __json_number_decode(val, "json.Number", ${rawExpr}); if (nv && nv._msg) return nv;`,
+		);
+		const val = f.type?.kind === "pointer" ? "{ value: nv }" : "nv";
+		this._emitAssign(f, val, lines);
+	},
+
+	_emitFieldDecoder(f, structName, lines, rawExpr) {
+		const valueType = f.type?.kind === "pointer" ? f.type.base : f.type;
+		if (this._jsonUnmarshalerInfo(valueType)) {
+			this._emitUnmarshalerField(f, lines, rawExpr);
+			return;
+		}
+		if (isNumberType(valueType)) {
+			this._emitNumberFieldDecoder(f, lines, rawExpr);
+			return;
+		}
+		if (isRawMessageType(f.type)) {
+			lines.push(
+				`      var rawBytes = __json_raw_bytes(${rawExpr}); rawBytes.__raw = true;`,
+			);
+			this._emitAssign(f, "rawBytes", lines);
+			return;
+		}
+		if (isByteSliceType(f.type)) {
+			lines.push(`      var u8v = __json_bytes_decode(val);`);
+			lines.push(`      if (u8v && u8v._msg) return u8v;`);
+			this._emitAssign(f, "u8v", lines);
+			return;
+		}
+
+		const base = unwrapNamed(f.type);
+		if (base?.kind === "basic") {
+			this._emitBasicFieldDecoder(f, base.name, structName, lines);
+			return;
+		}
+
+		if (f.type?.kind === "pointer" && f.type.base) {
+			const innerBase = unwrapNamed(f.type.base);
+			if (innerBase?.kind === "basic") {
+				this._emitPointerBasicFieldDecoder(
+					f,
+					innerBase.name,
+					structName,
+					lines,
+				);
+				return;
+			}
+			if (innerBase?.kind === "struct") {
+				const innerName = f.type.base.name?.split(".").pop() ?? "Object";
+				const dec = this._getJsonDecoder(f.type.base);
+				lines.push(`      var sub = target.${f.goName};`);
+				lines.push(
+					`      if (!sub) { sub = new ${innerName}(); target.${f.goName} = sub; }`,
+				);
+				lines.push(`      var err = ${dec}(val, sub);`);
+				lines.push(`      if (err) return err;`);
+				if (f.isEmbedded) {
+					lines.push(`      Object.assign(target, sub);`);
+				}
+				return;
+			}
+		}
+
+		if (base?.kind === "struct") {
+			const innerName = f.type.name?.split(".").pop() ?? "Object";
+			const dec = this._getJsonDecoder(f.type);
+			lines.push(`      var sub = target.${f.goName};`);
+			lines.push(
+				`      if (!sub) { sub = new ${innerName}(); target.${f.goName} = sub; }`,
+			);
+			lines.push(`      var err = ${dec}(val, sub);`);
+			lines.push(`      if (err) return err;`);
+			if (f.isEmbedded) {
+				lines.push(`      Object.assign(target, sub);`);
+			}
+			return;
+		}
+
+		if (COMPOSITE_KINDS.has(base?.kind)) {
+			const dec = this._getJsonDecoder(f.type);
+			lines.push(`      var box = { value: null };`);
+			lines.push(`      var err = ${dec}(val, null, box);`);
+			lines.push(`      if (err) return err;`);
+			this._emitAssign(f, "box.value", lines);
+			return;
+		}
+
+		this._emitAssign(f, "__json_dec_any(val)", lines);
+	},
+
+	// `*T` scalar fields: Go reports the element type in errors.
+	_emitPointerBasicFieldDecoder(f, basicName, _structName, lines) {
+		if (!SCALAR_KINDS.has(basicName)) {
+			this._emitAssign(f, "__json_dec_any(val)", lines);
+			return;
+		}
+		const display = this._jsonDisplayType(f.type.base);
+		lines.push(
+			`      var dv = ${this._jsonScalarDecodeExpr(basicName, display, "val", "raw")};`,
+		);
+		lines.push(`      if (dv && dv._msg) return dv;`);
+		this._emitAssign(f, "{ value: dv, __p: true }", lines);
+	},
+
+	_emitBasicFieldDecoder(f, basicName, _structName, lines) {
+		if (!SCALAR_KINDS.has(basicName)) {
+			this._emitAssign(f, "__json_dec_any(val)", lines);
+			return;
+		}
+		const display = this._jsonDisplayType(f.type);
+		lines.push(
+			`      var dv = ${this._jsonScalarDecodeExpr(basicName, display, "val", "raw")};`,
+		);
+		lines.push(`      if (dv && dv._msg) return dv;`);
+		this._emitAssign(f, "dv", lines);
+	},
+
+	_emitAssign(f, expr, lines) {
+		const path = f.path ?? [{ name: f.goName, isPtr: false }];
+		if (path.length === 1) {
+			lines.push(`      target.${f.goName} = ${expr};`);
+			return;
+		}
+
+		for (let i = 0; i < path.length - 1; i++) {
+			const seg = path[i];
+			const curPath = `target.${path
+				.slice(0, i + 1)
+				.map((p) => p.name)
+				.join(".")}`;
+			const ctor = seg.typeName || seg.name;
+			const initVal = ctor && ctor !== "Object" ? `new ${ctor}()` : `{}`;
+			lines.push(`      if (${curPath} == null) ${curPath} = ${initVal};`);
+		}
+		lines.push(`      target.${path.map((p) => p.name).join(".")} = ${expr};`);
+		lines.push(`      target.${f.goName} = ${expr};`);
+	},
+
+	_emitFieldNull(f, lines, rawExpr) {
+		// Go hands JSON null to UnmarshalJSON for non-pointer fields; nil pointers stay nil.
+		if (f.type?.kind !== "pointer" && this._jsonUnmarshalerInfo(f.type)) {
+			this._emitUnmarshalerField(f, lines, `"null"`);
+			return;
+		}
+		if (isRawMessageType(f.type)) {
+			lines.push(
+				`      var rawNull = __json_raw_bytes(${rawExpr}); rawNull.__raw = true;`,
+			);
+			this._emitAssign(f, "rawNull", lines);
+			return;
+		}
+		if (!isJsonNullAssignable(f.type)) return;
+		const path = f.path ?? [{ name: f.goName, isPtr: false }];
+		if (path.length === 1) {
+			lines.push(`      target.${f.goName} = null;`);
+			return;
+		}
+		lines.push(
+			`      target.${path.map((p) => p.name).join(".")} = null; target.${f.goName} = null;`,
+		);
+	},
+};