nomen-lang 0.11.0 → 0.12.0

package/dist/index.mjs

@@ -7168,6 +7168,15 @@ var FunctionCallNode = class extends BaseNode {
 	is_static;
 	is_func_param;
 	type_args;
+	/**
+	* True when `type_args` was NOT written at the call site — the checker
+	* recovered the arguments from the expected (annotation / return /
+	* parameter) type (check_function_call_node's expected-args branch). The
+	* redundant-type-annotation lint consults this: an annotation that
+	* instantiates the constructor is load-bearing and must never be flagged
+	* as redundant, even though `type_args` is populated after checking.
+	*/
+	type_args_from_expected;
 	ref_param_indices;
 	move_param_indices;
 	/**
@@ -11760,7 +11769,7 @@ function resolve_static_value(node, status) {
 	}
 	return null;
 }
-function build_array_values_node$1(node, status) {
+function build_array_values_node$2(node, status) {
 	node.values.forEach((value, i) => {
 		if (i > 0) emit_asm(status, ", ");
 		const resolved = resolve_static_value(value, status);
@@ -15170,11 +15179,11 @@ function block(ctx, stmts) {
 			out.push(...block(ctx, s.statements));
 			continue;
 		}
-		out.push(stmt(ctx, s));
+		out.push(stmt$1(ctx, s));
 	}
 	return out;
 }
-function stmt(ctx, n) {
+function stmt$1(ctx, n) {
 	switch (n.node_type) {
 		case "declare": return declare_stmt(ctx, n);
 		case "assign": return assign_stmt(ctx, n);
@@ -15183,7 +15192,7 @@ function stmt(ctx, n) {
 			return {
 				kind: "return",
 				node: n,
-				value: ret.value ? expr(ctx, ret.value) : null
+				value: ret.value ? expr$1(ctx, ret.value) : null
 			};
 		}
 		case "break": return {
@@ -15205,7 +15214,7 @@ function stmt(ctx, n) {
 			return {
 				kind: "if",
 				node: n,
-				cond: expr(ctx, iff.condition),
+				cond: expr$1(ctx, iff.condition),
 				then_branch: block(ctx, iff.if_branch?.statements),
 				else_branch: block(ctx, iff.else_branch?.statements)
 			};
@@ -15215,9 +15224,9 @@ function stmt(ctx, n) {
 			return {
 				kind: "while",
 				node: n,
-				cond: expr(ctx, wh.condition),
+				cond: expr$1(ctx, wh.condition),
 				body: block(ctx, wh.statements),
-				update: wh.update ? stmt(ctx, wh.update) : null
+				update: wh.update ? stmt$1(ctx, wh.update) : null
 			};
 		}
 		case "for": {
@@ -15226,9 +15235,9 @@ function stmt(ctx, n) {
 				kind: "for",
 				node: n,
 				item_name: String(f.item?.value ?? ""),
-				list: f.list ? expr(ctx, f.list) : null,
+				list: f.list ? expr$1(ctx, f.list) : null,
 				body: block(ctx, f.statements),
-				update: f.update ? stmt(ctx, f.update) : null
+				update: f.update ? stmt$1(ctx, f.update) : null
 			};
 		}
 		case "switch":
@@ -15240,7 +15249,7 @@ function stmt(ctx, n) {
 					node: n,
 					scrutinee: null,
 					arms: sw.cases.map((c) => ({
-						condition: c.condition ? expr(ctx, c.condition) : null,
+						condition: c.condition ? expr$1(ctx, c.condition) : null,
 						branch: block(ctx, c.branch?.statements)
 					})),
 					otherwise: sw.else_branch ? block(ctx, sw.else_branch.statements) : null
@@ -15250,9 +15259,9 @@ function stmt(ctx, n) {
 			return {
 				kind: "switch_match",
 				node: n,
-				scrutinee: m.value ? expr(ctx, m.value) : null,
+				scrutinee: m.value ? expr$1(ctx, m.value) : null,
 				arms: m.cases.map((c) => ({
-					condition: c.match_value ? expr(ctx, c.match_value) : null,
+					condition: c.match_value ? expr$1(ctx, c.match_value) : null,
 					branch: block(ctx, c.branch?.statements)
 				})),
 				otherwise: m.else_branch ? block(ctx, m.else_branch.statements) : null
@@ -15264,13 +15273,13 @@ function stmt(ctx, n) {
 			return {
 				kind: "eval",
 				node: n,
-				expr: expr(ctx, n)
+				expr: expr$1(ctx, n)
 			};
 		}
 		case "spawn": return {
 			kind: "spawn",
 			node: n,
-			call: expr(ctx, n.call)
+			call: expr$1(ctx, n.call)
 		};
 		case "async_block": return {
 			kind: "async_block",
@@ -15314,7 +15323,7 @@ function stmt(ctx, n) {
 			if (is_expr_node(n)) return {
 				kind: "eval",
 				node: n,
-				expr: expr(ctx, n)
+				expr: expr$1(ctx, n)
 			};
 			record_unknown(ctx, n);
 			return {
@@ -15328,10 +15337,10 @@ function assign_stmt(ctx, a) {
 	return {
 		kind: "assign",
 		node: a,
-		target: expr(ctx, a.left_value),
-		rhs: expr(ctx, a.right_value),
+		target: expr$1(ctx, a.left_value),
+		rhs: expr$1(ctx, a.right_value),
 		operator: a.operator ?? null,
-		swap: a.swap ? expr(ctx, a.swap) : null
+		swap: a.swap ? expr$1(ctx, a.swap) : null
 	};
 }
 function declare_stmt(ctx, d) {
@@ -15349,8 +15358,8 @@ function declare_stmt(ctx, d) {
 				is_ref: t?.is_ref,
 				is_nullable: t?.is_nullable
 			},
-			init: d.value ? expr(ctx, d.value) : null,
-			swap: d.swap ? expr(ctx, d.swap) : null,
+			init: d.value ? expr$1(ctx, d.value) : null,
+			swap: d.swap ? expr$1(ctx, d.swap) : null,
 			node: d
 		}
 	};
@@ -15372,10 +15381,10 @@ function is_expr_node(n) {
 	}
 }
 function call_facts(ctx, call) {
-	const args = (call.params ?? []).map((p) => expr(ctx, p));
+	const args = (call.params ?? []).map((p) => expr$1(ctx, p));
 	const swaps = [];
 	const swap_map = call.swap_params;
-	if (swap_map instanceof Map) for (const v of swap_map.values()) swaps.push(expr(ctx, v));
+	if (swap_map instanceof Map) for (const v of swap_map.values()) swaps.push(expr$1(ctx, v));
 	return {
 		args,
 		facts: {
@@ -15385,7 +15394,7 @@ function call_facts(ctx, call) {
 		}
 	};
 }
-function expr(ctx, n) {
+function expr$1(ctx, n) {
 	if (!n || typeof n !== "object") return {
 		kind: "leaf",
 		node: n ?? {},
@@ -15405,15 +15414,15 @@ function expr(ctx, n) {
 			return {
 				kind: "binary",
 				node: n,
-				left: expr(ctx, op.left_value),
-				right: expr(ctx, op.right_value)
+				left: expr$1(ctx, op.left_value),
+				right: expr$1(ctx, op.right_value)
 			};
 		}
 		case "range": return {
 			kind: "binary",
 			node: n,
-			left: expr(ctx, n.left_value),
-			right: expr(ctx, n.right_value)
+			left: expr$1(ctx, n.left_value),
+			right: expr$1(ctx, n.right_value)
 		};
 		case "grouped":
 		case "cast":
@@ -15422,7 +15431,7 @@ function expr(ctx, n) {
 			return {
 				kind: "wrap",
 				node: n,
-				inner: inner ? expr(ctx, inner) : null
+				inner: inner ? expr$1(ctx, inner) : null
 			};
 		}
 		case "array": return {
@@ -15430,7 +15439,7 @@ function expr(ctx, n) {
 			node: n,
 			callee: "[array literal]",
 			facts: {
-				args: (n.values ?? []).map((v) => expr(ctx, v)),
+				args: (n.values ?? []).map((v) => expr$1(ctx, v)),
 				ref_arg_indices: [],
 				swap_exprs: []
 			}
@@ -15467,7 +15476,7 @@ function expr(ctx, n) {
 				return {
 					kind: "method_call",
 					node: n,
-					receiver: expr(ctx, acc.target),
+					receiver: expr$1(ctx, acc.target),
 					name: acc.access.name,
 					facts: {
 						...facts,
@@ -15482,7 +15491,7 @@ function expr(ctx, n) {
 			return {
 				kind: "path",
 				node: n,
-				receiver: expr(ctx, acc.target),
+				receiver: expr$1(ctx, acc.target),
 				steps
 			};
 		}
@@ -15496,7 +15505,7 @@ function expr(ctx, n) {
 					node: n,
 					scrutinee: null,
 					arms: [{
-						condition: iff.condition ? expr(ctx, iff.condition) : null,
+						condition: iff.condition ? expr$1(ctx, iff.condition) : null,
 						branch: block(ctx, iff.if_branch?.statements)
 					}],
 					otherwise: iff.else_branch ? block(ctx, iff.else_branch.statements) : null
@@ -15509,7 +15518,7 @@ function expr(ctx, n) {
 					node: n,
 					scrutinee: null,
 					arms: sw.cases.map((c) => ({
-						condition: c.condition ? expr(ctx, c.condition) : null,
+						condition: c.condition ? expr$1(ctx, c.condition) : null,
 						branch: block(ctx, c.branch?.statements)
 					})),
 					otherwise: sw.else_branch ? block(ctx, sw.else_branch.statements) : null
@@ -15519,9 +15528,9 @@ function expr(ctx, n) {
 			return {
 				kind: "flow",
 				node: n,
-				scrutinee: m.value ? expr(ctx, m.value) : null,
+				scrutinee: m.value ? expr$1(ctx, m.value) : null,
 				arms: m.cases.map((c) => ({
-					condition: c.match_value ? expr(ctx, c.match_value) : null,
+					condition: c.match_value ? expr$1(ctx, c.match_value) : null,
 					branch: block(ctx, c.branch?.statements)
 				})),
 				otherwise: m.else_branch ? block(ctx, m.else_branch.statements) : null
@@ -15530,14 +15539,14 @@ function expr(ctx, n) {
 		case "spawn": return {
 			kind: "spawn",
 			node: n,
-			call: expr(ctx, n.call)
+			call: expr$1(ctx, n.call)
 		};
 		case "anon_struct": {
 			const anon = n;
 			return {
 				kind: "wrap",
 				node: n,
-				inner: anon.base ? expr(ctx, anon.base) : null
+				inner: anon.base ? expr$1(ctx, anon.base) : null
 			};
 		}
 		case "func": return {
@@ -15564,8 +15573,8 @@ function expr(ctx, n) {
 				return {
 					kind: "binary",
 					node: n,
-					left: expr(ctx, idx.target),
-					right: expr(ctx, idx.index)
+					left: expr$1(ctx, idx.target),
+					right: expr$1(ctx, idx.index)
 				};
 			}
 			record_unknown(ctx, n);
@@ -26370,7 +26379,7 @@ function peephole_optimize(code) {
 	}
 	return lines.join("\n");
 }
-function build_function_node$1(node, status) {
+function build_function_node$2(node, status) {
 	if (node.is_generic) return;
 	if (node.is_foreign) {
 		build_foreign$1(node, status);
@@ -26964,6 +26973,8 @@ function build_function_node$1(node, status) {
 		if (!status.heap_returning_functions) status.heap_returning_functions = /* @__PURE__ */ new Set();
 		status.heap_returning_functions.add(label_name);
 	}
+	const tail_branch = `b ${return_label}\n`;
+	if (status.code.endsWith(tail_branch)) status.code = status.code.slice(0, status.code.length - tail_branch.length);
 	emit_asm(status, `${return_label}:\n`);
 	if (node.name === "main") {
 		if (status.used_fibers) {
@@ -27277,7 +27288,7 @@ function resolve_global_const_value(name, status) {
 		return;
 	}
 }
-function build_struct_node$1(node, status) {
+function build_struct_node$2(node, status) {
 	if (node.is_generic) return;
 	const is_nested = !!status.function_return_label;
 	for (const func of node.functions) ensure_runtime_for_method_a64(func, status);
@@ -27730,7 +27741,7 @@ function build_init_function(node, status) {
 		} else if (field.value.node_type === "func" && field.type.name === "func") {
 			const prev_return_label = status.function_return_label;
 			status.function_return_label = `.return_${func_name}`;
-			build_function_node$1(field.value, status);
+			build_function_node$2(field.value, status);
 			status.function_return_label = prev_return_label;
 			ensure_newline(status);
 			emit_descriptor_address(status, "x1", materialize_lambda_descriptor_a64(field.value, status));
@@ -29145,11 +29156,11 @@ function build_block_node$1(node, status) {
 	const declarations_before = node.node_type === "func" ? 0 : status.scoped_declarations.length;
 	for (let child of node.statements) if (is_struct_node(child)) {
 		if (!should_emit_definition(child, status.emit_mode, status.structs, status.system_struct_names)) continue;
-		build_struct_node$1(child, status);
+		build_struct_node$2(child, status);
 	}
 	for (let child of node.statements) if (is_function_node(child)) {
 		if (!should_emit_definition(child, status.emit_mode, status.structs, status.system_struct_names)) continue;
-		build_function_node$1(child, status);
+		build_function_node$2(child, status);
 	}
 	if (node.node_type !== "root" && node.name?.toLocaleLowerCase() === "main" && status.module_init_statements?.length) {
 		const prologue = status.module_init_statements;
@@ -30076,7 +30087,7 @@ let label_counter$4 = 0;
 function reset_label_counter$4() {
 	label_counter$4 = 0;
 }
-function build_for_loop_node$1(node, status, nir, vector) {
+function build_for_loop_node$2(node, status, nir, vector) {
 	const old_scoped_declarations = enter_scope_frame(status);
 	const label = label_counter$4++;
 	const item_name = node.item.value;
@@ -30401,7 +30412,7 @@ function reset_label_counter$3() {
 function next_if_label() {
 	return label_counter$3++;
 }
-function build_if_else_node$1(node, status, nir) {
+function build_if_else_node$2(node, status, nir) {
 	if (!node.condition) {
 		if (!status.build_errors) status.build_errors = [];
 		status.build_errors.push({
@@ -32390,7 +32401,7 @@ const COMPILER_TEMP_PREFIXES = [
 function is_compiler_temp_name$1(name) {
 	return !!name && COMPILER_TEMP_PREFIXES.some((p) => name.startsWith(p));
 }
-function build_function_call_node$1(node, status) {
+function build_function_call_node$2(node, status) {
 	hoist_field_overrides(node, build_node, status);
 	if (node.is_enum_shorthand && node.params.length > 0) {
 		const found = find_enum_for_case(node.name, status);
@@ -33159,7 +33170,7 @@ function emit_return_value$1(value, nir_value, status) {
 	}
 	build_node(value, status);
 }
-function build_return_node$1(node, status, nir_value) {
+function build_return_node$2(node, status, nir_value) {
 	hoist_field_overrides(node.value, build_node, status);
 	if (node.from_inline) return;
 	const returns_nullable_struct = is_nullable_struct_type(status.function_return_type, status);
@@ -33719,7 +33730,7 @@ function mov_immediate_x0_and_store(status, name, value) {
 	emit_asm(status, `mov x0, #${value}\n`);
 	emit_var_store(status, "x0", name, 8);
 }
-function build_while_loop_node$1(node, status, nir, vector, unroll) {
+function build_while_loop_node$2(node, status, nir, vector, unroll) {
 	const old_scoped_declarations = enter_scope_frame(status);
 	const promoted = [];
 	const saved_reg_allocs = status.register_allocations ? new Map(status.register_allocations) : void 0;
@@ -35488,18 +35499,18 @@ function emit_stmt_dispatch(child, index, statements, status) {
 		const nstmt = ctx.stmts[index];
 		switch (nstmt.kind) {
 			case "if":
-				build_if_else_node$1(child, status, nstmt);
+				build_if_else_node$2(child, status, nstmt);
 				return 1;
 			case "while": {
 				const neon_plan = neon_vectorization_enabled() ? plan_vector_loop(nstmt, index, ctx.stmts, status) : null;
 				const unroll_plan = plan_full_unroll(nstmt, index, ctx.stmts, status.induction_const);
 				const lease = region_pool_enter(status, child, !!neon_plan || !!unroll_plan);
-				build_while_loop_node$1(child, status, nstmt, neon_plan, unroll_plan);
+				build_while_loop_node$2(child, status, nstmt, neon_plan, unroll_plan);
 				region_pool_exit(status, lease);
 				return 1;
 			}
 			case "for":
-				build_for_loop_node$1(child, status, nstmt, neon_vectorization_enabled() ? plan_vector_for(nstmt, index, ctx.stmts, status) : null);
+				build_for_loop_node$2(child, status, nstmt, neon_vectorization_enabled() ? plan_vector_for(nstmt, index, ctx.stmts, status) : null);
 				return 1;
 			case "switch_match":
 				if (child.node_type === "switch") build_switch_node$1(child, status, nstmt);
@@ -35508,7 +35519,7 @@ function emit_stmt_dispatch(child, index, statements, status) {
 			case "return": {
 				const restore_return = apply_forward_use(ctx.use_sites, nstmt.node);
 				try {
-					build_return_node$1(child, status, nstmt.value);
+					build_return_node$2(child, status, nstmt.value);
 					ensure_newline(status);
 					return 1;
 				} finally {
@@ -35533,7 +35544,7 @@ function emit_stmt_dispatch(child, index, statements, status) {
 						const slp = try_emit_slp_pair(index, statements, ctx.stmts, status);
 						if (slp > 1) return slp;
 					}
-					build_declaration_node(child, status, nstmt.decl.init, nstmt.decl.swap);
+					build_declaration_node$1(child, status, nstmt.decl.init, nstmt.decl.swap);
 					if (nstmt.decl.init && nstmt.decl.init.node.node_type !== "func") ensure_newline(status);
 					return 1;
 				} finally {
@@ -35546,7 +35557,7 @@ function emit_stmt_dispatch(child, index, statements, status) {
 						const slp = try_emit_slp_pair(index, statements, ctx.stmts, status);
 						if (slp > 1) return slp;
 					}
-					build_assignment_node(nstmt.node, status, nstmt.rhs, nstmt.swap);
+					build_assignment_node$1(nstmt.node, status, nstmt.rhs, nstmt.swap);
 					ensure_newline(status);
 					return 1;
 				} finally {
@@ -35569,7 +35580,7 @@ function emit_stmt_dispatch(child, index, statements, status) {
 				}
 			}
 			case "async_block":
-				build_async_block_node$1(child, status, nstmt);
+				build_async_block_node$2(child, status, nstmt);
 				return 1;
 			case "block":
 				build_nested_block_node$1(child, status, nstmt);
@@ -35616,7 +35627,7 @@ function try_emit_cset_pair(decl, nstmt, index, ctx, status) {
 		ensure_newline(status);
 		return 2;
 	}
-	build_declaration_node(decl, status, nstmt.decl.init, nstmt.decl.swap);
+	build_declaration_node$1(decl, status, nstmt.decl.init, nstmt.decl.swap);
 	if (nstmt.decl.init && nstmt.decl.init.node.node_type !== "func") ensure_newline(status);
 	emit_cond_cset(ifn.condition, status);
 	emit_var_store(status, "x0", decl.name, aarch64_size(decl.type?.name ?? "int"));
@@ -35797,7 +35808,7 @@ function try_emit_carry_fold(decl, nstmt, index, ctx, status) {
 		for (const s of intervening) {
 			const restore = apply_forward_use(ctx.use_sites, s.node);
 			try {
-				build_assignment_node(s.node, status, s.rhs, s.swap);
+				build_assignment_node$1(s.node, status, s.rhs, s.swap);
 				ensure_newline(status);
 			} finally {
 				restore?.();
@@ -35822,7 +35833,7 @@ function try_emit_carry_fold(decl, nstmt, index, ctx, status) {
 		const flag_reg = status.register_allocations?.get(fd.ast.name);
 		if (flag_reg?.startsWith("x") && !fd.n.decl.swap) emit_asm(status, `cset ${flag_reg}, ${cc}\n`);
 		else {
-			build_declaration_node(fd.ast, status, fd.n.decl.init, fd.n.decl.swap);
+			build_declaration_node$1(fd.ast, status, fd.n.decl.init, fd.n.decl.swap);
 			ensure_newline(status);
 			emit_asm(status, `cset x0, ${cc}\n`);
 			emit_var_store(status, "x0", fd.ast.name, aarch64_size(fd_type));
@@ -35963,7 +35974,7 @@ function emit_expr_from_nir$1(expr, status) {
 * __nomen_future_release, __nomen_future_cancel) are C functions in the
 * companion file, called via `bl` from assembly.
 */
-function build_async_block_node$1(node, status, nir) {
+function build_async_block_node$2(node, status, nir) {
 	const id = status.spawn_counter ?? 0;
 	status.spawn_counter = id + 1;
 	ensure_concurrency_runtime_a64(status);
@@ -36120,7 +36131,7 @@ function emit_nursery_joins_on_return_a64(status) {
 }
 //#endregion
 //#region ../src/build_aarch64/build_break_node.ts
-function build_break_node$1(status) {
+function build_break_node$2(status) {
 	const loop = status.loop_labels?.[status.loop_labels.length - 1];
 	if (loop) {
 		emit_cleanup_to_loop_depth(status);
@@ -38829,7 +38840,7 @@ function is_trait_type(name, status) {
 	return !!name && status.traits.some((t) => t.name === name);
 }
 /** Whether `name` is a declared VALUE struct (non-class, non-simple). */
-function is_value_struct(name, status) {
+function is_value_struct$1(name, status) {
 	if (!name) return false;
 	const s = status.structs.find((st) => st.name === name);
 	return !!s && !s.is_class && !s.is_simple_type;
@@ -38841,7 +38852,7 @@ function conforms_to_trait(struct_name, trait_name, status) {
 }
 /** Whether `struct_name` is a value struct that conforms to `trait_name`. */
 function is_value_struct_conformer(struct_name, trait_name, status) {
-	return !!struct_name && struct_name !== trait_name && is_value_struct(struct_name, status) && conforms_to_trait(struct_name, trait_name, status);
+	return !!struct_name && struct_name !== trait_name && is_value_struct$1(struct_name, status) && conforms_to_trait(struct_name, trait_name, status);
 }
 /** The one error wording for boxing a value that has no owner to give (T2). */
 function boxing_owns_error() {
@@ -41825,7 +41836,7 @@ function check_struct_node(struct, status) {
 		if (!is_owning_struct_type_requiring_move(new Type(mono_type_name(field.type)), status)) continue;
 		if (!status.warnings) status.warnings = [];
 		status.warnings.push({
-			message: `'mv' on field '${field.name}' is redundant: '${type_display(field.type)}' is a value struct — its ownership is derived from the type, so plain 'var' behaves identically`,
+			message: `'mv' on field '${field.name}' is redundant: '${type_display$1(field.type)}' is a value struct — its ownership is derived from the type, so plain 'var' behaves identically`,
 			start: field.start,
 			line: 0,
 			column: 0
@@ -42040,9 +42051,9 @@ function types_match(a, b) {
 	return a.name === b.name && !!a.is_ref === !!b.is_ref && !!a.is_view === !!b.is_view && !!a.is_array === !!b.is_array;
 }
 /** The user-visible spelling of a type (`List<int>`, `Map<string, int>`). */
-function type_display(t) {
+function type_display$1(t) {
 	if (!t.type_args?.length) return t.name ?? "?";
-	return `${t.name}<${t.type_args.map(type_display).join(", ")}>`;
+	return `${t.name}<${t.type_args.map(type_display$1).join(", ")}>`;
 }
 /**
 * B2 — walk `struct`'s inline value-struct fields (Box fields are pointers
@@ -45969,6 +45980,8 @@ function check_if_else_node(if_else, status) {
 	const null_check = get_null_check_var(if_else.condition, status);
 	status.stack.push(if_else);
 	const arms_base = status.values.length;
+	const condition_allocations = status.allocations;
+	status.allocations = [];
 	let if_status = clone_status(status);
 	let else_status = clone_status(status);
 	if (null_check) {
@@ -46001,6 +46014,7 @@ function check_if_else_node(if_else, status) {
 	if (if_else.if_branch) check_block_node(if_else.if_branch, if_status);
 	if (if_else.else_branch) check_block_node(if_else.else_branch, else_status);
 	status.stack.pop();
+	status.allocations = condition_allocations.concat(status.allocations);
 	const const_cond = evaluate_const_condition(if_else.condition, status);
 	const if_reachable = const_cond !== false;
 	const else_reachable = const_cond !== true;
@@ -46183,6 +46197,8 @@ function check_match_node(match_node, status) {
 	check_node(match_node.value, status);
 	const match_type = type_from_value_node(match_node.value, status);
 	match_node.value_type = match_type.name;
+	const scrutinee_allocations = status.allocations;
+	status.allocations = [];
 	status.stack.push(match_node);
 	const arms_base = status.values.length;
 	let branch_statuses = [];
@@ -46216,6 +46232,7 @@ function check_match_node(match_node, status) {
 		branch_statuses.push(else_status);
 	}
 	status.stack.pop();
+	status.allocations = scrutinee_allocations.concat(status.allocations);
 	for (let [i, value] of status.values.entries()) {
 		if (value.declaration === "const" && !value.is_set) {
 			let set_count = branch_statuses.filter((bs) => bs.values[i]?.is_set).length;
@@ -48873,6 +48890,7 @@ function check_function_call_node(node, status) {
 						type.type_args = expected_args;
 						node.type = type;
 						node.type_args = expected_args;
+						node.type_args_from_expected = true;
 						node.name = target.name;
 						if (is_overloaded(target, "#init")) node.mangled_name = mangled_label(func, target.name);
 					}
@@ -50914,7 +50932,7 @@ function emit_case_cast_panic(status) {
 	emit_asm(status, `mov x16, #1\n`);
 	emit_asm(status, `svc #0x80\n`);
 }
-function build_cast_node$1(node, status) {
+function build_cast_node$2(node, status) {
 	if (node.operator_func) {
 		build_struct_cast(node, status);
 		return;
@@ -51027,7 +51045,7 @@ function build_struct_cast(node, status) {
 }
 //#endregion
 //#region ../src/build_aarch64/build_continue_node.ts
-function build_continue_node$1(status) {
+function build_continue_node$2(status) {
 	const loop = status.loop_labels?.[status.loop_labels.length - 1];
 	if (loop) {
 		emit_cleanup_to_loop_depth(status);
@@ -52532,7 +52550,7 @@ function build_index_node(node, status) {
 }
 //#endregion
 //#region ../src/build_c/build_operation_node.ts
-function build_operation_node$1(node, status) {
+function build_operation_node$2(node, status) {
 	if (node.operator_func?.deferred) {
 		let left_type = type_from_value_node$1(node.left_value);
 		let struct = status.structs.find((s) => s.name === left_type.name);
@@ -52955,7 +52973,7 @@ function build_parameter_node(node, status) {
 * v1: fixed capacity (64 tasks per nursery). Exceeding it is undefined
 * behavior — a real implementation would grow or use a linked list.
 */
-function build_async_block_node(node, status, nir) {
+function build_async_block_node$1(node, status, nir) {
 	const id = status.spawn_counter ?? 0;
 	status.spawn_counter = id + 1;
 	ensure_concurrency_runtime(status);
@@ -53124,7 +53142,7 @@ function build_lambda_value(node, status, emit_name = true) {
 	status.c_scope_stack = [];
 	status.c_loop_frame_depth = void 0;
 	status.class_vars_frames = void 0;
-	build_function_node(node, status);
+	build_function_node$1(node, status);
 	status.lambda_definitions = (status.lambda_definitions ?? "") + status.code;
 	status.code = saved_code;
 	status.headers = saved_headers + status.headers;
@@ -53208,7 +53226,7 @@ function emit_swap_value$1(swap, nir, status) {
 	}
 	build_node$1(swap, status);
 }
-function build_declaration_node$1(node, status, nir_init, nir_swap) {
+function build_declaration_node$2(node, status, nir_init, nir_swap) {
 	if (node.in_place_push_slot && node.value?.node_type === "func_call") {
 		const recv_type = type_from_value_node$1(node.value);
 		const stamp = node.in_place_push_slot;
@@ -53268,7 +53286,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			const var_name = `_${node.name}_${i}`;
 			if ((var_type?.name ? status.structs.find((st) => st.name === var_type.name && !st.is_simple_type && !st.is_class) : void 0) && status.traits.find((t) => t.name === node.type.name)) {
 				const trait_type = new Type(node.type.name);
-				build_declaration_node$1(new DeclarationNode(node.start, node.visibility, node.declaration, var_name, trait_type, value), status, nir_elems?.[i - 1]);
+				build_declaration_node$2(new DeclarationNode(node.start, node.visibility, node.declaration, var_name, trait_type, value), status, nir_elems?.[i - 1]);
 				variables.push(var_name);
 				i += 1;
 				continue;
@@ -53665,7 +53683,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 				status.code += `${safe_name}->_vt = 0;\n`;
 				status.code += `${safe_name}->length = ${count}L;\n`;
 				status.code += `memcpy((char *)${safe_name} + sizeof(struct Array_${elem_name}), (${elem_c}[])`;
-				build_array_values_node(arr, status, nir_array_elements(nir_init, arr));
+				build_array_values_node$1(arr, status, nir_array_elements(nir_init, arr));
 				status.code += `, ${count}L * sizeof(${elem_c}));\n`;
 				return;
 			}
@@ -53912,7 +53930,7 @@ function range_count_c(range) {
 }
 //#endregion
 //#region ../src/build_c/build_for_loop_node.ts
-function build_for_loop_node(node, status, nir) {
+function build_for_loop_node$1(node, status, nir) {
 	const old_scoped_declarations = status.scoped_declarations;
 	status.scoped_declarations = enter_c_scope(status);
 	const old_deferred_frees = status.deferred_frees;
@@ -54106,7 +54124,7 @@ function strip_outer_parens(expr) {
 }
 //#endregion
 //#region ../src/build_c/build_if_else_node.ts
-function build_if_else_node(node, status, nir) {
+function build_if_else_node$1(node, status, nir) {
 	const old_scoped_declarations = status.scoped_declarations;
 	status.scoped_declarations = enter_c_scope(status);
 	const old_deferred_frees = status.deferred_frees;
@@ -54327,7 +54345,7 @@ function emit_return_value(value, nir_value, status) {
 	}
 	build_node$1(value, status);
 }
-function build_return_node(node, status, nir_value) {
+function build_return_node$1(node, status, nir_value) {
 	hoist_field_overrides(node.value, build_node$1, status, ";\n");
 	const ret_has = status.nullable_ret_has_param;
 	const returns_nullable_struct = !!ret_has;
@@ -54362,7 +54380,7 @@ function build_return_node(node, status, nir_value) {
 		const elem_is_class = !!status.structs.find((s) => s.name === ret_type.name && !s.is_simple_type)?.is_class;
 		const elem_c_type = ret_type.elem ? array_elem_c_type(ret_type) : elem_is_class ? `struct ${ret_type.name}*` : c_type(ret_type.name);
 		status.code += `${elem_c_type} ${return_array_var}[${return_array_len}] = `;
-		build_array_values_node(arr, status, nir_array_elements(nir_value, arr));
+		build_array_values_node$1(arr, status, nir_array_elements(nir_value, arr));
 		status.code += ";\n";
 	} else if (ret_type?.is_array && node.value.node_type === "value") {
 		return_array_var = node.value.value;
@@ -54733,7 +54751,7 @@ function is_reevaluatable(alloc) {
 	if (decl.is_heap_array_copy) return false;
 	return true;
 }
-function build_while_loop_node(node, status, nir) {
+function build_while_loop_node$1(node, status, nir) {
 	const old_scoped_declarations = status.scoped_declarations;
 	status.scoped_declarations = enter_c_scope(status);
 	const old_deferred_frees = status.deferred_frees;
@@ -54919,28 +54937,28 @@ function emit_stmt_from_nir(child, index, statements, status) {
 		const nstmt = ctx.stmts[index];
 		switch (nstmt.kind) {
 			case "if":
-				build_if_else_node(child, status, nstmt);
+				build_if_else_node$1(child, status, nstmt);
 				return;
 			case "while":
-				build_while_loop_node(child, status, nstmt);
+				build_while_loop_node$1(child, status, nstmt);
 				return;
 			case "for":
-				build_for_loop_node(child, status, nstmt);
+				build_for_loop_node$1(child, status, nstmt);
 				return;
 			case "switch_match":
 				if (child.node_type === "switch") build_switch_node(child, status, nstmt);
 				else build_match_node(child, status, nstmt);
 				return;
 			case "return":
-				build_return_node(child, status, nstmt.value);
+				build_return_node$1(child, status, nstmt.value);
 				if (!child.from_inline) with_semicolon_tail(status, child);
 				return;
 			case "declare":
-				build_declaration_node$1(child, status, nstmt.decl.init, nstmt.decl.swap);
+				build_declaration_node$2(child, status, nstmt.decl.init, nstmt.decl.swap);
 				if (!nstmt.decl.init || nstmt.decl.init.node.node_type !== "func") with_semicolon_tail(status, child);
 				return;
 			case "assign":
-				build_assignment_node$1(nstmt.node, status, nstmt.rhs, nstmt.swap);
+				build_assignment_node$2(nstmt.node, status, nstmt.rhs, nstmt.swap);
 				with_semicolon_tail(status, nstmt.node);
 				return;
 			case "eval": {
@@ -54954,7 +54972,7 @@ function emit_stmt_from_nir(child, index, statements, status) {
 				return;
 			}
 			case "async_block":
-				build_async_block_node(child, status, nstmt);
+				build_async_block_node$1(child, status, nstmt);
 				return;
 			case "block":
 				build_nested_block_node(child, status, nstmt);
@@ -55138,7 +55156,7 @@ function scan_borrow_only_strings(body) {
 }
 //#endregion
 //#region ../src/build_c/build_struct_node.ts
-function build_struct_node(node, status) {
+function build_struct_node$1(node, status) {
 	if (node.is_generic) return;
 	for (const func of node.functions) ensure_runtime_for_method(func, status);
 	if (node.is_simple_type) {
@@ -55874,7 +55892,7 @@ function build_block_node(node, status, with_declarations = true) {
 		}
 		for (let child of node.statements) if (is_struct_node(child)) {
 			if (!should_emit_definition(child, status.emit_mode, status.structs, status.system_struct_names)) continue;
-			build_struct_node(child, status);
+			build_struct_node$1(child, status);
 		}
 		if (node.node_type === "root") {
 			for (let child of node.statements) if (child.node_type === "declare") {
@@ -55896,7 +55914,7 @@ function build_block_node(node, status, with_declarations = true) {
 		}
 		for (let child of node.statements) if (is_function_node(child)) {
 			if (!should_emit_definition(child, status.emit_mode, status.structs, status.system_struct_names)) continue;
-			build_function_node(child, status);
+			build_function_node$1(child, status);
 		}
 	}
 	if (!with_declarations && node.name?.toLocaleLowerCase() === "main" && status.module_init_statements?.length) {
@@ -56090,7 +56108,7 @@ function statements_definitely_return(statements) {
 	}
 	return false;
 }
-function build_function_node(node, status) {
+function build_function_node$1(node, status) {
 	if (node.is_generic) return;
 	if (node.is_foreign) {
 		build_foreign(node, status);
@@ -56448,8 +56466,8 @@ function emit_nested_declarations(node, status) {
 	for (let child of block.statements) if (is_trait_node(child)) build_trait_node(child, status);
 	for (let child of block.statements) if (child.node_type === "enum") emit_enum_in_order(child, status);
 	for (let child of block.statements) if (child.node_type === "bitset") build_bitset_node(child, status);
-	for (let child of block.statements) if (is_struct_node(child)) build_struct_node(child, status);
-	for (let child of block.statements) if (is_function_node(child)) build_function_node(child, status);
+	for (let child of block.statements) if (is_struct_node(child)) build_struct_node$1(child, status);
+	for (let child of block.statements) if (is_function_node(child)) build_function_node$1(child, status);
 }
 //#endregion
 //#region ../src/build_c/utils/closure.ts
@@ -56600,7 +56618,7 @@ function capturing_closure_value(node, status) {
 * yields a static descriptor.
 */
 function build_lambda_closure_value(node, status, already_built = false) {
-	if (!already_built) build_function_node(node, status);
+	if (!already_built) build_function_node$1(node, status);
 	if (node.captures?.length) return capturing_closure_value(node, status);
 	return materialize_lambda_descriptor(node, status);
 }
@@ -56641,7 +56659,7 @@ const INT_LITERAL_SUFFIX = {
 	int64: "LL",
 	uint64: "ULL"
 };
-function build_value_node$1(node, status) {
+function build_value_node$2(node, status) {
 	if (node.is_struct_zero) {
 		status.code += `(struct ${mono_type_name(node.type)}){0}`;
 		return;
@@ -56697,7 +56715,7 @@ function escape_c_string(s) {
 * without them — or for an element whose lowered expr doesn't carry that
 * exact AST node — it is exactly the historical `build_node(value)`.
 */
-function build_array_values_node(node, status, nir_elements) {
+function build_array_values_node$1(node, status, nir_elements) {
 	status.code += `{`;
 	const elem_is_string = node.type?.name === "string";
 	const static_init = status.static_string_array_inits === true;
@@ -56722,14 +56740,14 @@ function build_array_values_node(node, status, nir_elements) {
 }
 //#endregion
 //#region ../src/build_c/build_break_node.ts
-function build_break_node(node, status) {
+function build_break_node$1(node, status) {
 	reclaim_to_loop_body(status);
 	status.loop_writebacks?.[status.loop_writebacks.length - 1]?.();
 	status.code += `break;\n`;
 }
 //#endregion
 //#region ../src/build_c/build_cast_node.ts
-function build_cast_node(node, status) {
+function build_cast_node$1(node, status) {
 	if (node.operator_func) {
 		const { struct_name, func_name, mangled_name } = node.operator_func;
 		const call_name = mangled_name || `${struct_name}_${c_function_name(func_name)}`;
@@ -56803,7 +56821,7 @@ function build_cast_node(node, status) {
 }
 //#endregion
 //#region ../src/build_c/build_continue_node.ts
-function build_continue_node(node, status) {
+function build_continue_node$1(node, status) {
 	reclaim_to_loop_body(status);
 	status.loop_writebacks?.[status.loop_writebacks.length - 1]?.();
 	status.code += `continue;\n`;
@@ -56896,7 +56914,7 @@ function is_compiler_temp_name(name) {
 		"_param_"
 	].some((p) => name.startsWith(p));
 }
-function build_function_call_node(node, status) {
+function build_function_call_node$1(node, status) {
 	if (node.is_enum_shorthand) {
 		if (node.move_param_indices?.length) for (const idx of node.move_param_indices) {
 			const param = node.params[idx];
@@ -57329,9 +57347,10 @@ function emit_nullable_arg_flag(arg, status) {
 //#endregion
 //#region ../src/build_c/build_let_node.ts
 function build_let_node(node, status) {
-	if (status.return_assign) {
+	const joins_through_branches = node.value.node_type === "if" || node.value.node_type === "match" || node.value.node_type === "switch";
+	if (status.return_assign && !joins_through_branches) {
 		status.code += `${status.return_assign} = `;
-		if (status.join_needs_owned_string && node.value.node_type !== "if" && node.value.node_type !== "match" && node.value.node_type !== "switch" && !is_owned_string_branch_value(node.value, status)) {
+		if (status.join_needs_owned_string && !is_owned_string_branch_value(node.value, status)) {
 			status.code += `nomen_str_dup(`;
 			build_node$1(node.value, status);
 			status.code += `)`;
@@ -57342,7 +57361,7 @@ function build_let_node(node, status) {
 }
 //#endregion
 //#region ../src/build_c/build_panic_node.ts
-function build_panic_node$1(node, status) {
+function build_panic_node$2(node, status) {
 	status.code += `printf("${node.message}\\n");\n`;
 	status.code += `exit(EXIT_FAILURE);\n`;
 }
@@ -57368,7 +57387,7 @@ function collect_traits(node, acc = []) {
 	for (const child of child_nodes(node)) collect_traits(child, acc);
 	return acc;
 }
-function build_root_node(node, status) {
+function build_root_node$1(node, status) {
 	status.headers += `#include <stdint.h>\n`;
 	status.headers += `#ifndef NOMEN_CLOSURE_STRUCT\n#define NOMEN_CLOSURE_STRUCT\nstruct nomen_closure { void *code; void *env; int owned; void (*destroy_env)(void *); };\n#endif\n`;
 	status.code += `
@@ -57547,7 +57566,7 @@ void **_get_trait_func(void **obj, int trait_index, int func_index)
 }
 //#endregion
 //#region ../src/build_c/build_todo_node.ts
-function build_todo_node$1(node, status) {
+function build_todo_node$2(node, status) {
 	status.code += `printf("${node.message}\\n");\n`;
 	status.code += `exit(EXIT_FAILURE);\n`;
 }
@@ -57564,19 +57583,19 @@ function build_node$1(node, status, with_semicolon = false) {
 	}
 	switch (node.node_type) {
 		case "root":
-			build_root_node(node, status);
+			build_root_node$1(node, status);
 			break;
 		case "declare": {
 			const decl = node;
-			build_declaration_node$1(decl, status);
+			build_declaration_node$2(decl, status);
 			if (decl.value?.node_type === "func") with_semicolon = false;
 			break;
 		}
 		case "assign":
-			build_assignment_node$1(node, status);
+			build_assignment_node$2(node, status);
 			break;
 		case "struct":
-			build_struct_node(node, status);
+			build_struct_node$1(node, status);
 			break;
 		case "extend": break;
 		case "trait":
@@ -57598,7 +57617,7 @@ function build_node$1(node, status, with_semicolon = false) {
 				build_magic_ctor_node$1(fc, status);
 				break;
 			}
-			build_function_call_node(node, status);
+			build_function_call_node$1(node, status);
 			break;
 		}
 		case "access": {
@@ -57607,7 +57626,7 @@ function build_node$1(node, status, with_semicolon = false) {
 				const afn = access.access;
 				if (afn.is_nursery_spawn) afn.is_statement = true;
 			}
-			build_access_node$1(access, status);
+			build_access_node$2(access, status);
 			break;
 		}
 		case "grouped":
@@ -57616,13 +57635,13 @@ function build_node$1(node, status, with_semicolon = false) {
 			status.code += ")";
 			break;
 		case "cast":
-			build_cast_node(node, status);
+			build_cast_node$1(node, status);
 			break;
 		case "op":
-			build_operation_node$1(node, status);
+			build_operation_node$2(node, status);
 			break;
 		case "if":
-			build_if_else_node(node, status);
+			build_if_else_node$1(node, status);
 			with_semicolon = false;
 			break;
 		case "match":
@@ -57634,39 +57653,39 @@ function build_node$1(node, status, with_semicolon = false) {
 			with_semicolon = false;
 			break;
 		case "for":
-			build_for_loop_node(node, status);
+			build_for_loop_node$1(node, status);
 			with_semicolon = false;
 			break;
 		case "while":
-			build_while_loop_node(node, status);
+			build_while_loop_node$1(node, status);
 			with_semicolon = false;
 			break;
 		case "break":
-			build_break_node(node, status);
+			build_break_node$1(node, status);
 			break;
 		case "continue":
-			build_continue_node(node, status);
+			build_continue_node$1(node, status);
 			break;
 		case "panic":
-			build_panic_node$1(node, status);
+			build_panic_node$2(node, status);
 			with_semicolon = false;
 			break;
 		case "todo":
-			build_todo_node$1(node, status);
+			build_todo_node$2(node, status);
 			with_semicolon = false;
 			break;
 		case "return":
 			if (node.from_inline) with_semicolon = false;
-			else build_return_node(node, status);
+			else build_return_node$1(node, status);
 			break;
 		case "let":
 			build_let_node(node, status);
 			break;
 		case "value":
-			build_value_node$1(node, status);
+			build_value_node$2(node, status);
 			break;
 		case "array":
-			build_array_values_node(node, status);
+			build_array_values_node$1(node, status);
 			break;
 		case "range":
 			build_range_node$1(node, status);
@@ -57676,7 +57695,7 @@ function build_node$1(node, status, with_semicolon = false) {
 			with_semicolon = false;
 			break;
 		case "async_block":
-			build_async_block_node(node, status);
+			build_async_block_node$1(node, status);
 			with_semicolon = false;
 			break;
 		case "block":
@@ -58665,7 +58684,7 @@ function field_path_root_struct$1(status, target) {
 	if (!path?.fields.length) return void 0;
 	return in_place_field_path_root_struct_name(status, path.root);
 }
-function build_access_node$1(node, status) {
+function build_access_node$2(node, status) {
 	let string_transfer_callee;
 	let target_type = type_from_value_node$1(node.target);
 	if (!target_type?.name && node.target.node_type === "value") {
@@ -59527,7 +59546,7 @@ function emit_rhs_value$1(rhs, nir, status) {
 	}
 	build_node$1(rhs, status);
 }
-function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
+function build_assignment_node$2(node, status, nir_rhs, nir_swap) {
 	hoist_field_overrides(node.right_value, build_node$1, status, ";\n", node.left_value.node_type === "value" ? node.left_value.value : void 0);
 	const lhs_nullable_type = lhs_nullable_struct_type(node, status);
 	if (!node.operator && lhs_nullable_type) {
@@ -61322,7 +61341,7 @@ function build_weak_ctor_a64(node, status) {
 }
 //#endregion
 //#region ../src/build_aarch64/build_panic_node.ts
-function build_panic_node(node, status) {
+function build_panic_node$1(node, status) {
 	const msg = node.message + "\\n";
 	const label = `_str_panic_${node.message.replace(/[^a-zA-Z0-9]/g, "_")}`;
 	status.strings.set(label, `"${msg}"`);
@@ -61364,7 +61383,7 @@ function evaluate_constant(node) {
 }
 //#endregion
 //#region ../src/build_aarch64/build_todo_node.ts
-function build_todo_node(node, status) {
+function build_todo_node$1(node, status) {
 	const msg = node.message + "\\n";
 	const label = `_str_todo_${node.message.replace(/[^a-zA-Z0-9]/g, "_")}`;
 	status.strings.set(label, `"${msg}"`);
@@ -61415,7 +61434,7 @@ function deref_load_instr(reg, type_name) {
 	if (size === 4) return signed ? `ldrsw x0, [${reg}]\n` : `ldr w0, [${reg}]\n`;
 	return `ldr x0, [${reg}]\n`;
 }
-function build_value_node(node, status) {
+function build_value_node$1(node, status) {
 	const original_value = node.value;
 	if (node.is_struct_zero) {
 		const struct_size = get_struct_size(mono_type_name(node.type), status);
@@ -61663,15 +61682,15 @@ function build_node(node, status, with_semicolon = false) {
 			break;
 		case "declare": {
 			const decl = node;
-			build_declaration_node(decl, status);
+			build_declaration_node$1(decl, status);
 			if (decl.value?.node_type === "func") with_semicolon = false;
 			break;
 		}
 		case "assign":
-			build_assignment_node(node, status);
+			build_assignment_node$1(node, status);
 			break;
 		case "func":
-			build_function_node$1(node, status);
+			build_function_node$2(node, status);
 			if (status.function_return_label) {
 				const fn = node;
 				if (fn.captures?.length) emit_capturing_closure_value_a64(fn, status);
@@ -61685,21 +61704,21 @@ function build_node(node, status, with_semicolon = false) {
 				build_magic_ctor_node(fc, status);
 				break;
 			}
-			build_function_call_node$1(node, status);
+			build_function_call_node$2(node, status);
 			break;
 		}
 		case "grouped":
 			build_node(node.value, status);
 			break;
 		case "op":
-			build_operation_node(node, status);
+			build_operation_node$1(node, status);
 			break;
 		case "if":
-			build_if_else_node$1(node, status);
+			build_if_else_node$2(node, status);
 			with_semicolon = false;
 			break;
 		case "cast":
-			build_cast_node$1(node, status);
+			build_cast_node$2(node, status);
 			break;
 		case "match":
 			build_match_node$1(node, status);
@@ -61710,30 +61729,30 @@ function build_node(node, status, with_semicolon = false) {
 			with_semicolon = false;
 			break;
 		case "for":
-			build_for_loop_node$1(node, status);
+			build_for_loop_node$2(node, status);
 			with_semicolon = false;
 			break;
 		case "while":
-			build_while_loop_node$1(node, status);
+			build_while_loop_node$2(node, status);
 			with_semicolon = false;
 			break;
 		case "break":
-			build_break_node$1(status);
+			build_break_node$2(status);
 			break;
 		case "continue":
-			build_continue_node$1(status);
+			build_continue_node$2(status);
 			break;
 		case "return":
-			build_return_node$1(node, status);
+			build_return_node$2(node, status);
 			break;
 		case "let":
 			build_let_node$1(node, status);
 			break;
 		case "value":
-			build_value_node(node, status);
+			build_value_node$1(node, status);
 			break;
 		case "array":
-			build_array_values_node$1(node, status);
+			build_array_values_node$2(node, status);
 			break;
 		case "range":
 			build_range_node(node, status);
@@ -61744,21 +61763,21 @@ function build_node(node, status, with_semicolon = false) {
 				const afn = access.access;
 				if (afn.is_nursery_spawn) afn.is_statement = true;
 			}
-			build_access_node(access, status);
+			build_access_node$1(access, status);
 			break;
 		}
 		case "panic":
-			build_panic_node(node, status);
+			build_panic_node$1(node, status);
 			break;
 		case "todo":
-			build_todo_node(node, status);
+			build_todo_node$1(node, status);
 			break;
 		case "raw":
 			build_raw_node$1(node, status);
 			with_semicolon = false;
 			break;
 		case "async_block":
-			build_async_block_node$1(node, status);
+			build_async_block_node$2(node, status);
 			with_semicolon = false;
 			break;
 		case "block":
@@ -62847,7 +62866,7 @@ function emit_init_value(value, nir, status) {
 function nir_array_element(nir, arr, i) {
 	return nir?.kind === "call" && nir.node === arr ? nir.facts.args[i] : void 0;
 }
-function build_declaration_node(node, status, nir_init, nir_swap) {
+function build_declaration_node$1(node, status, nir_init, nir_swap) {
 	if (!node.name && !node.type && !node.value) {
 		if (!status.build_errors) status.build_errors = [];
 		status.build_errors.push({
@@ -64231,7 +64250,7 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 			} else {
 				emit_asm(status, `.quad ${array_values.values.length}\n`);
 				emit_asm(status, `${node.name}: ${directive} `);
-				build_array_values_node$1(array_values, status);
+				build_array_values_node$2(array_values, status);
 				emit_asm(status, `\n.p2align 2\n`);
 			}
 		} else if (node.value.node_type === "range") {
@@ -65070,7 +65089,7 @@ function get_source_address(value, status, nir) {
 		ensure_newline(status);
 	}
 }
-function build_assignment_node(node, status, nir_rhs, nir_swap) {
+function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 	hoist_field_overrides(node.right_value, build_node, status, "", node.left_value.node_type === "value" ? node.left_value.value : void 0);
 	if (node.left_value.node_type === "index" || is_index_member_store(node)) {
 		build_index_store(node, status, nir_rhs);
@@ -66990,7 +67009,7 @@ function build_operator_operand(node, target_reg, status) {
 	}
 	build_operand(node, target_reg, status);
 }
-function build_operation_node(node, status) {
+function build_operation_node$1(node, status) {
 	if (node.operator_func?.deferred) {
 		let left_type = type_from_value_node$1(node.left_value);
 		let struct = status.structs.find((s) => s.name === left_type.name);
@@ -68860,9 +68879,9 @@ function build_func_field_call(node, access_func, status) {
 	call.is_func_param = true;
 	call.params = access_func.params;
 	call.type = access_func.type;
-	build_function_call_node$1(call, status);
+	build_function_call_node$2(call, status);
 }
-function build_access_node(node, status) {
+function build_access_node$1(node, status) {
 	status.at_addr_reg = void 0;
 	switch (node.access.node_type) {
 		case "access_field":
@@ -71268,8 +71287,2539 @@ function gather_normalized_struct_returners(root, status) {
 	for (const name of address_taken) status.func_address_taken.add(name);
 }
 //#endregion
+//#region ../src/build_js/call_with_refs.ts
+/**
+* A Nomen `ref` argument is an OUT-parameter: the callee may write through it
+* and the caller observes the new value. JS has no references to bindings, so
+* each ref argument is boxed (`{ v }`), the callee copies in at entry and
+* writes back on assignment, and the call site copies the box back into the
+* argument's lvalue afterwards.
+*
+* The whole call becomes an IIFE so the temp boxes stay scoped:
+*
+*   (() => { const t = { v: x }; const r = f(t); x = t.v; return r; })()
+*/
+function call_with_refs(status, args, ref_indices, build_call) {
+	const arg_exprs = args.map((arg) => expr(arg, status));
+	if (!ref_indices?.length) return build_call(arg_exprs);
+	const boxes = [];
+	const write_backs = [];
+	const call = build_call(arg_exprs.map((value, i) => {
+		if (!ref_indices.includes(i)) return value;
+		const temp = next_temp(status, "ref");
+		boxes.push(`const ${temp} = { v: ${value} };`);
+		write_backs.push(`${value} = ${temp}.v;`);
+		const arg = args[i];
+		if (arg.node_type === "value") {
+			const name = arg.value;
+			if (status.ref_params?.has(name)) write_backs.push(`__ref_${name}.v = ${name};`);
+		}
+		return temp;
+	}));
+	return `(() => { ${boxes.join(" ")} const __ret = ${call}; ${write_backs.join(" ")} return __ret; })()`;
+}
+//#endregion
+//#region ../src/build_js/types.ts
+/**
+* The checker stamps a `Type` on every expression node; the JS backend reads
+* it back without a CheckStatus (mirrors check/utils/type_from_value_node).
+*/
+function stamped_type(node) {
+	if (!node) return void 0;
+	switch (node.node_type) {
+		case "value": return node.type;
+		case "op": return node.type;
+		case "func_call": return node.type;
+		case "access": return stamped_type(node.access);
+		case "access_func": return node.type;
+		case "access_field": return node.type;
+		case "cast": return node.target_type;
+		case "if": return node.return_type;
+		case "array": return node.type;
+		case "range": return node.type;
+		default: return;
+	}
+}
+function type_name_of(node) {
+	return stamped_type(node)?.name ?? "";
+}
+/** The runtime representation family of an expression: JS `bigint` for every
+*  int family, `number` for floats, `string` for strings/chars (a char is a
+*  one-character string), `boolean` for bools, and a JS array for arrays. */
+function kind_of(node) {
+	const t = stamped_type(node);
+	if (!t) return "other";
+	if (t.is_array) return "array";
+	if (t.is_view) return t.name === "string" || t.name === "char" ? "string" : "array";
+	switch (get_built_in_type(t.name)?.kind) {
+		case "int": return "int";
+		case "float": return "float";
+		case "bool": return "bool";
+		case "char": return "char";
+		case "string": return "string";
+		default: return "other";
+	}
+}
+/** True when `name` is a user `struct` with value semantics (non-`mv`), so
+*  binding/assigning it copies the fields (MEMORY.md: "Assigning a struct
+*  creates an independent copy"). `mv`/owning structs move instead. */
+function is_value_struct(name, status) {
+	if (!name) return false;
+	const struct = status.structs.find((s) => s.name === name);
+	return !!struct && !struct.is_owning && !struct.is_class;
+}
+/** Wrap an emitted struct value in a deep copy when its type has value
+*  semantics; identity otherwise. */
+function copy_if_value_struct(value, type_name, status) {
+	return is_value_struct(type_name, status) ? `__copy(${value})` : value;
+}
+/** Wrap a value for a declared type: ints wrap at their width, everything
+*  else (arrays, views, structs, strings) is untouched. */
+function wrap_for_type(value, type) {
+	if (!type || type.is_array || type.is_view || type.is_nullable) return value;
+	return wrap_int_expression(value, type.name);
+}
+/** Wrap an int expression to its storage width. Nomen ints are 64-bit words
+*  (`int`/`uint` included, matching the C backend's `long`), so overflow
+*  wraps like the native backends instead of growing a JS `bigint`. Sized
+*  types wrap at their declared width. */
+function wrap_int_expression(value, type_name) {
+	const info = type_name ? get_built_in_type(type_name) : void 0;
+	if (info?.kind !== "int") return value;
+	const bits = type_name === "int" || type_name === "uint" ? 64 : info.bits ?? 64;
+	const bounded = bits >= 64 ? 64 : bits;
+	return info.signed ? `BigInt.asIntN(${bounded}, ${value})` : `BigInt.asUintN(${bounded}, ${value})`;
+}
+//#endregion
+//#region ../src/build_js/enums.ts
+/**
+* Enum values are plain JS objects: `{ $tag: n, <param>: value, … }`, where
+* `$tag` is the case index (the enum's declaration order, matching the C
+* backend's tag) and the payload fields are keyed by the ENUM's parameter
+* names (a match-site binding is positional — `.ok(x)` binds `x` to the
+* first payload field whatever the enum named it).
+*/
+/** Resolve the checker's flattened `Enum_case` name (`Res_ok`) to its enum
+*  and case index. */
+function find_enum_case(enums, value) {
+	for (const enum_node of enums) {
+		const prefix = `${enum_node.name}_`;
+		if (!value.startsWith(prefix)) continue;
+		const case_name = value.substring(prefix.length);
+		const case_index = enum_node.cases.findIndex((c) => c.name === case_name);
+		if (case_index !== -1) return {
+			enum_node,
+			case_index
+		};
+	}
+}
+/** The JS object literal for a case construction with the given argument
+*  expressions. */
+function enum_case_value(enum_node, case_index, args, status) {
+	const case_def = enum_node.cases[case_index];
+	const parts = [`$tag: ${case_index}`];
+	case_def.params.forEach((param, i) => {
+		if (args[i] === void 0) return;
+		const copied = status && is_value_struct(param.type?.name, status) ? `__copy(${args[i]})` : args[i];
+		parts.push(`${param.name}: ${copied}`);
+	});
+	return `({ ${parts.join(", ")} })`;
+}
+//#endregion
+//#region ../src/build_js/library.ts
+/**
+* The System-library surface the JS backend supports natively. The library's
+* own Nomen bodies are not emitted (they are raw/unsafe-heavy); instead these
+* containers map onto JS representations:
+*
+*   List<T>        → a JS array
+*   Set<T>         → a JS Set
+*   Map<K, V>      → a JS Map
+*   Box<T>         → `{ __value }` (the checker rewrites transparent access
+*                    `box.f` to `box.__value.f`)
+*   StringBuilder  → `{ s }`
+*   Buffer<T>      → a JS array (capacity is the array length)
+*   ClassBuffer<T> → a JS array (elements are object references)
+*
+* Method dispatch is by the RECEIVER's declared type name plus the method
+* name; anything unmapped falls through to a warning stub in the caller.
+*/
+/** Strip a monomorphization suffix: `List_int` → `List`, `StableList_X` →
+*  `StableList`. Longest prefixes first so `StringBuilder` wins over `String`. */
+function library_base_name(name) {
+	for (const base of [
+		"StringBuilder",
+		"ClassBuffer",
+		"StableList",
+		"Buffer",
+		"Atomic",
+		"Channel",
+		"Fiber",
+		"Mutex",
+		"Nursery",
+		"List",
+		"Task",
+		"Thread",
+		"Set",
+		"Map",
+		"Box"
+	]) if (name === base || name.startsWith(`${base}_`)) return base;
+	return name;
+}
+/** Is `name` a `Buffer<T>` (value slots) or `ClassBuffer<T>` (class slots)? */
+function is_buffer_type(name) {
+	return name === "Buffer" || name.startsWith("Buffer_") || name === "ClassBuffer" || name.startsWith("ClassBuffer_");
+}
+/** `ClassBuffer<T>` stores class references, so its stores are not copies. */
+function is_class_buffer_type(name) {
+	return name === "ClassBuffer" || name.startsWith("ClassBuffer_");
+}
+/** Constructors for the supported library types (`List<int>()`,
+*  `Box<int>(x)`, …). The checker monomorphizes the callee name
+*  (`List_int`, `Map_string_int`, `Box_P`), so match by prefix. */
+function library_constructor(name, args) {
+	if (name === "List" || name.startsWith("List_")) return args.length ? `[${args.join(", ")}]` : "[]";
+	if (name === "Set" || name.startsWith("Set_")) return "new Set()";
+	if (name === "Map" || name.startsWith("Map_")) return args.length ? `new Map(${args[0]})` : "new Map()";
+	if (name === "Box" || name.startsWith("Box_")) return `({ __value: ${args[0] ?? "null"} })`;
+	if (name === "StringBuilder") return `({ s: "" })`;
+	if (name === "StableList" || name.startsWith("StableList_")) return "[]";
+	if (name === "Channel" || name.startsWith("Channel_")) return "({ values: [], strings: [] })";
+	if (name === "Mutex" || name.startsWith("Mutex_")) return "({})";
+	if (name === "Atomic" || name.startsWith("Atomic_")) return "({ word: 0n })";
+	if (name === "Nursery" || name.startsWith("Nursery_")) return "({})";
+	if (is_buffer_type(name)) return "[]";
+}
+/** A method call on a `List<T>` receiver (a JS array). */
+function list_method(name, list, args) {
+	switch (name) {
+		case "length": return `BigInt(${list}.length)`;
+		case "at":
+		case "at_or_panic": return `__list_at(${list}, ${args[0]})`;
+		case "slot_ptr": return `${list}[Number(${args[0]})]`;
+		case "at_or": return `__list_at_or(${list}, ${args[0]}, ${args[1]})`;
+		case "set":
+		case "set_or_panic": return `(${list}[Number(${args[0]})] = ${args[1]})`;
+		case "push": return `${list}.push(${args[0]})`;
+		case "pop": return `${list}.pop()`;
+		case "remove_at_or_panic": return `${list}.splice(Number(${args[0]}), 1)[0]`;
+		case "slice": return `${list}.slice(Number(${args[0]}), Number(${args[1]}))`;
+		case "copy": return `${list}.slice()`;
+		case "clear": return `(${list}.length = 0)`;
+	}
+}
+/** A method call on a `Set<T>` receiver (a JS Set). */
+function set_method(name, set, args) {
+	switch (name) {
+		case "add": return `${set}.add(${args[0]})`;
+		case "has": return `${set}.has(${args[0]})`;
+		case "get":
+		case "get_or_panic": return `__set_get(${set}, ${args[0]})`;
+		case "get_or": return `(${set}.has(${args[0]}) ? ${set}.get(${args[0]}) : ${args[1]})`;
+		case "remove": return `${set}.delete(${args[0]})`;
+		case "copy": return `new Set(${set})`;
+		case "length": return `BigInt(${set}.size)`;
+	}
+}
+/** A method call on a `Map<K, V>` receiver (a JS Map). */
+function map_method(name, map, args) {
+	switch (name) {
+		case "set": return `${map}.set(${args[0]}, ${args[1]})`;
+		case "get":
+		case "get_or_panic": return `__map_get(${map}, ${args[0]})`;
+		case "get_or": return `(${map}.has(${args[0]}) ? ${map}.get(${args[0]}) : ${args[1]})`;
+		case "has": return `${map}.has(${args[0]})`;
+		case "remove": return `${map}.delete(${args[0]})`;
+		case "copy": return `new Map(${map})`;
+		case "length": return `BigInt(${map}.size)`;
+	}
+}
+function buffer_method(name, buf, args, options) {
+	const zero = /_(int|u32|u8)$/.test(name) ? "0n" : name.endsWith("_float") ? "0" : options.zero;
+	const store_value = (value) => options.class_elements ? value : `__copy(${value})`;
+	const load_value = (index) => options.copy_loads ? `__copy(${buf}[Number(${index})])` : `${buf}[Number(${index})]`;
+	switch (name) {
+		case "alloc":
+		case "alloc_int":
+		case "alloc_u32":
+		case "alloc_u8":
+		case "alloc_float": return `__buffer_alloc(${buf}, ${args[0]}, ${zero})`;
+		case "grow":
+		case "grow_int":
+		case "grow_u32":
+		case "grow_float": return `__buffer_grow(${buf}, ${args[0]}, ${zero})`;
+		case "load":
+		case "load_from":
+		case "load_int":
+		case "load_u32":
+		case "load_u8":
+		case "load_float": return load_value(args[0]);
+		case "store":
+		case "replace":
+		case "set": return `(${buf}[Number(${args[0]})] = ${store_value(args[1])})`;
+		case "store_int":
+		case "replace_int":
+		case "store_u32":
+		case "store_u8":
+		case "store_float":
+		case "store_take": return `(${buf}[Number(${args[0]})] = ${args[1]})`;
+		case "store_or_int":
+		case "store_or_u32": return `(${buf}[Number(${args[0]})] |= ${args[1]})`;
+		case "move":
+		case "move_int": return `__buffer_move(${buf}, ${args[0]})`;
+		case "modify": return `__buffer_modify(${buf}, ${args[0]}, ${args[1]})`;
+		case "shift": return `__buffer_shift(${buf}, ${args[0]}, ${args[1]})`;
+		case "move_range": return `__buffer_move_range(${buf}, ${args[0]}, ${args[1]}, ${args[2]})`;
+		case "zero":
+		case "zero_int":
+		case "zero_u32": return `__buffer_zero(${buf}, ${args[0]}, ${zero})`;
+		case "slice": return `${buf}.slice(Number(${args[0]}), Number(${args[1]}))`;
+		case "copy": return `__copy(${buf})`;
+		case "destroy_at": return "undefined";
+		case "clear_view": return `(${buf}.length = 0)`;
+	}
+}
+/** BigInt's raw per-limb accessors, over the `digits` Buffer (a JS array).
+*  `data_ptr` hands back the array itself, so the loop-hoisted `get_at`/
+*  `set_at` forms index it directly. */
+function bigint_method(name, self, args) {
+	switch (name) {
+		case "get": return `${self}.digits[Number(${args[0]})]`;
+		case "set": return `(${self}.digits[Number(${args[0]})] = ${args[1]})`;
+		case "data_ptr": return `${self}.digits`;
+		case "get_at": return `${args[0]}[Number(${args[1]})]`;
+		case "set_at": return `(${args[0]}[Number(${args[1]})] = ${args[2]})`;
+		case "div128": return `__div128(${args[0]}, ${args[1]}, ${args[2]})`;
+	}
+}
+/** A method call on a `StableList<T>` receiver (a JS array). */
+function stable_list_method(name, list, args) {
+	switch (name) {
+		case "push": return `${list}.push(__copy(${args[0]}))`;
+		case "at":
+		case "at_or_panic": return `__list_at(${list}, ${args[0]})`;
+		case "slot_ptr": return `${list}[Number(${args[0]})]`;
+		case "at_or": return `__list_at_or(${list}, ${args[0]}, ${args[1]})`;
+		case "copy": return `__copy(${list})`;
+	}
+}
+/**
+* Concurrency surface, run synchronously. The JS backend has no scheduler, so:
+*  - `Thread`/`Fiber.start` runs the deferred thunk now and returns a finished
+*    `Task`; `detach` runs and discards it;
+*  - `Task.result`/`result_uint64`/`is_done` read that finished result,
+*    `wait` is a no-op, `cancel`/`current_cancelled` are inert;
+*  - `Channel` is two in-memory FIFOs (receive yields zero when empty);
+*  - `Mutex.lock`/`unlock` and `Atomic`'s operations are plain value updates.
+*/
+function concurrency_method(base, name, self, args, is_static) {
+	switch (base) {
+		case "Thread":
+		case "Fiber":
+			if (is_static) return void 0;
+			if (name === "start") return `__spawn_start(${self})`;
+			if (name === "detach") return `__spawn_detach(${self})`;
+			return;
+		case "Nursery":
+			if (name === "start") return `__nursery_start(${self}, ${args[0]})`;
+			return;
+		case "Task":
+			if (is_static) {
+				if (name === "current_cancelled") return "false";
+				if (name === "set_pool_size") return args[0] ?? "0n";
+				if (name === "shutdown_pool") return "undefined";
+				return;
+			}
+			switch (name) {
+				case "wait": return `__task_wait(${self})`;
+				case "result": return `__task_result(${self})`;
+				case "result_uint64": return `__task_result_uint64(${self})`;
+				case "is_done": return "true";
+				case "cancel": return "undefined";
+			}
+			return;
+		case "Channel":
+			switch (name) {
+				case "send": return `__channel_send(${self}, ${args[0]})`;
+				case "send_string": return `__channel_send_string(${self}, ${args[0]})`;
+				case "receive": return `__channel_receive(${self})`;
+				case "receive_string": return `__channel_receive_string(${self})`;
+			}
+			return;
+		case "Mutex":
+			if (name === "lock" || name === "unlock") return "undefined";
+			return;
+		case "Atomic":
+			switch (name) {
+				case "load": return `${self}.word`;
+				case "store": return `(${self}.word = ${args[0]})`;
+				case "fetch_add": return `__atomic_fetch_add(${self}, ${args[0]})`;
+				case "swap": return `__atomic_swap(${self}, ${args[0]})`;
+			}
+			return;
+	}
+}
+/** A method call on a `StringBuilder` receiver (`{ s }`). */
+function string_builder_method(name, sb, args) {
+	switch (name) {
+		case "append":
+		case "append_string":
+		case "append_string_view":
+		case "append_int":
+		case "append_float":
+		case "append_char":
+		case "seed": return `(${sb}.s += __to_string(${args[0]}))`;
+		case "length": return `BigInt(${sb}.s.length)`;
+		case "to_string": return `${sb}.s`;
+		case "truncate": return `(${sb}.s = ${sb}.s.slice(0, Number(${args[0]})))`;
+		case "chomp": return `(${sb}.s = ${sb}.s.replace(/\\n$/, ""))`;
+		case "ends_with": return `${sb}.s.endsWith(${args[0]})`;
+		case "take_since": return `__sb_take_since(${sb}, ${args[0]})`;
+		case "clear": return `(${sb}.s = "")`;
+		case "ensure": return "undefined";
+	}
+}
+//#endregion
+//#region ../src/build_js/names.ts
+/**
+* JavaScript identifiers that Nomen allows as names but JS reserves (or that
+* would shadow a global the generated code relies on). Binding names go
+* through `js_name`; property names after `.` never do (JS allows reserved
+* words there).
+*/
+const JS_RESERVED = /* @__PURE__ */ new Set([
+	"arguments",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"undefined",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+/** The emitted JS binding name for a Nomen identifier. `#` markers (the
+*  compiler's special names, e.g. `#init`) are stripped, and a name that JS
+*  reserves is prefixed with `$`. */
+function js_name(name) {
+	const base = name.replace(/#/g, "");
+	return JS_RESERVED.has(base) ? `$${base}` : base;
+}
+/** The emitted JS name for a free/nested function (the checker's unique
+*  `label_name` when present, else the source name). */
+function function_label(func) {
+	return js_name(emission_label(func));
+}
+/** The emitted JS name for a struct method (`<Struct>_<method>`). */
+function method_label(struct_name, func_name) {
+	return js_name(`${struct_name}_${func_name}`);
+}
+/** The emitted JS name for a struct constructor factory. */
+function init_label(struct_name) {
+	return js_name(`${struct_name}_init`);
+}
+/** The emitted JS name for a struct's runtime method table (trait dispatch). */
+function type_label(struct_name) {
+	return js_name(`${struct_name}_type`);
+}
+/** The emitted JS name for a struct's `#init` body (called from the
+*  constructor IIFE, not part of the method table). */
+function init_body_label(struct_name, index) {
+	return js_name(`${struct_name}_init_body_${index}`);
+}
+//#endregion
+//#region ../src/build_js/build_function_node.ts
+/** Emit a free or nested function declaration. */
+function build_function_node(node, status) {
+	if (!node.has_body || node.is_generic) return;
+	const old_ref_params = status.ref_params;
+	status.ref_params = /* @__PURE__ */ new Set();
+	const params = node.params.map((param) => boxed_param_signature(param, status)).join(", ");
+	emit(status, `function ${function_label(node)}(${params}) {`);
+	status.indent += 1;
+	for (const param of node.params) emit_ref_prologue(param, status);
+	for (const statement of node.statements) stmt(statement, status);
+	status.indent -= 1;
+	emit(status, "}");
+	status.ref_params = old_ref_params;
+}
+/** A `ref` non-self parameter is passed as a box (`{ v }`); the JS parameter
+*  takes the box name and the body's prologue copies the value in. `self` is
+*  already a reference (an object), so a `ref self` receiver passes normally. */
+function boxed_param_signature(param, status) {
+	if (is_ref_param(param)) {
+		status.ref_params?.add(js_name(param.name));
+		return `__ref_${js_name(param.name)}`;
+	}
+	return param_signature(param);
+}
+function emit_ref_prologue(param, status) {
+	if (is_ref_param(param)) emit(status, `let ${js_name(param.name)} = __ref_${js_name(param.name)}.v;`);
+}
+/** A JS parameter list entry: `self` keeps its name; every other Nomen name
+*  is sanitized. `ref`/`mv` are compile-time modifiers with no JS analogue. */
+function param_signature(param) {
+	return param.is_self_param ? "self" : js_name(param.name);
+}
+/** A function LITERAL in expression position (`(x) => x * 2`, or a block-body
+*  lambda): a JS function expression. Captures are lexical — JS closures give
+*  the same shape the C backend builds environment structs for. */
+function build_function_expression(node, status) {
+	const fn = `function (${node.params.map(param_signature).join(", ")}) {\n${capture_body(status, () => {
+		for (const statement of node.statements) stmt(statement, status);
+	})}${"	".repeat(status.indent)}}`;
+	const copied = (node.captures ?? []).filter((capture) => !capture.is_move && is_value_struct(capture.type?.name, status));
+	if (copied.length === 0) return fn;
+	const names = copied.map((capture) => js_name(capture.name));
+	return `((${names.join(", ")}) => ${fn})(${names.map((name) => `__copy(${name})`).join(", ")})`;
+}
+/** A `ref` parameter other than the `self` receiver. The parser records `ref`
+*  on the type for ordinary parameters (`ref int x`) and on the parameter
+*  itself for `ref self`. */
+function is_ref_param(param) {
+	if (param.is_self_param) return false;
+	return !!(param.is_ref || param.type?.is_ref);
+}
+//#endregion
+//#region ../src/build_js/library_queue.ts
+/**
+* On-demand lowering of System-library code written in plain Nomen.
+*
+* The JS runtime natively models the containers (List/Map/Set/Box/…) and I/O,
+* but much of the library — `Text.Regex`, `Text.Chars`, `Json`, … — is
+* ordinary Nomen over strings, arrays, and ints. Rather than hand-port those,
+* the backend emits the checked body of each referenced method, exactly like
+* user code. A library body that needs raw memory (`#arch`, `unsafe`, pointer
+* indexing, foreign calls, threads) becomes a loud `__unsupported` stub
+* instead of silently wrong code.
+*/
+/** Library types the JS runtime models directly; their code is never lowered
+*  generically (the native mapping handles their supported surface). */
+const NATIVE_TYPES = /* @__PURE__ */ new Set([
+	"Array",
+	"Atomic",
+	"Box",
+	"Buffer",
+	"Channel",
+	"Console",
+	"Fiber",
+	"Format",
+	"List",
+	"Map",
+	"Mutex",
+	"Nursery",
+	"Set",
+	"StableList",
+	"String",
+	"StringBuilder",
+	"Task",
+	"Thread"
+]);
+/** Is this a library type we must not lower generically? */
+function is_native_library_type(name) {
+	if (NATIVE_TYPES.has(name)) return true;
+	if (NATIVE_TYPES.has(library_base_name(name))) return true;
+	if (is_buffer_type(name)) return true;
+	return !!get_built_in_type(name);
+}
+/** Queue a specific library method (only the one that is called). */
+function queue_library_method(struct, func, status) {
+	if (status.emitted_library.has(func)) return;
+	if (status.library_method_queue.some((entry) => entry.func === func)) return;
+	status.library_method_queue.push({
+		struct,
+		func
+	});
+}
+/** Queue a library struct's constructor factory. */
+function queue_library_init(struct, status) {
+	if (status.emitted_library.has(struct)) return;
+	if (status.library_init_queue.includes(struct)) return;
+	status.library_init_queue.push(struct);
+}
+/** Queue a library free function. */
+function queue_library_function(func, status) {
+	if (func.is_generic) return;
+	if (status.emitted_library.has(func)) return;
+	if (status.library_function_queue.includes(func)) return;
+	status.library_function_queue.push(func);
+}
+/** Find a struct method by name (and arity, so overloads resolve). */
+function library_method(struct, name, arg_count, is_static) {
+	const arity = is_static ? arg_count : arg_count + 1;
+	const candidates = struct.functions.filter((f) => f.name === name && f.has_body);
+	return candidates.find((f) => f.params.length === arity) ?? candidates.find((f) => f.params.length >= arity) ?? candidates[0];
+}
+/** The emitted JS label for a library method. Overloads (same name, different
+*  arity) get an arity suffix so the declarations stay distinct. */
+function library_method_label(struct, func) {
+	if (func.name === "#init") return js_name(`${struct.name}_lib_init_${func.params.length}`);
+	if (struct.functions.filter((f) => f.name === func.name && f.has_body).length <= 1) return method_label(struct.name, func.name);
+	return js_name(`${struct.name}_${func.name}_${func.params.length}`);
+}
+/** Emit every queued library declaration into `status.library_code`. The
+*  queue grows while bodies are emitted (a library body calls other library
+*  code), so this drains it to a fixed point. */
+function emit_library_queue(status) {
+	const outer_code = status.code;
+	const outer_indent = status.indent;
+	status.code = "";
+	status.indent = 0;
+	while (status.library_init_queue.length || status.library_method_queue.length || status.library_function_queue.length) {
+		const init = status.library_init_queue.shift();
+		if (init) {
+			if (!status.emitted_library.has(init)) {
+				status.emitted_library.add(init);
+				emit_library_init(init, status);
+			}
+			continue;
+		}
+		const entry = status.library_method_queue.shift();
+		if (entry) {
+			if (!status.emitted_library.has(entry.func)) {
+				status.emitted_library.add(entry.func);
+				emit_library_method(entry.struct, entry.func, status);
+			}
+			continue;
+		}
+		const func = status.library_function_queue.shift();
+		if (!func) continue;
+		if (status.emitted_library.has(func)) continue;
+		status.emitted_library.add(func);
+		emit_library_function(func, status);
+	}
+	status.library_code += status.code;
+	status.code = outer_code;
+	status.indent = outer_indent;
+}
+function emit_library_method(struct, func, status) {
+	const label = library_method_label(struct, func);
+	if (needs_raw_memory(func)) {
+		emit_library_stub(label, func, status);
+		return;
+	}
+	const old_ref_params = status.ref_params;
+	status.ref_params = /* @__PURE__ */ new Set();
+	emit(status, `function ${label}(${func.params.map((param) => boxed_param_signature(param, status)).join(", ")}) {`);
+	status.indent += 1;
+	for (const param of func.params) emit_ref_prologue(param, status);
+	for (const statement of func.statements) stmt(statement, status);
+	status.indent -= 1;
+	emit(status, "}");
+	status.ref_params = old_ref_params;
+}
+function emit_library_function(func, status) {
+	const label = js_name(func.name);
+	if (needs_raw_memory(func)) {
+		emit_library_stub(label, func, status);
+		return;
+	}
+	const old_ref_params = status.ref_params;
+	status.ref_params = /* @__PURE__ */ new Set();
+	emit(status, `function ${label}(${func.params.map((param) => boxed_param_signature(param, status)).join(", ")}) {`);
+	status.indent += 1;
+	for (const param of func.params) emit_ref_prologue(param, status);
+	for (const statement of func.statements) stmt(statement, status);
+	status.indent -= 1;
+	emit(status, "}");
+	status.ref_params = old_ref_params;
+}
+/** Emit a library struct's constructor factory (no methods, no `$type`). */
+function emit_library_init(struct, status) {
+	const fields = struct.fields.filter((field) => !!field.name);
+	const params = fields.map((field) => {
+		const name = js_name(field.name);
+		return field.value ? `${name} = ${expr(field.value, status)}` : name;
+	});
+	const properties = fields.map((field) => `${field.name}: ${js_name(field.name)}`);
+	emit(status, `function ${init_label(struct.name)}(${params.join(", ")}) {`);
+	status.indent += 1;
+	emit(status, `return { ${properties.join(", ")} };`);
+	status.indent -= 1;
+	emit(status, "}");
+}
+/** Emit a library body the JS backend cannot lower as a warning stub: the
+*  program keeps running without it (the call site sees a zero value). */
+function emit_library_stub(label, func, status) {
+	const old_ref_params = status.ref_params;
+	status.ref_params = /* @__PURE__ */ new Set();
+	const params = func.params.map((param) => boxed_param_signature(param, status)).join(", ");
+	const returned = func.return_type ? ` return ${zero_js_value(func.return_type)};` : "";
+	emit(status, `function ${label}(${params}) { __skip(${JSON.stringify(`library ${label}`)});${returned} }`);
+	status.ref_params = old_ref_params;
+}
+/** The JS value a skipped library body yields for its declared return type. */
+function zero_js_value(type) {
+	if (!type) return "undefined";
+	if (!type.name || type.name === "void" || type.name === "?") return "undefined";
+	switch (get_built_in_type(type.name)?.kind) {
+		case "int": return "0n";
+		case "float": return "0";
+		case "bool": return "false";
+		case "string":
+		case "char": return "\"\"";
+	}
+	if (type.is_array || type.is_view) return "[]";
+	return "null";
+}
+/** Does this library body rely on constructs the JS backend cannot express
+*  (raw asm/C, unsafe pointer work, foreign functions, threads)? */
+function needs_raw_memory(node) {
+	if (UNSUPPORTED_NODE_TYPES.has(node.node_type)) return true;
+	if (node.node_type === "func_call") {
+		const call = node;
+		if (call.name?.startsWith("foreign_")) return true;
+		if (call.resolved_function?.is_foreign) return true;
+		if (call.resolved_function && call.resolved_function.has_body === false) return true;
+	}
+	if (node.node_type === "access") {
+		if (node.access?.name?.startsWith("foreign_")) return true;
+	}
+	for (const child of child_nodes(node)) if (needs_raw_memory(child)) return true;
+	return false;
+}
+const UNSUPPORTED_NODE_TYPES = /* @__PURE__ */ new Set([
+	"raw",
+	"unsafe",
+	"spawn",
+	"async_block",
+	"class",
+	"index"
+]);
+/** The call text for a library method (used by the access builder). */
+function library_method_call(struct, func, target, args, status) {
+	queue_library_method(struct, func, status);
+	const label = library_method_label(struct, func);
+	if (target === void 0) return `${label}(${args.join(", ")})`;
+	return `${label}(${[expr(target, status), ...args].join(", ")})`;
+}
+//#endregion
+//#region ../src/build_js/build_access_node.ts
+/**
+* Emit a JS expression for a member access:
+*  - field access → `obj.field`;
+*  - static library calls (`Console.write`, `Format.pad`, …) → runtime helpers;
+*  - string/array builtins → the native JS equivalents;
+*  - the supported System containers (List/Map/StringBuilder) → their JS
+*    representations;
+*  - user struct methods → `<Struct>_<method>(self, args…)`.
+* Anything outside the supported subset becomes a loud runtime error.
+*/
+function build_access_node(node, status) {
+	const access = node.access;
+	if (access.node_type === "access_field") {
+		const target_type = type_name_of(node.target);
+		const bitset = status.bitsets.find((b) => b.name === target_type);
+		if (bitset) {
+			const index = bitset.cases.indexOf(access.name);
+			if (index !== -1) return `(1n << ${index}n)`;
+			return unsupported(`bitset ${target_type}.${access.name}`);
+		}
+		const enum_node = status.enums.find((e) => e.name === target_type);
+		if (enum_node) {
+			const case_index = enum_node.cases.findIndex((c) => c.name === access.name);
+			if (case_index !== -1) return enum_case_value(enum_node, case_index, [], status);
+		}
+		if (access.name === "length" && library_base_name(target_type) === "StringBuilder") return `BigInt(${expr(node.target, status)}.s.length)`;
+		if (access.name === "length" && library_base_name(target_type) === "Map") return `BigInt(${expr(node.target, status)}.size)`;
+		if (access.name === "length" && library_base_name(target_type) === "Set") return `BigInt(${expr(node.target, status)}.size)`;
+		if (access.name === "length" && library_base_name(target_type) === "List") return `BigInt(${expr(node.target, status)}.length)`;
+		if (access.name === "length" && library_base_name(target_type) === "StableList") return `BigInt(${expr(node.target, status)}.length)`;
+		if (is_buffer_type(target_type) && access.name === "cap") return `BigInt(${expr(node.target, status)}.length)`;
+		if (is_buffer_type(target_type) && access.name === "data") return "0n";
+		if (access.name === "length") {
+			const target_kind = kind_of(node.target);
+			if (target_kind === "array" || target_kind === "string") return `BigInt(${expr(node.target, status)}.length)`;
+		}
+		return `${expr(node.target, status)}.${access.name}`;
+	}
+	return build_method_call(node.target, access, status);
+}
+function build_method_call(target, access, status) {
+	const name = access.name;
+	const args = access.params.map((p) => expr(p, status));
+	const target_type = type_name_of(target);
+	const native_type = library_base_name(target_type);
+	const target_kind = kind_of(target);
+	const target_stamp = stamped_type(target);
+	const receiver_class = access.devirtualized_class ?? (target_stamp?.type_args?.length ? mono_type_name(target_stamp) : target_type);
+	if (access.is_func_field_call) return call_with_refs(status, access.params, access.ref_param_indices, (arg_exprs) => `${expr(target, status)}.${name}(${arg_exprs.join(", ")})`);
+	if (access.is_static) {
+		if (target_type === "Console") return `Console_${name}(${args.join(", ")})`;
+		if (target_type === "Format") return `Format_${name}(${args.join(", ")})`;
+		if (target_type === "Math" && name === "power") return `__math_power(${args.join(", ")})`;
+		if (target_type === "Array" && name === "with") return `__array_with(${args.join(", ")})`;
+		if (target_type === "int" && name === "parse") return `__parse_int(${args[0]})`;
+		if (target_type === "Time") return time_call(name, args);
+		if (target_type === "Utf8") return utf8_call(name, args);
+		const static_concurrency = concurrency_method(library_base_name(target_type), name, "undefined", args, true);
+		if (static_concurrency !== void 0) return static_concurrency;
+		const enum_node = status.enums.find((e) => e.name === target_type);
+		if (enum_node) {
+			const case_index = enum_node.cases.findIndex((c) => c.name === name);
+			if (case_index !== -1) return enum_case_value(enum_node, case_index, args, status);
+		}
+		if (status.structs.find((s) => s.name === target_type)) return call_with_refs(status, access.params, access.ref_param_indices, (arg_exprs) => `${method_label(target_type, name)}(${arg_exprs.join(", ")})`);
+		const library_struct = status.library_structs.find((s) => s.name === receiver_class && !is_native_library_type(s.name));
+		const library_func = library_struct && library_method(library_struct, name, args.length, true);
+		if (library_struct && library_func) return call_with_refs(status, access.params, access.ref_param_indices, (arg_exprs) => library_method_call(library_struct, library_func, void 0, arg_exprs, status));
+		return unsupported(`${target_type}.${name}`);
+	}
+	if (target_kind === "string" || target_kind === "char") {
+		const text = expr(target, status);
+		switch (name) {
+			case "to_string": return text;
+			case "length": return `BigInt(${text}.length)`;
+			case "at":
+			case "at_or_panic": return `__string_at(${text}, ${args[0]})`;
+			case "at_or": return `__string_at_or(${text}, ${args[0]}, ${args[1]})`;
+			case "slice":
+			case "substring": return `${text}.slice(Number(${args[0]}), Number(${args[1]}))`;
+			case "copy": return text;
+			case "trim": return `${text}.trim()`;
+			case "trim_start": return `${text}.replace(/^\\s+/, "")`;
+			case "trim_end": return `${text}.replace(/\\s+$/, "")`;
+			case "to_lowercase": return `${text}.toLowerCase()`;
+			case "to_uppercase": return `${text}.toUpperCase()`;
+			case "contains": return `${text}.includes(${args[0]})`;
+			case "starts_with": return `${text}.startsWith(${args[0]})`;
+			case "ends_with": return `${text}.endsWith(${args[0]})`;
+			case "index_of": return `BigInt(${text}.indexOf(${args[0]}))`;
+			case "index_of_from": return `BigInt(${text}.indexOf(${args[0]}, Number(${args[1]})))`;
+			case "replace_first": return `${text}.replace(${args[0]}, ${args[1]})`;
+			case "replace_all": return `${text}.replaceAll(${args[0]}, ${args[1]})`;
+			case "char_code_at": return `BigInt(${text}.charCodeAt(Number(${args[0]})))`;
+			case "char_code_at_or": return `__char_code_at_or(${text}, ${args[0]}, ${args[1]})`;
+			case "hash": return `__string_hash(${text})`;
+		}
+		return unsupported(`string.${name}`);
+	}
+	if (target_kind === "array") {
+		const list = expr(target, status);
+		switch (name) {
+			case "length": return `BigInt(${list}.length)`;
+			case "at": return `${list}[Number(${args[0]})]`;
+			case "set": return `(${list}[Number(${args[0]})] = ${stored_args(access.params, status)[1]})`;
+			case "push": return `${list}.push(${stored_args(access.params, status)[0]})`;
+			case "pop": return `${list}.pop()`;
+			case "slice": return `${list}.slice(Number(${args[0]}), Number(${args[1]}))`;
+			case "copy": return `${list}.slice()`;
+		}
+		return unsupported(`array.${name}`);
+	}
+	if (native_type === "List") {
+		const mapped = list_method(name, expr(target, status), stored_args(access.params, status));
+		if (mapped !== void 0) return mapped;
+	}
+	if (native_type === "Set") {
+		const mapped = set_method(name, expr(target, status), stored_args(access.params, status));
+		if (mapped !== void 0) return mapped;
+	}
+	if (native_type === "Map") {
+		const mapped = map_method(name, expr(target, status), stored_args(access.params, status));
+		if (mapped !== void 0) return mapped;
+	}
+	if (native_type === "StringBuilder") {
+		const mapped = string_builder_method(name, expr(target, status), args);
+		if (mapped !== void 0) return mapped;
+	}
+	if (native_type === "BigInt") {
+		const mapped = bigint_method(name, expr(target, status), args);
+		if (mapped !== void 0) return mapped;
+	}
+	if (native_type === "StableList") {
+		const mapped = stable_list_method(name, expr(target, status), stored_args(access.params, status));
+		if (mapped !== void 0) return mapped;
+	}
+	if (is_buffer_type(target_type)) {
+		const mapped = buffer_method(name, expr(target, status), args, {
+			class_elements: is_class_buffer_type(target_type),
+			...buffer_zero(target)
+		});
+		if (mapped !== void 0) return mapped;
+	}
+	const concurrency = concurrency_method(native_type, name, expr(target, status), args, false);
+	if (concurrency !== void 0) return concurrency;
+	if (status.structs.find((s) => s.name === receiver_class)) return call_with_refs(status, access.params, access.ref_param_indices, (arg_exprs) => `${method_label(receiver_class, name)}(${[expr(target, status), ...arg_exprs].join(", ")})`);
+	if (name === "hash" && target_kind === "int") return `BigInt.asUintN(64, ${expr(target, status)})`;
+	const library_struct = status.library_structs.find((s) => s.name === receiver_class && !is_native_library_type(s.name));
+	const library_func = library_struct && library_method(library_struct, name, args.length, false);
+	if (library_struct && library_func) return call_with_refs(status, access.params, access.ref_param_indices, (arg_exprs) => library_method_call(library_struct, library_func, target, arg_exprs, status));
+	if (name === "to_string") return `__to_string(${expr(target, status)})`;
+	if (status.traits.some((t) => t.name === target_type || t.name === receiver_class)) return `__dispatch(${[
+		expr(target, status),
+		JSON.stringify(name),
+		...args
+	].join(", ")})`;
+	return unsupported(`${target_type}.${name}`);
+}
+/** The zero value a freshly grown Buffer slot holds, and whether loads must
+*  copy: struct/enum slots have value semantics, scalars and strings don't. */
+function buffer_zero(target) {
+	const type = stamped_type(target);
+	const element_name = buffer_element_name(type);
+	const info = element_name ? get_built_in_type(element_name) : void 0;
+	if (is_class_buffer_type(type?.name ?? "")) return {
+		zero: "null",
+		copy_loads: false
+	};
+	switch (info?.kind) {
+		case "int": return {
+			zero: "0n",
+			copy_loads: false
+		};
+		case "float": return {
+			zero: "0",
+			copy_loads: false
+		};
+		case "bool": return {
+			zero: "false",
+			copy_loads: false
+		};
+		case "string":
+		case "char": return {
+			zero: "\"\"",
+			copy_loads: false
+		};
+		default: return {
+			zero: "undefined",
+			copy_loads: true
+		};
+	}
+}
+/** `Buffer_int` → `int`, `Buffer<T>` → `T`, `ClassBuffer_Animal` → `Animal`. */
+function buffer_element_name(type) {
+	const arg = type?.type_args?.[0];
+	if (arg) return arg.name;
+	const name = type?.name ?? "";
+	for (const prefix of ["ClassBuffer_", "Buffer_"]) if (name.startsWith(prefix)) return name.slice(prefix.length);
+}
+/** `System.Utf8` over the JS string model (code units, not bytes): decoding
+*  advances one code unit for BMP text and two for astral characters. */
+function utf8_call(name, args) {
+	switch (name) {
+		case "decode_at": return `__utf8_decode(${args[0]}, ${args[1]})`;
+		case "width_at": return `__utf8_decode(${args[0]}, ${args[1]}).byte_length`;
+		case "encode": return `__utf8_encode(${args[0]})`;
+		case "char_count": return `BigInt([...${args[0]}].length)`;
+	}
+	return unsupported(`Utf8.${name}`);
+}
+/** `System.Time` reads and sleeps, mapped onto JS clock/sleep primitives. */
+function time_call(name, args) {
+	switch (name) {
+		case "now_ms": return "BigInt(Date.now())";
+		case "now_ns": return "(BigInt(Date.now()) * 1000000n)";
+		case "now_unix": return "BigInt(Math.floor(Date.now() / 1000))";
+		case "sleep_ms": return `__sleep_ms(${args[0]})`;
+	}
+	return unsupported(`Time.${name}`);
+}
+/** Container stores copy value structs (MEMORY.md: a copy into a container
+*  slot is independent). Scalars/strings are identity under `__copy`. */
+function stored_args(args, status) {
+	return args.map((arg) => copy_if_value_struct(expr(arg, status), stamped_type(arg)?.name, status));
+}
+function unsupported(what) {
+	return `__skip(${JSON.stringify(what)})`;
+}
+//#endregion
+//#region ../src/build_js/build_array_values_node.ts
+/** Emit a JS array literal (`[a, b, c]`). */
+function build_array_values_node(node, status) {
+	return `[${node.values.map((v) => expr(v, status)).join(", ")}]`;
+}
+//#endregion
+//#region ../src/build_js/build_assignment_node.ts
+/** Emit an assignment (plain, compound, or `x = y swap z`). */
+function build_assignment_node(node, status) {
+	const left = expr(node.left_value, status);
+	const right = copy_if_value_struct(expr(node.right_value, status), stamped_type(node.right_value)?.name, status);
+	if (node.swap) {
+		const temp = next_temp(status, "swap");
+		emit(status, "{");
+		status.indent += 1;
+		emit(status, `const ${temp} = ${right};`);
+		emit(status, `${left} = ${temp};`);
+		emit(status, `${right} = ${expr(node.swap, status)};`);
+		status.indent -= 1;
+		emit(status, "}");
+		return;
+	}
+	const operator = node.operator ?? "=";
+	if (operator !== "=" && operator.endsWith("=")) {
+		const base_op = operator.slice(0, -1);
+		const target = stamped_type(node.left_value)?.name;
+		emit(status, `${left} = ${wrap_int_expression(`(${left} ${base_op} ${right})`, target)};`);
+	} else emit(status, `${left} = ${wrap_for_type(right, stamped_type(node.left_value))};`);
+	write_back_ref_param(node, status);
+}
+/** A `ref` parameter is a local bound from its box: after every assignment
+*  the box receives the new value (the caller copies it out at the call). */
+function write_back_ref_param(node, status) {
+	if (node.left_value.node_type !== "value") return;
+	const name = js_name(node.left_value.value);
+	if (!status.ref_params?.has(name)) return;
+	emit(status, `__ref_${name}.v = ${name};`);
+}
+//#endregion
+//#region ../src/build_js/build_async_block_node.ts
+/**
+* `async { ... }` — the JS backend runs the nursery INLINE, in source order.
+*
+* Concurrency is omitted rather than emulated: every `Thread(...).start()` /
+* `Fiber(...).start()` / `nursery.start(...)` inside the block runs its task
+* synchronously before returning, so the implicit join at the closing brace is
+* already satisfied. A named nursery (`async pool { ... }`) becomes a plain
+* object that `pool.start(Thread(...))` accepts.
+*/
+function build_async_block_node(node, status) {
+	emit(status, "{");
+	status.indent += 1;
+	build_nursery(node, status);
+	if (node.timeout) emit(status, `${expr(node.timeout, status)};`);
+	for (const statement of node.statements) stmt(statement, status);
+	status.indent -= 1;
+	emit(status, "}");
+}
+/** The value form of `async { ... }` (rare, but the checker can wrap one in a
+*  `let`): an IIFE that runs the block and yields `undefined`. */
+function build_async_block_expression(node, status) {
+	return `(() => {\n${capture_body(status, () => {
+		build_nursery(node, status);
+		if (node.timeout) emit(status, `${expr(node.timeout, status)};`);
+		for (const statement of node.statements) stmt(statement, status);
+	})}${"	".repeat(status.indent)}})()`;
+}
+function build_nursery(node, status) {
+	if (!node.nursery_name) return;
+	emit(status, `let ${js_name(node.nursery_name)} = {};`);
+}
+//#endregion
+//#region ../src/build_js/build_break_node.ts
+/** `break` (loop labels are not in the v1 subset). */
+function build_break_node(node, status) {
+	emit(status, "break;");
+}
+//#endregion
+//#region ../src/build_js/build_cast_node.ts
+/** Emit a JS expression for an `as` cast between the numeric/bool/char
+*  families. Sized int targets wrap with BigInt.asIntN/asUintN, matching the
+*  C backend's truncation. */
+function build_cast_node(node, status) {
+	const value = expr(node.value, status);
+	const from = kind_of(node.value);
+	const to = kind_of(node);
+	const target = node.target_type;
+	if (node.operator_func && status.structs.some((s) => s.name === node.operator_func?.struct_name)) {
+		const { struct_name, func_name } = node.operator_func;
+		return `${method_label(struct_name, func_name)}(${value})`;
+	}
+	if (node.enum_case_conversion) {
+		if (node.enum_case_conversion.direction === "case_to_base") return value;
+		const enum_node = status.enums.find((e) => e.name === node.target_type.name.split("_")[0]);
+		const case_name = node.target_type.name.split("_").slice(1).join("_");
+		const case_index = enum_node?.cases.findIndex((c) => c.name === case_name) ?? -1;
+		if (enum_node && case_index !== -1) return `__enum_to_case(${value}, ${case_index}, ${JSON.stringify(node.target_type.name)})`;
+		return value;
+	}
+	if (from === to) return value;
+	if (to === "float") return `Number(${value})`;
+	if (to === "int" && from === "float") return `BigInt(Math.trunc(${value}))`;
+	if (to === "int" && from === "char") return `BigInt(${value}.charCodeAt(0))`;
+	if (to === "int" && from === "bool") return `(${value} ? 1n : 0n)`;
+	if (to === "bool" && from === "int") return `(${value} !== 0n)`;
+	if (to === "char" && from === "int") return `String.fromCharCode(Number(${value}))`;
+	if (to === "char" && from === "bool") return `(${value} ? "\\x01" : "\\x00")`;
+	if (to === "string" && from !== "string") return `__to_string(${value})`;
+	if (to === "int" && from === "int") {
+		const info = get_built_in_type(target.name);
+		const bits = info?.bits ?? 64;
+		if (bits >= 64) return value;
+		return info?.signed ? `BigInt.asIntN(${bits}, ${value})` : `BigInt.asUintN(${bits}, ${value})`;
+	}
+	return value;
+}
+//#endregion
+//#region ../src/build_js/build_continue_node.ts
+/** `continue` (loop labels are not in the v1 subset). */
+function build_continue_node(node, status) {
+	emit(status, "continue;");
+}
+//#endregion
+//#region ../src/build_js/build_declaration_node.ts
+/** Emit a `var`/`const` declaration. Uninitialized locals get the type's
+*  zero value (JS `let x;` would be `undefined`, which no Nomen value is). */
+function build_declaration_node(node, status) {
+	const keyword = node.declaration === "const" ? "const" : "let";
+	const name = js_name(node.name);
+	const raw = node.value ? expr(node.value, status) : zero_value$1(node.type);
+	const copied = node.value ? copy_if_value_struct(raw, node.type?.name, status) : raw;
+	emit(status, `${keyword} ${name} = ${node.value ? wrap_for_type(copied, node.type) : copied};`);
+}
+function zero_value$1(type) {
+	if (!type) return "null";
+	if (type.is_array) return "[]";
+	switch (get_built_in_type(type.name)?.kind) {
+		case "int": return "0n";
+		case "float": return "0";
+		case "bool": return "false";
+		case "char":
+		case "string": return "\"\"";
+		default: return "null";
+	}
+}
+//#endregion
+//#region ../src/build_js/build_while_loop_node.ts
+/** Emit a while loop. The optional `; update` clause runs after each body
+*  iteration — including on `continue`, so it lowers to a `for (; cond;
+*  update)` loop rather than a `while` with the update appended to the body
+*  (JS `continue` would otherwise skip it and spin forever). */
+function build_while_loop_node(node, status) {
+	const condition = expr(node.condition, status);
+	if (node.update) emit(status, `for (; ${condition}; ${update_expression(node.update, status)}) {`);
+	else emit(status, `while (${condition}) {`);
+	status.indent += 1;
+	for (const statement of node.statements) stmt(statement, status);
+	status.indent -= 1;
+	emit(status, "}");
+}
+/** The `; update` clause as a JS expression (no trailing semicolon). */
+function update_expression(node, status) {
+	if (!node) return "";
+	if (node.node_type === "assign") {
+		const assign = node;
+		return `${expr(assign.left_value, status)} ${assign.operator ?? "="} ${expr(assign.right_value, status)}`;
+	}
+	return expr(node, status);
+}
+//#endregion
+//#region ../src/build_js/build_for_loop_node.ts
+/** Emit a `for` loop over a range (`for i of 0 .. n`) or an array
+*  (`for x of xs`, optionally with an index: `for i, x of xs`). A `; update`
+*  clause runs at the end of each iteration (matching the native backends). */
+function build_for_loop_node(node, status) {
+	const item_name = js_name(node.item.value);
+	const update = node.update ? update_expression(node.update, status) : void 0;
+	if (node.list.node_type === "range") {
+		const range = node.list;
+		const increment = `${item_name} = ${item_name} + 1n`;
+		emit(status, `for (let ${item_name} = ${expr(range.left_value, status)}, __end = ${expr(range.right_value, status)}; ${item_name} < __end; ${increment}) {`);
+		status.indent += 1;
+		for (const statement of node.statements) stmt(statement, status);
+		if (update) emit(status, `${update};`);
+		status.indent -= 1;
+		emit(status, "}");
+		return;
+	}
+	const list = expr(node.list, status);
+	if (node.item_is_ref) {
+		const array = next_temp(status, "arr");
+		const index = next_temp(status, "idx");
+		const increment = `${index} = ${index} + 1n`;
+		emit(status, "{");
+		status.indent += 1;
+		emit(status, `const ${array} = ${list};`);
+		emit(status, `for (let ${index} = 0n; ${index} < BigInt(${array}.length); ${increment}) {`);
+		status.indent += 1;
+		emit(status, `let ${item_name} = ${array}[Number(${index})];`);
+		emit(status, "try {");
+		status.indent += 1;
+		for (const statement of node.statements) stmt(statement, status);
+		if (update) emit(status, `${update};`);
+		status.indent -= 1;
+		emit(status, "} finally {");
+		status.indent += 1;
+		emit(status, `${array}[Number(${index})] = ${item_name};`);
+		status.indent -= 1;
+		emit(status, "}");
+		status.indent -= 1;
+		emit(status, "}");
+		status.indent -= 1;
+		emit(status, "}");
+		return;
+	}
+	if (node.index) {
+		const index_name = js_name(node.index.value);
+		emit(status, `for (let ${index_name} = 0n; ${index_name} < BigInt(${list}.length); ${index_name} = ${index_name} + 1n) {`);
+		status.indent += 1;
+		emit(status, `const ${item_name} = ${list}[Number(${index_name})];`);
+		for (const statement of node.statements) stmt(statement, status);
+		if (update) emit(status, `${update};`);
+		status.indent -= 1;
+		emit(status, "}");
+		return;
+	}
+	emit(status, `for (const ${item_name} of ${list}) {`);
+	status.indent += 1;
+	for (const statement of node.statements) stmt(statement, status);
+	if (update) emit(status, `${update};`);
+	status.indent -= 1;
+	emit(status, "}");
+}
+//#endregion
+//#region ../src/build_js/build_struct_node.ts
+/**
+* Emit a user struct: a constructor factory plus its methods.
+*
+*  - `P(a, b)` → `P_init(a, b)` returning a plain object `{ field: value }`
+*    (fields in declaration order; declared defaults become JS defaults);
+*  - `p.bump(x)` → `P_bump(p, x)` — `self` is the first JS parameter;
+*  - `#init`/`#destroy`/other `#`-named synthesized members are not emitted:
+*    construction is the factory, and the GC replaces destroy.
+*/
+function build_struct_node(node, status) {
+	if (node.is_generic) return;
+	const fields = node.fields.filter((f) => !!f.name);
+	const params = fields.map((field) => {
+		const name = js_name(field.name);
+		return field.value ? `${name} = ${copy_if_value_struct(expr(field.value, status), field.value ? void 0 : field.type?.name, status)}` : name;
+	});
+	const properties = [`$type: ${type_label(node.name)}`].concat(fields.map((field) => `${field.name}: ${copy_if_value_struct(js_name(field.name), field.type?.name, status)}`));
+	emit(status, `function ${init_label(node.name)}(${params.join(", ")}) {`);
+	status.indent += 1;
+	emit(status, `return { ${properties.join(", ")} };`);
+	status.indent -= 1;
+	emit(status, "}");
+	const methods = [];
+	for (const func of node.functions) {
+		if (!func.has_body || func.is_generic) continue;
+		if (func.name.startsWith("#")) continue;
+		emit_method(node, func, status);
+		methods.push(`${js_name(func.name)}: ${method_label(node.name, func.name)}`);
+	}
+	emit(status, `const ${type_label(node.name)} = { ${methods.join(", ")} };`);
+	node.functions.filter((func) => func.name === "#init" && func.has_body && !func.is_generic).forEach((func, index) => {
+		emit_method(node, func, status, init_body_label(node.name, index));
+	});
+}
+function emit_method(struct, func, status, label) {
+	const old_ref_params = status.ref_params;
+	status.ref_params = /* @__PURE__ */ new Set();
+	const params = func.params.map((param) => boxed_param_signature(param, status)).join(", ");
+	emit(status, `function ${label ?? method_label(struct.name, func.name)}(${params}) {`);
+	status.indent += 1;
+	for (const param of func.params) emit_ref_prologue(param, status);
+	for (const statement of func.statements) stmt(statement, status);
+	status.indent -= 1;
+	emit(status, "}");
+	status.ref_params = old_ref_params;
+}
+/** The literal for a freshly-constructed struct before its `#init` runs:
+*  declared field defaults, or the type's zero value. */
+function struct_zero_object(struct, status, include_type = true) {
+	const parts = include_type ? [`$type: ${type_label(struct.name)}`] : [];
+	for (const field of struct.fields) {
+		if (!field.name) continue;
+		const value = field.value ? copy_if_value_struct(expr(field.value, status), field.type?.name, status) : zero_value(field.type?.name ?? "");
+		parts.push(`${field.name}: ${value}`);
+	}
+	return `{ ${parts.join(", ")} }`;
+}
+/** The same object with its `#init` body applied. Emited at the constructor
+*  call site (the checker resolved which overload runs). */
+function struct_init_expression(struct, init_index, args, status) {
+	const args_text = args.length ? `, ${args.join(", ")}` : "";
+	return `(() => { const __self = ${struct_zero_object(struct, status)}; ${init_body_label(struct.name, init_index)}(__self${args_text}); return __self; })()`;
+}
+function zero_value(type_name) {
+	switch (type_name) {
+		case "float":
+		case "float32":
+		case "float64":
+		case "ufloat": return "0";
+		case "bool": return "false";
+		case "char": return "\"\\u0000\"";
+		case "string": return "\"\"";
+		case "": return "undefined";
+		default:
+			if (type_name.startsWith("int") || type_name.startsWith("uint")) return "0n";
+			return "null";
+	}
+}
+//#endregion
+//#region ../src/build_js/build_function_call_node.ts
+/**
+* Emit a JS expression for a call node:
+*  - interpolation helpers (`_string_interpolate_N[_kinds]`) → `__interp`;
+*  - enum case constructions → tagged object literals;
+*  - struct constructors → the `<Struct>_init` factory;
+*  - library containers (List/Map/Box/StringBuilder) → their JS values;
+*  - free/nested functions → the checker's emission label (with `ref`
+*    arguments boxed and copied back).
+*/
+function build_function_call_node(node, status) {
+	const name = node.name;
+	if (node.is_thread_ctor || node.is_fiber_ctor) {
+		const first = node.params[0];
+		return `({ __task: ${first?.node_type === "func_call" ? `() => (${expr(first, status)})` : `() => (${expr(first, status)}())`}, __result: undefined, __zero: ${zero_js_value(node.function_return_type)}, __done: false, started: false, $type: __spawn_methods })`;
+	}
+	if (is_interp_name(name)) {
+		const { kinds } = parse_interp_name(name);
+		const pattern = expr(node.params[0], status);
+		const args = node.params.slice(1).map((p) => expr(p, status));
+		return `__interp(${pattern}, "${kinds ? kinds.join("") : "s".repeat(args.length)}"${args.length ? `, ${args.join(", ")}` : ""})`;
+	}
+	if (node.is_enum_shorthand) {
+		const args = node.params.map((p) => expr(p, status));
+		const hit = find_enum_case(status.enums, name);
+		if (hit) return enum_case_value(hit.enum_node, hit.case_index, args, status);
+		const enum_node = status.enums.find((e) => e.name === node.type?.name);
+		if (enum_node) {
+			const case_name = name.replace(/^\./, "").replace(`${enum_node.name}_`, "");
+			const case_index = enum_node.cases.findIndex((c) => c.name === case_name);
+			if (case_index !== -1) return enum_case_value(enum_node, case_index, args, status);
+		}
+	}
+	const struct = status.structs.find((s) => s.name === name);
+	if (struct) {
+		const args = node.params.map((p) => expr(p, status));
+		if (node.resolved_function?.name === "#init" && init_has_self(node.resolved_function)) {
+			const index = struct.functions.filter((func) => func.name === "#init" && func.has_body && !func.is_generic && init_has_self(func)).indexOf(node.resolved_function);
+			if (index !== -1) return struct_init_expression(struct, index, args, status);
+		}
+		return `${node.mangled_name ?? init_label(name)}(${args.join(", ")})`;
+	}
+	const args = node.params.map((p) => expr(p, status));
+	const library = library_constructor(name, args);
+	if (library !== void 0) return library;
+	const library_struct = status.library_structs.find((s) => s.name === name && !is_native_library_type(s.name));
+	if (library_struct) {
+		if (node.resolved_function?.name === "#init" && init_has_self(node.resolved_function)) {
+			queue_library_method(library_struct, node.resolved_function, status);
+			const label = library_method_label(library_struct, node.resolved_function);
+			const args_text = args.length ? `, ${args.join(", ")}` : "";
+			return `(() => { const __self = ${struct_zero_object(library_struct, status, false)}; ${label}(__self${args_text}); return __self; })()`;
+		}
+		queue_library_init(library_struct, status);
+		return `${init_label(name)}(${args.join(", ")})`;
+	}
+	if (name === "parse_int" && args.length === 1) return `__parse_int(${args[0]})`;
+	if (node.resolved_function?.is_library) queue_library_function(node.resolved_function, status);
+	const label = function_label(node.resolved_function ?? node);
+	return call_with_refs(status, node.params, node.ref_param_indices, (arg_exprs) => `${label}(${arg_exprs.join(", ")})`);
+}
+/** A hand-written `#init` takes `self`; the checker's synthesized positional
+*  initializer (`#init = (field, …)`) does not, and the field factory covers
+*  it. */
+function init_has_self(func) {
+	return func.params?.[0]?.is_self_param === true;
+}
+//#endregion
+//#region ../src/build_js/build_grouped_node.ts
+/** A parenthesized expression: keep the grouping in the emitted JS. */
+function build_grouped_node(node, status) {
+	return `(${expr(node.value, status)})`;
+}
+//#endregion
+//#region ../src/build_js/build_if_else_node.ts
+/** Emit an if/else statement. (Expression-position `if` is not in the v1
+*  subset; using one as a value hits `__unsupported`.) */
+function build_if_else_node(node, status) {
+	emit(status, `if (${expr(node.condition, status)}) {`);
+	status.indent += 1;
+	for (const statement of node.if_branch?.statements ?? []) stmt(statement, status);
+	status.indent -= 1;
+	if (node.else_branch) {
+		emit(status, "} else {");
+		status.indent += 1;
+		for (const statement of node.else_branch.statements ?? []) stmt(statement, status);
+		status.indent -= 1;
+	}
+	emit(status, "}");
+}
+/** `if` in expression position (`const label = if c -> a else -> b`): an
+*  IIFE whose branches return their value. */
+function build_if_expression(node, status) {
+	return capture_expression(status, () => {
+		emit(status, `if (${expr(node.condition, status)}) {`);
+		status.indent += 1;
+		branch_body(node.if_branch?.statements ?? [], status, true);
+		status.indent -= 1;
+		if (node.else_branch) {
+			emit(status, "} else {");
+			status.indent += 1;
+			branch_body(node.else_branch.statements, status, true);
+			status.indent -= 1;
+		}
+		emit(status, "}");
+	});
+}
+//#endregion
+//#region ../src/build_js/build_match_node.ts
+/** `match` as a statement: an if/else chain over a hoisted scrutinee. Enum
+*  cases test the tag and bind the payload positionally. */
+function build_match_statement(node, status) {
+	emit_match(node, status, false);
+}
+/** `match` in expression position: an IIFE whose branches return. */
+function build_match_expression(node, status) {
+	return capture_expression(status, () => emit_match(node, status, true));
+}
+function emit_match(node, status, value_mode) {
+	const temp = next_temp(status, "match");
+	emit(status, "{");
+	status.indent += 1;
+	emit(status, `const ${temp} = ${expr(node.value, status)};`);
+	node.cases.forEach((match_case, index) => {
+		const enum_hit = match_case.match_value.node_type === "value" ? find_enum_case(status.enums, match_case.match_value.value) : void 0;
+		const condition = enum_hit ? `${temp}.$tag === ${enum_hit.case_index}` : `${temp} === ${expr(match_case.match_value, status)}`;
+		emit(status, `${index === 0 ? "if" : "else if"} (${condition}) {`);
+		status.indent += 1;
+		if (enum_hit) {
+			const case_def = enum_hit.enum_node.cases[enum_hit.case_index];
+			(match_case.params ?? []).forEach((param, i) => {
+				const field = case_def.params[i]?.name ?? `$${i}`;
+				const type_name = case_def.params[i]?.type?.name;
+				const value = is_value_struct(type_name, status) ? `__copy(${temp}.${field})` : `${temp}.${field}`;
+				emit(status, `const ${js_name(param)} = ${value};`);
+			});
+		}
+		branch_body(match_case.branch.statements ?? [], status, value_mode);
+		status.indent -= 1;
+		emit(status, "}");
+	});
+	emit(status, "else {");
+	status.indent += 1;
+	if (node.else_branch) branch_body(node.else_branch.statements ?? [], status, value_mode);
+	else if (value_mode) emit(status, `return __unsupported("match: no matching case");`);
+	else emit(status, `__panic("no matching match case");`);
+	status.indent -= 1;
+	emit(status, "}");
+	status.indent -= 1;
+	emit(status, "}");
+}
+//#endregion
+//#region ../src/build_js/build_operation_node.ts
+/** Emit a JS expression for a Nomen operator node. Ints are bigints and
+*  floats are numbers, so the same JS operator serves both; the one special
+*  case is string repetition (`"x" * n` → `.repeat(n)`). */
+function build_operation_node(node, status) {
+	const op = node.op;
+	if (op === "u-") return `(-${expr(node.left_value, status)})`;
+	if (op === "!") return `(!${expr(node.left_value, status)})`;
+	let left = expr(node.left_value, status);
+	let right = expr(node.right_value, status);
+	const result_kind = kind_of(node);
+	const left_kind = kind_of(node.left_value);
+	const right_kind = kind_of(node.right_value);
+	const arithmetic = [
+		"+",
+		"-",
+		"*",
+		"/",
+		"%",
+		"<<",
+		">>",
+		"&",
+		"|",
+		"^"
+	].includes(op);
+	if (arithmetic && result_kind === "int") {
+		if (left_kind === "char") left = `BigInt(${left}.charCodeAt(0))`;
+		if (right_kind === "char") right = `BigInt(${right}.charCodeAt(0))`;
+	}
+	if (arithmetic && result_kind === "char") return `__char_from_code((${left_kind === "char" ? `BigInt(${left}.charCodeAt(0))` : left} ${op} ${right_kind === "char" ? `BigInt(${right}.charCodeAt(0))` : right}) & 255n)`;
+	if (op === "*" && kind_of(node.left_value) === "string") return `(${left}.repeat(Number(${right})))`;
+	if (op === "+" && kind_of(node.left_value) === "array") return `(${left}.concat(${right}))`;
+	if (node.operator_func && !node.operator_func.deferred) {
+		const { struct_name, func_name, invert } = node.operator_func;
+		if (status.structs.some((s) => s.name === struct_name)) {
+			const call = `${method_label(struct_name, func_name)}(${left}, ${right})`;
+			return invert ? `(!${call})` : `(${call})`;
+		}
+	}
+	if ((op === "==" || op === "!=") && is_enum(node.left_value, status)) {
+		const compare = `__enum_eq(${left}, ${right})`;
+		return op === "==" ? compare : `(!${compare})`;
+	}
+	if (op === "==") return `(${left} === ${right})`;
+	if (op === "!=") return `(${left} !== ${right})`;
+	const result = `(${left} ${op} ${right})`;
+	if (arithmetic && result_kind === "int") return wrap_int_expression(result, stamped_type(node)?.name);
+	return result;
+}
+function is_enum(node, status) {
+	const type = stamped_type(node);
+	if (!type?.name) return false;
+	return status.enums.some((e) => e.name === type.name);
+}
+//#endregion
+//#region ../src/build_js/build_panic_node.ts
+/** `panic("…")` — the runtime prints the message to stderr and exits 2, the
+*  same contract as the native backends. */
+function build_panic_node(node, status) {
+	emit(status, `__panic(${JSON.stringify(node.message)});`);
+}
+//#endregion
+//#region ../src/build_js/build_return_node.ts
+/** Emit a return statement. */
+function build_return_node(node, status) {
+	if (node.value) emit(status, `return ${copy_if_value_struct(expr(node.value, status), stamped_type(node.value)?.name, status)};`);
+	else emit(status, "return;");
+}
+//#endregion
+//#region ../src/build_js/build_switch_node.ts
+/** `switch` as a statement: an if/else-if chain over boolean case
+*  expressions (Nomen switch cases are conditions, not values). */
+function build_switch_statement(node, status) {
+	emit_switch(node, status, false);
+}
+/** `switch` in expression position: an IIFE whose branches return. */
+function build_switch_expression(node, status) {
+	return capture_expression(status, () => emit_switch(node, status, true));
+}
+function emit_switch(node, status, value_mode) {
+	if (node.cases.length === 0) {
+		if (value_mode) emit(status, `return __unsupported("empty switch");`);
+		return;
+	}
+	node.cases.forEach((switch_case, index) => {
+		const condition = expr(switch_case.condition, status);
+		emit(status, `${index === 0 ? "if" : "else if"} (${condition}) {`);
+		status.indent += 1;
+		branch_body(switch_case.branch.statements ?? [], status, value_mode);
+		status.indent -= 1;
+		emit(status, "}");
+	});
+	if (node.else_branch) {
+		emit(status, "else {");
+		status.indent += 1;
+		branch_body(node.else_branch.statements ?? [], status, value_mode);
+		status.indent -= 1;
+		emit(status, "}");
+	} else if (value_mode) {
+		emit(status, "else {");
+		status.indent += 1;
+		emit(status, `return __unsupported("switch: no matching case");`);
+		status.indent -= 1;
+		emit(status, "}");
+	}
+}
+//#endregion
+//#region ../src/build_js/build_todo_node.ts
+/** `todo("…")` — same runtime contract as panic. */
+function build_todo_node(node, status) {
+	emit(status, `__panic(${JSON.stringify(node.message ? `todo: ${node.message}` : "todo")});`);
+}
+//#endregion
+//#region ../src/build_js/build_value_node.ts
+/**
+* A Nomen string/char literal is stored as its raw source text (quotes and
+* escapes included). JS understands the same escapes (`\n`, `\t`, `\\`, `\"`),
+* so the inner text passes through; the only rewrite needed is a REAL newline
+* or tab (a Nomen multi-line string), which would terminate a JS string
+* literal early.
+*/
+function string_inner(raw) {
+	let out = "";
+	for (const c of raw) if (c === "\n") out += "\\n";
+	else if (c === "\r") out += "\\r";
+	else if (c === "	") out += "\\t";
+	else out += c;
+	return out;
+}
+/** Escape a bare `"` (a char literal like `'"'`) so the JS string is valid;
+*  an already-escaped `\"` is left alone. */
+function escape_quotes(text) {
+	let out = "";
+	let backslashes = 0;
+	for (const c of text) {
+		if (c === "\"" && backslashes % 2 === 0) out += "\\\"";
+		else out += c;
+		backslashes = c === "\\" ? backslashes + 1 : 0;
+	}
+	return out;
+}
+const FLOAT_LITERAL = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+/** Emit an expression for a literal or identifier value. */
+function build_value_node(node, status) {
+	const value = node.value;
+	if (node.is_enum_shorthand) {
+		const hit = find_enum_case(status.enums, value);
+		if (hit) return enum_case_value(hit.enum_node, hit.case_index, [], status);
+	}
+	const allocation = status.allocations?.get(value);
+	if (allocation) {
+		if (!status.inlining) status.inlining = /* @__PURE__ */ new Set();
+		if (status.inlining.has(value)) return "undefined";
+		status.inlining.add(value);
+		const text = expr(allocation, status);
+		status.inlining.delete(value);
+		return `(${text})`;
+	}
+	if (value === "true" || value === "false") return value;
+	if (value === "null") return "null";
+	if (value === "self") return "self";
+	if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) return `"${escape_quotes(string_inner(value.slice(1, -1)))}"`;
+	if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) return `"${escape_quotes(string_inner(value.slice(1, -1)))}"`;
+	if (is_int_literal(value)) {
+		const n = parse_int_literal_bigint(value);
+		return n === null ? "0n" : `${n}n`;
+	}
+	if (FLOAT_LITERAL.test(value)) return value.replace(/_/g, "");
+	if (/^(?:T|TK|TV)_(?:TAKES_OWNERSHIP|IS_VALUE_STRUCT|NEEDS_STRDUP|FAT)$/.test(value)) return "false";
+	if (/^(?:T|TK|TV)_SIZE$/.test(value)) return "0n";
+	const resolved = node.resolved_function;
+	if (resolved) return function_label(resolved);
+	return js_name(value);
+}
+//#endregion
+//#region ../src/build_js/build_node.ts
+/** Append a statement line at the current indentation. */
+function emit(status, text) {
+	status.code += "	".repeat(status.indent) + text + "\n";
+}
+/** A fresh generated temp name (`__match_0`, `__switch_1`, …). */
+function next_temp(status, prefix) {
+	const name = `__${prefix}_${status.temp}`;
+	status.temp += 1;
+	return name;
+}
+/**
+* Emit an expression-position construct (if/switch/match used as a value) as
+* an IIFE. The builder emits statements into a scratch buffer at one extra
+* indent level; the wrapper becomes a single JS expression.
+*/
+function capture_expression(status, build) {
+	return `(() => {\n${capture_body(status, build)}${"	".repeat(status.indent)}})()`;
+}
+/** Emit statements into a scratch buffer at one extra indent level and return
+*  the text (used by expression-position function literals and the IIFE
+*  wrapper). */
+function capture_body(status, build) {
+	const saved_code = status.code;
+	const saved_indent = status.indent;
+	status.code = "";
+	status.indent = saved_indent + 1;
+	build();
+	const body = status.code;
+	status.code = saved_code;
+	status.indent = saved_indent;
+	return body;
+}
+/**
+* Emit a branch's statements. In value mode the branch's LAST statement is
+* its result: a trailing `let` wrapper (the parser's expression statement)
+* becomes `return <expr>;`, an explicit `return` stays as-is, and any other
+* statement is returned as an expression.
+*/
+function branch_body(statements, status, value_mode) {
+	if (!value_mode) {
+		for (const statement of statements) stmt(statement, status);
+		return;
+	}
+	for (let i = 0; i < statements.length; i++) {
+		const statement = statements[i];
+		if (!(i === statements.length - 1)) {
+			stmt(statement, status);
+			continue;
+		}
+		if (statement.node_type === "let") {
+			const value = statement.value;
+			emit(status, `return ${value ? expr(value, status) : "undefined"};`);
+			return;
+		}
+		if (statement.node_type === "return") {
+			stmt(statement, status);
+			return;
+		}
+		emit(status, `return ${expr(statement, status)};`);
+		return;
+	}
+	emit(status, "return undefined;");
+}
+/** Emit the JS expression text for a Nomen expression node. */
+function expr(node, status) {
+	switch (node.node_type) {
+		case "value": return build_value_node(node, status);
+		case "op": return build_operation_node(node, status);
+		case "if": return build_if_expression(node, status);
+		case "switch": return build_switch_expression(node, status);
+		case "match": return build_match_expression(node, status);
+		case "cast": return build_cast_node(node, status);
+		case "access": return build_access_node(node, status);
+		case "func_call": return build_function_call_node(node, status);
+		case "array": return build_array_values_node(node, status);
+		case "async_block": return build_async_block_expression(node, status);
+		case "spawn": return expr(node.call, status);
+		case "grouped": return build_grouped_node(node, status);
+		case "func": return build_function_expression(node, status);
+		default: return `__skip(${JSON.stringify(`expression ${node.node_type}`)})`;
+	}
+}
+/** Emit a Nomen statement node (with its checker-hoisted allocation temps). */
+function stmt(node, status) {
+	switch (node.node_type) {
+		case "declare":
+			build_declaration_node(node, status);
+			return;
+		case "assign":
+			build_assignment_node(node, status);
+			return;
+		case "if":
+			build_if_else_node(node, status);
+			return;
+		case "switch":
+			build_switch_statement(node, status);
+			return;
+		case "match":
+			build_match_statement(node, status);
+			return;
+		case "while":
+			build_while_loop_node(node, status);
+			return;
+		case "for":
+			build_for_loop_node(node, status);
+			return;
+		case "return":
+			build_return_node(node, status);
+			return;
+		case "break":
+			build_break_node(node, status);
+			return;
+		case "continue":
+			build_continue_node(node, status);
+			return;
+		case "panic":
+			build_panic_node(node, status);
+			return;
+		case "todo":
+			build_todo_node(node, status);
+			return;
+		case "func":
+			build_function_node(node, status);
+			return;
+		case "struct":
+			build_struct_node(node, status);
+			return;
+		case "enum":
+		case "bitset":
+		case "trait":
+		case "extend":
+		case "import": return;
+		case "block":
+			emit_block(node, status);
+			return;
+		case "async_block":
+			build_async_block_node(node, status);
+			return;
+		case "spawn":
+			emit(status, `${expr(node.call, status)};`);
+			return;
+		case "let": {
+			const value = node.value;
+			if (value) stmt(value, status);
+			return;
+		}
+		case "raw": return;
+		default: emit(status, `${expr(node, status)};`);
+	}
+}
+function emit_block(node, status) {
+	emit(status, "{");
+	status.indent += 1;
+	for (const statement of node.statements ?? []) stmt(statement, status);
+	status.indent -= 1;
+	emit(status, "}");
+}
+//#endregion
+//#region ../src/build_js/build_root_node.ts
+/**
+* Emit the program: every non-library root statement in order, then the
+* entry-point call. The System library's own declarations are skipped — the
+* JS runtime provides the supported slice of its surface (Console, Format,
+* the string/array builtins), and anything else fails loudly at the call
+* site.
+*/
+function build_root_node(root, status) {
+	let main;
+	for (const statement of root.statements) {
+		if (is_library(statement)) continue;
+		if (statement.node_type === "import") continue;
+		if (statement.node_type === "func" && statement.name === "main") main = statement;
+		stmt(statement, status);
+	}
+	emit(status, `main${main && main.params.length > 0 ? "({})" : "()"};`);
+}
+function is_library(node) {
+	return node.is_library === true;
+}
+//#endregion
+//#region ../src/build_js/BuildStatus.ts
+function create_status(root) {
+	return {
+		root,
+		code: "",
+		indent: 0,
+		structs: [],
+		library_structs: [],
+		enums: [],
+		bitsets: [],
+		traits: [],
+		temp: 0,
+		library_code: "",
+		library_method_queue: [],
+		library_init_queue: [],
+		library_function_queue: [],
+		emitted_library: /* @__PURE__ */ new Set(),
+		errors: []
+	};
+}
+//#endregion
+//#region ../src/build_js/runtime.ts
+function runtime(target = "node") {
+	return `${target === "browser" ? `const __out = (s) => {
+	const write = globalThis.__nomen_write;
+	if (write) write(String(s));
+	else console.log(String(s));
+};
+const __stderr = (s) => {
+	const write = globalThis.__nomen_write;
+	if (write) write(String(s));
+	else console.error(String(s));
+};
+const __read_stdin = () => "";
+const __exit = (code) => {
+	throw new Error("__nomen_exit:" + code);
+};` : `import { readFileSync } from "node:fs";
+
+const __out = (s) => process.stdout.write(String(s));
+const __stderr = (s) => process.stderr.write(String(s));
+const __read_stdin = () => {
+	try {
+		return readFileSync(0, "utf8");
+	} catch (e) {
+		return "";
+	}
+};
+const __exit = (code) => process.exit(code);`}
+
+// printf "%f" (six decimals). toFixed matches for the magnitudes demos use;
+// note the >1e21 divergence (printf keeps expanding, toFixed goes exponent).
+function __fmt_f(x) {
+	if (Number.isNaN(x)) return "nan";
+	if (x === Infinity) return "inf";
+	if (x === -Infinity) return "-inf";
+	return x.toFixed(6);
+}
+
+function __to_string(v) {
+	if (typeof v === "string") return v;
+	if (typeof v === "bigint") return v.toString();
+	if (typeof v === "number") return __fmt_f(v);
+	if (typeof v === "boolean") return v ? "true" : "false";
+	if (v === null || v === undefined) return "null";
+	// An enum renders as its tag (the native backends delegate enum
+	// to_string to the int tag; a bitset is already a bigint).
+	if (typeof v === "object" && typeof v.$tag === "number") return String(v.$tag);
+	return String(v);
+}
+
+function __render(kind, v) {
+	if (kind === "i" || kind === "u") return BigInt(v).toString();
+	if (kind === "f") return __fmt_f(Number(v));
+	return __to_string(v);
+}
+
+// The compiler's interpolation helper: the pattern carries one "%s" per
+// argument (literal "%" bytes are copied verbatim — no printf directives).
+function __interp(pattern, kinds, ...args) {
+	const parts = pattern.split("%s");
+	let out = parts[0];
+	for (let i = 0; i < args.length; i++) {
+		out += __render(kinds[i] || "s", args[i]) + (parts[i + 1] || "");
+	}
+	return out;
+}
+
+function __string_at(text, i) {
+	const index = Number(i);
+	if (index < 0 || index >= text.length) __panic("index out of range");
+	return text.at(index);
+}
+
+function __string_at_or(text, i, fallback) {
+	const index = Number(i);
+	if (index < 0 || index >= text.length) return fallback;
+	return text.at(index);
+}
+
+function __char_code_at_or(text, i, fallback) {
+	const index = Number(i);
+	if (index < 0 || index >= text.length) return fallback;
+	return BigInt(text.charCodeAt(index));
+}
+
+function __math_power(base, exp) {
+	let result = 1n;
+	let n = exp;
+	while (n > 0n) {
+		result = result * base;
+		n = n - 1n;
+	}
+	return result;
+}
+
+function __sleep_ms(ms) {
+	const wait = Number(ms);
+	if (wait > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, wait);
+}
+
+function __string_hash(text) {
+	let h = 5381n;
+	for (const ch of text) h = BigInt.asUintN(64, h * 33n + BigInt(ch.charCodeAt(0)));
+	return h;
+}
+
+function __char_from_code(code) {
+	return String.fromCharCode(Number(code) & 0xff);
+}
+
+function __utf8_decode(text, index) {
+	const i = Number(index);
+	if (i < 0 || i >= text.length) __panic("byte index out of range");
+	const cp = text.codePointAt(i);
+	const width = cp > 0xffff ? 2 : 1;
+	return { code_point: BigInt(cp), byte_length: BigInt(width) };
+}
+
+function __utf8_encode(code_point) {
+	let cp = Number(code_point);
+	if (cp < 0 || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) cp = 0xfffd;
+	return String.fromCodePoint(cp);
+}
+
+function __parse_int(text) {
+	if (typeof text !== "string" || !/^[+-]?[0-9]+$/.test(text)) __panic("invalid int: " + text);
+	return BigInt(text);
+}
+
+function __dispatch(self, name, ...args) {
+	const table = self && self.$type;
+	const fn = table && table[name];
+	if (!fn) __unsupported("trait method " + name);
+	return fn(self, ...args);
+}
+
+function __set_get(set, value) {
+	if (!set.has(value)) __panic("set value not found");
+	return set.get(value);
+}
+
+function __array_with(value, count) {
+	const n = Number(count);
+	const out = [];
+	for (let i = 0; i < n; i++) out.push(value);
+	return out;
+}
+
+// --- Buffer (a JS array stands in for the native slab) --------------------
+
+// 128/64 unsigned division (BigInt.div128): the native form saturates when
+// the high word is at least the divisor.
+function __div128(hi, lo, d) {
+	const h = BigInt.asUintN(64, BigInt(hi));
+	const l = BigInt.asUintN(64, BigInt(lo));
+	const divisor = BigInt.asUintN(64, BigInt(d));
+	if (h >= divisor) return 18446744073709551615n;
+	return ((h << 64n) | l) / divisor;
+}
+
+function __buffer_alloc(buf, size, zero) {
+	const n = Number(size);
+	buf.length = 0;
+	if (n > 0) buf.length = n;
+	buf.fill(zero);
+	return BigInt(n);
+}
+
+function __buffer_grow(buf, needed, zero) {
+	const n = Number(needed);
+	if (buf.length >= n) return BigInt(buf.length);
+	const old = buf.length;
+	buf.length = n;
+	for (let i = old; i < n; i++) buf[i] = zero;
+	return BigInt(n);
+}
+
+function __buffer_move(buf, i) {
+	const index = Number(i);
+	const value = buf[index];
+	buf[index] = undefined;
+	return value;
+}
+
+function __buffer_shift(buf, dst, src) {
+	const d = Number(dst);
+	const s = Number(src);
+	if (d === s) return;
+	buf[d] = buf[s];
+	buf[s] = undefined;
+}
+
+function __buffer_move_range(buf, dst, src, count) {
+	const d = Number(dst);
+	const s = Number(src);
+	const n = Number(count);
+	if (n <= 0) return;
+	for (let i = 0; i < n; i++) buf[d + i] = buf[s + i];
+	// Zero the source slots the destination does not cover.
+	for (let i = d + n; i < s + n; i++) buf[i] = undefined;
+}
+
+function __buffer_modify(buf, i, f) {
+	const index = Number(i);
+	const value = f(buf[index]);
+	buf[index] = value;
+	return value;
+}
+
+function __buffer_zero(buf, len, zero) {
+	const n = Number(len);
+	for (let i = 0; i < n && i < buf.length; i++) buf[i] = zero;
+}
+
+// --- Concurrency, run synchronously --------------------------------------
+// There is no scheduler here: a started task runs its thunk to completion
+// before start() returns, and the returned Task already holds the result.
+
+// Trait dispatch reads the concrete value's $type table, so the synthesized
+// values carry the methods their traits declare.
+const __spawn_methods = {
+	start: (self) => __spawn_start(self),
+	detach: (self) => __spawn_detach(self),
+};
+
+const __task_methods = {
+	wait: () => {},
+	result: (self) => __task_result(self),
+	result_uint64: (self) => __task_result_uint64(self),
+	is_done: () => true,
+	cancel: () => {},
+	current_cancelled: () => false,
+};
+
+function __spawn_start(thread) {
+	if (!thread.started) {
+		thread.started = true;
+		if (typeof thread.__task === "function") thread.__result = thread.__task();
+		thread.__done = true;
+	}
+	return {
+		__result: thread.__result,
+		__zero: thread.__zero,
+		__done: true,
+		__consumed: false,
+		$type: __task_methods,
+	};
+}
+
+function __spawn_detach(thread) {
+	__spawn_start(thread);
+}
+
+function __nursery_start(nursery, thread) {
+	return __spawn_start(thread);
+}
+
+function __task_wait(task) {}
+
+function __task_result(task) {
+	if (task.__consumed) return task.__zero;
+	task.__consumed = true;
+	return task.__result === undefined ? task.__zero : task.__result;
+}
+
+function __task_result_uint64(task) {
+	const value = __task_result(task);
+	return value === undefined ? 0n : BigInt(value);
+}
+
+function __channel_send(channel, value) {
+	channel.values.push(value);
+}
+
+function __channel_send_string(channel, value) {
+	channel.strings.push(String(value));
+}
+
+function __channel_receive(channel) {
+	return channel.values.length ? channel.values.shift() : 0n;
+}
+
+function __channel_receive_string(channel) {
+	return channel.strings.length ? channel.strings.shift() : "";
+}
+
+function __atomic_fetch_add(atomic, value) {
+	const previous = atomic.word;
+	atomic.word = BigInt.asUintN(64, BigInt(previous) + BigInt(value));
+	return previous;
+}
+
+function __atomic_swap(atomic, value) {
+	const previous = atomic.word;
+	atomic.word = value;
+	return previous;
+}
+
+function __list_at(list, i) {
+	const index = Number(i);
+	if (index < 0 || index >= list.length) __panic("index out of range");
+	return list[index];
+}
+
+function __list_at_or(list, i, fallback) {
+	const index = Number(i);
+	if (index < 0 || index >= list.length) return fallback;
+	return list[index];
+}
+
+function __map_get(map, key) {
+	if (!map.has(key)) __panic("map key not found");
+	return map.get(key);
+}
+
+function __sb_take_since(sb, mark) {
+	const at = Number(mark);
+	const taken = sb.s.slice(at);
+	sb.s = sb.s.slice(0, at);
+	return taken;
+}
+
+// Nomen value structs are copied on binding, assignment, return, container
+// store, and closure capture. JS objects are by reference, so the builders
+// wrap those transfers in this deep clone.
+function __copy(value) {
+	if (Array.isArray(value)) return value.map(__copy);
+	if (value instanceof Map) return new Map([...value].map(([k, v]) => [__copy(k), __copy(v)]));
+	if (value instanceof Set) return new Set([...value].map(__copy));
+	if (value && typeof value === "object") {
+		const out = {};
+		for (const key of Object.keys(value)) out[key] = __copy(value[key]);
+		return out;
+	}
+	return value;
+}
+
+function __enum_to_case(value, tag, name) {
+	if (!value || value.$tag !== tag) {
+		__panic("base to case conversion: the value carries a different variant (" + name + ")");
+	}
+	return value;
+}
+
+function __enum_eq(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	if (a.$tag !== b.$tag) return false;
+	const ka = Object.keys(a).filter((k) => k !== "$tag");
+	const kb = Object.keys(b).filter((k) => k !== "$tag");
+	if (ka.length !== kb.length) return false;
+	for (const k of ka) {
+		if (a[k] !== b[k]) return false;
+	}
+	return true;
+}
+
+function __panic(message) {
+	__stderr("panic: " + __to_string(message) + "\\n");
+	__exit(2);
+}
+
+function __unsupported(what) {
+	throw new Error("js backend: unsupported feature: " + what);
+}
+
+// A library feature the JS backend cannot express (raw memory, GUI, threads).
+// Cross-compiled programs keep running without it: warn once per feature and
+// let the caller see the statement's zero value.
+const __skipped = new Set();
+function __skip(what) {
+	if (!__skipped.has(what)) {
+		__skipped.add(what);
+		__stderr("js backend: skipping unavailable feature: " + what + "\\n");
+	}
+	return undefined;
+}
+
+// --- Console --------------------------------------------------------------
+
+function Console_write(s) { __out(s); }
+function Console_write_line(s) { __out(s + "\\n"); }
+
+let __stdin_lines = null;
+let __stdin_index = 0;
+function __ensure_stdin() {
+	if (__stdin_lines !== null) return;
+	try {
+		__stdin_lines = __read_stdin().split("\\n");
+	} catch (e) {
+		__stdin_lines = [];
+	}
+}
+function Console_read_line() {
+	__ensure_stdin();
+	const line = __stdin_lines[__stdin_index] || "";
+	__stdin_index++;
+	return line;
+}
+function Console_read_char() {
+	__ensure_stdin();
+	const line = __stdin_lines[__stdin_index] || "";
+	if (line.length === 0) return "";
+	__stdin_lines[__stdin_index] = line.slice(1);
+	return line[0];
+}
+function Console_platform() { return "js"; }
+
+// --- Format (the helpers interpolation specs lower to) --------------------
+
+function __pad_to(s, width, zero, signFirst) {
+	let w = width;
+	let left = false;
+	if (w < 0n) { left = true; w = -w; }
+	const total = BigInt(s.length);
+	if (w <= total) return s;
+	const count = Number(w - total);
+	if (left) return s + " ".repeat(count);
+	if (zero && signFirst) return s[0] + "0".repeat(count) + s.slice(1);
+	return (zero ? "0" : " ").repeat(count) + s;
+}
+
+function Format_pad(text, width) {
+	return __pad_to(text, width, false, false);
+}
+
+function __int_digits(mag, base, upper) {
+	const digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
+	let s = "";
+	if (mag === 0n) return "0";
+	while (mag > 0n) {
+		s = digits[Number(mag % base)] + s;
+		mag /= base;
+	}
+	return s;
+}
+
+function __int_base(signed, value, base, upper, width, zero, group) {
+	let neg = signed && value < 0n;
+	let mag = neg ? -value : value;
+	let s = __int_digits(mag, base, upper);
+	if (group && base === 10n) s = s.replace(/\\B(?=(\\d{3})+(?!\\d))/g, ",");
+	if (neg) s = "-" + s;
+	return __pad_to(s, width, zero, neg);
+}
+
+function Format_int_base(value, base, upper, width, zero, group) {
+	return __int_base(true, value, base, upper, width, zero, group);
+}
+
+function Format_uint_base(value, base, upper, width, zero, group) {
+	return __int_base(false, value, base, upper, width, zero, group);
+}
+
+// A printf float directive built by the checker: %[0][-][width][.places][fFeE]
+function Format_float_fixed(value, spec) {
+	const m = /^%(0)?(-)?(\\d+)?(?:\\.(\\d+))?([fFeE])$/.exec(spec);
+	if (!m) __unsupported("float directive " + spec);
+	const zero = !!m[1];
+	const left = !!m[2];
+	const width = m[3] ? BigInt(m[3]) : 0n;
+	const places = m[4] !== undefined ? Number(m[4]) : 6;
+	const letter = m[5];
+	let body;
+	if (letter === "f") {
+		body = value.toFixed(places);
+	} else {
+		body = value.toExponential(places);
+		// printf pads the exponent to at least two digits (1.50e+00).
+		body = body.replace(/e([+-])(\\d)$/, "e$10$2");
+		if (letter === "E") body = body.replace("e", "E");
+	}
+	if (width === 0n) return body;
+	return __pad_to(body, left ? -width : width, zero, false);
+}
+
+function Format_float_grouped(value, places) {
+	const text = value.toFixed(Number(places));
+	const dot = text.indexOf(".");
+	const head = dot === -1 ? text : text.slice(0, dot);
+	const tail = dot === -1 ? "" : text.slice(dot);
+	const grouped = head.replace(/\\B(?=(\\d{3})+(?!\\d))/g, ",");
+	return grouped + tail;
+}
+
+// --- Custom patterns (#,##0.00, 0.0%, #,##0.00;(#,##0.00)) ----------
+
+function __pat_sections(pattern) {
+	let quoted = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const c = pattern[i];
+		if (quoted) {
+			if (c === "'") quoted = false;
+		} else if (c === "'") {
+			quoted = true;
+		} else if (c === ";") {
+			return [pattern.slice(0, i), pattern.slice(i + 1)];
+		}
+	}
+	return [pattern, null];
+}
+
+function __pat_has_percent(pattern) {
+	let quoted = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const c = pattern[i];
+		if (quoted) {
+			if (c === "'") quoted = false;
+		} else if (c === "'") {
+			quoted = true;
+		} else if (c === "%") {
+			return true;
+		}
+	}
+	return false;
+}
+
+function __pat_max_frac(pattern) {
+	let quoted = false;
+	let inFrac = false;
+	let count = 0;
+	let best = 0;
+	for (let i = 0; i < pattern.length; i++) {
+		const c = pattern[i];
+		if (quoted) {
+			if (c === "'") quoted = false;
+			continue;
+		}
+		if (c === "'") { quoted = true; continue; }
+		if (c === ";") { inFrac = false; count = 0; continue; }
+		if (c === ".") { inFrac = true; continue; }
+		if (c === "0" || c === "#") {
+			if (inFrac) {
+				count += 1;
+				if (count > best) best = count;
+			}
+			continue;
+		}
+		inFrac = false;
+		count = 0;
+	}
+	return best;
+}
+
+function __pat_shape_int(intDigits, padSlots, hasComma, groupSize) {
+	let digits = intDigits;
+	if (digits === "0" && padSlots === 0) return "";
+	if (digits.length < padSlots) digits = "0".repeat(padSlots - digits.length) + digits;
+	if (hasComma && groupSize > 0 && digits.length > groupSize) {
+		digits = digits.replace(new RegExp("\\\\B(?=(\\\\d{" + groupSize + "})+(?!\\\\d))", "g"), ",");
+	}
+	return digits;
+}
+
+function __pat_shape_frac(fracRaw, fracSlots, fracMin) {
+	let kept = fracRaw.length > fracSlots ? fracRaw.slice(0, fracSlots) : fracRaw;
+	let n = kept.length;
+	while (n > fracMin) {
+		if (kept[n - 1] === "0") n -= 1;
+		else { n = fracMin; break; }
+	}
+	kept = kept.slice(0, n);
+	if (kept.length < fracMin) kept += "0".repeat(fracMin - kept.length);
+	return kept;
+}
+
+function __pat_render(section, intDigits, fracRaw, negative) {
+	let quoted = false;
+	let firstSlot = -1;
+	let lastSlot = -1;
+	let dot = -1;
+	let padSlots = 0;
+	let fracSlots = 0;
+	let fracMin = 0;
+	let hasComma = false;
+	let slotsAfterComma = 0;
+
+	for (let i = 0; i < section.length; i++) {
+		const c = section[i];
+		if (quoted) { if (c === "'") quoted = false; continue; }
+		if (c === "'") { quoted = true; continue; }
+		if (c === "." && dot === -1) dot = i;
+		if (c === "0" || c === "#") {
+			lastSlot = i;
+			if (dot === -1) {
+				if (firstSlot === -1) firstSlot = i;
+				slotsAfterComma += 1;
+				if (c === "0") padSlots += 1;
+			} else {
+				fracSlots += 1;
+				if (c === "0") fracMin = fracSlots;
+			}
+		}
+		if (c === "," && dot === -1) { hasComma = true; slotsAfterComma = 0; }
+	}
+
+	let out = negative ? "-" : "";
+	quoted = false;
+	for (let i = 0; i < firstSlot; i++) {
+		const c = section[i];
+		if (quoted) {
+			if (c === "'") quoted = false;
+			else out += c;
+		} else if (c === "'") {
+			quoted = true;
+		} else {
+			out += c;
+		}
+	}
+
+	out += __pat_shape_int(intDigits, padSlots, hasComma, slotsAfterComma);
+	const kept = __pat_shape_frac(fracRaw, fracSlots, fracMin);
+	if (kept.length > 0) out += "." + kept;
+
+	quoted = false;
+	for (let i = lastSlot + 1; i < section.length; i++) {
+		const c = section[i];
+		if (quoted) {
+			if (c === "'") quoted = false;
+			else out += c;
+		} else if (c === "'") {
+			quoted = true;
+		} else if (i !== dot) {
+			out += c;
+		}
+	}
+	return out;
+}
+
+function __pat_apply(pattern, negative, intDigits, fracRaw) {
+	const [positive, negativeSection] = __pat_sections(pattern);
+	if (negative && negativeSection !== null) {
+		return __pat_render(negativeSection, intDigits, fracRaw, false);
+	}
+	return __pat_render(positive, intDigits, fracRaw, negative);
+}
+
+function Format_int_pattern(value, pattern) {
+	let negative = value < 0n;
+	let mag = negative ? -value : value;
+	if (__pat_has_percent(pattern)) mag = mag * 100n;
+	return __pat_apply(pattern, negative, mag.toString(), "");
+}
+
+function Format_uint_pattern(value, pattern) {
+	let mag = value;
+	if (__pat_has_percent(pattern)) mag = mag * 100n;
+	return __pat_apply(pattern, false, mag.toString(), "");
+}
+
+function Format_float_pattern(value, pattern) {
+	let negative = value < 0;
+	let mag = negative ? -value : value;
+	if (__pat_has_percent(pattern)) mag = mag * 100;
+	const maxFrac = __pat_max_frac(pattern);
+	const rendered = mag.toFixed(maxFrac);
+	const dot = rendered.indexOf(".");
+	const intDigits = dot === -1 ? rendered : rendered.slice(0, dot);
+	const frac = dot === -1 ? "" : rendered.slice(dot + 1);
+	return __pat_apply(pattern, negative, intDigits, frac);
+}
+
+`;
+}
+//#endregion
+//#region ../src/build_js/build_js.ts
+function build_js(root, options) {
+	const status = create_status(root);
+	collect_types(root, status);
+	index_allocations(root, status);
+	build_root_node(root, status);
+	emit_library_queue(status);
+	return {
+		headers: "",
+		code: `${runtime(options?.target ?? "node")}${status.library_code}${status.code}`,
+		errors: status.errors.length ? status.errors : void 0
+	};
+}
+/** Index every checker-hoisted temp by name so `build_value_node` can inline
+*  its initializer at the reference site. */
+function index_allocations(root, status) {
+	status.allocations = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		for (const allocation of node.allocations ?? []) {
+			const name = allocation.name;
+			const value = allocation.value;
+			if (name && value) status.allocations?.set(name, value);
+		}
+		for (const child of child_nodes(node)) visit(child);
+	};
+	visit(root);
+}
+/** Pre-collect every user struct/enum in the tree (declarations may be
+*  nested inside function bodies and are emitted where they appear, but the
+*  expression builders need the full type table up front). Library types are
+*  skipped — the runtime provides the supported slice of their surface. */
+function collect_types(root, status) {
+	const visit = (node) => {
+		const is_library = node.is_library === true;
+		if (node.node_type === "struct") {
+			if (is_library) status.library_structs.push(node);
+			else status.structs.push(node);
+		}
+		if (!is_library && node.node_type === "enum") status.enums.push(node);
+		if (node.node_type === "bitset") status.bitsets.push(node);
+		if (node.node_type === "trait") status.traits.push(node);
+		for (const child of child_nodes(node)) visit(child);
+	};
+	visit(root);
+}
+//#endregion
 //#region ../src/build.ts
 function build(root, options = {}) {
+	if (options.arch === "js") return build_js(root, { target: options.js_target });
 	let status = {
 		root,
 		structs: [],
@@ -71852,8 +74402,6 @@ const NO_SPACE_AFTER = /* @__PURE__ */ new Set([
 	"#",
 	"...",
 	"!",
-	"???",
-	"!!!",
 	"::"
 ]);
 const KEEP_SPACING = /* @__PURE__ */ new Set([
@@ -71971,11 +74519,7 @@ const COMPOUND_SYMBOLS = [
 	"->",
 	"=>"
 ];
-const LONG_COMPOUND_SYMBOLS = [
-	"...",
-	"???",
-	"!!!"
-];
+const LONG_COMPOUND_SYMBOLS = ["..."];
 function tokenize(input, preserve_source = false) {
 	let status = {
 		i: 0,
@@ -73095,217 +75639,15 @@ function skip_balanced_block(source, brace) {
 	return n;
 }
 //#endregion
-//#region ../src/lib.ts
-function read_library_config(lib_dir) {
-	const config_path = path.join(lib_dir, "package.jsonc");
-	const json = fs.readFileSync(config_path, "utf8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-	return JSON.parse(json);
-}
-function resolve_export_files(lib_dir, pattern) {
-	const base = pattern.replace(/\/?\*$/, "").replace(/^\.\//, "");
-	const src_dir = path.resolve(lib_dir, base);
-	if (!fs.existsSync(src_dir)) return [];
-	return fs.readdirSync(src_dir).filter((f) => f.endsWith(".nm")).sort().map((f) => path.join(src_dir, f));
-}
-const FILE_ORDER = [
-	"Disposable",
-	"Stringable",
-	"Equatable",
-	"Hashable",
-	"Sendable",
-	"Task",
-	"Mutex",
-	"Channel",
-	"int",
-	"uint",
-	"int8",
-	"uint8",
-	"int16",
-	"uint16",
-	"int32",
-	"int64",
-	"uint64",
-	"float",
-	"char",
-	"String",
-	"Array",
-	"Console",
-	"Math",
-	"bool"
-];
-function get_file_priority(file_path) {
-	const name = path.basename(file_path, ".nm");
-	const idx = FILE_ORDER.indexOf(name);
-	if (idx >= 0) return idx;
-	return FILE_ORDER.length;
-}
-function extract_deps(source) {
-	const deps = [];
-	for (const line of source.split("\n")) {
-		const trimmed = line.trim();
-		if (trimmed.startsWith("import ")) deps.push(trimmed.slice(7).trim());
-		else if (trimmed.startsWith("pub struct ") || trimmed.startsWith("internal struct ") || trimmed.startsWith("struct ")) {
-			const colon_idx = trimmed.indexOf(":");
-			if (colon_idx >= 0) {
-				const trait_name = trimmed.slice(colon_idx + 1).trim().split(/\s|<|{/)[0];
-				if (trait_name) deps.push(trait_name);
-			}
-			break;
-		} else if (trimmed.startsWith("pub class ") || trimmed.startsWith("internal class ") || trimmed.startsWith("class ")) {
-			const colon_idx = trimmed.indexOf(":");
-			if (colon_idx >= 0) {
-				const trait_name = trimmed.slice(colon_idx + 1).trim().split(/\s|<|{/)[0];
-				if (trait_name) deps.push(trait_name);
-			}
-			break;
-		} else if (trimmed.startsWith("pub trait ") || trimmed.startsWith("internal trait ") || trimmed.startsWith("trait ")) break;
-		else if (trimmed.length > 0 && !is_comment_line(trimmed)) break;
-	}
-	return deps;
-}
-function is_comment_line(trimmed) {
-	return trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*");
-}
-function extract_type_names(source) {
-	const names = [];
-	for (let line of source.split("\n")) {
-		const m = line.trim().match(/^(?:pub|internal) (?:checked )?(?:mv )?(?:struct|class|trait|enum|bitset) (\w+)/);
-		if (m) names.push(m[1]);
-	}
-	return names;
-}
-function extract_free_func_names(source) {
-	const names = [];
-	for (let line of source.split("\n")) {
-		const m = line.match(/^(?:(?:pub|internal)\s+|foreign\s+|pub\s+foreign\s+)func\s+(\w+)/);
-		if (m) names.push(m[1]);
-	}
-	return names;
-}
-function build_type_map(files, lib_dir) {
-	const all_type_names = /* @__PURE__ */ new Set();
-	const file_sources = /* @__PURE__ */ new Map();
-	const func_to_type = /* @__PURE__ */ new Map();
-	for (const f of files) {
-		const source = fs.readFileSync(f, "utf8");
-		file_sources.set(f, source);
-		const type_names = extract_type_names(source);
-		for (const name of type_names) all_type_names.add(name);
-		const first_type = type_names[0];
-		if (first_type) {
-			for (const fname of extract_free_func_names(source)) if (!func_to_type.has(fname)) func_to_type.set(fname, first_type);
-		}
-	}
-	const types = /* @__PURE__ */ new Map();
-	const functions = /* @__PURE__ */ new Map();
-	for (const f of files) {
-		const source = file_sources.get(f);
-		const deps = extract_deps(source);
-		for (const token of tokenize(source)) {
-			if (deps.includes(token.value)) continue;
-			if (all_type_names.has(token.value)) {
-				deps.push(token.value);
-				continue;
-			}
-			const dep_type = func_to_type.get(token.value);
-			if (dep_type && !deps.includes(dep_type)) deps.push(dep_type);
-		}
-		const parts = path.relative(path.resolve(lib_dir, "System"), f).split(path.sep);
-		const namespace = parts.length > 1 ? parts[0] : void 0;
-		const type_names = extract_type_names(source);
-		for (const name of type_names) types.set(name, {
-			name,
-			source,
-			path: f,
-			deps,
-			namespace
-		});
-		const free_funcs = extract_free_func_names(source);
-		if (type_names.length > 0) {
-			const shared = types.get(type_names[0]);
-			for (const fname of free_funcs) if (!functions.has(fname)) functions.set(fname, shared);
-		} else for (const fname of free_funcs) if (!functions.has(fname)) functions.set(fname, {
-			name: fname,
-			source,
-			path: f,
-			deps,
-			namespace
-		});
-	}
-	for (const [, entry] of types) {
-		if (entry.deps.includes("Buffer") && !entry.deps.includes("ClassBuffer")) entry.deps.push("ClassBuffer");
-		if (entry.deps.includes("ClassBuffer") && !entry.deps.includes("Buffer")) entry.deps.push("Buffer");
-	}
-	return {
-		types,
-		functions
-	};
-}
-function build_library(lib_dir) {
-	const config = read_library_config(lib_dir);
-	let all_files = [];
-	for (const pattern of Object.values(config.exports)) all_files = all_files.concat(resolve_export_files(lib_dir, pattern));
-	all_files.sort((a, b) => get_file_priority(a) - get_file_priority(b));
-	const source = all_files.map((f) => fs.readFileSync(f, "utf8")).join("\n");
-	const { types, functions } = build_type_map(all_files, lib_dir);
-	const namespaces = /* @__PURE__ */ new Map();
-	for (const [name, type] of types) if (type.namespace) {
-		let ns = namespaces.get(type.namespace);
-		if (!ns) {
-			ns = /* @__PURE__ */ new Set();
-			namespaces.set(type.namespace, ns);
-		}
-		ns.add(name);
-	}
-	return {
-		name: config.name,
-		source,
-		types,
-		functions,
-		namespaces,
-		dir: path.resolve(lib_dir)
-	};
-}
-const library_cache = /* @__PURE__ */ new Map();
-function get_library(lib_dir) {
-	const cached = library_cache.get(lib_dir);
-	if (cached) return cached;
-	const lib = build_library(lib_dir);
-	library_cache.set(lib_dir, lib);
-	return lib;
-}
-/**
-* Every valid namespace-path prefix implied by the library's file layout
-* (`Controls`, `Controls/Geometry`, `Stream/File`, ... and their
-* `System/`-rooted forms). A type's path (`core/System/Controls/Geometry.nm`)
-* contributes the chain of directories leading to it plus the module file's
-* own base name, so both `Controls::Button` (namespace) and
-* `Controls::Geometry::Size` (module) validate.
-*/
-function library_path_prefixes(library) {
-	const prefixes = /* @__PURE__ */ new Set();
-	const system_root = path.resolve(library.dir, "System");
-	for (const entry of library.types.values()) {
-		const rel = path.relative(system_root, entry.path);
-		if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) continue;
-		const parts = rel.replace(/\.nm$/, "").split(path.sep);
-		for (let i = 1; i <= parts.length; i++) {
-			const joined = parts.slice(0, i).join("/");
-			prefixes.add(joined);
-			prefixes.add(`System/${joined}`);
-		}
-	}
-	return prefixes;
-}
-//#endregion
 //#region ../src/check/warnings.ts
 /**
-* Lint pass run after a successful check. It walks the AST to surface three
+* Lint pass run after a successful check. It walks the AST to surface four
 * kinds of warning:
 *
 *  - an unused value/parameter (declared but never read)
 *  - a `var` that is never reassigned (it could be a `const`)
 *  - a function or method that is never called
+*  - a type annotation that repeats what the initializer already infers
 *
 * The analysis is deliberately conservative: it biases towards not warning
 * when ownership (mv/ref/cp), trait vtables, library code or the `_`-discard
@@ -73362,6 +75704,9 @@ function emit_warnings(root, status) {
 			else add_warning(status, `Ref parameter '${param.name}' is never written through — take it by value (or drop 'ref')`, param.name_start ?? param.start);
 		}
 	}
+	for_each_node(root, (node) => {
+		if (node.node_type === "declare") warn_redundant_annotation(node, status);
+	});
 	status.warnings = dedupe_warnings(status.warnings);
 }
 function dedupe_warnings(warnings) {
@@ -73437,6 +75782,61 @@ function warn_var_not_changed(decl, locals, status) {
 		replace_text: "const"
 	} : void 0);
 }
+/**
+* A declaration whose annotation repeats what its initializer already infers
+* (NOMEN_AGENTS.md, "Prefer implicit types"): `const Point p = Point(2, 3)`
+* or `var int x = 5`. The recognised forms mirror `nomen format`'s
+* conservative strip — a constructor call with every generic argument written
+* at the call, and a single self-describing literal — so everything the
+* warning flags is also what formatting removes. Forms whose annotation is
+* load-bearing stay silent: generic constructions the annotation instantiates
+* (`var List<int> v = List()`), enum shorthand (`.east`), wider/narrower
+* literals (`var int16 small = 300`), nullables, view/ref bindings, and
+* constrained declarations. Library code is exempt.
+*/
+function warn_redundant_annotation(decl, status) {
+	if (decl.is_library || decl.is_loop_iterator || decl.is_readonly) return;
+	if (status.library_boundary !== void 0 && decl.start >= status.library_boundary) return;
+	if (!decl.type.name || decl.type_start === void 0 || decl.name_start === void 0) return;
+	if (decl.type.is_view || decl.type.is_ref || decl.type.is_nullable || decl.type.is_array) return;
+	if (decl.declaration === "view" || decl.declaration === "ref") return;
+	if (decl.constraint) return;
+	const value = decl.value;
+	if (!value) return;
+	if (value.node_type === "func_call") {
+		const call = value;
+		if (call.is_thread_ctor || call.is_fiber_ctor || call.is_awaitable_ctor || call.is_weak_ctor || call.is_func_value_ctor || call.is_enum_shorthand || call.field_overrides?.length) return;
+		if (call.resolved_function?.name !== "#init") return;
+		const struct = status.structs.find((s) => s.name === call.name);
+		if (!struct) return;
+		if (call.type_args_from_expected) return;
+		if (struct.type_params.length && (call.type_args?.length ?? 0) !== struct.type_params.length) return;
+	} else if (value.node_type === "value") {
+		const text = value.value;
+		if (literal_type_name(text) === void 0) return;
+	} else return;
+	if (type_display(decl.type) !== type_display(type_from_value_node(value, status))) return;
+	add_warning(status, `Type annotation on '${decl.name}' is redundant — '${type_display(decl.type)}' is already inferred; run 'nomen format' to drop it`, decl.type_start, {
+		title: "Drop redundant type",
+		param_start: decl.start,
+		replace_start: decl.type_start,
+		replace_end: decl.name_start,
+		replace_text: ""
+	});
+}
+/** The type a literal value spells out on its own; undefined when it doesn't. */
+function literal_type_name(text) {
+	if (text === "true" || text === "false") return "bool";
+	if (text.length >= 2 && text.startsWith("\"") && text.endsWith("\"")) return "string";
+	if (text.length >= 3 && text.startsWith("'") && text.endsWith("'")) return "char";
+	if (/^-?\d+$/.test(text)) return "int";
+	if (/^-?(\d+\.\d*|\.\d+)([eE][+-]?\d+)?$/.test(text)) return "float";
+}
+/** The user-visible spelling of a type (`List<int>`, `Map<string, int>`). */
+function type_display(t) {
+	if (!t.type_args?.length) return t.name ?? "?";
+	return `${t.name}<${t.type_args.map(type_display).join(", ")}>`;
+}
 /** Names that count as a "use": call targets, method names, and value reads. */
 function collect_referenced_names(root) {
 	const names = /* @__PURE__ */ new Set();
@@ -74927,26 +77327,31 @@ function parse_embed_file(status) {
 	const full = path.isAbsolute(rel_path) ? rel_path : path.join(base, rel_path);
 	let content;
 	try {
-		content = fs.readFileSync(full, "utf8");
-	} catch {
+		content = fs.readFileSync(full);
+	} catch (cause) {
+		const idx = status.tokens.findIndex((t) => t.value === "#embed_file" && t.i === start);
+		const near = status.tokens.slice(Math.max(0, idx - 2), idx + 4).map((t) => t.value);
+		console.log(`[embed-debug] tokens near: ${JSON.stringify(near)} embed_root=${JSON.stringify(status.embed_root)}`);
 		add_error(status, `#embed_file could not read '${rel_path}' (resolved '${full}')`, start);
 		return new ValueNode(start, "\"\"");
 	}
-	return new ValueNode(start, `"${escape_embedded(content)}"`);
+	return new ValueNode(start, `"${escape_embedded_bytes(content)}"`);
 }
-/** Encode file contents as a source-level string literal body. */
-function escape_embedded(content) {
+/** Encode file contents as a source-level string literal body —
+*  byte-transparent: printable ASCII passes through, everything else
+*  (control bytes, quotes, backslashes, and every byte ≥ 0x7F) becomes a
+*  three-digit octal escape, which the escape scanner decodes back to the
+*  same byte. Self-terminating in C string literals too (the decoder
+*  consumes exactly three octal digits). */
+function escape_embedded_bytes(content) {
 	let out = "";
-	for (const ch of content) {
-		const code = ch.charCodeAt(0);
-		if (ch === "\\") out += "\\\\";
-		else if (ch === "\"") out += "\\\"";
-		else if (ch === "\n") out += "\\n";
-		else if (ch === "\r") out += "\\r";
-		else if (ch === "	") out += "\\t";
-		else if (code < 32 || code === 127) out += `\\${code.toString(8).padStart(3, "0")}`;
-		else out += ch;
-	}
+	for (const byte of content) if (byte === 92) out += "\\\\";
+	else if (byte === 34) out += "\\\"";
+	else if (byte === 10) out += "\\n";
+	else if (byte === 13) out += "\\r";
+	else if (byte === 9) out += "\\t";
+	else if (byte < 32 || byte >= 127) out += `\\${byte.toString(8).padStart(3, "0")}`;
+	else out += String.fromCharCode(byte);
 	return out;
 }
 //#endregion
@@ -76454,6 +78859,9 @@ function validate_qualified_paths(status, prefixes) {
 	}
 }
 function mark_library_nodes(root, boundary) {
+	function is_node(value) {
+		return !!value && typeof value === "object" && typeof value.node_type === "string";
+	}
 	function walk(node) {
 		if (!node || typeof node !== "object") return;
 		if (Array.isArray(node)) {
@@ -76461,33 +78869,16 @@ function mark_library_nodes(root, boundary) {
 			return;
 		}
 		const type = node.node_type;
-		if (type === "func") {
-			if (node.start >= boundary) node.is_library = true;
-			if (node.statements) walk(node.statements);
-			if (node.allocations) walk(node.allocations);
-			return;
-		}
-		if (type === "struct") {
-			if (node.start >= boundary) node.is_library = true;
-			if (node.functions) for (const f of node.functions) walk(f);
-			if (node.fields) walk(node.fields);
-		}
-		if (type === "trait") {
-			if (node.start >= boundary) node.is_library = true;
-			if (node.functions) for (const f of node.functions) walk(f);
-			if (node.fields) walk(node.fields);
-		}
-		if (type === "enum" || type === "bitset") {
+		if (type === "func" || type === "struct" || type === "trait" || type === "enum" || type === "bitset" || type === "declare") {
 			if (node.start >= boundary) node.is_library = true;
 		}
-		if (type === "declare") {
-			if (node.start >= boundary) node.is_library = true;
-		}
-		if (type === "extend") {
-			if (node.functions) for (const f of node.functions) walk(f);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const item of value) if (is_node(item)) walk(item);
+			} else if (is_node(value)) walk(value);
 		}
-		if (node.statements) walk(node.statements);
-		if (node.allocations) walk(node.allocations);
 	}
 	walk(root);
 }
@@ -76495,7 +78886,9 @@ function mark_library_nodes(root, boundary) {
 * The base directory for `#embed_file` paths: the package root (the nearest
 * enclosing directory with a package.jsonc), falling back to the entry
 * file's folder. No file path — undefined, so `#embed_file` resolves
-* against the process CWD.
+* against the process CWD. Exported for the library builder, which inlines
+* library-level embeds against each source file's own root (the
+* concatenated library source is parsed without a file path).
 */
 function embed_root_for(file_path) {
 	if (!file_path) return void 0;
@@ -76652,6 +79045,228 @@ function format_errors(source, errors) {
 	return errors;
 }
 //#endregion
+//#region ../src/lib.ts
+function read_library_config(lib_dir) {
+	const config_path = path.join(lib_dir, "package.jsonc");
+	const json = fs.readFileSync(config_path, "utf8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+	return JSON.parse(json);
+}
+function resolve_export_files(lib_dir, pattern) {
+	const base = pattern.replace(/\/?\*$/, "").replace(/^\.\//, "");
+	const src_dir = path.resolve(lib_dir, base);
+	if (!fs.existsSync(src_dir)) return [];
+	return fs.readdirSync(src_dir).filter((f) => f.endsWith(".nm")).sort().map((f) => path.join(src_dir, f));
+}
+const FILE_ORDER = [
+	"Disposable",
+	"Stringable",
+	"Equatable",
+	"Hashable",
+	"Sendable",
+	"Task",
+	"Mutex",
+	"Channel",
+	"int",
+	"uint",
+	"int8",
+	"uint8",
+	"int16",
+	"uint16",
+	"int32",
+	"int64",
+	"uint64",
+	"float",
+	"char",
+	"String",
+	"Array",
+	"Console",
+	"Math",
+	"bool"
+];
+function get_file_priority(file_path) {
+	const name = path.basename(file_path, ".nm");
+	const idx = FILE_ORDER.indexOf(name);
+	if (idx >= 0) return idx;
+	return FILE_ORDER.length;
+}
+function extract_deps(source) {
+	const deps = [];
+	for (const line of source.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("import ")) deps.push(trimmed.slice(7).trim());
+		else if (trimmed.startsWith("pub struct ") || trimmed.startsWith("internal struct ") || trimmed.startsWith("struct ")) {
+			const colon_idx = trimmed.indexOf(":");
+			if (colon_idx >= 0) {
+				const trait_name = trimmed.slice(colon_idx + 1).trim().split(/\s|<|{/)[0];
+				if (trait_name) deps.push(trait_name);
+			}
+			break;
+		} else if (trimmed.startsWith("pub class ") || trimmed.startsWith("internal class ") || trimmed.startsWith("class ")) {
+			const colon_idx = trimmed.indexOf(":");
+			if (colon_idx >= 0) {
+				const trait_name = trimmed.slice(colon_idx + 1).trim().split(/\s|<|{/)[0];
+				if (trait_name) deps.push(trait_name);
+			}
+			break;
+		} else if (trimmed.startsWith("pub trait ") || trimmed.startsWith("internal trait ") || trimmed.startsWith("trait ")) break;
+		else if (trimmed.length > 0 && !is_comment_line(trimmed)) break;
+	}
+	return deps;
+}
+function is_comment_line(trimmed) {
+	return trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*");
+}
+function extract_type_names(source) {
+	const names = [];
+	for (let line of source.split("\n")) {
+		const m = line.trim().match(/^(?:pub|internal) (?:checked )?(?:mv )?(?:struct|class|trait|enum|bitset) (\w+)/);
+		if (m) names.push(m[1]);
+	}
+	return names;
+}
+function extract_free_func_names(source) {
+	const names = [];
+	for (let line of source.split("\n")) {
+		const m = line.match(/^(?:(?:pub|internal)\s+|foreign\s+|pub\s+foreign\s+)func\s+(\w+)/);
+		if (m) names.push(m[1]);
+	}
+	return names;
+}
+function build_type_map(files, lib_dir, file_texts) {
+	const all_type_names = /* @__PURE__ */ new Set();
+	const file_sources = /* @__PURE__ */ new Map();
+	const func_to_type = /* @__PURE__ */ new Map();
+	for (const f of files) {
+		const source = file_texts?.get(f) ?? fs.readFileSync(f, "utf8");
+		file_sources.set(f, source);
+		const type_names = extract_type_names(source);
+		for (const name of type_names) all_type_names.add(name);
+		const first_type = type_names[0];
+		if (first_type) {
+			for (const fname of extract_free_func_names(source)) if (!func_to_type.has(fname)) func_to_type.set(fname, first_type);
+		}
+	}
+	const types = /* @__PURE__ */ new Map();
+	const functions = /* @__PURE__ */ new Map();
+	for (const f of files) {
+		const source = file_sources.get(f);
+		const deps = extract_deps(source);
+		for (const token of tokenize(source)) {
+			if (deps.includes(token.value)) continue;
+			if (all_type_names.has(token.value)) {
+				deps.push(token.value);
+				continue;
+			}
+			const dep_type = func_to_type.get(token.value);
+			if (dep_type && !deps.includes(dep_type)) deps.push(dep_type);
+		}
+		const parts = path.relative(path.resolve(lib_dir, "System"), f).split(path.sep);
+		const namespace = parts.length > 1 ? parts[0] : void 0;
+		const type_names = extract_type_names(source);
+		for (const name of type_names) types.set(name, {
+			name,
+			source,
+			path: f,
+			deps,
+			namespace
+		});
+		const free_funcs = extract_free_func_names(source);
+		if (type_names.length > 0) {
+			const shared = types.get(type_names[0]);
+			for (const fname of free_funcs) if (!functions.has(fname)) functions.set(fname, shared);
+		} else for (const fname of free_funcs) if (!functions.has(fname)) functions.set(fname, {
+			name: fname,
+			source,
+			path: f,
+			deps,
+			namespace
+		});
+	}
+	for (const [, entry] of types) {
+		if (entry.deps.includes("Buffer") && !entry.deps.includes("ClassBuffer")) entry.deps.push("ClassBuffer");
+		if (entry.deps.includes("ClassBuffer") && !entry.deps.includes("Buffer")) entry.deps.push("Buffer");
+	}
+	return {
+		types,
+		functions
+	};
+}
+function build_library(lib_dir) {
+	const config = read_library_config(lib_dir);
+	let all_files = [];
+	for (const pattern of Object.values(config.exports)) all_files = all_files.concat(resolve_export_files(lib_dir, pattern));
+	all_files.sort((a, b) => get_file_priority(a) - get_file_priority(b));
+	const file_texts = new Map(all_files.map((f) => [f, inline_library_embeds(f, fs.readFileSync(f, "utf8"))]));
+	const source = all_files.map((f) => file_texts.get(f)).join("\n");
+	const { types, functions } = build_type_map(all_files, lib_dir, file_texts);
+	const namespaces = /* @__PURE__ */ new Map();
+	for (const [name, type] of types) if (type.namespace) {
+		let ns = namespaces.get(type.namespace);
+		if (!ns) {
+			ns = /* @__PURE__ */ new Set();
+			namespaces.set(type.namespace, ns);
+		}
+		ns.add(name);
+	}
+	return {
+		name: config.name,
+		source,
+		types,
+		functions,
+		namespaces,
+		dir: path.resolve(lib_dir)
+	};
+}
+const library_cache = /* @__PURE__ */ new Map();
+/**
+* `#embed_file` inside LIBRARY sources resolves against the library's own
+* package root, but the concatenated library source is parsed without a
+* file path — the caller's CWD/package root would win, and the directive
+* would fail (or read the wrong file) for every program built outside the
+* repo. Inline the directive textually at concat time: the file's bytes
+* become an escape-encoded string literal exactly like parse_embed_file
+* produces, so downstream sees a plain literal. Library sources are
+* trusted repo files, so a plain directive match is fine.
+*/
+function inline_library_embeds(file, text) {
+	if (!text.includes("#embed_file")) return text;
+	const base = embed_root_for(file) ?? path.dirname(file);
+	return text.replace(/#embed_file\("([^"]+)"\)/g, (_match, rel_path) => {
+		const full = path.isAbsolute(rel_path) ? rel_path : path.join(base, rel_path);
+		return `"${escape_embedded_bytes(fs.readFileSync(full))}"`;
+	});
+}
+function get_library(lib_dir) {
+	const cached = library_cache.get(lib_dir);
+	if (cached) return cached;
+	const lib = build_library(lib_dir);
+	library_cache.set(lib_dir, lib);
+	return lib;
+}
+/**
+* Every valid namespace-path prefix implied by the library's file layout
+* (`Controls`, `Controls/Geometry`, `Stream/File`, ... and their
+* `System/`-rooted forms). A type's path (`core/System/Controls/Geometry.nm`)
+* contributes the chain of directories leading to it plus the module file's
+* own base name, so both `Controls::Button` (namespace) and
+* `Controls::Geometry::Size` (module) validate.
+*/
+function library_path_prefixes(library) {
+	const prefixes = /* @__PURE__ */ new Set();
+	const system_root = path.resolve(library.dir, "System");
+	for (const entry of library.types.values()) {
+		const rel = path.relative(system_root, entry.path);
+		if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) continue;
+		const parts = rel.replace(/\.nm$/, "").split(path.sep);
+		for (let i = 1; i <= parts.length; i++) {
+			const joined = parts.slice(0, i).join("/");
+			prefixes.add(joined);
+			prefixes.add(`System/${joined}`);
+		}
+	}
+	return prefixes;
+}
+//#endregion
 //#region src/args.ts
 const STRING_OPTIONS = /* @__PURE__ */ new Map([
 	["in", "in"],
@@ -76776,7 +79391,7 @@ function print_help() {
 		"  --config, -c <path>     Path to a config file",
 		"  --watch, -w             Watch for file changes",
 		"  --filter, -f <regex>    Only run test files whose path matches this regex",
-		"  --arch, -a <arch>       Target architecture: aarch64 | c (default: aarch64)",
+		"  --arch, -a <arch>       Target architecture: aarch64 | c | js (default: aarch64)",
 		"  --platform, -p <name>   Target platform: macos, ios, linux, android, windows, web",
 		"  --lib, -l <path>        Path to System library directory (containing package.jsonc)",
 		"  --audit                 Audit the generated program for memory issues",
@@ -77905,6 +80520,17 @@ function processFile(filename, config, mode, program_args) {
 	}
 	const basename = path.basename(filename, ".nm");
 	const buildDir = build_dir_for(resolved, filename.endsWith(".test.nm"));
+	if (arch === "js") {
+		if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir, { recursive: true });
+		const jsfile = path.join(buildDir, basename + ".mjs");
+		fs.writeFileSync(jsfile, result.code);
+		console.log(`Created ${jsfile} in ${(performance.now() - startTime).toFixed(2)}ms`);
+		if (mode === "run") {
+			execFileSync(process.env.NODE ?? "node", [jsfile, ...program_args], { stdio: "inherit" });
+			console.log(`Completed in ${(performance.now() - startTime).toFixed(2)}ms`);
+		}
+		return;
+	}
 	if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir, { recursive: true });
 	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const headerfile = path.join(buildDir, "main.h");