nomen-lang 0.0.16 → 0.0.18

package/dist/index.mjs

@@ -1777,6 +1777,11 @@ var AccessFunctionCallNode = class extends BaseNode {
 	* FunctionCallNode.nullable_param_indices.
 	*/
 	nullable_param_indices;
+	/**
+	* Indices of arguments whose corresponding callee parameter is a `view T`
+	* (notably `view string`). See FunctionCallNode.view_param_indices.
+	*/
+	view_param_indices;
 	swap_params;
 	variadic_param_name;
 	variadic_param_index;
@@ -1828,6 +1833,12 @@ var AccessFunctionCallNode = class extends BaseNode {
 	* the programmer is asserting the array is long enough positionally.
 	*/
 	skip_bounds_check;
+	/**
+	* The concrete FunctionNode the checker resolved this method call to.
+	* See FunctionCallNode.resolved_function — used by build-time passes for
+	* callee-signature facts (notably hidden string-length companions).
+	*/
+	resolved_function;
 	constructor(start, name, type, params, is_static) {
 		super("access_func", start);
 		this.name = name;
@@ -1901,6 +1912,14 @@ var FunctionCallNode = class extends BaseNode {
 	* struct pointer — see ROADBLOCKS "Nullable structs".
 	*/
 	nullable_param_indices;
+	/**
+	* Indices of arguments whose corresponding callee parameter is a `view T`
+	* (notably `view string`). Populated during the check pass when the
+	* callee's signature is resolved. The build uses this to pass the (ptr,
+	* len) pair at the call boundary: a view-typed argument passes through,
+	* an owned `string` argument is wrapped with its strlen.
+	*/
+	view_param_indices;
 	swap_params;
 	variadic_param_name;
 	variadic_param_index;
@@ -1934,6 +1953,14 @@ var FunctionCallNode = class extends BaseNode {
 	* tag+payload temp), mirroring `Enum.case(args)` access calls.
 	*/
 	is_enum_shorthand;
+	/**
+	* The concrete FunctionNode the checker resolved this call to (plain
+	* function, struct constructor, or monomorphized/specialized copy).
+	* Build-time passes consult it for callee-signature facts that only the
+	* checker can resolve robustly (overloads, monos) — notably the hidden
+	* string-length companion params (`ParameterNode.hidden_len`).
+	*/
+	resolved_function;
 	constructor(start, name, type, params, is_static) {
 		super("func_call", start);
 		this.name = name;
@@ -2055,6 +2082,29 @@ function type_from_value_node$1(node) {
 	return new Type("");
 }
 //#endregion
+//#region ../src/build_common/hidden_len.ts
+/**
+* Indices of a call's DECLARED arguments whose callee parameter carries the
+* hidden string-length companion (`ParameterNode.hidden_len`, stamped by the
+* post-check `stamp_hidden_string_lens` pass). The backends append one
+* companion argument right after each such argument — `long _<name>_len` on
+* C, the next AAPCS slot on aarch64 — and the hoist scan treats these args
+* like `.length` reads so a loop-invariant strlen temp covers them.
+*
+* Resolution comes from the checker's `resolved_function` stamp (exact for
+* overloads and monomorphized copies); an unstamped call site (synthesized
+* nodes, indirect func-value calls) yields no companions, which matches the
+* qualification pass — those callees are never stamped `hidden_len`.
+*/
+function callee_hidden_len_indices(call) {
+	const func = call.resolved_function;
+	if (!func) return [];
+	const self_offset = func.params[0]?.is_self_param ? 1 : 0;
+	const out = [];
+	for (let i = 0; i < call.params.length; i++) if (func.params[i + self_offset]?.hidden_len) out.push(i);
+	return out;
+}
+//#endregion
 //#region ../src/build_common/mono_name.ts
 function mono_type_name(type_or_name, type_args) {
 	const name = typeof type_or_name === "string" ? type_or_name : type_or_name.name;
@@ -2153,6 +2203,27 @@ var ParameterNode = class extends BaseNode {
 	is_variadic_tuple;
 	func_params;
 	func_return_type;
+	/**
+	* Parallel-length equalities (`a.length == b.length` conjuncts) stripped
+	* from `constraint` at signature-registration time — before any call site
+	* can observe this function, so declaration order never matters (a
+	* forward-referenced callee must not ask its caller to prove a clause no
+	* call site could). The callee's own param check seeds
+	* `status.equal_lengths` from these so its body still gets the assumption.
+	*/
+	stripped_length_equalities;
+	/**
+	* True for a by-value `string` param whose function body reads
+	* `<name>.length` (and never rebinds/mutates/escapes it) — stamped by the
+	* post-check pass `stamp_hidden_string_lens`. The backends lower it as TWO
+	* parameters: the `char*` itself plus a trailing companion length
+	* (`long _<name>_len` on C; the next AAPCS slot on aarch64), so the body's
+	* `.length` reads are register/stack loads instead of a per-call `strlen`.
+	* Call sites append the companion argument (a hoisted loop-invariant
+	* strlen temp when one exists — see scan_string_length_hoists). Mirrors
+	* the nullable `_has` companion convention.
+	*/
+	hidden_len;
 	constructor(start, name, type, default_value, is_self_param, declaration) {
 		super("param", start);
 		this.name = name;
@@ -2217,6 +2288,12 @@ var FunctionNode = class extends BaseNode {
 	type_params = [];
 	scope;
 	/**
+	* Set once the post-check `stamp_hidden_string_lens` pass has considered
+	* this function — guards against double-stamping when a check pass runs
+	* twice over a shared tree.
+	*/
+	hidden_len_stamped;
+	/**
 	* Optional contract on the return value, parsed from `out TYPE: constraint`.
 	* The placeholder `out` refers to the return value; other identifiers refer
 	* to the function's parameters. Used by check_function_call to propagate
@@ -4396,6 +4473,11 @@ function build_function_node$1(node, status) {
 				first_pass_slot += 1;
 				continue;
 			}
+			if (param.type.is_view) {
+				first_pass_slot += 2;
+				continue;
+			}
+			if (param.hidden_len) first_pass_slot++;
 			const is_struct_type = !!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type);
 			const is_trait_type = !!status.traits.find((t) => t.name === param.type.name);
 			const is_enum_with_data = !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data);
@@ -4433,7 +4515,11 @@ function build_function_node$1(node, status) {
 	status.ref_class_slots = /* @__PURE__ */ new Map();
 	status.function_struct_param_slots = /* @__PURE__ */ new Set();
 	const old_variadic_params_aarch64 = status.function_variadic_params;
+	const old_view_params = status.function_view_params;
 	status.function_variadic_params = /* @__PURE__ */ new Set();
+	status.function_view_params = /* @__PURE__ */ new Set();
+	const old_hidden_len_params = status.hidden_len_params;
+	status.hidden_len_params = /* @__PURE__ */ new Set();
 	status.moved_class_params = /* @__PURE__ */ new Map();
 	let moved_param_save_slots = /* @__PURE__ */ new Map();
 	if (has_body) {
@@ -4454,6 +4540,22 @@ function build_function_node$1(node, status) {
 				}
 				param_idx++;
 			}
+			if (param.type.is_view) {
+				const offset = allocate_stack_space(status, 16, 16);
+				status.stack_offsets.set(param.name, offset);
+				status.function_view_params.add(param.name);
+				for (const half of [0, 1]) {
+					const p_slot = param_idx + half;
+					if (p_slot < 8) status.code += `str ${param_regs[p_slot]}, [x29, #${offset + half * 8}]\n`;
+					else {
+						const k = p_slot - 8;
+						status.code += `ldr x9, [x29, #${overflow_placeholder(node.name, k)}]\n`;
+						status.code += `str x9, [x29, #${offset + half * 8}]\n`;
+					}
+				}
+				param_idx += 2;
+				continue;
+			}
 			if (callee_map.has(param.name)) {
 				const reg = callee_map.get(param.name);
 				status.function_param_regs.set(param.name, reg);
@@ -4487,6 +4589,19 @@ function build_function_node$1(node, status) {
 				}
 			}
 			param_idx++;
+			if (param.hidden_len) {
+				const len_offset = allocate_stack_space(status, 8, 8);
+				status.stack_offsets.set(`_${param.name}_len`, len_offset);
+				if (!status.hidden_len_params) status.hidden_len_params = /* @__PURE__ */ new Set();
+				status.hidden_len_params.add(param.name);
+				if (param_idx < 8) status.code += `str ${param_regs[param_idx]}, [x29, #${len_offset}]\n`;
+				else {
+					const k = param_idx - 8;
+					status.code += `ldr x9, [x29, #${overflow_placeholder(node.name, k)}]\n`;
+					status.code += `str x9, [x29, #${len_offset}]\n`;
+				}
+				param_idx++;
+			}
 			if (param.declaration === "var") status.function_param_vars.add(param.name);
 			if (param.type.is_array) {
 				if (!param.is_variadic ? array_struct_name(param.type, status) : void 0) {
@@ -4502,6 +4617,7 @@ function build_function_node$1(node, status) {
 	for (let i = 0; i < node.params.length; i++) {
 		const param = node.params[i];
 		if (param.is_variadic) pidx++;
+		if (param.hidden_len) pidx++;
 		if (param.is_moved) {
 			if (!!status.structs.find((s) => s.name === param.type.name && s.is_class)) {
 				const reg = callee_map.get(param.name) ?? param_regs[pidx];
@@ -4627,6 +4743,8 @@ function build_function_node$1(node, status) {
 	status.ref_class_slots = old_ref_class_slots;
 	status.function_struct_param_slots = old_struct_param_slots;
 	status.function_variadic_params = old_variadic_params_aarch64;
+	status.function_view_params = old_view_params;
+	status.hidden_len_params = old_hidden_len_params;
 	status.function_return_label = old_return_label;
 	status.struct_return_buffer = void 0;
 	status.return_buffer_stack_offset = void 0;
@@ -6314,6 +6432,108 @@ function build_swap_params(node, status) {
 	}
 }
 //#endregion
+//#region ../src/build_aarch64/utils/view_value.ts
+/**
+* Resolve the struct name of an expression's value by walking the access
+* chain through the (monomorphized) struct table — bare names via
+* variable_types / scoped declarations / `self`, field accesses via the
+* base struct's field type, method calls via the method's return type.
+* Fallback for cached node types that lost their modifiers (generic bodies
+* re-checked after monomorphization can carry a stale plain `string`).
+*/
+function value_struct_name$1(node, status) {
+	if (node.node_type === "value") {
+		const name = node.value;
+		if (name === "self" && status.current_struct) return status.current_struct.name;
+		const vt = status.variable_types?.get(name);
+		if (vt?.name) return vt.name;
+		const decl = status.scoped_declarations.findLast((d) => d.name === name);
+		if (decl?.type?.name) return decl.type.name;
+		return;
+	}
+	if (node.node_type === "access") {
+		const inner = node.access;
+		const base = value_struct_name$1(node.target, status);
+		if (!base) return void 0;
+		const struct = status.structs.find((s) => s.name === base && !s.is_generic);
+		if (!struct) return void 0;
+		if (inner.node_type === "access_field") return struct.fields.find((f) => f.name === inner.name)?.type?.name;
+		if (inner.node_type === "access_func") return struct.functions.find((f) => f.name === inner.name)?.return_type?.name;
+	}
+}
+/**
+* Whether an expression is a `view T` VALUE — a (ptr, len) pair that can be
+* passed to a `view T` parameter unchanged (loaded from the value's two
+* stack slots, or produced directly by a view-returning call). Recovers
+* `is_view` from the cached node type, the declared variable type, the
+* current function's view params, or (for method calls whose cached type
+* lost the modifier) the callee's declared return type.
+*/
+function is_view_value$1(node, status) {
+	if (type_from_value_node$1(node)?.is_view) return true;
+	if (node.node_type === "value") {
+		const name = node.value;
+		if (status.variable_types?.get(name)?.is_view) return true;
+		if (status.function_view_params?.has(name)) return true;
+	}
+	if (node.node_type === "access" && node.access.node_type === "access_func") {
+		const access = node.access;
+		const recv_struct = value_struct_name$1(node.target, status);
+		if ((status.structs.find((s) => s.name === recv_struct && !s.is_generic)?.functions.find((f) => f.name === access.name || f.name === `#${access.name}`))?.return_type?.is_view) return true;
+	}
+	return false;
+}
+/**
+* Emit the (ptr, len) pair for a `view string` argument into x0/x1.
+* - A view VALUE (a view local/param's two stack slots, or a view-returning
+*   call that leaves the pair in x0/x1) passes through unchanged.
+* - An owned string expression builds its pointer into x0, then measures it
+*   with strlen — an implicit owned→view borrow; ownership stays with the
+*   caller.
+*/
+function emit_view_string_arg(arg, status) {
+	if (is_view_value$1(arg, status)) {
+		if (arg.node_type === "value") {
+			const base = status.stack_offsets?.get(arg.value);
+			if (base !== void 0) {
+				status.code += `ldr x0, [x29, #${base}]\n`;
+				status.code += `ldr x1, [x29, #${base + 8}]\n`;
+				return;
+			}
+		}
+		build_node$1(arg, status);
+		if (!status.code.endsWith("\n")) status.code += "\n";
+		return;
+	}
+	build_node$1(arg, status);
+	if (!status.code.endsWith("\n")) status.code += "\n";
+	status.code += `str x0, [sp, #-16]!\n`;
+	status.code += `bl _strlen\n`;
+	status.code += `mov x1, x0\n`;
+	status.code += `ldr x0, [sp], #16\n`;
+}
+/**
+* Materialize a `view string` into an OWNED heap string. The (ptr, len)
+* pair must be in x0/x1 on entry; on exit x0 holds a malloc'd, null-
+* terminated copy of exactly len bytes (and the caller must reclaim it —
+* set last_result_is_heap / mark the target as a heap string). Mirrors the
+* view `.to_string` builtin sequence.
+*/
+function emit_view_materialize_owned(status) {
+	status.code += `stp x0, x1, [sp, #-16]!\n`;
+	status.code += `add x0, x1, #1\n`;
+	emit_malloc(status);
+	status.code += `str x0, [sp, #-16]!\n`;
+	status.code += `ldr x1, [sp, #16]\n`;
+	status.code += `ldr x2, [sp, #24]\n`;
+	status.code += `ldr x0, [sp]\n`;
+	status.code += `bl _memcpy\n`;
+	status.code += `ldr x0, [sp]\n`;
+	status.code += `ldr x1, [sp, #24]\n`;
+	status.code += `strb wzr, [x0, x1]\n`;
+	status.code += `add sp, sp, #32\n`;
+}
+//#endregion
 //#region ../src/build_aarch64/build_declaration_node.ts
 /**
 * Pass a struct-typed param by address. For ValueNode (variable references)
@@ -6476,10 +6696,13 @@ function build_constructor_params(fc, param_regs, status) {
 		const elem_struct = status.structs.find((s) => s.name === elem_type_name && !s.is_simple_type);
 		const elem_size = elem_struct ? get_struct_size(elem_type_name, status) : 8;
 		const count = arr.values.length;
-		const arr_offset = allocate_stack_space(status, Math.max(count, 1) * elem_size, 16);
+		const arr_offset = allocate_stack_space(status, 8 + Math.max(count, 1) * elem_size, 16);
+		const data_base = arr_offset + 8;
+		status.code += `mov x0, #${count}\n`;
+		status.code += `str x0, [x29, #${arr_offset}]\n`;
 		for (let j = count - 1; j >= 0; j--) {
 			const arg = arr.values[j];
-			const slot_offset = arr_offset + j * elem_size;
+			const slot_offset = data_base + j * elem_size;
 			if (elem_struct && arg.node_type === "func_call") {
 				const tfc = arg;
 				const fc_param_regs = [
@@ -6539,7 +6762,7 @@ function build_constructor_params(fc, param_regs, status) {
 		emit_int_immediate(status, String(count));
 		if (!status.code.endsWith("\n")) status.code += "\n";
 		status.code += `str x0, [x29, #${count_slot}]\n`;
-		status.code += `add x0, x29, #${arr_offset}\n`;
+		status.code += `add x0, x29, #${data_base}\n`;
 		status.code += `str x0, [x29, #${ptr_slot}]\n`;
 		const reg_slots = Math.min(total_slots, 7);
 		for (let i = 0; i < reg_slots; i++) status.code += `ldr ${param_regs[i]}, [x29, #${slots_base + i * 8}]\n`;
@@ -7414,10 +7637,18 @@ function build_declaration_node$1(node, status) {
 			const value_node = node.value;
 			const raw = get_raw_value$1(value_node);
 			const is_literal = /^(\+|-)?\d+(\.\d+)?$/.test(raw) || raw.startsWith("\"") || raw === "true" || raw === "false";
-			if (!!status.function_return_label) {
+			const use_stack = !!status.function_return_label;
+			const is_heap_alias = node.type.name === "string" && !is_literal && status.heap_strings?.has(raw);
+			if (use_stack) {
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(node.name, offset);
-				if (node.type.name === "string" && !is_literal && status.heap_strings?.has(raw)) {
+				if (node.type.name === "string" && !node.type.is_view && is_view_value$1(node.value, status)) {
+					emit_view_string_arg(node.value, status);
+					emit_view_materialize_owned(status);
+					status.code += `str x0, [x29, #${offset}]\n`;
+					mark_heap_string(status, node.name);
+					status.last_result_is_heap = false;
+				} else if (is_heap_alias) {
 					emit_var_load(status, "x0", raw, 8);
 					emit_strdup(status);
 					status.code += `str x0, [x29, #${offset}]\n`;
@@ -7570,6 +7801,14 @@ function build_declaration_node$1(node, status) {
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(node.name, offset);
 			} else emit_data(status, `${node.name}: .space ${size}\n`);
+			if (node.type.name === "string" && !node.type.is_view && is_view_value$1(node.value, status)) {
+				emit_view_string_arg(node.value, status);
+				emit_view_materialize_owned(status);
+				emit_var_store(status, "x0", node.name, size);
+				mark_heap_string(status, node.name);
+				status.last_result_is_heap = false;
+				return;
+			}
 			build_node$1(node.value, status);
 			emit_var_store(status, "x0", node.name, size);
 			check_heap();
@@ -8292,10 +8531,13 @@ function build_function_call_node$1(node, status) {
 			const elem_type_name = arr.type.name || "int";
 			const elem_struct = status.structs.find((s) => s.name === elem_type_name && !s.is_simple_type);
 			const elem_size = elem_struct ? get_struct_size(elem_type_name, status) : 8;
-			const arr_offset = allocate_stack_space(status, arr.values.length * elem_size, 16);
+			const arr_offset = allocate_stack_space(status, 8 + Math.max(arr.values.length, 1) * elem_size, 16);
+			const data_base = arr_offset + 8;
+			status.code += `mov x0, #${arr.values.length}\n`;
+			status.code += `str x0, [x29, #${arr_offset}]\n`;
 			for (let j = arr.values.length - 1; j >= 0; j--) {
 				const arg = arr.values[j];
-				const slot_offset = arr_offset + j * elem_size;
+				const slot_offset = data_base + j * elem_size;
 				if (elem_struct && arg.node_type === "func_call") {
 					const fc = arg;
 					const fc_param_regs = [
@@ -8338,16 +8580,29 @@ function build_function_call_node$1(node, status) {
 				non_variadic.push({
 					node: param,
 					is_struct: is_struct_type$2(param_type, status) || is_enum_with_data_type$1(param_type, status),
-					is_ref: !!is_ref_param
+					is_ref: !!is_ref_param,
+					is_view: !!node.view_param_indices?.includes(i)
 				});
 			}
 			const nv = non_variadic.length;
-			const total_slots = nv + 2;
+			const nv_slot = [];
+			let nv_total = 0;
+			for (let i = 0; i < nv; i++) {
+				nv_slot.push(nv_total);
+				nv_total += non_variadic[i].is_view ? 2 : 1;
+			}
+			const total_slots = nv_total + 2;
 			const slots_base = allocate_stack_space(status, total_slots * 8, 16);
-			const count_slot = slots_base + nv * 8;
+			const count_slot = slots_base + nv_total * 8;
 			const ptr_slot = count_slot + 8;
 			for (let i = nv - 1; i >= 0; i--) {
 				const ep = non_variadic[i];
+				if (ep.is_view) {
+					emit_view_string_arg(ep.node, status);
+					status.code += `str x0, [x29, #${slots_base + nv_slot[i] * 8}]\n`;
+					status.code += `str x1, [x29, #${slots_base + (nv_slot[i] + 1) * 8}]\n`;
+					continue;
+				}
 				if (ep.is_struct) emit_struct_address(ep.node, status);
 				else if (ep.is_ref) {
 					const ep_name = ep.node.node_type === "value" ? ep.node.value : void 0;
@@ -8356,11 +8611,11 @@ function build_function_call_node$1(node, status) {
 					else emit_address_of(ep.node, status);
 				} else build_node$1(ep.node, status);
 				if (!status.code.endsWith("\n")) status.code += "\n";
-				status.code += `str x0, [x29, #${slots_base + i * 8}]\n`;
+				status.code += `str x0, [x29, #${slots_base + nv_slot[i] * 8}]\n`;
 			}
 			status.code += `mov x0, #${arr.values.length}\n`;
 			status.code += `str x0, [x29, #${count_slot}]\n`;
-			status.code += `add x0, x29, #${arr_offset}\n`;
+			status.code += `add x0, x29, #${data_base}\n`;
 			status.code += `str x0, [x29, #${ptr_slot}]\n`;
 			for (let s = 0; s < total_slots; s++) {
 				const slot = start_reg + s;
@@ -8381,13 +8636,33 @@ function build_function_call_node$1(node, status) {
 				}
 			}
 		} else {
-			const has_args = node.params.length > 0;
+			const view_arg_set = new Set(node.view_param_indices ?? []);
+			const hidden_len_indices = callee_hidden_len_indices(node);
+			const hidden_len_set = new Set(hidden_len_indices);
+			const hidden_len_slots = /* @__PURE__ */ new Map();
+			const arg_slot = [];
+			let total_slots = 0;
+			for (let i = 0; i < node.params.length; i++) {
+				arg_slot.push(total_slots);
+				total_slots += view_arg_set.has(i) ? 2 : 1;
+				if (hidden_len_set.has(i)) {
+					hidden_len_slots.set(i, total_slots);
+					total_slots += 1;
+				}
+			}
+			const has_args = total_slots > 0;
 			let args_base = 0;
-			if (has_args) args_base = allocate_stack_space(status, node.params.length * 8, 16);
+			if (has_args) args_base = allocate_stack_space(status, total_slots * 8, 16);
 			for (let i = node.params.length - 1; i >= 0; i--) {
 				const param = node.params[i];
 				const param_type = param.type?.name || "";
 				const is_ref_param = node.ref_param_indices?.includes(i);
+				if (view_arg_set.has(i)) {
+					emit_view_string_arg(param, status);
+					status.code += `str x0, [x29, #${args_base + arg_slot[i] * 8}]\n`;
+					status.code += `str x1, [x29, #${args_base + (arg_slot[i] + 1) * 8}]\n`;
+					continue;
+				}
 				const arr_arg_name = param.node_type === "value" ? param.value : void 0;
 				if (!!arr_arg_name && !!status.heap_array_vars?.has(arr_arg_name)) build_node$1(param, status);
 				else if (param.node_type === "array" && param_type) {
@@ -8445,19 +8720,35 @@ function build_function_call_node$1(node, status) {
 				} else if (is_struct_type$2(param_type, status) || is_enum_with_data_type$1(param_type, status)) emit_struct_address(node.params[i], status);
 				else build_node$1(node.params[i], status);
 				if (!status.code.endsWith("\n")) status.code += "\n";
-				status.code += `str x0, [x29, #${args_base + i * 8}]\n`;
+				status.code += `str x0, [x29, #${args_base + arg_slot[i] * 8}]\n`;
+			}
+			for (const i of hidden_len_indices) {
+				const arg = node.params[i];
+				let computed = false;
+				if (arg.node_type === "value") {
+					const hoisted = status.string_length_slots?.get(arg.value);
+					if (hoisted !== void 0) {
+						status.code += `ldr x0, [x29, #${hoisted}]\n`;
+						computed = true;
+					}
+				}
+				if (!computed) {
+					status.code += `ldr x0, [x29, #${args_base + arg_slot[i] * 8}]\n`;
+					status.code += `bl _strlen\n`;
+				}
+				status.code += `str x0, [x29, #${args_base + hidden_len_slots.get(i) * 8}]\n`;
 			}
 			if (has_args) {
-				for (let i = 0; i < node.params.length; i++) {
-					const slot = start_reg + i;
+				for (let s = 0; s < total_slots; s++) {
+					const slot = start_reg + s;
 					if (slot >= 8) continue;
 					const reg = param_regs[slot];
 					if (reg === "x0") continue;
-					status.code += `ldr ${reg}, [x29, #${args_base + i * 8}]\n`;
+					status.code += `ldr ${reg}, [x29, #${args_base + s * 8}]\n`;
 				}
 				if (!is_struct) status.code += `ldr x0, [x29, #${args_base}]\n`;
 			}
-			overflow_count = Math.max(0, node.params.length - (8 - start_reg));
+			overflow_count = Math.max(0, total_slots - (8 - start_reg));
 			if (overflow_count > 0) {
 				outgoing_size = Math.ceil(overflow_count * 8 / 16) * 16;
 				status.code += `sub sp, sp, #${outgoing_size}\n`;
@@ -8769,9 +9060,13 @@ function static_enum_case(operand, enum_node, status) {
 //#region ../src/build_aarch64/build_operation_node.ts
 let string_counter$1 = 0;
 let coalesce_counter = 0;
+let view_cmp_counter = 0;
+let sc_counter = 0;
 function reset_string_counter$1() {
 	string_counter$1 = 0;
 	coalesce_counter = 0;
+	view_cmp_counter = 0;
+	sc_counter = 0;
 }
 function is_comparison(op) {
 	return [
@@ -9052,6 +9347,29 @@ function build_operation_node$1(node, status) {
 		status.code += `cset x0, ${node.op === "==" ? "eq" : "ne"}\n`;
 		return;
 	}
+	if ((node.op === "==" || node.op === "!=") && node.operator_func?.struct_name === "string" && (is_view_value$1(node.left_value, status) || is_view_value$1(node.right_value, status))) {
+		const id = view_cmp_counter++;
+		const len_ne_label = `.Lview_cmp_len_ne_${id}`;
+		const done_label = `.Lview_cmp_done_${id}`;
+		emit_view_string_arg(node.right_value, status);
+		status.code += `stp x0, x1, [sp, #-16]!\n`;
+		emit_view_string_arg(node.left_value, status);
+		status.code += `ldr x2, [sp, #8]\n`;
+		status.code += `cmp x1, x2\n`;
+		status.code += `b.ne ${len_ne_label}\n`;
+		status.code += `mov x2, x1\n`;
+		status.code += `ldr x1, [sp]\n`;
+		status.code += `bl _memcmp\n`;
+		status.code += `cmp x0, #0\n`;
+		status.code += `cset x0, ${node.op === "==" ? "eq" : "ne"}\n`;
+		status.code += `b ${done_label}\n`;
+		status.code += `${len_ne_label}:\n`;
+		status.code += `mov x0, #0\n`;
+		if (node.op === "!=") status.code += `mov x0, #1\n`;
+		status.code += `${done_label}:\n`;
+		status.code += `add sp, sp, #16\n`;
+		return;
+	}
 	if (node.operator_func) {
 		const left_type = type_from_value_node$1(node.left_value);
 		const is_array_op = node.operator_func.struct_name.startsWith("Array") && left_type.is_array;
@@ -9185,6 +9503,25 @@ function build_operation_node$1(node, status) {
 		else status.code += `fmov x0, d0\n`;
 		return;
 	}
+	if (node.op === "&&" || node.op === "||") {
+		const id = sc_counter++;
+		const skip_right = `.Lsc_skip_${id}`;
+		const done = `.Lsc_done_${id}`;
+		build_operand$1(node.left_value, "x0", status);
+		if (!status.code.endsWith("\n")) status.code += "\n";
+		status.code += `cmp x0, #0\n`;
+		status.code += node.op === "&&" ? `b.eq ${skip_right}\n` : `b.ne ${skip_right}\n`;
+		build_operand$1(node.right_value, "x0", status);
+		if (!status.code.endsWith("\n")) status.code += "\n";
+		status.code += `cmp x0, #0\n`;
+		status.code += `cset x0, ne\n`;
+		status.code += `b ${done}\n`;
+		status.code += `${skip_right}:\n`;
+		if (node.op === "&&") status.code += `mov x0, #0\n`;
+		else status.code += `mov x0, #1\n`;
+		status.code += `${done}:\n`;
+		return;
+	}
 	const need_spill = !is_simple(node.left_value);
 	build_operand$1(node.right_value, "x2", status);
 	if (need_spill) {
@@ -9195,19 +9532,7 @@ function build_operation_node$1(node, status) {
 	if (!status.code.endsWith("\n")) status.code += "\n";
 	if (need_spill) status.code += `ldr x2, [sp], #16\n`;
 	const unsigned = is_unsigned_type(node.left_value) || is_unsigned_type(node.right_value);
-	if (node.op === "&&") {
-		status.code += `cmp x1, #0\n`;
-		status.code += `cset x1, ne\n`;
-		status.code += `cmp x2, #0\n`;
-		status.code += `cset x2, ne\n`;
-		status.code += `and x0, x1, x2\n`;
-	} else if (node.op === "||") {
-		status.code += `cmp x1, #0\n`;
-		status.code += `cset x1, ne\n`;
-		status.code += `cmp x2, #0\n`;
-		status.code += `cset x2, ne\n`;
-		status.code += `orr x0, x1, x2\n`;
-	} else if (is_comparison(node.op)) {
+	if (is_comparison(node.op)) {
 		status.code += `cmp x1, x2\n`;
 		status.code += `cset x0, ${map_cmp(node.op, unsigned)}\n`;
 	} else {
@@ -9447,6 +9772,12 @@ function build_return_node$1(node, status) {
 		if (override_ctor) status.struct_return_buffer = saved_buffer;
 	}
 	if (!status.code.endsWith("\n")) status.code += "\n";
+	if (status.function_return_type?.is_view && status.function_return_type.name === "string" && node.value && !is_view_value$1(node.value, status)) {
+		status.code += `str x0, [sp, #-16]!\n`;
+		status.code += `bl _strlen\n`;
+		status.code += `mov x1, x0\n`;
+		status.code += `ldr x0, [sp], #16\n`;
+	}
 	if (status.function_return_type?.name === "string" && !status.function_return_type?.is_view && node.value.node_type === "value" && node.value.value.length >= 2 && node.value.value.startsWith("\"") && node.value.value.endsWith("\"")) {
 		const fn_name = status.current_function_name;
 		const mangled = status.current_struct ? `${status.current_struct.name}_${fn_name}` : fn_name;
@@ -9767,7 +10098,7 @@ function build_value_node$1(node, status) {
 }
 //#endregion
 //#region ../src/build_common/scan_string_length_hoists.ts
-const NON_IDENTIFIERS = /* @__PURE__ */ new Set([
+const NON_IDENTIFIERS$1 = /* @__PURE__ */ new Set([
 	"true",
 	"false",
 	"null",
@@ -9776,12 +10107,12 @@ const NON_IDENTIFIERS = /* @__PURE__ */ new Set([
 	"default"
 ]);
 function is_identifier(value) {
-	return !!value && !NON_IDENTIFIERS.has(value) && !/^(\+|-)?\d+(\.\d+)?$/.test(value) && !value.startsWith("\"") && !value.startsWith("'");
+	return !!value && !NON_IDENTIFIERS$1.has(value) && !/^(\+|-)?\d+(\.\d+)?$/.test(value) && !value.startsWith("\"") && !value.startsWith("'");
 }
-function root_name(node) {
+function root_name$1(node) {
 	if (!node) return void 0;
 	if (node.node_type === "value") return node.value;
-	if (node.node_type === "access") return root_name(node.target);
+	if (node.node_type === "access") return root_name$1(node.target);
 }
 /**
 * Find the bare `string` variables whose `.length` is read inside a while
@@ -9868,9 +10199,9 @@ function scan_string_length_hoists(condition, statements, update, status) {
 			}
 			case "assign": {
 				const assign = n;
-				const lhs = root_name(assign.left_value);
+				const lhs = root_name$1(assign.left_value);
 				if (lhs) invalidated.add(lhs);
-				const swap = root_name(assign.swap);
+				const swap = root_name$1(assign.swap);
 				if (swap) invalidated.add(swap);
 				walk_children(n, in_boundary);
 				return;
@@ -9892,11 +10223,20 @@ function scan_string_length_hoists(condition, statements, update, status) {
 			case "access_func": {
 				const call = n;
 				for (const indices of [call.ref_param_indices, call.mov_param_indices]) for (const i of indices ?? []) {
-					const arg = root_name(call.params?.[i]);
+					const arg = root_name$1(call.params?.[i]);
 					if (arg) invalidated.add(arg);
 				}
 				if (call.swap_params) {
-					for (const [i, swap] of call.swap_params) for (const arg of [root_name(call.params?.[i]), root_name(swap)]) if (arg) invalidated.add(arg);
+					for (const [i, swap] of call.swap_params) for (const arg of [root_name$1(call.params?.[i]), root_name$1(swap)]) if (arg) invalidated.add(arg);
+				}
+				if (!in_boundary && call.resolved_function) {
+					const self_offset = call.resolved_function.params[0]?.is_self_param ? 1 : 0;
+					const params = call.params ?? [];
+					for (let i = 0; i < params.length; i++) {
+						if (!call.resolved_function.params[i + self_offset]?.hidden_len) continue;
+						const arg = params[i];
+						if (arg.node_type === "value" && is_identifier(arg.value) && is_string_target(arg)) candidates.set(arg.value, arg);
+					}
 				}
 				walk_children(n, in_boundary);
 				return;
@@ -10073,6 +10413,7 @@ function build_while_loop_node$1(node, status) {
 		if (!status.string_length_slots) status.string_length_slots = /* @__PURE__ */ new Map();
 		for (const [name, target] of hoists) {
 			if (status.string_length_slots.has(name)) continue;
+			if (status.hidden_len_params?.has(name)) continue;
 			const offset = allocate_stack_space(status, 8);
 			status.string_length_slots.set(name, offset);
 			build_node$1(target, status);
@@ -10317,6 +10658,10 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 			emit_owning_replace_T(elem, status);
 			return true;
 		}
+		if (func_name === "shift_T") {
+			emit_owning_shift_T(elem, status, "x0");
+			return true;
+		}
 		return false;
 	}
 	if (owning_buffer_is_string_elem_aarch64(struct_node)) {
@@ -10328,6 +10673,10 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 			emit_string_replace_T(status, "x0");
 			return true;
 		}
+		if (func_name === "shift_T") {
+			emit_string_shift_T(status, "x0");
+			return true;
+		}
 	}
 	return false;
 }
@@ -10341,7 +10690,7 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 	const elem = owning_buffer_element_aarch64(node, status);
 	if (elem) {
-		if (func_name !== "store_T" && func_name !== "replace_T") return false;
+		if (func_name !== "store_T" && func_name !== "replace_T" && func_name !== "shift_T") return false;
 		emit_owning_standalone_struct(elem, func_name, status);
 		return true;
 	}
@@ -10354,12 +10703,20 @@ function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 			emit_string_replace_T(status, "x19");
 			return true;
 		}
+		if (func_name === "shift_T") {
+			emit_string_shift_T(status, "x19");
+			return true;
+		}
 	}
 	return false;
 }
 function emit_owning_standalone_struct(elem, func_name, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	if (func_name === "shift_T") {
+		emit_owning_shift_T(elem, status, "x19");
+		return true;
+	}
 	status.code += `stp x20, x21, [sp, #-16]!\n`;
 	status.code += `str x22, [sp, #-16]!\n`;
 	status.code += `ldr x20, [x19, #8]\n`;
@@ -10459,6 +10816,59 @@ function emit_string_replace_T(status, self_reg) {
 	status.code += `${done}:\n`;
 	status.code += `ldp x20, x21, [sp], #16\n`;
 }
+/**
+* Specialized `Buffer<string>` shift_T. `self_reg` is the register holding
+* the Buffer pointer ("x0" inline, "x19" standalone); x1 = dst, x2 = src.
+* Move slot src into slot dst — free dst's heap copy, take over src's
+* pointer, zero src. Exactly one slot owns the string afterwards.
+*/
+function emit_string_shift_T(status, self_reg) {
+	const done = `.Lstr_sh_done_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+	status.code += `stp x20, x21, [sp, #-16]!\n`;
+	status.code += `ldr x9, [${self_reg}, #8]\n`;
+	status.code += `add x20, x9, x1, lsl #3\n`;
+	status.code += `add x21, x9, x2, lsl #3\n`;
+	status.code += `cmp x20, x21\n`;
+	status.code += `b.eq ${done}\n`;
+	status.code += `ldr x0, [x20]\n`;
+	emit_free(status);
+	status.code += `ldr x9, [x21]\n`;
+	status.code += `str x9, [x20]\n`;
+	status.code += `str xzr, [x21]\n`;
+	status.code += `${done}:\n`;
+	status.code += `ldp x20, x21, [sp], #16\n`;
+}
+/**
+* Specialized owning-value-struct shift_T. `self_reg` holds the Buffer
+* pointer ("x0" inline, "x19" standalone); x1 = dst, x2 = src (slot indices).
+* Destroy dst's old value, copy src's bytes over it wholesale (the moved
+* struct's owned pointers transfer — no deep copy), zero src.
+*/
+function emit_owning_shift_T(elem, status, self_reg) {
+	const T_SIZE = get_struct_size(elem.name, status);
+	const done = `.Lown_sh_done_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+	status.code += `stp x20, x21, [sp, #-16]!\n`;
+	status.code += `str x22, [sp, #-16]!\n`;
+	status.code += `ldr x9, [${self_reg}, #8]\n`;
+	status.code += `mov x22, #${T_SIZE}\n`;
+	status.code += `madd x20, x1, x22, x9\n`;
+	status.code += `madd x21, x2, x22, x9\n`;
+	status.code += `cmp x20, x21\n`;
+	status.code += `b.eq ${done}\n`;
+	status.code += `mov x0, x20\n`;
+	status.code += `bl ${elem.name}_destroy\n`;
+	status.code += `mov x0, x20\n`;
+	status.code += `mov x1, x21\n`;
+	status.code += `mov x2, x22\n`;
+	status.code += `bl _memcpy\n`;
+	status.code += `mov x0, x21\n`;
+	status.code += `mov x1, #0\n`;
+	status.code += `mov x2, x22\n`;
+	status.code += `bl _memset\n`;
+	status.code += `${done}:\n`;
+	status.code += `ldr x22, [sp], #16\n`;
+	status.code += `ldp x20, x21, [sp], #16\n`;
+}
 function emit_owning_store_T(elem, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
@@ -11192,10 +11602,14 @@ function build_struct_functions$1(node, status) {
 		if (needs_x19) callee_idx = 1;
 		const old_ref_params = status.function_ref_params;
 		const old_ref_class_slots = status.ref_class_slots;
+		const old_view_params = status.function_view_params;
+		const old_hidden_len_params = status.hidden_len_params;
 		status.function_param_regs = /* @__PURE__ */ new Map();
 		status.function_param_vars = /* @__PURE__ */ new Set();
 		status.function_ref_params = /* @__PURE__ */ new Set();
 		status.ref_class_slots = /* @__PURE__ */ new Map();
+		status.function_view_params = /* @__PURE__ */ new Set();
+		status.hidden_len_params = /* @__PURE__ */ new Set();
 		status.struct_return_buffer = void 0;
 		const return_struct = !func.return_type?.is_array && !!status.structs.find((s) => s.name === func.return_type?.name && !s.is_simple_type && !s.is_class);
 		let return_buffer_stack_offset;
@@ -11218,6 +11632,10 @@ function build_struct_functions$1(node, status) {
 				if (param.type.is_ref) status.function_ref_params.add(param.name);
 				continue;
 			}
+			if (param.type.is_view) {
+				slot_idx += 2;
+				continue;
+			}
 			if ((!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data)) && callee_idx < callee_saved.length) {
 				const saved_reg = callee_saved[callee_idx++];
 				if (saved_reg !== "x19" || !needs_x19) status.code += `str ${saved_reg}, [sp, #-16]!\n`;
@@ -11235,6 +11653,7 @@ function build_struct_functions$1(node, status) {
 				if (!status.class_vars) status.class_vars = /* @__PURE__ */ new Set();
 				status.class_vars.add(param.name);
 			}
+			if (param.hidden_len) slot_idx++;
 			slot_idx++;
 		}
 		status.code += `sub sp, sp, #${stack_placeholder}\n`;
@@ -11255,6 +11674,22 @@ function build_struct_functions$1(node, status) {
 				second_slot_idx += 2;
 				continue;
 			}
+			if (param.type.is_view) {
+				const offset = allocate_stack_space(status, 16, 16);
+				status.stack_offsets.set(param.name, offset);
+				status.function_view_params.add(param.name);
+				for (const half of [0, 1]) {
+					const p_slot = second_slot_idx + half;
+					if (p_slot < 8) status.code += `str ${param_regs[p_slot]}, [x29, #${offset + half * 8}]\n`;
+					else {
+						const k = p_slot - 8;
+						status.code += `ldr x9, [x29, #${overflow_placeholder(func_label, k)}]\n`;
+						status.code += `str x9, [x29, #${offset + half * 8}]\n`;
+					}
+				}
+				second_slot_idx += 2;
+				continue;
+			}
 			if (!(!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data))) {
 				const size = aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, size);
@@ -11285,6 +11720,20 @@ function build_struct_functions$1(node, status) {
 					}
 				}
 			}
+			if (param.hidden_len) {
+				const len_offset = allocate_stack_space(status, 8, 8);
+				status.stack_offsets.set(`_${param.name}_len`, len_offset);
+				if (!status.hidden_len_params) status.hidden_len_params = /* @__PURE__ */ new Set();
+				status.hidden_len_params.add(param.name);
+				const len_slot = second_slot_idx + 1;
+				if (len_slot < 8) status.code += `str ${param_regs[len_slot]}, [x29, #${len_offset}]\n`;
+				else {
+					const k = len_slot - 8;
+					status.code += `ldr x9, [x29, #${overflow_placeholder(func_label, k)}]\n`;
+					status.code += `str x9, [x29, #${len_offset}]\n`;
+				}
+				second_slot_idx++;
+			}
 			second_slot_idx++;
 		}
 		const moved_param_save_slots = /* @__PURE__ */ new Map();
@@ -11374,6 +11823,8 @@ function build_struct_functions$1(node, status) {
 		status.function_param_vars = old_param_vars;
 		status.function_ref_params = old_ref_params;
 		status.ref_class_slots = old_ref_class_slots;
+		status.function_view_params = old_view_params;
+		status.hidden_len_params = old_hidden_len_params;
 		status.function_return_label = old_return_label;
 		status.force_heap_strings = old_force_heap;
 		status.struct_return_buffer = void 0;
@@ -11779,7 +12230,7 @@ function extract_aarch64_asm(func, platform) {
 	return asm;
 }
 function count_x19_reads(asm) {
-	const matches = asm.match(/\bx19\b/g);
+	const matches = asm.split("\n").map((l) => l.replace(/\/\/.*$/, "")).join("\n").match(/\bx19\b/g);
 	return matches ? matches.length : 0;
 }
 function build_naked_inline(struct_node, func, status) {
@@ -11787,6 +12238,8 @@ function build_naked_inline(struct_node, func, status) {
 	const standalone_return_label = `.return_${struct_node.name}_${func.name.replace(/#/g, "")}`;
 	asm = asm.replaceAll(`b ${standalone_return_label}`, "");
 	if (count_x19_reads(asm) === 1) asm = asm.replace(/\bx19\b/g, "x0");
+	const site = inline_counter++;
+	asm = asm.replace(/(\.L[A-Za-z0-9_]+)/g, `$1_${site}`);
 	status.code += asm + "\n";
 }
 function build_inline_method(struct_node, func, status) {
@@ -11811,15 +12264,27 @@ function build_inline_method(struct_node, func, status) {
 	const old_buffer_data_cache = status.buffer_data_cache;
 	const old_heap_cleanup_stack = status.heap_cleanup_stack;
 	const old_moved = status.moved;
+	const old_outer_scope_declarations = status.outer_scope_declarations;
+	const old_current_struct = status.current_struct;
+	const old_current_function_name = status.current_function_name;
+	const old_return_assign = status.return_assign;
+	const old_join_needs_owned_string = status.join_needs_owned_string;
+	const old_emitted_allocations = status.emitted_allocations;
 	const return_label = `.inline_ret_${inline_counter++}`;
 	status.function_return_label = return_label;
 	status.scoped_declarations = [];
+	status.outer_scope_declarations = [];
 	status.function_return_type = void 0;
 	status.struct_return_buffer = void 0;
 	status.return_buffer_stack_offset = void 0;
 	status.buffer_data_cache = void 0;
 	status.heap_cleanup_stack = [];
 	status.moved = /* @__PURE__ */ new Set();
+	status.current_struct = struct_node;
+	status.current_function_name = func.name;
+	status.return_assign = void 0;
+	status.join_needs_owned_string = void 0;
+	status.emitted_allocations = /* @__PURE__ */ new Set();
 	if (needs_x19) {
 		status.code += `str x19, [sp, #-16]!\n`;
 		status.code += `mov x19, x0\n`;
@@ -11877,9 +12342,11 @@ function build_inline_method(struct_node, func, status) {
 		status.code += `str x8, [x29, #${return_buffer_stack_offset}]\n`;
 		status.return_buffer_stack_offset = return_buffer_stack_offset;
 	}
+	const code_length_before_body = status.code.length;
 	build_block_node$1(func, status);
 	const standalone_return_label = `.return_${struct_node.name}_${func.name.replace(/#/g, "")}`;
-	status.code = status.code.replaceAll(`b ${standalone_return_label}`, `b ${return_label}`);
+	const body = status.code.slice(code_length_before_body);
+	status.code = status.code.slice(0, code_length_before_body) + body.replaceAll(`b ${standalone_return_label}\n`, `b ${return_label}\n`);
 	status.code += `${return_label}:\n`;
 	for (let i = saved_stack_slots.length - 1; i >= 0; i--) status.code += `add sp, sp, #16\n`;
 	for (let ci = callee_idx - 1; ci >= 0; ci--) {
@@ -11900,6 +12367,12 @@ function build_inline_method(struct_node, func, status) {
 	status.buffer_data_cache = old_buffer_data_cache;
 	status.heap_cleanup_stack = old_heap_cleanup_stack;
 	status.moved = old_moved;
+	status.outer_scope_declarations = old_outer_scope_declarations;
+	status.current_struct = old_current_struct;
+	status.current_function_name = old_current_function_name;
+	status.return_assign = old_return_assign;
+	status.join_needs_owned_string = old_join_needs_owned_string;
+	status.emitted_allocations = old_emitted_allocations;
 }
 let inline_fn_depth = 0;
 const MAX_INLINE_DEPTH = 2;
@@ -11919,15 +12392,27 @@ function build_inline_function(func, status) {
 	const old_buffer_data_cache = status.buffer_data_cache;
 	const old_heap_cleanup_stack = status.heap_cleanup_stack;
 	const old_moved = status.moved;
+	const old_outer_scope_declarations = status.outer_scope_declarations;
+	const old_current_struct = status.current_struct;
+	const old_current_function_name = status.current_function_name;
+	const old_return_assign = status.return_assign;
+	const old_join_needs_owned_string = status.join_needs_owned_string;
+	const old_emitted_allocations = status.emitted_allocations;
 	const return_label = `.inline_fn_ret_${inline_counter++}`;
 	status.function_return_label = return_label;
 	status.scoped_declarations = [];
+	status.outer_scope_declarations = [];
 	status.function_return_type = void 0;
 	status.struct_return_buffer = void 0;
 	status.return_buffer_stack_offset = void 0;
 	status.buffer_data_cache = void 0;
 	status.heap_cleanup_stack = [];
 	status.moved = /* @__PURE__ */ new Set();
+	status.current_struct = void 0;
+	status.current_function_name = func.name;
+	status.return_assign = void 0;
+	status.join_needs_owned_string = void 0;
+	status.emitted_allocations = /* @__PURE__ */ new Set();
 	const param_regs = [
 		"x0",
 		"x1",
@@ -11996,6 +12481,12 @@ function build_inline_function(func, status) {
 	status.buffer_data_cache = old_buffer_data_cache;
 	status.heap_cleanup_stack = old_heap_cleanup_stack;
 	status.moved = old_moved;
+	status.outer_scope_declarations = old_outer_scope_declarations;
+	status.current_struct = old_current_struct;
+	status.current_function_name = old_current_function_name;
+	status.return_assign = old_return_assign;
+	status.join_needs_owned_string = old_join_needs_owned_string;
+	status.emitted_allocations = old_emitted_allocations;
 	inline_fn_depth--;
 	return true;
 }
@@ -12150,8 +12641,25 @@ function load_nursery_struct_address(target, status) {
 }
 //#endregion
 //#region ../src/build_aarch64/build_access_node.ts
+/**
+* Whether `struct_node` is a monomorphized `Array<T>` (`Array_<T>`). The mono
+* name is unambiguous — the compiler derives it itself (`"Array_" + elem`)
+* for every `Array<T>` instantiation, so a name match is always an Array mono.
+*/
+function is_array_mono_struct(struct_node, status) {
+	return !!struct_node && !struct_node.is_generic && struct_node.name.startsWith("Array_") && !!status.structs.find((s) => s.name === struct_node.name);
+}
 function emit_string_length$1(target, status) {
 	if (target.node_type === "value") {
+		const name = target.value;
+		if (name !== "self" && status.hidden_len_params?.has(name)) {
+			const len_slot = status.stack_offsets?.get(`_${name}_len`);
+			if (len_slot !== void 0) {
+				status.last_result_is_heap = false;
+				status.code += `ldr x0, [x29, #${len_slot}]\n`;
+				return;
+			}
+		}
 		const slot = status.string_length_slots?.get(target.value);
 		if (slot !== void 0) {
 			status.last_result_is_heap = false;
@@ -12221,18 +12729,7 @@ function build_view_op(node, access_func, status) {
 	if (access_func.name === "to_string" && t.name === "string") {
 		status.code += `ldr x0, [x29, #${base}]\n`;
 		status.code += `ldr x1, [x29, #${base + 8}]\n`;
-		status.code += `stp x0, x1, [sp, #-16]!\n`;
-		status.code += `add x0, x1, #1\n`;
-		emit_malloc(status);
-		status.code += `str x0, [sp, #-16]!\n`;
-		status.code += `ldr x1, [sp, #16]\n`;
-		status.code += `ldr x2, [sp, #24]\n`;
-		status.code += `ldr x0, [sp]\n`;
-		status.code += `bl _memcpy\n`;
-		status.code += `ldr x0, [sp]\n`;
-		status.code += `ldr x1, [sp, #24]\n`;
-		status.code += `strb wzr, [x0, x1]\n`;
-		status.code += `add sp, sp, #32\n`;
+		emit_view_materialize_owned(status);
 		status.last_result_is_heap = true;
 		return true;
 	}
@@ -12440,6 +12937,14 @@ function build_access_field(node, status) {
 	}
 	const target_name = node.target.node_type === "value" ? node.target.value : target_type?.name;
 	const access_field = node.access;
+	if (access_field.name === "length" && node.target.node_type === "value" && node.target.value === "self" && is_array_mono_struct(status.current_struct, status)) {
+		const self_reg = get_param_reg("self", status);
+		if (self_reg) {
+			if (self_reg !== "x0") status.code += `mov x0, ${self_reg}\n`;
+			status.code += `ldr x0, [x0, #-8]\n`;
+			return;
+		}
+	}
 	if (access_field.type?.name === "func") {
 		status.code += `adr x0, ${target_type.name}_${access_field.name}\n`;
 		return;
@@ -13078,14 +13583,41 @@ function build_access_method(node, access_func, status) {
 		"x6",
 		"x7"
 	];
-	const overflow_count = Math.max(0, access_func.params.length - (8 - start_reg));
+	const view_arg_set = new Set(access_func.view_param_indices ?? []);
+	const hidden_len_indices = callee_hidden_len_indices(access_func);
+	const hidden_len_set = new Set(hidden_len_indices);
+	const hidden_len_slots = /* @__PURE__ */ new Map();
+	const arg_slot = [];
+	let total_arg_slots = 0;
+	for (let i = 0; i < access_func.params.length; i++) {
+		arg_slot.push(total_arg_slots);
+		total_arg_slots += view_arg_set.has(i) ? 2 : 1;
+		if (hidden_len_set.has(i)) {
+			hidden_len_slots.set(i, total_arg_slots);
+			total_arg_slots += 1;
+		}
+	}
+	const overflow_count = Math.max(0, total_arg_slots - (8 - start_reg));
 	let overflow_base = 0;
 	if (overflow_count > 0) overflow_base = allocate_stack_space(status, overflow_count * 8, 16);
+	const has_view_args = view_arg_set.size > 0;
+	let view_spill_base = 0;
+	if (has_view_args) view_spill_base = allocate_stack_space(status, total_arg_slots * 8, 16);
+	const view_half_store = (j, half) => {
+		const half_slot = start_reg + arg_slot[j] + half;
+		return half_slot >= 8 ? overflow_base + (half_slot - 8) * 8 : view_spill_base + (arg_slot[j] + half) * 8;
+	};
 	const ref_class_param_reload = [];
 	for (let i = access_func.params.length - 1; i >= 0; i--) {
 		const param = access_func.params[i];
 		const is_ref_param = access_func.ref_param_indices?.includes(i);
 		const param_type = param.type?.name || "";
+		if (view_arg_set.has(i)) {
+			emit_view_string_arg(param, status);
+			status.code += `str x0, [x29, #${view_half_store(i, 0)}]\n`;
+			status.code += `str x1, [x29, #${view_half_store(i, 1)}]\n`;
+			continue;
+		}
 		const is_struct = is_struct_type(param_type, status) || is_enum_with_data_type(param_type, status);
 		if (is_ref_param) {
 			const rp_name = param.node_type === "value" ? param.value : void 0;
@@ -13107,14 +13639,66 @@ function build_access_method(node, access_func, status) {
 				if (!status.code.endsWith("\n")) status.code += "\n";
 			}
 		} else build_node$1(param, status);
-		const slot = start_reg + i;
+		const slot = start_reg + arg_slot[i];
 		if (!status.code.endsWith("\n")) status.code += "\n";
 		if (slot >= 8) status.code += `str x0, [x29, #${overflow_base + (slot - 8) * 8}]\n`;
 		else {
-			const reg = param_regs[i];
+			const reg = param_regs[arg_slot[i]];
 			if (reg && reg !== "x0") status.code += `mov ${reg}, x0\n`;
 		}
 	}
+	if (has_view_args) for (let j = 0; j < access_func.params.length; j++) {
+		if (!view_arg_set.has(j)) continue;
+		for (const half of [0, 1]) {
+			const half_slot = start_reg + arg_slot[j] + half;
+			if (half_slot >= 8) continue;
+			status.code += `ldr x${half_slot}, [x29, #${view_spill_base + (arg_slot[j] + half) * 8}]\n`;
+		}
+	}
+	if (hidden_len_indices.length > 0) {
+		const needs_strlen = hidden_len_indices.some((i) => {
+			const arg = access_func.params[i];
+			if (arg.node_type !== "value") return true;
+			return !status.string_length_slots?.has(arg.value);
+		});
+		const live_regs = [];
+		if (needs_strlen) {
+			const max_live = Math.min(7, start_reg + total_arg_slots - 1);
+			for (let s = start_reg; s <= max_live; s++) live_regs.push(`x${s}`);
+		}
+		const reg_save_base = needs_strlen ? allocate_stack_space(status, Math.max(live_regs.length, 1) * 8, 16) : 0;
+		const len_save_base = allocate_stack_space(status, hidden_len_indices.length * 8, 16);
+		for (let k = 0; k < live_regs.length; k++) status.code += `str ${live_regs[k]}, [x29, #${reg_save_base + k * 8}]\n`;
+		for (let h = 0; h < hidden_len_indices.length; h++) {
+			const i = hidden_len_indices[h];
+			const arg = access_func.params[i];
+			let computed = false;
+			if (arg.node_type === "value") {
+				const hoisted = status.string_length_slots?.get(arg.value);
+				if (hoisted !== void 0) {
+					status.code += `ldr x9, [x29, #${hoisted}]\n`;
+					status.code += `str x9, [x29, #${len_save_base + h * 8}]\n`;
+					computed = true;
+				}
+			}
+			if (!computed) {
+				const src_slot = start_reg + arg_slot[i];
+				if (src_slot < 8) {
+					const save_index = src_slot - start_reg;
+					status.code += `ldr x0, [x29, #${reg_save_base + save_index * 8}]\n`;
+				} else status.code += `ldr x0, [x29, #${overflow_base + (src_slot - 8) * 8}]\n`;
+				status.code += `bl _strlen\n`;
+				status.code += `str x0, [x29, #${len_save_base + h * 8}]\n`;
+			}
+		}
+		for (let k = live_regs.length - 1; k >= 0; k--) status.code += `ldr ${live_regs[k]}, [x29, #${reg_save_base + k * 8}]\n`;
+		for (let h = 0; h < hidden_len_indices.length; h++) {
+			const dest_slot = start_reg + hidden_len_slots.get(hidden_len_indices[h]);
+			status.code += `ldr x9, [x29, #${len_save_base + h * 8}]\n`;
+			if (dest_slot < 8) status.code += `mov x${dest_slot}, x9\n`;
+			else status.code += `str x9, [x29, #${overflow_base + (dest_slot - 8) * 8}]\n`;
+		}
+	}
 	if (!status.code.endsWith("\n")) status.code += "\n";
 	if (needs_self_save) status.code += `ldr x0, [sp], #16\n`;
 	let outgoing_size = 0;
@@ -14218,6 +14802,84 @@ function has_flag_name(name) {
 	return `${name}_has`;
 }
 //#endregion
+//#region ../src/build_c/utils/view_value.ts
+/**
+* Resolve the struct name of an expression's value by walking the access
+* chain through the (monomorphized) struct table — bare names via
+* variable_types / scoped declarations / `self`, field accesses via the
+* base struct's field type, method calls via the method's return type.
+* Fallback for cached node types that lost their modifiers (generic bodies
+* re-checked after monomorphization can carry a stale plain `string`).
+*/
+function value_struct_name(node, status) {
+	if (node.node_type === "value") {
+		const name = node.value;
+		if (name === "self" && status.current_struct) return status.current_struct.name;
+		const vt = status.variable_types?.get(name);
+		if (vt?.name) return vt.name;
+		const decl = status.scoped_declarations.findLast((d) => d.name === name);
+		if (decl?.type?.name) return decl.type.name;
+		return;
+	}
+	if (node.node_type === "access") {
+		const inner = node.access;
+		const base = value_struct_name(node.target, status);
+		if (!base) return void 0;
+		const struct = status.structs.find((s) => s.name === base && !s.is_generic);
+		if (!struct) return void 0;
+		if (inner.node_type === "access_field") return struct.fields.find((f) => f.name === inner.name)?.type?.name;
+		if (inner.node_type === "access_func") return struct.functions.find((f) => f.name === inner.name)?.return_type?.name;
+	}
+}
+/**
+* Whether an expression is a `view T` VALUE at the C level — a nomen_view
+* (ptr, len) struct expression that can pass through a `view T` parameter
+* unchanged. Recovers `is_view` from the cached node type, the declared
+* variable type, the current function's view params, or (for method calls
+* whose cached type lost the modifier) the callee's declared return type.
+*/
+function is_view_value(node, status) {
+	if (type_from_value_node$1(node)?.is_view) return true;
+	if (node.node_type === "value") {
+		const name = node.value;
+		if (status.variable_types?.get(name)?.is_view) return true;
+		if (status.function_view_params?.has(name)) return true;
+	}
+	if (node.node_type === "access" && node.access.node_type === "access_func") {
+		const access = node.access;
+		const recv_struct = value_struct_name(node.target, status);
+		if ((status.structs.find((s) => s.name === recv_struct && !s.is_generic)?.functions.find((f) => f.name === access.name || f.name === `#${access.name}`))?.return_type?.is_view) return true;
+	}
+	return false;
+}
+/**
+* Emit a C expression for an argument passed to a `view string` parameter.
+* A view-typed argument is already a nomen_view — pass it through. An owned
+* `string` expression is wrapped into a nomen_view carrying its strlen (an
+* implicit owned→view borrow; the caller keeps ownership of the string).
+* Statement-expression form evaluates the operand exactly once.
+*/
+function c_view_string_arg(arg, status) {
+	if (is_view_value(arg, status)) {
+		build_node(arg, status);
+		return;
+	}
+	status.code += `({ char* _p = `;
+	build_node(arg, status);
+	status.code += `; nomen_view _v = { (void*)_p, (long)strlen(_p) }; _v; })`;
+}
+/**
+* Emit a C expression materializing a `view string` into an OWNED heap
+* string (malloc len+1 / memcpy / null-terminate). Used when a view value
+* initializes an owned `string` declaration (`const string s = v`) — the
+* resulting pointer is heap-owned and must be freed at scope exit.
+*/
+function c_materialize_view_string(arg, status) {
+	status.code += `({ nomen_view _t = `;
+	build_node(arg, status);
+	status.code += `; char* _r = malloc(_t.len + 1); memcpy(_r, _t.ptr, _t.len); _r[_t.len] = 0; _r; })`;
+}
+//#endregion
 //#region ../src/build_c/build_operation_node.ts
 function build_operation_node(node, status) {
 	if (node.operator_func?.deferred) {
@@ -14324,8 +14986,16 @@ function build_operation_node(node, status) {
 		status.code += `)`;
 	} else if (node.operator_func) {
 		const label = node.operator_func.mangled_name || `${node.operator_func.struct_name}_${node.operator_func.func_name}`;
-		const is_string_op = node.type?.name === "string";
 		const is_string_cmp = node.op === "==" || node.op === "!=";
+		if (is_string_cmp && node.operator_func.struct_name === "string" && (is_view_value(node.left_value, status) || is_view_value(node.right_value, status))) {
+			status.code += `({ nomen_view _a = `;
+			c_view_string_arg(node.left_value, status);
+			status.code += `, _b = `;
+			c_view_string_arg(node.right_value, status);
+			status.code += `; ((_a.len == _b.len) && (memcmp(_a.ptr, _b.ptr, _a.len) == 0))${node.op === "!=" ? " == 0" : ""}; })`;
+			return;
+		}
+		const is_string_op = node.type?.name === "string";
 		const left_temp = (is_string_op || is_string_cmp) && is_owned_heap_temp(node.left_value, status);
 		const right_temp = (is_string_op || is_string_cmp) && is_owned_heap_temp(node.right_value, status);
 		if (left_temp || right_temp) {
@@ -14579,7 +15249,7 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 		}
 		const is_destructured_field_access = dec.value?.node_type === "access" && dec.value.access.node_type === "access_field" && !dec.value.is_moved;
 		const is_borrowed_string = is_string_borrow(dec.value) || !!status.string_borrow_vars?.has(dec.name);
-		const value_is_heap_string = dec.type.name === "string" && (dec.value?.node_type === "access" && dec.value.access.node_type === "access_func" || dec.value?.node_type === "func_call");
+		const value_is_heap_string = dec.type.name === "string" && (dec.value?.node_type === "access" && dec.value.access.node_type === "access_func" || dec.value?.node_type === "func_call" || !!dec.value && !dec.type.is_view && is_view_value(dec.value, status));
 		const dec_value = dec.value;
 		const dec_val_is_string_literal = dec.value?.node_type === "value" && dec_value.value.length >= 2 && dec_value.value.startsWith("\"") && dec_value.value.endsWith("\"");
 		const dec_val_is_heap_string_var = dec.value?.node_type === "value" && !dec_val_is_string_literal && !!status.scoped_declarations.find((d) => d.name === dec_value.value);
@@ -14857,6 +15527,70 @@ function reclaim_to_loop_body(status) {
 	return loopBodyIdx;
 }
 //#endregion
+//#region ../src/build_c/utils/hidden_len_call.ts
+function needs_len_materialize(arg) {
+	if (arg.node_type === "value") return false;
+	if (arg.node_type === "access" && arg.access.node_type === "access_field") return false;
+	return true;
+}
+/**
+* Emit the statement-expression prologue materialising every non-lvalue
+* hidden-len argument once. Must be called immediately BEFORE the call's
+* label text is emitted; the args loop then substitutes the temps, and
+* close_hidden_len_wrap() terminates the expression after the call.
+*/
+function open_hidden_len_wrap(indices, params, status) {
+	const temps = /* @__PURE__ */ new Map();
+	const to_materialize = indices.filter((i) => params[i] && needs_len_materialize(params[i]));
+	if (to_materialize.length === 0) return {
+		temps,
+		open: false
+	};
+	status.code += `({ `;
+	for (const i of to_materialize) {
+		const tmp = `_hlm_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+		status.code += `char* ${tmp} = `;
+		build_node(params[i], status);
+		status.code += `; `;
+		temps.set(i, tmp);
+	}
+	return {
+		temps,
+		open: true
+	};
+}
+function close_hidden_len_wrap(wrap, status) {
+	if (wrap.open) status.code += `; })`;
+}
+/**
+* Emit the companion length EXPRESSION for the argument at a hidden-len
+* index (the caller emits the separating `, `). `temp` is the materialised
+* pointer temp when one exists (open_hidden_len_wrap).
+*/
+function emit_hidden_len_expr(arg, temp, status) {
+	if (temp) {
+		status.code += `strlen(${temp})`;
+		return;
+	}
+	if (arg.node_type === "value") {
+		const value = arg.value;
+		if (value.startsWith("\"")) {
+			status.code += `sizeof(${value}) - 1`;
+			return;
+		}
+		const hoisted = status.string_length_temps?.get(value);
+		if (hoisted) {
+			status.code += hoisted;
+			return;
+		}
+		status.code += `strlen(${value})`;
+		return;
+	}
+	status.code += `strlen(`;
+	build_node(arg, status);
+	status.code += `)`;
+}
+//#endregion
 //#region ../src/build_c/build_access_node.ts
 /**
 * The C type of a single element of a `view T` slice, used to cast the
@@ -14918,6 +15652,66 @@ function build_vtable_target(node, status) {
 	status.code = status.code.substring(0, before);
 	status.code += "&" + expr;
 }
+/**
+* An Array method's `self` is a `struct Array_<T>*` — header `[0]=_vt`,
+* `[8]=length`, elements at `+16` — which is exactly what a heap receiver
+* (`struct Array_<T>*`) already is. A NON-heap receiver (a plain stack C
+* array `T w[N]`, or a variadic `...T` param lowered to `T *w`) would pass
+* the bare element pointer, so the callee's `self->length` and the raw
+* bodies' `(T*)((char*)self + sizeof(*self))` reads land on garbage
+* (`w[1]`, `w + 2`). When such a receiver with a usable length calls a
+* method on the mono `Array_<T>` struct, build a statement-expression
+* temporary carrying a proper header plus a copy of the elements — the
+* same wrap the binary-operator operand path uses
+* (build_array_operand_for_call). A `ref self` callee additionally gets
+* its element copy written back after the call, so mutations through
+* `self` reach the caller's array.
+*/
+function array_receiver_wrap(node, target_type, target_method, mono_struct_name, status) {
+	if (!target_type?.is_array || !mono_struct_name.startsWith("Array_")) return void 0;
+	if (node.target.node_type !== "value") return void 0;
+	const target_value = node.target.value;
+	if (target_type.is_array_heap || status.heap_array_vars?.has(target_value)) return void 0;
+	let length;
+	if (status.stack_array_lengths?.has(target_value)) length = status.stack_array_lengths.get(target_value);
+	else if (target_type.length) {
+		const before = status.code.length;
+		build_node(target_type.length, status);
+		length = status.code.substring(before);
+		status.code = status.code.substring(0, before);
+	} else if (status.function_variadic_params?.has(target_value)) length = `_${target_value}_len`;
+	if (!length) return void 0;
+	const before = status.code.length;
+	status.suppress_dereference = true;
+	build_node(node.target, status);
+	status.suppress_dereference = false;
+	const recv = status.code.substring(before);
+	status.code = status.code.substring(0, before);
+	const elem_c = c_type(target_type.name);
+	const id = status.label_counter = (status.label_counter ?? 0) + 1;
+	const wrap = `_arrm_${id}`;
+	const method_self_is_ref = !!target_method?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref));
+	const ret = target_method?.return_type;
+	const ret_c = !ret?.name ? "void" : ret.is_array ? "void*" : c_type(ret.name);
+	const bytes = `${length} * sizeof(${elem_c})`;
+	const length_is_literal = /^(\d+L?|0x[0-9a-fA-F]+)$/.test(length.trim());
+	let prefix;
+	let self_expr;
+	if (length_is_literal) {
+		prefix = `({ struct { struct ${mono_struct_name} _h; ${elem_c} _d[${length}]; } ${wrap}; ${wrap}._h._vt = 0; ${wrap}._h.length = ${length}; memcpy(${wrap}._d, ${recv}, ${bytes}); ` + (method_self_is_ref && ret_c !== "void" ? `${ret_c} _arrm_r_${id} = ` : "");
+		self_expr = `(struct ${mono_struct_name}*)&${wrap}`;
+	} else {
+		prefix = `({ char ${wrap}[sizeof(struct ${mono_struct_name}) + ${bytes}]; struct ${mono_struct_name}* _arrm_p_${id} = (struct ${mono_struct_name}*)${wrap}; _arrm_p_${id}->_vt = 0; _arrm_p_${id}->length = ${length}; memcpy(${wrap} + sizeof(struct ${mono_struct_name}), ${recv}, ${bytes}); ` + (method_self_is_ref && ret_c !== "void" ? `${ret_c} _arrm_r_${id} = ` : "");
+		self_expr = `_arrm_p_${id}`;
+	}
+	const copy_back = `memcpy(${recv}, ${length_is_literal ? `${wrap}._d` : `${wrap} + sizeof(struct ${mono_struct_name})`}, ${bytes}); `;
+	const suffix = (method_self_is_ref ? `; ${copy_back}` + (ret_c !== "void" ? `_arrm_r_${id}; ` : `(void)0; `) : "") + `; })`;
+	return {
+		prefix,
+		self_expr,
+		suffix
+	};
+}
 function build_access_node(node, status) {
 	let target_type = type_from_value_node$1(node.target);
 	if (!target_type?.name && node.target.node_type === "value") {
@@ -15225,20 +16019,36 @@ function build_access_node(node, status) {
 					}
 				}
 				const label = access_func.mangled_name || trait_default_label || `${mono_struct_name}_${access_func.name.replace(/#/g, "")}`;
+				const array_wrap = array_receiver_wrap(node, method_type, target_method, mono_struct_name, status);
+				if (array_wrap) status.code += array_wrap.prefix;
+				const hidden_len = callee_hidden_len_indices(access_func);
+				const hidden_wrap = open_hidden_len_wrap(hidden_len, access_func.params, status);
 				status.code += `${label}(`;
 				if (!access_func.is_static) {
-					const method_self_is_ref = !!target_method?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref));
-					if (!built_in_types.includes(method_type?.name || "") || method_self_is_ref) {
-						const target_value = node.target.node_type === "value" ? node.target.value : "";
-						const target_is_ref_class_param = !!status.ref_class_params?.has(target_value);
-						if (!(!!status.function_ref_params?.has(target_value) || !!status.class_vars?.has(target_value) || !!status.heap_array_vars?.has(target_value))) status.code += "&";
-						else if (target_is_ref_class_param) {} else status.suppress_dereference = true;
+					if (array_wrap) status.code += array_wrap.self_expr;
+					else {
+						const method_self_is_ref = !!target_method?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref));
+						if (!built_in_types.includes(method_type?.name || "") || method_self_is_ref) {
+							const target_value = node.target.node_type === "value" ? node.target.value : "";
+							const target_is_ref_class_param = !!status.ref_class_params?.has(target_value);
+							if (!(!!status.function_ref_params?.has(target_value) || !!status.class_vars?.has(target_value) || !!status.heap_array_vars?.has(target_value))) status.code += "&";
+							else if (target_is_ref_class_param) {} else status.suppress_dereference = true;
+						}
+						build_node(node.target, status);
+						status.suppress_dereference = false;
 					}
-					build_node(node.target, status);
-					status.suppress_dereference = false;
 				}
 				for (let i = 0; i < access_func.params.length; i++) {
 					if (!access_func.is_static || i > 0) status.code += ", ";
+					const hidden_temp = hidden_wrap.temps.get(i);
+					if (hidden_temp) {
+						status.code += `${hidden_temp}, strlen(${hidden_temp})`;
+						continue;
+					}
+					if (access_func.view_param_indices?.includes(i)) {
+						c_view_string_arg(access_func.params[i], status);
+						continue;
+					}
 					const param_type = type_from_value_node$1(access_func.params[i]);
 					const param_value = access_func.params[i].node_type === "value" ? access_func.params[i].value : "";
 					const arg_is_struct_or_trait = !!status.structs.find((s) => s.name === param_type.name && !s.is_simple_type) || !!status.traits.find((t) => t.name === param_type.name) || !!status.class_vars?.has(param_value);
@@ -15259,8 +16069,14 @@ function build_access_node(node, status) {
 						build_node(access_func.params[i], status);
 						status.suppress_dereference = false;
 					} else build_node(access_func.params[i], status);
+					if (hidden_len.includes(i)) {
+						status.code += `, `;
+						emit_hidden_len_expr(access_func.params[i], void 0, status);
+					}
 				}
 				status.code += ")";
+				close_hidden_len_wrap(hidden_wrap, status);
+				if (array_wrap) status.code += array_wrap.suffix;
 			}
 			if (access_func.mov_param_indices) for (const idx of access_func.mov_param_indices) {
 				const param = access_func.params[idx];
@@ -15302,6 +16118,11 @@ function resolve_access_field_type(node, status) {
 }
 function emit_string_length(target, status) {
 	if (target.node_type === "value") {
+		const name = target.value;
+		if (name !== "self" && status.hidden_len_params?.has(c_function_name(name))) {
+			status.code += `_${c_function_name(name)}_len`;
+			return;
+		}
 		const temp = status.string_length_temps?.get(target.value);
 		if (temp) {
 			status.code += temp;
@@ -15826,6 +16647,10 @@ function build_parameter_node(node, status) {
 		status.code += `)`;
 		return;
 	}
+	if (!node.is_self_param && node.type.is_view) {
+		status.code += `nomen_view ${c_function_name(node.name)}`;
+		return;
+	}
 	const cls = classify_param(node.type, type_name, {
 		is_ref: node.is_ref || node.type.is_ref,
 		is_self: node.is_self_param,
@@ -15953,6 +16778,7 @@ function has_string_fields(node, status) {
 const OWNING_BUFFER_METHODS = /* @__PURE__ */ new Set([
 	"store_T",
 	"replace_T",
+	"shift_T",
 	"destroy",
 	"#destroy"
 ]);
@@ -15987,6 +16813,15 @@ function emit_owning_buffer_string_body(func_name, status) {
 		status.code += `if (val != _old) { free(_old); _slots[i] = val ? strdup(val) : 0; }\n`;
 		return true;
 	}
+	if (func_name === "shift_T") {
+		status.code += `char** _slots = (char**)self->data;\n`;
+		status.code += `if (dst != src) {\n`;
+		status.code += `free(_slots[dst]);\n`;
+		status.code += `_slots[dst] = _slots[src];\n`;
+		status.code += `_slots[src] = 0;\n`;
+		status.code += `}\n`;
+		return true;
+	}
 	if (func_name === "destroy") {
 		status.code += `if (self->data) {\n`;
 		status.code += `char** _slots = (char**)self->data;\n`;
@@ -16026,6 +16861,15 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status);
 		return true;
 	}
+	if (func_name === "shift_T") {
+		status.code += `${Tptr}_slots = ${Tcast}(unsigned long long)self->data;\n`;
+		status.code += `if (dst != src) {\n`;
+		status.code += `${elem.name}_destroy(&_slots[dst]);\n`;
+		status.code += `_slots[dst] = _slots[src];\n`;
+		status.code += `memset((void*)&_slots[src], 0, sizeof(struct ${elem.name}));\n`;
+		status.code += `}\n`;
+		return true;
+	}
 	if (func_name === "destroy") {
 		status.code += `if (self->data) {\n`;
 		status.code += `${Tptr}_slots = ${Tcast}(unsigned long long)self->data;\n`;
@@ -16348,6 +17192,10 @@ function build_struct_functions(node, status, skip_init = false) {
 		const old_borrow_only = status.c_borrow_only_strings;
 		const old_return_type = status.function_return_type;
 		const old_function_name = status.current_function_name;
+		const old_view_params = status.function_view_params;
+		status.function_view_params = /* @__PURE__ */ new Set();
+		const old_hidden_len_params = status.hidden_len_params;
+		status.hidden_len_params = /* @__PURE__ */ new Set();
 		status.current_function_name = func.name;
 		status.function_ref_params = /* @__PURE__ */ new Set();
 		status.class_vars = /* @__PURE__ */ new Set();
@@ -16359,6 +17207,8 @@ function build_struct_functions(node, status, skip_init = false) {
 		const self_param = func.params[0]?.is_self_param ? func.params[0] : null;
 		status.self_is_ref = !!self_param?.is_ref || self_param?.declaration === "var";
 		for (let param of func.params) {
+			if (param.type.is_view && !param.is_self_param) status.function_view_params.add(c_function_name(param.name));
+			if (param.hidden_len) status.hidden_len_params.add(c_function_name(param.name));
 			const param_struct = status.structs.find((s) => s.name === param.type.name);
 			const param_trait = status.traits.find((t) => t.name === param.type.name);
 			if (param.is_self_param || param_struct && !param_struct.is_simple_type || param_trait || param.is_ref || param.type.is_ref || param.declaration === "var" && param_struct && !param_struct.is_simple_type) {
@@ -16409,6 +17259,7 @@ function build_struct_functions(node, status, skip_init = false) {
 		for (let i = 0; i < func.params.length; i++) {
 			if (i > 0) status.code += ", ";
 			build_parameter_node(func.params[i], status);
+			if (func.params[i].hidden_len) status.code += `, long _${c_function_name(func.params[i].name)}_len`;
 		}
 		status.code += `)`;
 		forward_decl_referenced_types(func, status);
@@ -16438,6 +17289,8 @@ function build_struct_functions(node, status, skip_init = false) {
 		status.c_borrow_only_strings = old_borrow_only;
 		status.function_return_type = old_return_type;
 		status.current_function_name = old_function_name;
+		status.function_view_params = old_view_params;
+		status.hidden_len_params = old_hidden_len_params;
 	}
 	status.current_struct = old_current_struct;
 	for (let traitName of node.traits) {
@@ -16568,6 +17421,7 @@ function build_function_node(node, status) {
 	else {
 		if (node.return_type.name) {
 			if (node.return_type.is_array) status.code += `struct Array_${node.return_type.name}* `;
+			else if (node.return_type.is_view) status.code += `nomen_view `;
 			else {
 				const mono_return_name = mono_type_name(node.return_type);
 				const return_is_class = !!status.structs.find((s) => s.name === mono_return_name && s.is_class);
@@ -16588,6 +17442,7 @@ function build_function_node(node, status) {
 			if (node.params[i].is_variadic) status.code += `long _${node.params[i].name}_len, `;
 			build_parameter_node(node.params[i], status);
 			if (is_nullable_struct_type(node.params[i].type, status) && !node.params[i].is_self_param) status.code += `, unsigned char ${has_flag_name(c_function_name(node.params[i].name))}`;
+			if (node.params[i].hidden_len) status.code += `, long _${c_function_name(node.params[i].name)}_len`;
 		}
 		if (is_nullable_struct_type(node.return_type, status)) {
 			if (!first_param) status.code += ", ";
@@ -16616,6 +17471,10 @@ function build_function_node(node, status) {
 	status.ref_class_param_types = /* @__PURE__ */ new Map();
 	const old_variadic_params = status.function_variadic_params;
 	status.function_variadic_params = /* @__PURE__ */ new Set();
+	const old_hidden_len_params = status.hidden_len_params;
+	status.hidden_len_params = /* @__PURE__ */ new Set();
+	const old_view_params = status.function_view_params;
+	status.function_view_params = /* @__PURE__ */ new Set();
 	const old_return_type = status.function_return_type;
 	status.function_return_type = node.return_type;
 	const old_nullable_ret_has = status.nullable_ret_has_param;
@@ -16625,6 +17484,8 @@ function build_function_node(node, status) {
 	status.current_function_name = node.name;
 	for (let param of node.params) {
 		if (param.is_variadic) status.function_variadic_params.add(c_function_name(param.name));
+		if (param.hidden_len) status.hidden_len_params.add(c_function_name(param.name));
+		if (param.type.is_view && !param.is_self_param) status.function_view_params.add(c_function_name(param.name));
 		if (!param.is_variadic ? array_struct_name(param.type, status) : void 0) {
 			const pname = c_function_name(param.name);
 			if (!status.heap_array_vars) status.heap_array_vars = /* @__PURE__ */ new Set();
@@ -16657,6 +17518,8 @@ function build_function_node(node, status) {
 	status.ref_class_params = old_ref_class_params;
 	status.ref_class_param_types = old_ref_class_param_types;
 	status.function_variadic_params = old_variadic_params;
+	status.hidden_len_params = old_hidden_len_params;
+	status.function_view_params = old_view_params;
 	status.function_return_type = old_return_type;
 	status.nullable_ret_has_param = old_nullable_ret_has;
 	status.current_function_name = old_function_name;
@@ -17370,7 +18233,8 @@ function build_declaration_node(node, status) {
 				const val_node = node.value;
 				const val_is_string_literal = node.value.node_type === "value" && val_node.value.length >= 2 && val_node.value.startsWith("\"") && val_node.value.endsWith("\"");
 				const val_is_heap_string_var = node.value.node_type === "value" && !val_is_string_literal && !!status.scoped_declarations.find((d) => d.name === val_node.value);
-				if (node.declaration === "var" && node.type.name === "string" && !node.type.is_view && (val_is_string_literal || val_is_heap_string_var) && !is_borrow_only_string) {
+				if (node.type.name === "string" && !node.type.is_view && is_view_value(node.value, status)) c_materialize_view_string(node.value, status);
+				else if (node.declaration === "var" && node.type.name === "string" && !node.type.is_view && (val_is_string_literal || val_is_heap_string_var) && !is_borrow_only_string) {
 					status.code += `strdup(`;
 					build_node(node.value, status);
 					status.code += `)`;
@@ -17587,10 +18451,17 @@ function build_function_call_node(node, status) {
 	}
 	const is_struct = status.structs.find((s) => s.name === node.name && !s.is_simple_type);
 	const func_name = is_struct ? `${node.name}_init` : c_function_name(node.name);
+	const hidden_len = callee_hidden_len_indices(node);
+	const hidden_wrap = open_hidden_len_wrap(hidden_len, node.params, status);
 	status.code += `${func_name}(`;
 	const variadic_idx = node.variadic_param_name ? node.params.findIndex((p) => p.node_type === "array") : -1;
 	for (let i = 0; i < node.params.length; i++) {
 		if (i > 0) status.code += ", ";
+		const hidden_temp = hidden_wrap.temps.get(i);
+		if (hidden_temp) {
+			status.code += `${hidden_temp}, strlen(${hidden_temp})`;
+			continue;
+		}
 		if (i === variadic_idx && node.params[i].node_type === "array") {
 			const arr = node.params[i];
 			status.code += `${arr.values.length}, (${c_type(arr.type.name)}[]){`;
@@ -17612,6 +18483,10 @@ function build_function_call_node(node, status) {
 			status.suppress_dereference = false;
 			continue;
 		}
+		if (node.view_param_indices?.includes(i)) {
+			c_view_string_arg(node.params[i], status);
+			continue;
+		}
 		const is_ref_param = node.ref_param_indices?.includes(i);
 		const param_is_class = !!status.structs.find((s) => s.name === param_type.name && s.is_class);
 		if (is_ref_param && param_is_class) {
@@ -17641,6 +18516,10 @@ function build_function_call_node(node, status) {
 			status.code += `, `;
 			emit_nullable_arg_flag(node.params[i], status);
 		}
+		if (hidden_len.includes(i)) {
+			status.code += `, `;
+			emit_hidden_len_expr(node.params[i], void 0, status);
+		}
 	}
 	if (is_nullable_struct_type(node.type, status)) {
 		const flag_name = status.current_nullable_call_flag;
@@ -17656,6 +18535,7 @@ function build_function_call_node(node, status) {
 		}
 	}
 	status.code += ")";
+	close_hidden_len_wrap(hidden_wrap, status);
 	if (node.name.startsWith("_string_interpolate_")) status.interpolate_string_counts.add(node.params.length - 1);
 	if (node.swap_params?.size) for (const [idx, swap_expr] of node.swap_params) {
 		const source = node.params[idx];
@@ -18064,10 +18944,13 @@ function build_return_node(node, status) {
 			}
 		}
 		if (returns_borrowed_string || returns_string_literal || returns_borrow_var) status.code += `strdup(`;
+		const wrap_view_string_return = !!ret_type.is_view && ret_type.name === "string" && !is_view_value(node.value, status);
 		const expr_type_name = node.type?.name || "";
 		const expr_is_simple = !status.structs.find((s) => s.name === expr_type_name && !s.is_simple_type);
 		if (is_struct && expr_is_simple && !returns_borrowed_string && !ret_type.is_view) status.code += return_is_class ? `(struct ${mono_ret_name}*)` : `(struct ${mono_ret_name})`;
+		if (wrap_view_string_return) status.code += `({ char* _p = `;
 		build_node(node.value, status);
+		if (wrap_view_string_return) status.code += `; nomen_view _v = { (void*)_p, (long)strlen(_p) }; _v; })`;
 		if (returns_borrowed_string || returns_string_literal || returns_borrow_var) status.code += `)`;
 		status.code += `;\n`;
 		if (node.value.node_type === "func_call" && node.value.field_overrides?.length) emit_field_overrides("_return_val", node.value, build_node, status, "", ";\n");
@@ -18257,7 +19140,7 @@ function build_value_node(node, status) {
 	else value = c_function_name(value);
 	if (value.startsWith("\"")) value = escape_c_string(value);
 	if (value !== "self" && status.function_ref_params?.has(value) && !status.suppress_dereference) status.code += `*`;
-	if (value === "self" && status.function_ref_params?.has("self") && !status.suppress_dereference) status.code += `*`;
+	if (value === "self" && status.function_ref_params?.has("self") && !status.suppress_dereference && status.current_struct?.name !== "string") status.code += `*`;
 	if (value !== "self" && status.ref_class_params?.has(value) && !status.suppress_dereference) {
 		status.code += `(*${value})`;
 		return;
@@ -18281,6 +19164,7 @@ function build_while_loop_node(node, status) {
 		if (!status.string_length_temps) status.string_length_temps = /* @__PURE__ */ new Map();
 		for (const [name, target] of hoists) {
 			if (status.string_length_temps.has(name)) continue;
+			if (status.hidden_len_params?.has(c_function_name(name))) continue;
 			const temp = `_slh_${status.label_counter = (status.label_counter ?? 0) + 1}`;
 			status.string_length_temps.set(name, temp);
 			status.code += `const long ${temp} = (long)strlen(`;
@@ -20123,6 +21007,16 @@ function add_error(status, message, start) {
 	});
 }
 //#endregion
+//#region ../src/nodes/set_resolved_function.ts
+function set_resolved_function(node, func) {
+	Object.defineProperty(node, "resolved_function", {
+		value: func,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
+}
+//#endregion
 //#region ../src/nodes/clone_node.ts
 function clone_type$2(type) {
 	const t = new Type(type.name, type.is_static, type.is_array, type.length ? clone_node(type.length) : void 0);
@@ -20157,10 +21051,13 @@ function clone_node(node) {
 			c.type_args = n.type_args?.map(clone_type$2);
 			c.ref_param_indices = n.ref_param_indices?.slice();
 			c.mov_param_indices = n.mov_param_indices?.slice();
+			c.nullable_param_indices = n.nullable_param_indices?.slice();
+			c.view_param_indices = n.view_param_indices?.slice();
 			c.swap_params = n.swap_params ? new Map([...n.swap_params].map(([k, v]) => [k, clone_node(v)])) : void 0;
 			c.variadic_param_name = n.variadic_param_name;
 			c.variadic_param_index = n.variadic_param_index;
 			c.is_enum_shorthand = n.is_enum_shorthand;
+			set_resolved_function(c, n.resolved_function);
 			c.allocations = n.allocations?.map(clone_node);
 			return c;
 		}
@@ -20188,6 +21085,7 @@ function clone_node(node) {
 			c.mangled_name = n.mangled_name;
 			c.owned_return = n.owned_return;
 			c.nullable_param_indices = n.nullable_param_indices?.slice();
+			c.view_param_indices = n.view_param_indices?.slice();
 			c.return_bounds = n.return_bounds ? {
 				upper: n.return_bounds.upper.slice(),
 				lower: n.return_bounds.lower.slice(),
@@ -20199,6 +21097,7 @@ function clone_node(node) {
 			c.function_return_type = n.function_return_type ? clone_type$2(n.function_return_type) : void 0;
 			c.is_statement = n.is_statement;
 			c.skip_bounds_check = n.skip_bounds_check;
+			set_resolved_function(c, n.resolved_function);
 			c.allocations = n.allocations?.map(clone_node);
 			return c;
 		}
@@ -20386,6 +21285,7 @@ function clone_node(node) {
 			c.return_constraint = n.return_constraint ? clone_node(n.return_constraint) : void 0;
 			c.returns_mov = n.returns_mov;
 			c.is_library = n.is_library;
+			c.is_inline = n.is_inline;
 			return c;
 		}
 		case "param": {
@@ -20396,7 +21296,10 @@ function clone_node(node) {
 			c.default_value_start = n.default_value_start;
 			c.is_variadic = n.is_variadic;
 			c.is_ref = n.is_ref;
+			c.is_variadic_tuple = n.is_variadic_tuple;
+			c.hidden_len = n.hidden_len;
 			c.constraint = n.constraint ? clone_node(n.constraint) : void 0;
+			c.stripped_length_equalities = n.stripped_length_equalities?.map((e) => ({ ...e }));
 			c.func_params = n.func_params?.map((p) => clone_node(p));
 			c.func_return_type = n.func_return_type ? clone_type$2(n.func_return_type) : void 0;
 			c.allocations = n.allocations?.map(clone_node);
@@ -20954,6 +21857,40 @@ function snapshot_bounds(name, status) {
 		lower_bound_inclusive_exprs: decl.lower_bound_inclusive_exprs?.slice()
 	};
 }
+function snapshot_all_bounds(status) {
+	const snap = /* @__PURE__ */ new Map();
+	for (const v of status.values) snap.set(v, {
+		range_lower: v.range_lower,
+		range_upper: v.range_upper,
+		upper_bound_exprs: v.upper_bound_exprs?.slice(),
+		lower_bound_exprs: v.lower_bound_exprs?.slice(),
+		upper_bound_inclusive_exprs: v.upper_bound_inclusive_exprs?.slice(),
+		lower_bound_inclusive_exprs: v.lower_bound_inclusive_exprs?.slice(),
+		upper_bound_expr: v.upper_bound_expr,
+		lower_bound_expr: v.lower_bound_expr,
+		alias_of: v.alias_of,
+		known_length: v.known_length,
+		path_bounds: v.path_bounds ? new Map(v.path_bounds) : void 0
+	});
+	return snap;
+}
+function restore_all_bounds(status, snap) {
+	for (const v of status.values) {
+		const s = snap.get(v);
+		if (!s) continue;
+		v.range_lower = s.range_lower;
+		v.range_upper = s.range_upper;
+		v.upper_bound_exprs = s.upper_bound_exprs;
+		v.lower_bound_exprs = s.lower_bound_exprs;
+		v.upper_bound_inclusive_exprs = s.upper_bound_inclusive_exprs;
+		v.lower_bound_inclusive_exprs = s.lower_bound_inclusive_exprs;
+		v.upper_bound_expr = s.upper_bound_expr;
+		v.lower_bound_expr = s.lower_bound_expr;
+		v.alias_of = s.alias_of;
+		v.known_length = s.known_length;
+		v.path_bounds = s.path_bounds;
+	}
+}
 /**
 * Serialize an AST expression to a canonical string for comparison.
 * E.g. `list.length` → "list.length", `self.length` → resolves alias to actual var.
@@ -20963,7 +21900,7 @@ function expr_to_string(node, status) {
 		const vn = node;
 		if (status) {
 			const decl = status.values.findLast((v) => v.name === vn.value);
-			if (decl?.alias_of) return decl.alias_of;
+			if (decl?.alias_of) return canonicalize_length_path(decl.alias_of, status);
 		}
 		return vn.value;
 	}
@@ -20972,7 +21909,10 @@ function expr_to_string(node, status) {
 		if (access.access.node_type === "access_field") {
 			const target = expr_to_string(access.target, status);
 			const field = access.access.name;
-			if (target) return `${target}.${field}`;
+			if (target) {
+				const path = `${target}.${field}`;
+				return status ? canonicalize_length_path(path, status) : path;
+			}
 		} else if (access.access.node_type === "access_func") {
 			const target = expr_to_string(access.target, status);
 			const method = access.access.name;
@@ -20981,9 +21921,148 @@ function expr_to_string(node, status) {
 				"size",
 				"count",
 				"cap"
-			].includes(method)) return `${target}.${method}`;
-		}
-	}
+			].includes(method)) {
+				const path = `${target}.${method}`;
+				return status ? canonicalize_length_path(path, status) : path;
+			}
+		}
+	}
+}
+/**
+* Rewrite a `<base>.<field>` path through the assumed parallel-length
+* equalities (`a.length == b.length` param contracts) to a canonical
+* representative, so a bound phrased against either container's length
+* (`i < xs.length`) verifies a constraint on the other (`hash.length`).
+* Each equation's `a` side is the representative; following `b → a` edges
+* to a fixed point makes the rewrite idempotent and confluent for chains
+* (a==b, b==c all canonicalize to the chain head). Only touches paths whose
+* field has a recorded equation.
+*/
+function canonicalize_length_path(path, status) {
+	const eqs = status.equal_lengths;
+	if (!eqs?.length) return path;
+	const m = /^(\w+)\.(length|count|size|cap)$/.exec(path);
+	if (!m) return path;
+	const field = m[2];
+	let base = m[1];
+	for (let step = 0; step < eqs.length; step++) {
+		const eq = eqs.find((e) => e.field === field && (e.a === base || e.b === base));
+		if (!eq || eq.a === base) break;
+		base = eq.a;
+	}
+	return `${base}.${field}`;
+}
+/**
+* Remove `X.<f> == Y.<f>` clauses (same container-size field on two params,
+* one of them `param_name`) from a parameter constraint, recording each as an
+* ASSUMED parallel-length equality on `status.equal_lengths`. Such a clause
+* relates two runtime lengths, which the verifier can never prove at a call
+* site — instead it is trusted there (stripped from the contract) and made
+* available to the body's bounds machinery via expr_to_string
+* canonicalization. Returns the rewritten constraint, or undefined when
+* everything was stripped. Nodes are only rebuilt when something changed.
+*/
+function strip_length_equalities(constraint, param_name, status) {
+	if (!constraint) return void 0;
+	if (constraint.node_type !== "op") return constraint;
+	const op = constraint;
+	if (op.op === "&&") {
+		const left = strip_length_equalities(op.left_value, param_name, status);
+		const right = strip_length_equalities(op.right_value, param_name, status);
+		if (left && right) {
+			if (left === op.left_value && right === op.right_value) return constraint;
+			return new OperationNode(op.start, "&&", left, right, op.type);
+		}
+		return left ?? right;
+	}
+	if (op.op !== "==") return constraint;
+	const extract = (side) => {
+		if (side.node_type !== "access") return void 0;
+		const access = side;
+		let field;
+		if (access.access.node_type === "access_field") field = access.access.name;
+		else if (access.access.node_type === "access_func") field = access.access.name;
+		if (!field || !NON_NEGATIVE_FIELDS$1.has(field)) return void 0;
+		if (access.target.node_type !== "value") return void 0;
+		const base = access.target.value;
+		if (base !== param_name && !status.values.some((v) => v.name === base)) return void 0;
+		return {
+			base,
+			field
+		};
+	};
+	const lhs = extract(op.left_value);
+	const rhs = extract(op.right_value);
+	if (!lhs || !rhs || lhs.field !== rhs.field) return constraint;
+	if (lhs.base === rhs.base) return constraint;
+	if (!status.equal_lengths) status.equal_lengths = [];
+	const other = lhs.base;
+	const paired = rhs.base;
+	if (!status.equal_lengths.some((e) => e.field === lhs.field && (e.a === other && e.b === paired || e.a === paired && e.b === other))) status.equal_lengths.push({
+		a: other,
+		b: paired,
+		field: lhs.field
+	});
+}
+/**
+* Registration-time variant of strip_length_equalities: removes
+* `<container>.<size> == <container>.<size>` conjuncts from a parameter
+* constraint and returns them alongside the remaining constraint. Used when a
+* function signature is REGISTERED — before any call site can observe it — so
+* a forward-referenced callee never hands its caller a clause no call site
+* could prove (declaration order must not matter). Bases are validated
+* against `known_names` (the function's own parameters) instead of
+* status.values, because at registration time nothing has been pushed into
+* any scope yet. Does NOT touch status.equal_lengths: the extracted
+* equalities are returned for the callee's own param check to seed.
+*/
+function extract_length_equalities_at_registration(constraint, param_name, known_names) {
+	const equalities = [];
+	if (!constraint) return {
+		constraint,
+		equalities
+	};
+	const walk = (node) => {
+		if (node.node_type !== "op") return node;
+		const op = node;
+		if (op.op === "&&") {
+			const left = walk(op.left_value);
+			const right = walk(op.right_value);
+			if (left && right) {
+				if (left === op.left_value && right === op.right_value) return node;
+				return new OperationNode(op.start, "&&", left, right, op.type);
+			}
+			return left ?? right;
+		}
+		if (op.op !== "==") return node;
+		const extract = (side) => {
+			if (side.node_type !== "access") return void 0;
+			const access = side;
+			let field;
+			if (access.access.node_type === "access_field") field = access.access.name;
+			else if (access.access.node_type === "access_func") field = access.access.name;
+			if (!field || !NON_NEGATIVE_FIELDS$1.has(field)) return void 0;
+			if (access.target.node_type !== "value") return void 0;
+			return {
+				base: access.target.value,
+				field
+			};
+		};
+		const lhs = extract(op.left_value);
+		const rhs = extract(op.right_value);
+		if (!lhs || !rhs || lhs.field !== rhs.field) return node;
+		if (lhs.base === rhs.base) return node;
+		for (const base of [lhs.base, rhs.base]) if (base !== param_name && !known_names.has(base)) return node;
+		equalities.push({
+			a: lhs.base,
+			b: rhs.base,
+			field: lhs.field
+		});
+	};
+	return {
+		constraint: walk(constraint),
+		equalities
+	};
 }
 /**
 * Extract flow-sensitive bounds from a comparison condition.
@@ -21079,32 +22158,59 @@ function apply_bounds(condition, status, is_loop = false) {
 		var_decl = status.values.findLast((v) => v.name === base);
 	}
 	if (!var_decl) return;
+	let path_entry;
+	if (bound.var_name.includes(".") && bound.var_name !== var_decl.name) {
+		if (!var_decl.path_bounds) var_decl.path_bounds = /* @__PURE__ */ new Map();
+		path_entry = var_decl.path_bounds.get(bound.var_name);
+		if (!path_entry) {
+			path_entry = {};
+			var_decl.path_bounds.set(bound.var_name, path_entry);
+		}
+	}
+	const push_unique = (arr, expr) => {
+		const out = arr ?? [];
+		if (!out.includes(expr)) out.push(expr);
+		return out;
+	};
 	if (bound.op === "<" || bound.op === "<=") {
 		const inclusive = bound.op === "<=";
 		if (!var_decl.upper_bound_exprs) var_decl.upper_bound_exprs = [];
 		if (!var_decl.upper_bound_inclusive_exprs) var_decl.upper_bound_inclusive_exprs = [];
 		if (inclusive) {
-			if (!var_decl.upper_bound_inclusive_exprs.includes(bound.expr)) var_decl.upper_bound_inclusive_exprs.push(bound.expr);
-		} else if (!var_decl.upper_bound_exprs.includes(bound.expr)) var_decl.upper_bound_exprs.push(bound.expr);
+			var_decl.upper_bound_inclusive_exprs = push_unique(var_decl.upper_bound_inclusive_exprs, bound.expr);
+			if (path_entry) path_entry.upper_inclusive = push_unique(path_entry.upper_inclusive, bound.expr);
+		} else {
+			var_decl.upper_bound_exprs = push_unique(var_decl.upper_bound_exprs, bound.expr);
+			if (path_entry) path_entry.upper = push_unique(path_entry.upper, bound.expr);
+		}
 		var_decl.upper_bound_expr = bound.expr;
 		const num = numeric_interval(string_to_node(bound.expr), status);
 		if (num) {
 			const hi = bound.op === "<=" ? num.upper : num.lower;
 			if (is_loop) var_decl.range_upper = hi;
 			else if (var_decl.range_upper === void 0 || hi < var_decl.range_upper) var_decl.range_upper = hi;
+			if (path_entry) {
+				if (is_loop) path_entry.range_upper = hi;
+				else if (path_entry.range_upper === void 0 || hi < path_entry.range_upper) path_entry.range_upper = hi;
+			}
 		}
 	} else if (bound.op === ">" || bound.op === ">=") {
 		const inclusive = bound.op === ">=";
 		if (!var_decl.lower_bound_exprs) var_decl.lower_bound_exprs = [];
 		if (!var_decl.lower_bound_inclusive_exprs) var_decl.lower_bound_inclusive_exprs = [];
 		if (inclusive) {
-			if (!var_decl.lower_bound_inclusive_exprs.includes(bound.expr)) var_decl.lower_bound_inclusive_exprs.push(bound.expr);
-		} else if (!var_decl.lower_bound_exprs.includes(bound.expr)) var_decl.lower_bound_exprs.push(bound.expr);
+			var_decl.lower_bound_inclusive_exprs = push_unique(var_decl.lower_bound_inclusive_exprs, bound.expr);
+			if (path_entry) path_entry.lower_inclusive = push_unique(path_entry.lower_inclusive, bound.expr);
+		} else {
+			var_decl.lower_bound_exprs = push_unique(var_decl.lower_bound_exprs, bound.expr);
+			if (path_entry) path_entry.lower = push_unique(path_entry.lower, bound.expr);
+		}
 		var_decl.lower_bound_expr = bound.expr;
 		const num = numeric_interval(string_to_node(bound.expr), status);
 		if (num) {
 			const lo = bound.op === ">=" ? num.lower : num.upper;
 			if (var_decl.range_lower === void 0 || lo > var_decl.range_lower) var_decl.range_lower = lo;
+			if (path_entry && (path_entry.range_lower === void 0 || lo > path_entry.range_lower)) path_entry.range_lower = lo;
 		}
 	}
 	apply_inverse_numeric_bound(bound, var_decl, status);
@@ -21259,6 +22365,31 @@ function substitute_constraint(node, lhs_name, param_to_arg, visited = /* @__PUR
 	}
 	return node;
 }
+/** Extract `return_bounds` from a value node that is a call (or wraps one). */
+function call_return_bounds(value) {
+	if (!value) return void 0;
+	if (value.node_type === "func_call" || value.node_type === "access_func") return value.return_bounds;
+	if (value.node_type === "access" && value.access.node_type === "access_func") return value.access.return_bounds;
+}
+/**
+* Transfer a call's return-contract bounds onto the variable the call result
+* is bound to (`const int m = mid(xs)` / `m = mid(xs)`). Without this, only
+* the nested form `xs.at(mid(xs))` carried the contract (via the call node's
+* `return_bounds` decoration); binding to a variable dropped it and forced
+* unreadable nesting. Uses the same funneled semantics as the nested path
+* (collect_return_bounds: `<=` lands in the strict `upper` array), so both
+* forms verify identically.
+*/
+function apply_return_bounds_to_var(name, rb, status) {
+	if (!rb) return;
+	const decl = status.values.findLast((v) => v.name === name);
+	if (!decl) return;
+	const push = (arr, add) => arr ? (arr.push(...add.filter((e) => !arr.includes(e))), arr) : add.slice();
+	if (rb.upper.length) decl.upper_bound_exprs = push(decl.upper_bound_exprs, rb.upper);
+	if (rb.lower.length) decl.lower_bound_exprs = push(decl.lower_bound_exprs, rb.lower);
+	if (rb.upper_inclusive.length) decl.upper_bound_inclusive_exprs = push(decl.upper_bound_inclusive_exprs, rb.upper_inclusive);
+	if (rb.lower_inclusive.length) decl.lower_bound_inclusive_exprs = push(decl.lower_bound_inclusive_exprs, rb.lower_inclusive);
+}
 /**
 * Build an expression node tree from a dotted path string (e.g. "list",
 * "self.items") for use in return-contract substitution. Used to map `self`
@@ -22256,6 +23387,7 @@ function is_inside_core_method(status) {
 	return false;
 }
 function check_function_call(node, status, func, target_type, self_value, self_path) {
+	set_resolved_function(node, func);
 	const access_scope = status.stack.at(-1);
 	if (func.name === "#init") {
 		const struct_name = target_type?.name || func.return_type.name;
@@ -22321,6 +23453,10 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 				if (!node.nullable_param_indices.includes(i)) node.nullable_param_indices.push(i);
 			}
 		}
+		if (func_param && func_param.type.is_view && !func_param.is_self_param) {
+			if (!node.view_param_indices) node.view_param_indices = [];
+			if (!node.view_param_indices.includes(i)) node.view_param_indices.push(i);
+		}
 		const old_expected_type = status.expected_type;
 		const old_allow_null = status.allow_null_value;
 		if (func_param) {
@@ -22474,6 +23610,18 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			if (access.access.node_type === "access_field") field_name = access.access.name;
 			else if (access.access.node_type === "access_func") field_name = access.access.name;
 			if (field_name && NON_NEGATIVE_FIELDS.has(field_name)) alias_of = expr_to_string(param, status);
+			const access_path = expr_to_string(param, status);
+			if (access_path && access_path.includes(".")) {
+				const path_bounds = status.values.findLast((v) => v.name === access_path.split(".")[0])?.path_bounds?.get(access_path);
+				if (path_bounds) {
+					upper_bound_exprs = path_bounds.upper?.slice();
+					lower_bound_exprs = path_bounds.lower?.slice();
+					upper_bound_inclusive_exprs = path_bounds.upper_inclusive?.slice();
+					lower_bound_inclusive_exprs = path_bounds.lower_inclusive?.slice();
+					range_lower = path_bounds.range_lower;
+					range_upper = path_bounds.range_upper;
+				}
+			}
 		}
 		let nested_rb;
 		if (param.node_type === "func_call" || param.node_type === "access_func") nested_rb = param.return_bounds;
@@ -22692,6 +23840,222 @@ function receiver_is_const(target_type, self_value, status) {
 	return !!binding && binding.declaration === "const" && !binding.type.is_ref;
 }
 //#endregion
+//#region ../src/build_common/fold_asm_constants.ts
+/**
+* A tiny constant-propagation peephole over monomorphized raw aarch64
+* assembly (`#arch: aarch64` blocks after T → concrete-type substitution).
+*
+* Raw library code is written generically: `mov x3, #T_SIZE` followed by a
+* runtime width dispatch (`cmp x3, #8 / b.gt … / cmp x3, #1 / b.eq …`).
+* After substitution T_SIZE is a literal, so every dispatched branch has a
+* compile-time outcome — but as TEXT, so nothing folds it. This pass tracks
+* `mov <reg>, #<imm>` definitions per basic block and:
+*
+*   - folds `cmp <reg>, #<imm>` + following `b.<cond> <label>` when the
+*     comparison's outcome is known: never-taken branches are dropped,
+*     always-taken ones become unconditional `b <label>`,
+*   - rewrites `madd <d>, <n>, <m>, xzr` / `mul <d>, <n>, <m>` as
+*     `lsl <d>, <n>, #<log2>` when `<m>` is a known power-of-two constant
+*     (the element-stride multiply in every load_T/store_T body).
+*
+* Soundness: a register's definition is only tracked from its immediate
+* `mov` to its next write; the map is cleared at labels (jump targets may
+* arrive with different values), at unconditional branches, at calls
+* (`bl`/`blr` clobber the caller-saved set), and at any instruction form we
+* do not model. Dead code left behind dropped branches (e.g. the
+* width-matched tails and the memcpy copy path) stays in place — it is
+* unreachable, and removing it would require a full reachability pass.
+* Comments (`// …`) are ignored.
+*/
+const REG = /^[wx][0-9]+$/;
+const COND_OPS = /* @__PURE__ */ new Set([
+	"eq",
+	"ne",
+	"gt",
+	"ge",
+	"lt",
+	"le",
+	"hi",
+	"hs",
+	"lo",
+	"ls",
+	"al"
+]);
+function split_comment(line) {
+	return line.replace(/\/\/.*$/, "");
+}
+/** Does `a <cond> b` hold? (signed semantics; immediates here are small.) */
+function cond_holds(cond, a, b) {
+	switch (cond) {
+		case "eq": return a === b;
+		case "ne": return a !== b;
+		case "gt": return a > b;
+		case "ge": return a >= b;
+		case "lt": return a < b;
+		case "le": return a <= b;
+		case "hi": return a > b;
+		case "hs": return a >= b;
+		case "lo": return a < b;
+		case "ls": return a <= b;
+		case "al": return true;
+		default: return false;
+	}
+}
+function is_pow2(n) {
+	if (n > 0 && (n & n - 1) === 0) return Math.log2(n);
+}
+function fold_asm_constants(asm) {
+	const lines = asm.split("\n");
+	const out = [];
+	const defs = /* @__PURE__ */ new Map();
+	const clear = () => defs.clear();
+	/** Invalidate the destination register of a general instruction. */
+	const invalidate_dest = (ops) => {
+		const first = ops.split(",")[0]?.trim();
+		if (first && REG.test(first)) defs.delete(first);
+	};
+	let i = 0;
+	while (i < lines.length) {
+		const raw_line = lines[i];
+		const line = split_comment(raw_line).trim();
+		if (!line) {
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (/^\.[\w$]+:$/.test(line) || line.startsWith(".")) {
+			clear();
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		const m = /^(\w+)\s*(.*)$/.exec(line);
+		if (!m) {
+			clear();
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		const mn = m[1];
+		const ops = m[2].trim();
+		if (mn === "bl" || mn === "blr" || mn === "b" || mn === "br" || mn === "ret") {
+			clear();
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (mn === "mov") {
+			const mm = /^([wx][0-9]+)\s*,\s*#(-?\d+)$/.exec(ops);
+			if (mm) {
+				defs.set(mm[1], parseInt(mm[2], 10));
+				out.push(raw_line);
+				i++;
+				continue;
+			}
+			invalidate_dest(ops);
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (mn === "cmp") {
+			const cm = /^([wx][0-9]+)\s*,\s*#(-?\d+)$/.exec(ops);
+			if (cm && defs.has(cm[1])) {
+				const a = defs.get(cm[1]);
+				const b = parseInt(cm[2], 10);
+				const run = [];
+				let j = i + 1;
+				while (j < lines.length) {
+					const t = split_comment(lines[j]).trim();
+					if (!t) {
+						j++;
+						continue;
+					}
+					const bm = /^b\.(\w+)\s+(\S+)$/.exec(t);
+					if (bm && COND_OPS.has(bm[1])) {
+						run.push({
+							cond: bm[1],
+							label: bm[2],
+							line_idx: j
+						});
+						j++;
+						continue;
+					}
+					break;
+				}
+				if (run.length > 0) {
+					let follower = "";
+					for (let k = run[run.length - 1].line_idx + 1; k < lines.length; k++) {
+						const t = split_comment(lines[k]).trim();
+						if (!t) continue;
+						follower = t;
+						break;
+					}
+					const follower_mn = /^(\S+)/.exec(follower)?.[1] ?? "";
+					if (follower === "" || follower.startsWith(".") || [
+						"cmp",
+						"tst",
+						"cmn",
+						"b",
+						"bl",
+						"ret",
+						"cbz",
+						"cbnz"
+					].includes(follower_mn)) {
+						for (const r of run) if (cond_holds(r.cond, a, b)) {
+							out.push(`b ${r.label}`);
+							break;
+						}
+						i = run[run.length - 1].line_idx + 1;
+						continue;
+					}
+				}
+			}
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (mn === "madd" || mn === "mul") {
+			const parts = ops.split(",").map((p) => p.trim());
+			if (parts.length === (mn === "madd" ? 4 : 3)) {
+				const dest = parts[0];
+				const srcs = [parts[1], parts[2]];
+				const addend = mn === "madd" ? parts[3] : void 0;
+				const addend_zero = mn === "madd" ? /^(x|w)zr$/.test(addend ?? "") : true;
+				let folded = false;
+				if (addend_zero && REG.test(dest)) for (const [n_reg, m_reg] of [[srcs[0], srcs[1]], [srcs[1], srcs[0]]]) {
+					const c = m_reg !== void 0 && REG.test(m_reg) ? defs.get(m_reg) : void 0;
+					const shift = c !== void 0 ? is_pow2(c) : void 0;
+					if (shift !== void 0 && REG.test(n_reg) && !defs.has(n_reg)) {
+						out.push(`lsl ${dest}, ${n_reg}, #${shift}`);
+						defs.delete(dest);
+						i++;
+						folded = true;
+						break;
+					}
+				}
+				if (folded) continue;
+			}
+			invalidate_dest(ops);
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (![
+			"str",
+			"stp",
+			"cmp",
+			"tst",
+			"cbz",
+			"cbnz",
+			"tbz",
+			"tbnz"
+		].includes(mn)) invalidate_dest(ops);
+		out.push(raw_line);
+		i++;
+	}
+	return out.join("\n");
+}
+//#endregion
 //#region ../src/nodes/ExtendNode.ts
 /**
 * An `extend struct Name { ... }` / `extend class Name { ... }` declaration.
@@ -23089,6 +24453,7 @@ function check_declaration_node(decl, status) {
 				status.pending_return_bounds.delete(decl.name);
 			}
 		}
+		if (decl.value) apply_return_bounds_to_var(decl.name, call_return_bounds(decl.value), status);
 	}
 }
 /**
@@ -23708,6 +25073,15 @@ function gather_structs(block, status) {
 				func.scope = status.stack.at(-1) || block;
 				func.return_type = materialize_type(func.return_type, status);
 				instantiate_generic_type(func.return_type, status);
+				const param_names = new Set(func.params.map((p) => p.name));
+				for (const param of func.params) {
+					if (!param.constraint) continue;
+					const { constraint, equalities } = extract_length_equalities_at_registration(param.constraint, param.name, param_names);
+					if (equalities.length) {
+						param.constraint = constraint;
+						param.stripped_length_equalities = equalities;
+					}
+				}
 				status.functions.push(func);
 			}
 			break;
@@ -23821,7 +25195,16 @@ function check_function_parameter_node(param, status) {
 		is_set: true,
 		is_null: param.type.is_nullable ? true : void 0
 	});
+	if (param.stripped_length_equalities?.length) {
+		if (!status.equal_lengths) status.equal_lengths = [];
+		for (const eq of param.stripped_length_equalities) if (!status.equal_lengths.some((e) => e.field === eq.field && (e.a === eq.a && e.b === eq.b || e.a === eq.b && e.b === eq.a))) status.equal_lengths.push(eq);
+	}
 	if (param.constraint) {
+		const stripped = strip_length_equalities(param.constraint, param.name, status);
+		if (stripped !== param.constraint) {
+			param.constraint = stripped;
+			if (!param.constraint) return;
+		}
 		check_node(param.constraint, status);
 		const constraint_type = type_from_value_node(param.constraint, status);
 		if (constraint_type.name && constraint_type.name !== "bool") add_error(status, `Constraint must be a boolean expression, got ${constraint_type.name}`, param.constraint.start);
@@ -23844,7 +25227,15 @@ function clone_status(status) {
 			upper_bound_exprs: v.upper_bound_exprs?.slice(),
 			lower_bound_exprs: v.lower_bound_exprs?.slice(),
 			upper_bound_inclusive_exprs: v.upper_bound_inclusive_exprs?.slice(),
-			lower_bound_inclusive_exprs: v.lower_bound_inclusive_exprs?.slice()
+			lower_bound_inclusive_exprs: v.lower_bound_inclusive_exprs?.slice(),
+			path_bounds: v.path_bounds ? new Map([...v.path_bounds].map(([k, b]) => [k, {
+				upper: b.upper?.slice(),
+				lower: b.lower?.slice(),
+				upper_inclusive: b.upper_inclusive?.slice(),
+				lower_inclusive: b.lower_inclusive?.slice(),
+				range_lower: b.range_lower,
+				range_upper: b.range_upper
+			}])) : void 0
 		})),
 		function_value_base: status.function_value_base,
 		structs: status.structs.slice(),
@@ -23857,6 +25248,7 @@ function clone_status(status) {
 		type_params: status.type_params,
 		errors: status.errors,
 		buffer_caps: status.buffer_caps,
+		equal_lengths: status.equal_lengths?.slice(),
 		mutated_local_names: status.mutated_local_names
 	};
 }
@@ -23869,12 +25261,22 @@ function check_function_node(func, status) {
 	if (func.checked) return;
 	func.checked = true;
 	status.functions.push(func);
+	const param_names = new Set(func.params.map((p) => p.name));
+	for (const param of func.params) {
+		if (!param.constraint) continue;
+		const { constraint, equalities } = extract_length_equalities_at_registration(param.constraint, param.name, param_names);
+		if (equalities.length) {
+			param.constraint = constraint;
+			param.stripped_length_equalities = equalities;
+		}
+	}
 	if (is_generic_func(func)) {
 		func.is_generic = true;
 		return;
 	}
 	let function_status = clone_status(status);
 	function_status.function_value_base = function_status.values.length;
+	function_status.equal_lengths = [];
 	const structs_before = function_status.structs.length;
 	const enums_before = function_status.enums.length;
 	const types_before = function_status.types.length;
@@ -24812,6 +26214,7 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 			value = value.replace(new RegExp(`\\b${param}_NEEDS_STRDUP\\b`, "g"), type === "string" ? "1" : "0");
 		}
 		for (const pname of deref_params) value = value.replace(new RegExp(`(?<![&*.>\\w])\\b${pname}\\b(?![\\w])`, "g"), `(*${pname})`);
+		if (raw_block_is_pure_asm(value)) value = fold_asm_constants(value);
 		raw.value = value;
 		return;
 	}
@@ -26037,13 +27440,17 @@ function check_assignment_node(assign, status) {
 		left_value.lower_bound_exprs = void 0;
 		left_value.upper_bound_inclusive_exprs = void 0;
 		left_value.lower_bound_inclusive_exprs = void 0;
+		left_value.path_bounds = void 0;
 		left_value.alias_of = void 0;
 		left_value.class_alias_of = void 0;
 		left_value.type.length = void 0;
 		if (assign.left_value.node_type === "value") invalidate_view_borrows_of(status, left_value.name);
 		let synthetic_rhs;
 		if (is_trackable_compound) synthetic_rhs = new OperationNode(assign.right_value.start, compound_op, assign.left_value, assign.right_value, left_value.type);
-		if ((!is_compound || synthetic_rhs) && left_value_name === left_value.name) track_assignment_bounds(left_value.name, synthetic_rhs ?? assign.right_value, status, self_snapshot);
+		if ((!is_compound || synthetic_rhs) && left_value_name === left_value.name) {
+			track_assignment_bounds(left_value.name, synthetic_rhs ?? assign.right_value, status, self_snapshot);
+			if (!is_compound) apply_return_bounds_to_var(left_value.name, call_return_bounds(assign.right_value), status);
+		}
 		if (!is_compound && left_value.type.name === "string" && assign.right_value.node_type === "value" && assign.right_value.value.startsWith("\"") && assign.right_value.value.endsWith("\"")) {
 			const len = assign.right_value.value.length - 2;
 			left_value.type.length = new ValueNode(assign.right_value.start, len.toString(), new Type("int"));
@@ -26701,7 +28108,11 @@ function check_operation_node(op, status) {
 				var_obj.is_null = false;
 			}
 		}
-		if (!check_node(op.right_value, status)) return false;
+		const saved_bounds = snapshot_all_bounds(status);
+		apply_bounds(op.left_value, status);
+		const right_ok = check_node(op.right_value, status);
+		restore_all_bounds(status, saved_bounds);
+		if (!right_ok) return false;
 		if (saved_null !== void 0 && left_check) {
 			const var_obj = status.values.findLast((v) => v.name === left_check.name);
 			if (var_obj) var_obj.is_null = saved_null;
@@ -26709,6 +28120,16 @@ function check_operation_node(op, status) {
 		op.type = new Type("bool");
 		return true;
 	}
+	if (op.op === "||") {
+		if (!check_node(op.left_value, status)) return false;
+		const saved_bounds = snapshot_all_bounds(status);
+		apply_negated_bounds(op.left_value, status);
+		const right_ok = check_node(op.right_value, status);
+		restore_all_bounds(status, saved_bounds);
+		if (!right_ok) return false;
+		op.type = new Type("bool");
+		return true;
+	}
 	const is_equality = op.op === "==" || op.op === "!=";
 	const is_null_coalesce = op.op === "??";
 	const old_allow_null = status.allow_null_value;
@@ -26786,7 +28207,6 @@ function check_operation_node(op, status) {
 		case ">=":
 		case "<":
 		case "<=":
-		case "||":
 			op.type = new Type("bool");
 			break;
 		case "??": {
@@ -27272,6 +28692,251 @@ function promote_allocations(node, status) {
 	}
 }
 //#endregion
+//#region ../src/check/stamp_hidden_string_lens.ts
+/**
+* Post-check pass implementing the PERF gap 2.4 fix: thread a string's
+* length through the call boundary so a per-character helper doesn't pay one
+* `strlen` per CALL.
+*
+* For every function whose Nomen-level body reads `<param>.length` on a
+* by-value `string` param (and never rebinds, mutates, or escapes it), the
+* param is stamped `hidden_len`. The backends then lower it as TWO
+* parameters — the `char*` plus a trailing `long _<name>_len` companion
+* (mirroring the nullable `_has` companion) — and the body's `.length` reads
+* become loads of that companion instead of `strlen`. Call sites append the
+* companion argument, preferring a loop-invariant hoisted strlen temp
+* (scan_string_length_hoists treats such args like `.length` reads), so a
+* helper called once per line over a large document costs ONE strlen, not
+* O(lines).
+*
+* Conservative exclusions (any of these keeps the plain one-pointer ABI):
+* - raw blocks anywhere in the body (opaque code may touch the param), or no
+*   body at all
+* - `#init`/`#destroy`/`init`/`destroy`/`main` and any non-identifier or
+*   `_`/`#`-prefixed name (operators, compiler-generated helpers) — their
+*   call sites use bespoke emission paths
+* - variadic params anywhere (their call sites pack hidden count/ptr pairs)
+* - `is_inline` functions (the aarch64 inline splicer)
+* - trait method declarations/default bodies, and struct methods that
+*   implement a trait method (vtable dispatch uses the trait's declared
+*   signature)
+* - functions referenced as VALUES anywhere in the program (`var func f =
+*   helper`, `obj.method` as a value, nursery.spawn targets) — indirect
+*   calls use the declared ABI
+* - params that are ref/mov/view/nullable/variadic/self, or that the body
+*   assigns to, passes ref/mov/swap, mutates through a `var self`/`ref self`
+*   string method, or references across a nested func/async boundary, or
+*   whose companion name `_<name>_len` collides with any declared name in
+*   the body
+*/
+const NON_IDENTIFIERS = /* @__PURE__ */ new Set([
+	"true",
+	"false",
+	"null",
+	"self",
+	"as",
+	"default"
+]);
+function is_plain_identifier(value) {
+	if (!value) return false;
+	if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(value)) return false;
+	if (value.startsWith("_")) return false;
+	return !NON_IDENTIFIERS.has(value);
+}
+function root_name(node) {
+	if (!node) return void 0;
+	if (node.node_type === "value") {
+		const v = node.value;
+		return is_plain_identifier(v) ? v : void 0;
+	}
+	if (node.node_type === "access") return root_name(node.target);
+}
+function collect_functions(root, status) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (func, struct, is_trait_func) => {
+		if (seen.has(func)) return;
+		seen.add(func);
+		out.push({
+			func,
+			struct,
+			is_trait_func
+		});
+	};
+	for (const struct of status.structs) for (const func of struct.functions) add(func, struct);
+	for (const trait of status.traits) for (const func of trait.functions) add(func, void 0, true);
+	for (const func of status.functions) add(func);
+	walk_tree(root, (n) => {
+		if (n.node_type === "struct") {
+			const s = n;
+			for (const func of s.functions) add(func, s);
+		} else if (n.node_type === "trait") {
+			const t = n;
+			for (const func of t.functions) add(func, void 0, true);
+		} else if (n.node_type === "func") add(n);
+	});
+	return out;
+}
+/** Names of functions referenced as VALUES (func-typed, non-call nodes). */
+function collect_value_referenced_names(root, status) {
+	const excluded = /* @__PURE__ */ new Set();
+	const visit = (n) => {
+		if (n.type?.name !== "func") return;
+		if (n.node_type === "value") {
+			const v = n.value;
+			if (is_plain_identifier(v)) excluded.add(v);
+		} else if (n.node_type === "access_field") {
+			const name = n.name;
+			if (is_plain_identifier(name)) excluded.add(name);
+		}
+	};
+	walk_tree(root, visit);
+	for (const struct of status.structs) walk_tree(struct, visit);
+	for (const trait of status.traits) walk_tree(trait, visit);
+	for (const func of status.functions) walk_tree(func, visit);
+	return excluded;
+}
+function walk_tree(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) walk_tree(item, visit);
+		return;
+	}
+	const n = node;
+	if (typeof n.node_type !== "string") return;
+	visit(n);
+	const record = n;
+	for (const key of Object.keys(record)) {
+		if (key === "parent" || key === "scope" || key === "node_type") continue;
+		walk_tree(record[key], visit);
+	}
+}
+function stamp_hidden_string_lens(root, status) {
+	const value_referenced = collect_value_referenced_names(root, status);
+	const owners = collect_functions(root, status);
+	const string_struct = status.structs.find((s) => s.name === "string");
+	for (const { func, struct, is_trait_func } of owners) {
+		if (func.hidden_len_stamped) continue;
+		func.hidden_len_stamped = true;
+		if (!func.has_body || func.statements.length === 0) continue;
+		if (func.is_inline || is_trait_func) continue;
+		const bare_name = func.name.replace(/^#/, "");
+		if (!is_plain_identifier(func.name)) continue;
+		if ([
+			"main",
+			"init",
+			"destroy"
+		].includes(bare_name)) continue;
+		if (value_referenced.has(func.name)) continue;
+		if (func.params.some((p) => p.is_variadic || p.is_variadic_tuple)) continue;
+		if (struct && trait_declares_method(struct, func.name, status)) continue;
+		const candidates = /* @__PURE__ */ new Set();
+		for (const param of func.params) if (param_is_hidden_len_candidate(param)) candidates.add(param.name);
+		if (candidates.size === 0) continue;
+		const reads = /* @__PURE__ */ new Set();
+		const invalidated = /* @__PURE__ */ new Set();
+		const declared_names = /* @__PURE__ */ new Set();
+		let has_raw = false;
+		const visit_children = (n, in_boundary) => {
+			const record = n;
+			for (const key of Object.keys(record)) {
+				if (key === "parent" || key === "scope" || key === "node_type") continue;
+				const child = record[key];
+				if (Array.isArray(child)) {
+					for (const item of child) if (item && typeof item === "object" && item.node_type) visit(item, in_boundary);
+				} else if (child && typeof child === "object" && child.node_type) visit(child, in_boundary);
+			}
+		};
+		const visit = (n, in_boundary) => {
+			switch (n.node_type) {
+				case "raw":
+					has_raw = true;
+					return;
+				case "func":
+				case "async_block":
+					visit_children(n, true);
+					return;
+				case "value": {
+					const v = n.value;
+					if (in_boundary && is_plain_identifier(v)) invalidated.add(v);
+					return;
+				}
+				case "access": {
+					const access = n;
+					if (!in_boundary && access.access.node_type === "access_field" && access.access.name === "length" && access.target.node_type === "value") {
+						const name = access.target.value;
+						if (name !== void 0 && candidates.has(name)) reads.add(name);
+					}
+					if (!in_boundary && access.access.node_type === "access_func" && access.target.node_type === "value") {
+						const name = access.target.value;
+						const call = access.access;
+						if (name !== void 0 && candidates.has(name)) {
+							const self_param = (string_struct?.functions.find((f) => f.name === call.name || f.name === `#${call.name}`))?.params?.[0];
+							if (self_param?.is_self_param && (self_param.declaration === "var" || self_param.is_ref)) invalidated.add(name);
+						}
+					}
+					visit_children(n, in_boundary);
+					return;
+				}
+				case "assign": {
+					const assign = n;
+					const lhs = root_name(assign.left_value);
+					if (lhs) invalidated.add(lhs);
+					const swap = root_name(assign.swap);
+					if (swap) invalidated.add(swap);
+					visit_children(n, in_boundary);
+					return;
+				}
+				case "declare":
+				case "param": {
+					const name = n.name;
+					if (name) declared_names.add(name);
+					visit_children(n, in_boundary);
+					return;
+				}
+				case "for": {
+					const item = n.item;
+					if (item?.value) declared_names.add(item.value);
+					visit_children(n, in_boundary);
+					return;
+				}
+				case "func_call":
+				case "access_func": {
+					const call = n;
+					for (const indices of [call.ref_param_indices, call.mov_param_indices]) for (const i of indices ?? []) {
+						const arg = root_name(call.params?.[i]);
+						if (arg) invalidated.add(arg);
+					}
+					if (call.swap_params) {
+						for (const [i, swap] of call.swap_params) for (const arg of [root_name(call.params?.[i]), root_name(swap)]) if (arg) invalidated.add(arg);
+					}
+					visit_children(n, in_boundary);
+					return;
+				}
+				default:
+					visit_children(n, in_boundary);
+					return;
+			}
+		};
+		for (const stmt of func.statements) visit(stmt, false);
+		if (has_raw) continue;
+		for (const name of candidates) {
+			if (!reads.has(name)) continue;
+			if (invalidated.has(name)) continue;
+			if (declared_names.has(`_${name}_len`)) continue;
+			const param = func.params.find((p) => p.name === name);
+			param.hidden_len = true;
+		}
+	}
+}
+function trait_declares_method(struct, method_name, status) {
+	for (const trait_name of struct.traits) if (status.traits.find((t) => t.name === trait_name)?.functions.some((f) => f.name === method_name)) return true;
+	return false;
+}
+function param_is_hidden_len_candidate(param) {
+	return !param.is_self_param && !param.is_variadic && !param.is_variadic_tuple && !param.is_ref && !param.is_moved && param.type.name === "string" && !param.type.is_array && !param.type.is_ref && !param.type.is_view && !param.type.is_nullable;
+}
+//#endregion
 //#region ../src/check/warnings.ts
 /**
 * Lint pass run after a successful check. It walks the AST to surface three
@@ -27474,6 +29139,7 @@ function check(root) {
 		mutated_local_names: /* @__PURE__ */ new Set()
 	};
 	check_node(root, status);
+	stamp_hidden_string_lens(root, status);
 	if (!status.errors.length) emit_warnings(root, status);
 	return {
 		ok: !status.errors.length,
@@ -29168,7 +30834,8 @@ function parse_visibility(visibility, status) {
 			break;
 		case "inline":
 			consume(status);
-			if (peek_next(status) === "func") parse_function(visibility, status, void 0, true);
+			if (peek_current(status) === "inline") consume(status);
+			if (peek_current(status) === "func") parse_function(visibility, status, void 0, true);
 			else add_error(status, "Expected func after inline", get_index(status));
 			break;
 		case "#": {