nomen-lang 0.0.17 → 0.0.19

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
@@ -2673,6 +2750,20 @@ function is_container_borrow_access(node) {
 	return !!node && node.node_type === "access" && node.access?.node_type === "access_func" && !node.access.owned_return && is_container_borrow_accessor_name(node.access.name);
 }
 /**
+* Whether `target` (the receiver of a `.to_string()` call) is a `view string`
+* VALUE — a named view local/param (the checker stamps variable references
+* with the declared type, and substitute_type preserves `is_view` across
+* monomorphization) or an inline `.slice(...)` chain (a slice call always
+* produces a view, even when its cached type lost the modifier). Such a call
+* MATERIALIZES a fresh owned heap copy (malloc + memcpy), unlike
+* `to_string` on an owned string (the `string_to_string` identity).
+*/
+function is_view_materialization_target(target) {
+	if (!target || typeof target !== "object") return false;
+	if (target.type?.is_view) return true;
+	return target.node_type === "access" && target.access?.node_type === "access_func" && !target.access.owned_return && target.access.name === "slice";
+}
+/**
 * Whether a function has any `return <expr>` statement in its body (used by
 * the C backend's gather, which registers every string-returning function
 * that actually returns — the backend strdup's borrows at the return site,
@@ -2781,6 +2872,7 @@ function value_is_owned_string(v, table, visiting, borrow_names, enclosing_fn) {
 			if (mangled.startsWith("_string_interpolate_")) return true;
 			if (mangled.endsWith("_to_string") && mangled !== "string_to_string") return true;
 			if (raw === "to_string" && v.target?.type?.name && v.target.type.name !== "string") return true;
+			if (raw === "to_string" && is_view_materialization_target(v.target)) return true;
 			if (!v.access.owned_return && is_container_borrow_accessor_name(raw)) return !is_call_site_borrow_accessor(enclosing_fn);
 			const resolved = method_call_returns_owned(v, table, visiting);
 			if (resolved !== void 0) return resolved;
@@ -4396,6 +4488,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 +4530,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 +4555,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 +4604,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 +4632,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 +4758,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 +6447,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 +6711,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 +6777,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 +7652,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 +7816,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 +8546,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 +8595,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 +8626,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 +8651,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 +8735,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 +9075,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 +9362,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 +9518,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 +9547,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 {
@@ -9244,6 +9584,7 @@ function is_owned_heap_temp$1(node, status) {
 		if (mangled.startsWith("_string_interpolate_")) return true;
 		if (mangled.endsWith("_to_string") && mangled !== "string_to_string") return true;
 		if (raw_name === "to_string" && target_type_name && target_type_name !== "string") return true;
+		if (raw_name === "to_string" && status && node.node_type === "access" && is_view_value$1(node.target, status)) return true;
 		const heap_set = status?.heap_returning_functions;
 		if (heap_set?.has(mangled)) return true;
 		if (heap_set && target_value && heap_set.has(`${target_value}_${raw_name}`)) return true;
@@ -9447,6 +9788,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 +10114,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 +10123,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 +10215,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 +10239,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 +10429,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 +10674,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 +10689,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 +10706,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 +10719,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 +10832,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 +11618,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 +11648,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 +11669,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 +11690,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 +11736,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 +11839,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;
@@ -11786,10 +12253,17 @@ function build_naked_inline(struct_node, func, status) {
 	let asm = extract_aarch64_asm(func, status.platform);
 	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 x19_reads = count_x19_reads(asm);
+	let prologue = "";
+	let epilogue = "";
+	if (x19_reads === 1) asm = asm.replace(/\bx19\b/g, "x0");
+	else if (x19_reads > 1) {
+		prologue = `str x19, [sp, #-16]!\nmov x19, x0\n`;
+		epilogue = `ldr x19, [sp], #16\n`;
+	}
 	const site = inline_counter++;
-	asm = asm.replace(/(\.L[A-Za-z0-9_]+)/g, `$1_${site}`);
-	status.code += asm + "\n";
+	asm = asm.replace(/(\.L[A-Za-z0-9_]+)/g, `$1__ni${site}`);
+	status.code += prologue + asm + "\n" + epilogue;
 }
 function build_inline_method(struct_node, func, status) {
 	if (emit_owning_buffer_inline_aarch64(struct_node, func.name, status)) return;
@@ -11814,6 +12288,11 @@ function build_inline_method(struct_node, func, status) {
 	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 = [];
@@ -11824,6 +12303,11 @@ function build_inline_method(struct_node, func, status) {
 	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`;
@@ -11881,9 +12365,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--) {
@@ -11905,6 +12391,11 @@ function build_inline_method(struct_node, func, status) {
 	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;
@@ -11925,6 +12416,11 @@ function build_inline_function(func, status) {
 	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 = [];
@@ -11935,6 +12431,11 @@ function build_inline_function(func, status) {
 	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",
@@ -12004,6 +12505,11 @@ function build_inline_function(func, status) {
 	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;
 }
@@ -12158,8 +12664,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;
@@ -12188,6 +12711,14 @@ function emit_string_length$1(target, status) {
 *                     struct element, with x0 = temp address)
 *   v.to_string()  →  malloc(len+1); memcpy; null-terminate; owned copy in x0
 *                     (string views only)
+* The receiver is either a NAMED view local/param (pair in its two stack
+* slots) or an INLINE view-producing expression such as
+* `text.slice(start, end).to_string()` — the expression leaves the pair in
+* x0/x1, which is spilled to scratch slots first. Without this, the inline
+* chain falls through to struct-method dispatch and resolves to
+* `string_to_string` (an identity `mov x0, x19`), handing consumers the raw
+* slice pointer — not NUL-terminated at len — and strlen-based readers run
+* past the slice.
 * Returns true if handled (caller skips struct-method dispatch).
 */
 function build_view_op(node, access_func, status) {
@@ -12196,11 +12727,19 @@ function build_view_op(node, access_func, status) {
 		const vt = status.variable_types?.get(node.target.value);
 		if (vt?.is_view) t = vt;
 	}
-	if (!t?.is_view) return false;
-	if (node.target.node_type !== "value") return false;
-	const base = status.stack_offsets?.get(node.target.value);
-	if (base === void 0) return false;
-	const elem_name = t.name === "string" ? "char" : t.name;
+	if (!t?.is_view && !is_view_value$1(node.target, status)) return false;
+	let base;
+	if (node.target.node_type === "value") base = status.stack_offsets?.get(node.target.value);
+	if (base === void 0) {
+		build_node$1(node.target, status);
+		if (!status.code.endsWith("\n")) status.code += "\n";
+		const temp_base = allocate_stack_space(status, 16, 16);
+		status.code += `str x0, [x29, #${temp_base}]\n`;
+		status.code += `str x1, [x29, #${temp_base + 8}]\n`;
+		base = temp_base;
+	}
+	const view_elem = t?.name || "string";
+	const elem_name = view_elem === "string" ? "char" : view_elem;
 	if (access_func.name === "at" && access_func.params.length === 1) {
 		build_node$1(access_func.params[0], status);
 		if (!status.code.endsWith("\n")) status.code += "\n";
@@ -12226,21 +12765,10 @@ function build_view_op(node, access_func, status) {
 		else status.code += `ldr x0, [x0, x1, lsl #3]\n`;
 		return true;
 	}
-	if (access_func.name === "to_string" && t.name === "string") {
+	if (access_func.name === "to_string" && view_elem === "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;
 	}
@@ -12448,6 +12976,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;
@@ -13086,14 +13622,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;
@@ -13115,14 +13678,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;
@@ -14226,6 +14841,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) {
@@ -14332,8 +15025,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) {
@@ -14587,7 +15288,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);
@@ -14865,6 +15566,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
@@ -14926,6 +15691,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") {
@@ -15233,20 +16058,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);
@@ -15267,8 +16108,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];
@@ -15310,6 +16157,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;
@@ -15834,6 +16686,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,
@@ -15961,6 +16817,7 @@ function has_string_fields(node, status) {
 const OWNING_BUFFER_METHODS = /* @__PURE__ */ new Set([
 	"store_T",
 	"replace_T",
+	"shift_T",
 	"destroy",
 	"#destroy"
 ]);
@@ -15995,6 +16852,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`;
@@ -16034,6 +16900,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`;
@@ -16356,6 +17231,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();
@@ -16367,6 +17246,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) {
@@ -16417,6 +17298,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);
@@ -16446,6 +17328,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) {
@@ -16576,6 +17460,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);
@@ -16596,6 +17481,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 += ", ";
@@ -16624,6 +17510,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;
@@ -16633,6 +17523,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();
@@ -16665,6 +17557,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;
@@ -17378,7 +18272,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 += `)`;
@@ -17595,10 +18490,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)}[]){`;
@@ -17620,6 +18522,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) {
@@ -17649,6 +18555,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;
@@ -17664,6 +18574,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];
@@ -18072,10 +18983,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");
@@ -18289,6 +19203,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(`;
@@ -20131,6 +21046,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);
@@ -20165,10 +21090,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;
 		}
@@ -20196,6 +21124,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(),
@@ -20207,6 +21136,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;
 		}
@@ -20405,7 +21335,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);
@@ -21111,6 +22044,66 @@ function strip_length_equalities(constraint, param_name, status) {
 	});
 }
 /**
+* 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.
 * E.g. `j < list.length` → { var: "j", op: "<", expr: "list.length" }
 * Returns undefined if the condition isn't a simple var-vs-expr comparison.
@@ -22433,6 +23426,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;
@@ -22498,6 +23492,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) {
@@ -24075,6 +25073,29 @@ function clone_type(t) {
 	c.type_args = t.type_args;
 	return c;
 }
+/**
+* Strip parallel-length equality clauses (`a.length == b.length`) from every
+* parameter's constraint of `func` at SIGNATURE-GATHER time — before any call
+* site can observe the signature, regardless of declaration order. A
+* forward-referenced callee must not hand its caller a clause no call site
+* could ever prove; the clause becomes an assumed equality for the callee's
+* own body instead (stashed on the param, seeded into scope when its params
+* are checked). Idempotent: a constraint already stripped has no clauses
+* left to extract. `check_function_node` re-runs the same extraction at
+* registration for function clones that never pass through a gather pass
+* (generic monomorphizations).
+*/
+function strip_param_length_equalities(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;
+		}
+	}
+}
 function gather_structs(block, status) {
 	const names_in_block = {
 		structs: /* @__PURE__ */ new Set(),
@@ -24091,6 +25112,7 @@ function gather_structs(block, status) {
 				names_in_block.structs.add(struct.name);
 				struct.scope = status.stack.at(-1) || block;
 				struct.is_generic = struct.type_params.length > 0;
+				for (const func of struct.functions) strip_param_length_equalities(func);
 				status.types.push(struct.name);
 				status.structs.push(struct);
 			}
@@ -24103,6 +25125,7 @@ function gather_structs(block, status) {
 				names_in_block.traits.add(trait.name);
 				status.types.push(trait.name);
 				status.traits.push(trait);
+				for (const func of trait.functions) strip_param_length_equalities(func);
 			}
 			break;
 		}
@@ -24114,6 +25137,7 @@ 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);
+				strip_param_length_equalities(func);
 				status.functions.push(func);
 			}
 			break;
@@ -24179,7 +25203,10 @@ function apply_extensions(block, status) {
 			continue;
 		}
 		ext.scope = target;
-		for (const func of ext.functions) target.functions.push(func);
+		for (const func of ext.functions) {
+			strip_param_length_equalities(func);
+			target.functions.push(func);
+		}
 		for (let i = 0; i < ext.traits.length; i++) {
 			if (target.traits.includes(ext.traits[i])) {
 				add_error(status, `Type '${ext.name}' already conforms to trait '${ext.traits[i]}'`, ext.start);
@@ -24227,6 +25254,10 @@ 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) {
@@ -24289,6 +25320,15 @@ 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;
@@ -26905,7 +27945,7 @@ function check_if_else_node(if_else, status) {
 	const else_returns = if_else.else_branch && block_always_returns(if_else.else_branch);
 	const if_falls_through = if_reachable && !if_returns;
 	const else_falls_through = else_reachable && (!has_else || !else_returns);
-	if (!has_else && else_reachable) apply_negated_bounds(if_else.condition, status);
+	if (!has_else && else_reachable && !if_returns) apply_negated_bounds(if_else.condition, status);
 	for (let [i, value] of status.values.entries()) {
 		const contributing_sets = [];
 		if (if_falls_through) contributing_sets.push(!!if_status.values[i].is_set);
@@ -26959,6 +27999,7 @@ function check_if_else_node(if_else, status) {
 			}
 		}
 	}
+	if (!has_else && if_returns && else_reachable) apply_negated_bounds(if_else.condition, status);
 	if (if_else.if_branch && !if_else.else_branch) {
 		const parent = status.stack.at(-1);
 		if (parent && (parent.node_type === "declare" || parent.node_type === "assign")) add_error(status, "If expression must have an else branch", if_else.start);
@@ -27711,6 +28752,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
@@ -27913,6 +29199,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,