nomen-lang 0.2.0 → 0.2.2

package/dist/index.mjs

@@ -21164,7 +21164,8 @@ function build_return_node$1(node, status, nir_value) {
 		else if ((node.value.node_type === "match" || node.value.node_type === "switch") && !return_join_owned_string) needs_borrow_strdup = true;
 	}
 	if (needs_borrow_strdup) {
-		emit_strdup_string(status);
+		if (is_view_value(node.value, status) && (node.value.node_type === "value" || node.value.node_type === "access")) emit_view_materialize_owned(status);
+		else emit_strdup_string(status);
 		if (!status.code.endsWith("\n")) status.code += "\n";
 		status.last_result_is_heap = true;
 	}
@@ -24379,13 +24380,17 @@ function emit_struct_address(node, status) {
 /**
 * Whether an argument expression is a fat string VALUE: either its static
 * type names `string`, or it is a string literal (whose ValueNode.type may
-* be unset). Literals ride the pair ABI like any string.
+* be unset). Literals ride the pair ABI like any string. A `view string`
+* counts too — it IS the same (ptr, len) pair at runtime, so a view
+* argument to a non-view `string` param (e.g. a `.slice` receiver) must
+* occupy two slots just like an owned string. (`view` DECLARED params are
+* unaffected: the view_arg_set check runs first.)
 */
 function arg_is_string$1(node) {
 	const v = node;
 	if (node.node_type === "value" && typeof v.value === "string" && v.value.startsWith("\"")) return true;
 	const t = type_from_value_node$1(node);
-	return t?.name === "string" && !t.is_view && !t.is_array;
+	return t?.name === "string" && !t.is_array;
 }
 function build_function_call_node$1(node, status) {
 	if (node.is_enum_shorthand && node.params.length > 0) {
@@ -25992,6 +25997,12 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 			status.last_result_is_heap = false;
 			emit_rhs_value$1(node.right_value, nir_rhs, status);
 			if (!status.code.endsWith("\n")) status.code += "\n";
+			const assign_lhs_type = status.scoped_declarations.find((d) => d.name === name)?.type ?? status.variable_types?.get(name);
+			const rhs_is_view_into_owned = !node.swap && !node.operator && size === 16 && assign_lhs_type?.name === "string" && !assign_lhs_type.is_view && is_view_value(node.right_value, status);
+			if (rhs_is_view_into_owned) {
+				emit_view_materialize_owned(status);
+				if (!status.code.endsWith("\n")) status.code += "\n";
+			}
 			const saves_fat_pair = size === 16;
 			if (saves_fat_pair) status.code += `stp x0, x1, [sp, #-16]!\n`;
 			else status.code += `str x0, [sp, #-16]!\n`;
@@ -26007,7 +26018,10 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 			const move_source = rhs_is_string_var && node.last_use_move && move_on_last_use_enabled() ? rhs_value.value : void 0;
 			const explicit_move_source = !node.swap && !!rhs_value && rhs_value.is_moved && size === 16 && rhs_value.type?.name === "string" && !rhs_value.type?.is_view ? rhs_value.value : void 0;
 			const borrow_needs_dup = !node.swap && size === 16 && is_string_borrow(node.right_value) && !!status.force_heap_strings?.has(name);
-			if (rhs_is_string_var && move_source === void 0 || borrow_needs_dup) emit_strdup_string(status);
+			if (rhs_is_view_into_owned) {
+				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+				status.heap_strings.add(name);
+			} else if (rhs_is_string_var && move_source === void 0 || borrow_needs_dup) emit_strdup_string(status);
 			if (rhs_is_string_var || borrow_needs_dup) {
 				if (move_source !== void 0) status.heap_strings?.delete(move_source);
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
@@ -29176,13 +29190,14 @@ function build_access_field(node, status) {
 /**
 * Whether an argument expression is a fat string VALUE: either its static
 * type names `string`, or it is a string literal (whose ValueNode.type may
-* be unset). Literals ride the pair ABI like any string.
+* be unset). Literals ride the pair ABI like any string. A `view string`
+* counts too — same pair ABI (see build_function_call_node).
 */
 function arg_is_string(node) {
 	const v = node;
 	if (node.node_type === "value" && typeof v.value === "string" && v.value.startsWith("\"")) return true;
 	const t = type_from_value_node$1(node);
-	return t?.name === "string" && !t.is_view && !t.is_array;
+	return t?.name === "string" && !t.is_array;
 }
 function build_access_method(node, access_func, status) {
 	let target_type = type_from_value_node$1(node.target);
@@ -29742,7 +29757,7 @@ function build_access_method(node, access_func, status) {
 		status.stack_offsets.set(temp_addr, temp_offset);
 		status.code += `add x8, x29, #${temp_offset}\n`;
 	}
-	const receiver_is_string = !access_func.is_static && target_type?.name === "string" && !target_type.is_view && !target_type.is_array && !method_self_is_ref;
+	const receiver_is_string = !access_func.is_static && target_type?.name === "string" && !target_type.is_array && !method_self_is_ref;
 	let frees_string_receiver = false;
 	if (receiver_is_string) {
 		status.last_result_is_heap = false;
@@ -32535,8 +32550,9 @@ function build_struct_functions(node, status, skip_init = false) {
 		} else if (return_type.startsWith("Array_")) status.code += `void* ${emit_label}(`;
 		else if (func.return_type.is_view) status.code += `nomen_view ${emit_label}(`;
 		else {
-			const return_struct = status.structs.find((s) => s.name === return_type && !s.is_simple_type);
-			const return_trait = status.traits.find((t) => t.name === return_type);
+			const mono_return_type = mono_type_name(func.return_type);
+			const return_struct = status.structs.find((s) => s.name === mono_return_type && !s.is_simple_type);
+			const return_trait = status.traits.find((t) => t.name === mono_return_type);
 			if (return_struct && !return_struct.is_class) {
 				const swap = status.code;
 				status.code = status.headers;
@@ -32544,7 +32560,7 @@ function build_struct_functions(node, status, skip_init = false) {
 				status.headers = status.code;
 				status.code = swap;
 			}
-			if (return_struct || return_trait) status.code += `struct ${return_type}`;
+			if (return_struct || return_trait) status.code += `struct ${mono_return_type}`;
 			else status.code += `${c_type(return_type)}`;
 			if (return_struct?.is_class || return_trait) status.code += `*`;
 			status.code += ` ${emit_label}(`;
@@ -34102,6 +34118,7 @@ function build_return_node(node, status, nir_value) {
 			if (!returned_value_decl) returns_borrow_var = true;
 			else if (is_string_borrow(returned_value_decl.value) || !!status.string_borrow_vars?.has(var_name)) returns_borrow_var = true;
 		}
+		const returns_view_value = ret_type.name === "string" && !ret_type.is_view && !ret_type.is_array && is_view_value(node.value, status) && (node.value.node_type === "value" || node.value.node_type === "access");
 		if (returns_borrowed_string) {
 			const access = node.value.access;
 			if (access.node_type === "access_func") {
@@ -34128,16 +34145,17 @@ function build_return_node(node, status, nir_value) {
 			}
 		}
 		const returns_string_zero = ret_type.name === "string" && !ret_type.is_view && !ret_type.is_array && node.value.node_type === "value" && (node.value.value === "0" || node.value.value === "null");
-		if (!returns_string_zero && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `nomen_str_dup(`;
+		if (!returns_string_zero && !returns_view_value && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `nomen_str_dup(`;
 		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 += `({ nomen_string _p = `;
 		if (returns_string_zero) status.code += `(nomen_string){0,0}`;
+		else if (returns_view_value) c_materialize_view_string(node.value, status);
 		else emit_return_value(node.value, nir_value, status);
 		if (wrap_view_string_return) status.code += `; nomen_view _v = { (void*)_p.ptr, _p.len }; _v; })`;
-		if (!returns_string_zero && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `)`;
+		if (!returns_string_zero && !returns_view_value && (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");
 		reclaim_all_c_scopes(status);
@@ -35329,6 +35347,17 @@ function build_access_node(node, status) {
 					status.code += `]`;
 					return;
 				}
+				if (access_func.name === "slice" && target_type.name === "string" && access_func.params.length === 2) {
+					const tmp = `_vsl_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+					status.code += `({ nomen_view ${tmp} = `;
+					build_node(node.target, status);
+					status.code += `; long _s = `;
+					build_node(access_func.params[0], status);
+					status.code += `; nomen_view _r; _r.ptr = (void*)((char*)${tmp}.ptr + _s); _r.len = (long)(`;
+					build_node(access_func.params[1], status);
+					status.code += ` - _s); _r; })`;
+					return;
+				}
 				if (access_func.name === "to_string" && target_type.name === "string") {
 					const tmp = `_vts_${status.label_counter = (status.label_counter ?? 0) + 1}`;
 					status.code += `({ nomen_view ${tmp} = `;
@@ -35867,9 +35896,15 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			} else {
 				if (lhs_is_string && !rhs_is_bare_value) {
 					const temp = `_reassign_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+					const rhs_is_view = is_view_value(node.right_value, status);
 					status.code += `nomen_string ${temp} = `;
-					emit_rhs_value(node.right_value, nir_rhs, status);
+					if (rhs_is_view) c_materialize_view_string(node.right_value, status);
+					else emit_rhs_value(node.right_value, nir_rhs, status);
 					status.code += `;\nfree(${lhs_name}.ptr);\n${lhs_name} = ${temp};\n`;
+					if (rhs_is_view) {
+						if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+						status.heap_strings.add(lhs_name);
+					}
 					return;
 				}
 				status.code += `free(${lhs_name}.ptr);\n`;
@@ -35883,6 +35918,13 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			if (rhs_is_bare_value) {
 				if (lhs_is_class) {
 					if (!node.swap) splice_decl_from_c_scopes(status, rhs.value);
+				} else if (lhs_is_string && !node.swap && rhs.node_type === "value" && is_view_value(rhs, status)) {
+					status.code += `${lhs_name} = `;
+					c_materialize_view_string(rhs, status);
+					status.code += `;\n`;
+					if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+					status.heap_strings.add(lhs_name);
+					return;
 				} else if (!node.swap && rhs.is_moved) {
 					const src_name = rhs.value;
 					if (string_var_owns_heap(status, src_name)) {
@@ -40205,6 +40247,15 @@ function evaluate_operation(op, status) {
 				}
 				if (op.op === "<=" && left_decl?.upper_bound_inclusive_exprs?.length && target_str) {
 					if (left_decl.upper_bound_inclusive_exprs.includes(target_str)) return true;
+					if (left_decl.upper_bound_inclusive_exprs.some((u) => upper_implies(u, target_str))) return true;
+					for (const u of left_decl.upper_bound_inclusive_exprs) {
+						const v = parse_offset_expr(u);
+						if (v && v.offset === 0 && u !== target_str) {
+							const vdecl = status.values.findLast((vv) => vv.name === v.base);
+							if (vdecl?.upper_bound_exprs?.includes(target_str)) return true;
+							if (vdecl?.upper_bound_inclusive_exprs?.includes(target_str)) return true;
+						}
+					}
 				}
 				if (op.op === "<" && left_decl?.upper_bound_inclusive_exprs?.length && target_str && left_decl.upper_bound_inclusive_exprs.includes(target_str)) return "unsafe";
 				if (left_decl?.upper_bound_expr && target_str) {
@@ -40363,7 +40414,7 @@ function evaluate_operation(op, status) {
 				const right_base_name = right_str.split(".")[0];
 				const rdecl = status.values.findLast((v) => v.name === right_base_name);
 				const ra = rdecl?.alias_of ? parse_offset_expr(rdecl.alias_of) : void 0;
-				const right_base = ra ? ra.base : right_str;
+				const right_base = ra && !(right_str === ra.base || ra.offset === 0 && right_str.startsWith(ra.base + ".")) ? ra.base : right_str;
 				const right_off = ra ? ra.offset : 0;
 				if (left_base === right_base) {
 					const d = left_off - right_off;
@@ -40514,6 +40565,7 @@ function is_nonnegative_access(node, status) {
 			if (m) {
 				const field_path = m[1];
 				const offset_str = m[2];
+				if (!field_path.includes(".")) return false;
 				const last = field_path.split(".").at(-1);
 				if (last && NON_NEGATIVE_FIELDS.has(last)) {
 					if (!offset_str) return true;
@@ -40721,6 +40773,30 @@ function materialize_type(type, status) {
 //#endregion
 //#region ../src/check/utils/view_fields.ts
 /**
+* Whether the named struct (or any value struct embedded in its fields,
+* recursively) declares a `view T` field. A struct with view fields carries
+* non-owning borrows inside its bytes, which drives the borrow rules:
+* copies are sound (a pair copy aliases nothing owned), but escapes
+* (returning, outer-scope assignment) are checked against where those
+* borrows were taken.
+*/
+function struct_has_view_fields(type_name, status) {
+	if (!type_name) return false;
+	const struct = status.structs.find((s) => s.name === type_name && !s.is_simple_type);
+	return !!struct && has_view_fields(struct, status, /* @__PURE__ */ new Set());
+}
+function has_view_fields(struct, status, visited) {
+	if (visited.has(struct.name)) return false;
+	visited.add(struct.name);
+	for (const field of struct.fields) {
+		if (field.type.is_view) return true;
+		if (field.type.is_ref || field.type.is_array) continue;
+		const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class);
+		if (field_struct && has_view_fields(field_struct, status, visited)) return true;
+	}
+	return false;
+}
+/**
 * The root variable an access chain bottoms out at (`line.text` → "line",
 * `a.b.c` → "a", bare `x` → "x"). Returns undefined when the chain does not
 * bottom out in a plain name (e.g. a call receiver).
@@ -40842,6 +40918,23 @@ function view_borrows_root_at_self(sv) {
 	return !!owners?.size && [...owners].every((o) => o === "self");
 }
 /**
+* Whether a value of this type can carry a non-owning view borrow: the type
+* itself is a `view`, a `ref` (a borrow by definition — keep the existing
+* taint), a struct declaring (transitively) `view T` fields, or a generic
+* instantiation with such an argument. Anything else (primitives, owned
+* strings, containers of owned values) owns its storage outright, so a call
+* producing it does not propagate its view arguments' borrows — tainting it
+* is a false positive (e.g. returning `slice_string(view)` from a function
+* returning owned `string`). Callers pass an unset/unknown type through as
+* carrying, preserving today's behavior where nothing is known.
+*/
+function type_can_carry_view_borrow(type, status) {
+	if (!type || !type.name) return true;
+	if (type.is_view || type.is_ref) return true;
+	if (struct_has_view_fields(type.name, status)) return true;
+	return (type.type_args ?? []).some((t) => type_can_carry_view_borrow(t, status));
+}
+/**
 * Whether reading view fields of `root` is currently rejected because their
 * source was mutated (reassigned / ref-mutated).
 */
@@ -40966,7 +41059,7 @@ function check_declaration_node(decl, status) {
 			if (type_from_value_node(decl.value, status)?.is_const_ref) decl.type.is_const_ref = true;
 		}
 		let view_borrows;
-		if (decl.value?.node_type === "func_call") {
+		if (decl.value?.node_type === "func_call" && type_can_carry_view_borrow(decl.type, status)) {
 			view_borrows = ctor_call_view_borrow(decl.value, status);
 			if (view_borrows?.size) for (const [, info] of view_borrows) {
 				const depth = info.depth ?? status.scope_depth;
@@ -43887,7 +43980,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 				lower_bound_inclusive_exprs = decl.lower_bound_inclusive_exprs;
 				upper_bound_expr = decl.upper_bound_expr;
 				lower_bound_expr = decl.lower_bound_expr;
-				alias_of = decl.alias_of;
+				alias_of = decl.alias_of ?? expr_to_string(param, status);
 			}
 		} else if (param.node_type === "op") {
 			const pop = param;
@@ -43981,12 +44074,24 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			});
 			if (self_value && self_value !== "?") {
 				const self_type = target_type || func.params[0]?.type;
+				const self_path_or_value = self_path ?? self_value;
+				const self_base = status.values.findLast((v) => v.name === self_path_or_value.split(".")[0]);
 				status.values.push({
 					declaration: "const",
 					name: "self",
 					type: self_type,
 					is_set: true,
-					alias_of: self_path ?? self_value
+					alias_of: self_path_or_value,
+					range_lower: self_base?.range_lower,
+					range_upper: self_base?.range_upper,
+					upper_bound_exprs: self_base?.upper_bound_exprs?.slice(),
+					lower_bound_exprs: self_base?.lower_bound_exprs?.slice(),
+					upper_bound_inclusive_exprs: self_base?.upper_bound_inclusive_exprs?.slice(),
+					lower_bound_inclusive_exprs: self_base?.lower_bound_inclusive_exprs?.slice(),
+					upper_bound_expr: self_base?.upper_bound_expr,
+					lower_bound_expr: self_base?.lower_bound_expr,
+					known_length: self_base?.known_length,
+					path_bounds: self_base?.path_bounds
 				});
 			}
 			const satisfied = evaluate_const_condition(func_param.constraint, status);
@@ -45160,7 +45265,7 @@ function check_assignment_node(assign, status) {
 			const src_name = value_from_value_node(assign.right_value);
 			const src_sv = assign.right_value.node_type === "value" ? status.values.findLast((v) => v.name === src_name) : void 0;
 			if (src_sv?.has_view_borrows) propagate_view_borrows(left_value, src_sv);
-		} else if (assign.right_value.node_type === "func_call" && type_from_value_node(assign.right_value, status)?.name) {
+		} else if (assign.right_value.node_type === "func_call" && type_from_value_node(assign.right_value, status)?.name && type_can_carry_view_borrow(type_from_value_node(assign.right_value, status), status)) {
 			const infos = ctor_call_view_borrow(assign.right_value, status);
 			if (infos?.size) {
 				for (const [, info] of infos) {
@@ -46002,7 +46107,7 @@ function check_return_node(ret, status) {
 			if (!safe_view_from_self && !explicit_mov) add_error(status, `cannot return a borrowed reference — use 'move' (with swap) to transfer ownership`, ret.value.start);
 		}
 	} else if (func && ret.value.node_type === "func_call") {
-		const infos = ctor_call_view_borrow(ret.value, status);
+		const infos = type_can_carry_view_borrow(ret.type, status) ? ctor_call_view_borrow(ret.value, status) : void 0;
 		if (infos?.size && ![...infos.keys()].every((o) => o === "self")) add_error(status, `cannot return '${ret.type.name}' — its 'view' field(s) borrow from this scope`, ret.value.start);
 	}
 	if (func) {
@@ -49276,6 +49381,14 @@ function project_root_for(input_path) {
 function build_dir_for(input_path, is_test) {
 	return is_test ? path.join(project_root_for(input_path), "build", "test") : path.join(project_root_for(input_path), "build");
 }
+/**
+* The linked binary path for `input_path`: an explicit `--out` wins,
+* otherwise `<build dir>/<entry basename>`.
+*/
+function outfile_for(input_path, is_test, out) {
+	if (out) return path.resolve(out);
+	return path.join(build_dir_for(input_path, is_test), path.basename(input_path, ".nm"));
+}
 //#endregion
 //#region src/test.ts
 const RECORD_PREFIX = "\\nomen|";
@@ -49746,6 +49859,7 @@ try {
 		if (args.audit_runtime) config.audit_runtime = args.audit_runtime;
 		if (args.release) config.release = args.release;
 		if (args.fast_math) config.fast_math = args.fast_math;
+		if (args.out) config.out = args.out;
 		if (fs.lstatSync(args.in).isDirectory()) {
 			if (args.watch) watchPath(args.in, config, mode, args.program_args);
 			else processFolder(args.in, config, mode, args.program_args);
@@ -49872,7 +49986,8 @@ function processFile(filename, config, mode, program_args) {
 	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const headerfile = path.join(buildDir, "main.h");
 	const codefile = path.join(buildDir, basename + ext);
-	const outfile = path.join(buildDir, basename);
+	const outfile = outfile_for(resolved_path, filename.endsWith(".test.nm"), config.out);
+	if (!fs.existsSync(path.dirname(outfile))) fs.mkdirSync(path.dirname(outfile), { recursive: true });
 	fs.writeFileSync(headerfile, result.headers);
 	fs.writeFileSync(codefile, result.code);
 	let companionfile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nomen-lang",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "The CLI for the Nomen programming language.",
   "keywords": [],
   "license": "ISC",

package/src/index.ts

@@ -14,7 +14,7 @@ import { parse_args, print_help, type Args } from "./args.ts";
 import { run_docs } from "./docs.ts";
 import render_errors, { render_warnings } from "./format_errors.ts";
 import { find_bundled, run_init } from "./init.ts";
-import { build_dir_for } from "./paths.ts";
+import { build_dir_for, outfile_for } from "./paths.ts";
 import { runTests } from "./test.ts";
 import type Config from "./types/Config.ts";
 
@@ -170,6 +170,7 @@ try {
 		if (args.audit_runtime) config.audit_runtime = args.audit_runtime;
 		if (args.release) config.release = args.release;
 		if (args.fast_math) config.fast_math = args.fast_math;
+		if (args.out) config.out = args.out;
 
 		// Is the --in path a folder
 		if (fs.lstatSync(args.in).isDirectory()) {
@@ -370,7 +371,8 @@ function processFile(filename: string, config: Config, mode: Mode, program_args:
 	}
 
 	const basename = path.basename(filename, ".nm");
-	// Output lives in the project's `build/` — `build/test` for *.test.nm.
+	// Output lives in the project's `build/` — `build/test` for *.test.nm —
+	// unless an explicit --out names the linked binary.
 	const buildDir = build_dir_for(resolved_path, filename.endsWith(".test.nm"));
 	if (!fs.existsSync(buildDir)) {
 		fs.mkdirSync(buildDir, { recursive: true });
@@ -378,7 +380,10 @@ function processFile(filename: string, config: Config, mode: Mode, program_args:
 	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const headerfile = path.join(buildDir, "main.h");
 	const codefile = path.join(buildDir, basename + ext);
-	const outfile = path.join(buildDir, basename);
+	const outfile = outfile_for(resolved_path, filename.endsWith(".test.nm"), config.out);
+	if (!fs.existsSync(path.dirname(outfile))) {
+		fs.mkdirSync(path.dirname(outfile), { recursive: true });
+	}
 	fs.writeFileSync(headerfile, result.headers);
 	fs.writeFileSync(codefile, result.code);
 

package/src/paths.ts

@@ -26,3 +26,12 @@ export function build_dir_for(input_path: string, is_test: boolean): string {
 		? path.join(project_root_for(input_path), "build", "test")
 		: path.join(project_root_for(input_path), "build");
 }
+
+/**
+ * The linked binary path for `input_path`: an explicit `--out` wins,
+ * otherwise `<build dir>/<entry basename>`.
+ */
+export function outfile_for(input_path: string, is_test: boolean, out?: string): string {
+	if (out) return path.resolve(out);
+	return path.join(build_dir_for(input_path, is_test), path.basename(input_path, ".nm"));
+}

package/src/types/Config.ts

@@ -6,4 +6,5 @@ export default interface Config {
 	audit_runtime?: string;
 	release?: boolean;
 	fast_math?: boolean;
+	out?: string;
 }