gofront 1.7.0 → 1.8.0

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

@@ -1,6 +1,7 @@
 // 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) {
@@ -33,6 +34,18 @@ function isRawMessageType(t) {
 	);
 }
 
+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 (
@@ -77,6 +90,27 @@ const QUOTABLE_KINDS = new Set([
 // 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;
 
@@ -94,11 +128,13 @@ export const jsonMethods = {
 		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]})`;
@@ -106,7 +142,7 @@ export const jsonMethods = {
 		if (fn === "Unmarshal") {
 			const targetType = expr.args[1]?._type;
 			const dec = this._getJsonDecoder(targetType);
-			return `__json_unmarshal(${dec}, ${args[0]}, ${args[1]})`;
+			return `__json_unmarshal(${dec}, ${args[0]}, ${args[1]}, ${this._jsonTargetArgs(targetType)})`;
 		}
 		if (fn === "Valid") {
 			return `__json_valid(${args[0]})`;
@@ -114,18 +150,27 @@ export const jsonMethods = {
 		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",
-						`  if (v === null || v === undefined) return "null";\n  var s = (typeof v === "string" ? v : new TextDecoder().decode(v)).trim();\n  return s.length > 0 ? s : "null";`,
-					),
+					declareCodec(fnName, "v", `  return __json_enc_raw(v);`),
 				);
 			}
 			return fnName;
@@ -170,7 +215,7 @@ export const jsonMethods = {
 			return fnName;
 		}
 
-		if (base?.kind === "slice") {
+		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)) {
@@ -222,8 +267,95 @@ export const jsonMethods = {
 		}
 	},
 
+	// 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;
@@ -387,7 +519,7 @@ export const jsonMethods = {
 			case "float32":
 				return "__json_float32";
 			case "float64":
-				return "(v => { if (!isFinite(v)) throw new Error('json: unsupported value: ' + v); return String(v); })";
+				return "__json_float64";
 			default:
 				return "__json_enc_any";
 		}
@@ -407,11 +539,12 @@ export const jsonMethods = {
 			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})) parts.push(${keyLiteral} + ${encoded});`;
+					return `if (!__json_is_zero(${valName}, ${isStruct}, ${isMap})) parts.push(${keyLiteral} + ${encoded});`;
 				}
 				return `parts.push(${keyLiteral} + ${encoded});`;
 			});
@@ -451,13 +584,13 @@ export const jsonMethods = {
 		if (nilChecks.length > 0) {
 			lines.push(`  if (!(${nilChecks.join(" || ")})) {`);
 			lines.push(
-				`    var val = (v.${f.goName} !== undefined ? v.${f.goName} : (${conds.join(" && ")} ? ${leaf} : undefined));`,
+				`    var val = (${conds.join(" && ")} ? ${leaf} : v.${f.goName});`,
 			);
 			lines.push(`    if (val !== undefined) { ${onVal("val")} }`);
 			lines.push(`  }`);
 		} else {
 			lines.push(
-				`  { var val = (v.${f.goName} !== undefined ? v.${f.goName} : (${conds.join(" && ")} ? ${leaf} : undefined)); if (val !== undefined) { ${onVal("val")} } }`,
+				`  { var val = (${conds.join(" && ")} ? ${leaf} : v.${f.goName}); if (val !== undefined) { ${onVal("val")} } }`,
 			);
 		}
 	},
@@ -465,9 +598,9 @@ export const jsonMethods = {
 	_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) =>
-				`((typeof ${v} === "string" ? ${v} : new TextDecoder().decode(${v})).trim() || "null")`;
+			return (v) => `__json_enc_raw(${v})`;
 		}
 		// Marshalers and pointers go through the shared encoders.
 		const special =
@@ -488,7 +621,7 @@ export const jsonMethods = {
 			const enc = this._getJsonEncoder(f.type, addr);
 			return (v) => `${enc}(${v})`;
 		}
-		if (base?.kind === "slice") {
+		if (base?.kind === "slice" || base?.kind === "array") {
 			const enc = this._getJsonEncoder(base.elem, true);
 			return (v) => `__json_enc_slice(${v}, ${enc})`;
 		}
@@ -523,8 +656,7 @@ export const jsonMethods = {
 			case "float32":
 				return (v) => `__json_float32(${v})`;
 			case "float64":
-				return (v) =>
-					`(!isFinite(${v}) ? (() => { throw new Error("json: unsupported value: " + ${v}); })() : String(${v}))`;
+				return (v) => `__json_float64(${v})`;
 			default:
 				return (v) => `__json_enc_any(${v})`;
 		}
@@ -536,6 +668,10 @@ export const jsonMethods = {
 			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);
 		}
@@ -584,8 +720,8 @@ export const jsonMethods = {
 			return fnName;
 		}
 
-		if (base?.kind === "slice") return this._getSliceDecoder(base);
-		if (base?.kind === "map") return this._getMapDecoder(base);
+		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);
@@ -614,6 +750,37 @@ export const jsonMethods = {
 		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");
@@ -628,7 +795,7 @@ export const jsonMethods = {
 				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 = Object.create(null); out.__map = true;\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;`,
+					`  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;`,
 				),
 			);
 		}
@@ -653,14 +820,16 @@ export const jsonMethods = {
 
 	// Go-style display of a type in decode error messages (reflect's Type.String()).
 	_jsonDisplayType(t) {
-		if (!t) return "interface {}";
-		if (t.kind === "pointer") return `*${this._jsonDisplayType(t.base)}`;
-		if (t.kind === "named") return this._jsonTypeName(t);
-		if (t.kind === "basic") return BASIC_DISPLAY[t.name] ?? t.name;
-		if (t.kind === "slice") return `[]${this._jsonDisplayType(t.elem)}`;
-		if (t.kind === "map")
-			return `map[${this._jsonDisplayType(t.key)}]${this._jsonDisplayType(t.value ?? t.elem)}`;
-		return "interface {}";
+		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`).
@@ -683,6 +852,9 @@ export const jsonMethods = {
 
 	_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)) {
@@ -697,27 +869,39 @@ export const jsonMethods = {
 			return (v, rawExpr) =>
 				this._jsonScalarDecodeExpr(base.name, display, v, rawExpr);
 		}
-		if (elemType?.kind === "pointer" && elemType.base) {
-			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") {
-				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 }; })())`;
-			}
-		}
+		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 (v) => `__json_dec_any(${v})`;
+		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) {
@@ -736,6 +920,11 @@ export const jsonMethods = {
 			`    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 {`);
@@ -750,6 +939,9 @@ export const jsonMethods = {
 			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;
@@ -809,12 +1001,24 @@ export const jsonMethods = {
 		}
 	},
 
+	_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;`,
@@ -877,16 +1081,7 @@ export const jsonMethods = {
 			return;
 		}
 
-		if (base?.kind === "slice") {
-			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;
-		}
-
-		if (base?.kind === "map") {
+		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);`);

package/src/backend/js/stdlib/maps.js

@@ -11,14 +11,6 @@ export const mapsMethods = {
 			return `__equal(${a1}, ${b1})`;
 		}
 		switch (fn) {
-			case "Keys": {
-				const [m] = a();
-				return `Object.keys(${m})`;
-			}
-			case "Values": {
-				const [m] = a();
-				return `Object.values(${m})`;
-			}
 			case "Clone": {
 				const [m] = a();
 				return `({...${m}})`;

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

@@ -9,8 +9,10 @@ const MATH1 = {
 	Sqrt: "sqrt",
 	Cbrt: "cbrt",
 	Log: "log",
+	Log1p: "log1p",
 	Log2: "log2",
 	Log10: "log10",
+	Expm1: "expm1",
 	Sin: "sin",
 	Cos: "cos",
 	Tan: "tan",
@@ -37,7 +39,7 @@ const MATH_EXTRA = {
 	Inf: ([x]) => `(${x} >= 0 ? Infinity : -Infinity)`,
 	IsNaN: ([x]) => `Number.isNaN(${x})`,
 	IsInf: ([x, y]) =>
-		`(${y} > 0 ? ${x} === Infinity : ${y} < 0 ? ${x} === -Infinity : !Number.isFinite(${x}))`,
+		`(${y} > 0 ? ${x} === Infinity : ${y} < 0 ? ${x} === -Infinity : Math.abs(${x}) === Infinity)`,
 	NaN: () => "NaN",
 	Exp2: ([x]) => `Math.pow(2, ${x})`,
 	Signbit: ([x]) => `(${x} < 0 || Object.is(${x}, -0))`,
@@ -46,6 +48,20 @@ const MATH_EXTRA = {
 	Dim: ([x, y]) => `Math.max(${x} - ${y}, 0)`,
 	Remainder: ([x, y]) =>
 		`((x, y) => { if (isNaN(x) || isNaN(y) || y === 0 || !isFinite(x)) return NaN; if (!isFinite(y)) return x; const q = x / y; const r = Math.round(q); const diff = Math.abs(q - r); const n = (diff === 0.5 && (r % 2 !== 0)) ? (r < q ? r + 1 : r - 1) : r; return x - n * y; })(${x}, ${y})`,
+	Frexp: ([x]) =>
+		`((f) => { if (f === 0 || !Number.isFinite(f)) return [f, 0]; const buf = new ArrayBuffer(8); const f64 = new Float64Array(buf); const u32 = new Uint32Array(buf); f64[0] = f; let hi = u32[1]; let exp = (hi >>> 20) & 0x7ff; if (exp === 0) { f64[0] = f * Math.pow(2, 54); hi = u32[1]; exp = ((hi >>> 20) & 0x7ff) - 54; } exp -= 1022; u32[1] = (hi & 0x800fffff) | 0x3fe00000; return [f64[0], exp]; })(${x})`,
+	Ldexp: ([frac, exp]) =>
+		`((frac, exp) => { if (frac === 0 || !Number.isFinite(frac)) return frac; if (exp > 1023) return frac < 0 ? -Infinity : Infinity; if (exp < -1074) return frac < 0 ? -0 : 0; if (exp >= -1022) return frac * Math.pow(2, exp); return frac * Math.pow(2, exp + 54) * Math.pow(2, -54); })(${frac}, ${exp})`,
+	Modf: ([f]) =>
+		`((x) => { if (Number.isNaN(x)) return [NaN, NaN]; if (!Number.isFinite(x)) return [x, NaN]; const i = Math.trunc(x); const frac = x === i ? (x < 0 || Object.is(x, -0) ? -0 : 0) : x - i; return [i, frac]; })(${f})`,
+	FMA: ([x, y, z]) =>
+		`((x, y, z) => { if (Number.isNaN(x) || Number.isNaN(y) || Number.isNaN(z)) return NaN; if ((x === 0 && !Number.isFinite(y)) || (y === 0 && !Number.isFinite(x))) return NaN; const p = x * y; if (!Number.isFinite(p) && !Number.isFinite(z) && ((p > 0 && z < 0) || (p < 0 && z > 0))) return NaN; return p + z; })(${x}, ${y}, ${z})`,
+	RoundToEven: ([x]) =>
+		`((x) => { if (x === 0 || !Number.isFinite(x)) return x; const t = Math.trunc(x); const f = Math.abs(x - t); if (f < 0.5) return Object.is(t, 0) && (x < 0 || Object.is(x, -0)) ? -0 : t; if (f > 0.5) return x > 0 ? t + 1 : t - 1; const res = t % 2 === 0 ? t : (x > 0 ? t + 1 : t - 1); return Object.is(res, 0) && (x < 0 || Object.is(x, -0)) ? -0 : res; })(${x})`,
+	Nextafter: ([x, y]) =>
+		`((x, y) => { if (Number.isNaN(x) || Number.isNaN(y)) return NaN; if (x === y) return x; if (x === 0) { const s = Number.MIN_VALUE; return y > 0 ? s : -s; } const buf = new ArrayBuffer(8); const f64 = new Float64Array(buf); const i64 = new BigInt64Array(buf); f64[0] = x; let b = i64[0]; if ((x > 0 && y > x) || (x < 0 && y > x)) b = b + (x > 0 ? 1n : -1n); else b = b + (x > 0 ? -1n : 1n); i64[0] = b; return f64[0]; })(${x}, ${y})`,
+	Nextafter32: ([x, y]) =>
+		`((x, y) => { if (Number.isNaN(x) || Number.isNaN(y)) return NaN; if (x === y) return x; if (x === 0) { const s = 1.401298464324817e-45; return y > 0 ? s : -s; } const buf = new ArrayBuffer(4); const f32 = new Float32Array(buf); const i32 = new Int32Array(buf); f32[0] = x; let b = i32[0]; if ((x > 0 && y > x) || (x < 0 && y > x)) b = b + (x > 0 ? 1 : -1); else b = b + (x > 0 ? -1 : 1); i32[0] = b; return f32[0]; })(${x}, ${y})`,
 	Float64bits: ([x]) =>
 		`((f) => { const b = new ArrayBuffer(8); new Float64Array(b)[0] = f; return Number(new BigUint64Array(b)[0]); })(${x})`,
 	Float64frombits: ([b]) =>

package/src/backend/js/stdlib/simd.js

@@ -13,10 +13,20 @@ export const simdMethods = {
 				return `__simd_splat(${args[0]})`;
 			case "NewF32x4":
 				return `__simd_f32x4(${args[0]}, ${args[1]}, ${args[2]}, ${args[3]})`;
+			case "Select":
+				return `__simd_select(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "Shuffle":
+				return `__simd_shuffle(${args.join(", ")})`;
 			case "LoadF32x4":
 				return `__simd_load(${args[0]}, ${args[1]})`;
 			case "StoreF32x4":
 				return `__simd_store(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "LoadF32x4Slice":
+				return `__simd_load_slice(${args[0]}, ${args[1]})`;
+			case "StoreF32x4Slice":
+				return `__simd_store_slice(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "Pad4":
+				return `(Math.floor((${args[0]} + 3) / 4) * 4)`;
 			default:
 				return undefined;
 		}

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

@@ -34,26 +34,26 @@ const SLICES_DISPATCH = {
 		`((s, f) => { if (!s || s.length === 0) throw new Error("slices.MinFunc: empty list"); return s.reduce((m, x) => f(x, m) < 0 ? x : m); })(${a[0]}, ${a[1]})`,
 	Clone: (a) => `((s) => s ? s.slice() : null)(${a[0]})`,
 	Compact: (a) =>
-		`((s) => { if (!s || s.length === 0) return s; let k = 1; for (let i = 1; i < s.length; i++) { if (s[i] !== s[k - 1]) s[k++] = s[i]; } return ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]})`,
+		`((s) => { if (!s || s.length === 0) return s; let k = 1; for (let i = 1; i < s.length; i++) { if (s[i] !== s[k - 1]) s[k++] = s[i]; } return s[__sv] !== undefined ? __slice(s, 0, k) : ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]})`,
 	CompactFunc: (a) =>
-		`((s, f) => { if (!s || s.length === 0) return s; let k = 1; for (let i = 1; i < s.length; i++) { if (!f(s[i], s[k - 1])) s[k++] = s[i]; } return ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]}, ${a[1]})`,
+		`((s, f) => { if (!s || s.length === 0) return s; let k = 1; for (let i = 1; i < s.length; i++) { if (!f(s[i], s[k - 1])) s[k++] = s[i]; } return s[__sv] !== undefined ? __slice(s, 0, k) : ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]}, ${a[1]})`,
 	Concat: (a) =>
 		a.length === 0
 			? "null"
 			: `((...slices) => { const nonNull = slices.filter(Boolean); if (nonNull.length === 0) return slices[0] === null ? null : []; if (ArrayBuffer.isView(nonNull[0])) { const totalLen = nonNull.reduce((sum, s) => sum + s.length, 0); const out = new nonNull[0].constructor(totalLen); let off = 0; for (const s of nonNull) { out.set(s, off); off += s.length; } return out; } return [].concat(...slices.map(s => s ? (ArrayBuffer.isView(s) ? Array.from(s) : s) : [])); })(${a.map((x) => `(${x})`).join(", ")})`,
 	Delete: (a) =>
-		`((s, i, j) => { if (!s && i === 0 && j === 0) return s; s = s || []; if (i < 0 || j < i || j > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { s.copyWithin(i, j); return s.subarray(0, s.length - (j - i)); } s.splice(i, j - i); return s; })(${a[0]}, ${a[1]}, ${a[2]})`,
+		`((s, i, j) => { if (!s && i === 0 && j === 0) return s; s = s || []; if (i < 0 || j < i || j > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { s.copyWithin(i, j); return s.subarray(0, s.length - (j - i)); } if (s[__sv] !== undefined) { s.copyWithin(i, j); return __slice(s, 0, s.length - (j - i)); } s.splice(i, j - i); return s; })(${a[0]}, ${a[1]}, ${a[2]})`,
 	DeleteFunc: (a) =>
-		`((s, f) => { if (!s || s.length === 0) return s; let k = 0; for (let i = 0; i < s.length; i++) { if (!f(s[i])) s[k++] = s[i]; } return ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]}, ${a[1]})`,
+		`((s, f) => { if (!s || s.length === 0) return s; let k = 0; for (let i = 0; i < s.length; i++) { if (!f(s[i])) s[k++] = s[i]; } return s[__sv] !== undefined ? __slice(s, 0, k) : ArrayBuffer.isView(s) ? s.subarray(0, k) : (s.length = k, s); })(${a[0]}, ${a[1]})`,
 	Insert: (a, isTyped) => {
 		const items = a.slice(2);
 		const nilInit = isTyped ? "new Uint8Array(0)" : "[]";
-		return `((s, i, ...v) => { if (!s && i === 0) s = ${nilInit}; if (!s || i < 0 || i > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { const res = new s.constructor(s.length + v.length); res.set(s.subarray(0, i), 0); res.set(v, i); res.set(s.subarray(i), i + v.length); return res; } s.splice(i, 0, ...v); return s; })(${a[0]}, ${a[1]}${items.length ? `, ${items.join(", ")}` : ""})`;
+		return `((s, i, ...v) => { if (!s && i === 0) s = ${nilInit}; if (!s || i < 0 || i > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { const res = new s.constructor(s.length + v.length); res.set(s.subarray(0, i), 0); res.set(v, i); res.set(s.subarray(i), i + v.length); return res; } if (s[__sv] !== undefined) s = Array.from(s); s.splice(i, 0, ...v); return s; })(${a[0]}, ${a[1]}${items.length ? `, ${items.join(", ")}` : ""})`;
 	},
 	Replace: (a, isTyped) => {
 		const items = a.slice(3);
 		const nilInit = isTyped ? "new Uint8Array(0)" : "[]";
-		return `((s, i, j, ...v) => { if (!s && i === 0 && j === 0) s = ${nilInit}; if (!s || i < 0 || j < i || j > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { const res = new s.constructor(s.length - (j - i) + v.length); res.set(s.subarray(0, i), 0); res.set(v, i); res.set(s.subarray(j), i + v.length); return res; } s.splice(i, j - i, ...v); return s; })(${a[0]}, ${a[1]}, ${a[2]}${items.length ? `, ${items.join(", ")}` : ""})`;
+		return `((s, i, j, ...v) => { if (!s && i === 0 && j === 0) s = ${nilInit}; if (!s || i < 0 || j < i || j > s.length) throw new Error("runtime error: slice bounds out of range"); if (ArrayBuffer.isView(s)) { const res = new s.constructor(s.length - (j - i) + v.length); res.set(s.subarray(0, i), 0); res.set(v, i); res.set(s.subarray(j), i + v.length); return res; } if (s[__sv] !== undefined) s = Array.from(s); s.splice(i, j - i, ...v); return s; })(${a[0]}, ${a[1]}, ${a[2]}${items.length ? `, ${items.join(", ")}` : ""})`;
 	},
 	Grow: (a, isTyped) => {
 		const nilInit = isTyped ? "new Uint8Array(0)" : "[]";
@@ -62,6 +62,15 @@ const SLICES_DISPATCH = {
 	Clip: (a) => `((s) => s ? s.slice() : null)(${a[0]})`,
 };
 
+const VIEW_AWARE = new Set([
+	"Compact",
+	"CompactFunc",
+	"Delete",
+	"DeleteFunc",
+	"Insert",
+	"Replace",
+]);
+
 /** @type {ThisType<CodeGen>} */
 export const slicesMethods = {
 	_genSlices(fn, a, expr) {
@@ -70,8 +79,29 @@ export const slicesMethods = {
 			const [a1, b1] = a();
 			return `__equal(${a1}, ${b1})`;
 		}
+		// Struct and array elements are values: compare them field by field
+		// (`.includes` and `.indexOf` compare object identity).
+		if (
+			(fn === "Contains" || fn === "Index") &&
+			this._sliceElemIsAggregate(expr)
+		) {
+			this.useHelper("equal");
+			const [s1, v1] = a();
+			const found = fn === "Contains" ? "true" : "i";
+			const missing = fn === "Contains" ? "false" : "-1";
+			return `((s, v) => { s = s || []; for (let i = 0; i < s.length; i++) { if (__equal(s[i], v)) return ${found}; } return ${missing}; })(${s1}, ${v1})`;
+		}
 		const isTyped = isTypedArraySlice(expr?.args?.[0]?._type);
 		const gen = SLICES_DISPATCH[fn];
+		// These shrink or grow the slice in place; a slice view (`__sv`) has a
+		// fixed length, so they reslice it or copy it to a plain array.
+		if (VIEW_AWARE.has(fn)) this.useHelper("slice");
 		return gen ? gen(a(), isTyped) : undefined;
 	},
+
+	_sliceElemIsAggregate(expr) {
+		let t = expr?.args?.[0]?._type;
+		while (t?.kind === "named") t = t.underlying;
+		return t?.kind === "slice" && Boolean(this._aggregateBase(t.elem));
+	},
 };