nomen-lang 0.6.1 → 0.6.3

package/package.json

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

package/src/index.ts

@@ -310,9 +310,7 @@ function processFolder(folder: string, config: Config, mode: Mode, program_args:
 	let dirent;
 	while ((dirent = dir.readSync()) !== null) {
 		if (shouldProcessFile(dirent.name)) {
-			// Folder mode checks each file in its own context — anchoring
-			// here would recompile the whole project once per file.
-			processFile(path.join(folder, dirent.name), config, mode, program_args, false);
+			processFile(path.join(folder, dirent.name), config, mode, program_args);
 			// @ts-ignore
 			let _ = fs.watch;
 		}
@@ -324,46 +322,7 @@ function shouldProcessFile(filename: string) {
 	return path.extname(filename) === SUPPORTED_EXTENSION;
 }
 
-/**
- * The project's entry file for `file_path`: walk up to the nearest
- * `package.jsonc` and resolve its `entry` field, so any file inside a project
- * is checked with the entry's import context (`import types` resolves
- * against the project's `src/`, not the file's own folder). Returns
- * undefined when the file is standalone, IS the entry, sits in an
- * entry-less project (e.g. a library checkout), or the config is malformed.
- */
-function project_entry_for(file_path: string): string | undefined {
-	let dir = path.dirname(file_path);
-	for (let i = 0; i < 20; i++) {
-		const config_path = path.join(dir, "package.jsonc");
-		if (fs.existsSync(config_path)) {
-			try {
-				const raw = fs.readFileSync(config_path, "utf8");
-				const json = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-				const parsed = JSON.parse(json);
-				if (parsed.entry) {
-					const entry = path.resolve(dir, parsed.entry);
-					if (entry !== file_path && fs.existsSync(entry)) return entry;
-				}
-			} catch {
-				// malformed config — keep the file's own context
-			}
-			return undefined;
-		}
-		const parent = path.dirname(dir);
-		if (parent === dir) return undefined;
-		dir = parent;
-	}
-	return undefined;
-}
-
-function processFile(
-	filename: string,
-	config: Config,
-	mode: Mode,
-	program_args: string[],
-	anchor_to_project = true,
-) {
+function processFile(filename: string, config: Config, mode: Mode, program_args: string[]) {
 	console.log("Processing", filename);
 
 	const arch = config.arch || "aarch64";
@@ -374,22 +333,15 @@ function processFile(
 		config.lib = resolve_lib(resolved);
 	}
 
-	// A `*.test.nm` file keeps its own join context: the test harness
-	// anchors at the test's folder and pulls the program's `src/` module in
-	// with `main` stripped, which the entry's context would not do.
-	const anchor =
-		anchor_to_project && !resolved.endsWith(".test.nm")
-			? (project_entry_for(resolved) ?? resolved)
-			: resolved;
-	if (anchor !== resolved) {
-		console.log("Anchored to project entry", anchor);
-	}
-
 	let startTime = performance.now();
 
-	const input = join(anchor, config.lib);
+	// Compile the file the user named (or the discovered entry). `join`
+	// resolves its imports relative to its own folder and gathers the
+	// project's module declarations, so an explicitly-passed `--in` is never
+	// silently replaced by the `package.jsonc` `entry`.
+	const input = join(resolved, config.lib);
 	const library = config.lib ? get_library(config.lib) : undefined;
-	const parsed = parse(input, library, anchor);
+	const parsed = parse(input, library, resolved);
 
 	let errors = parsed.errors;
 

package/src/init.ts

@@ -63,13 +63,22 @@ nomen test
 `;
 }
 
-// Resolve a bundled asset (core/ or NOMEN_AGENTS.md) shipped alongside the
+// Resolve a bundled asset (core/, n/ or NOMEN_AGENTS.md) shipped alongside the
 // CLI. In the published package these sit next to dist/; in the dev tree they
-// live one level up (the repo root), so check both.
+// live one level up (the repo root), so check both. In the dev tree the
+// REPO's live copy wins — a stale `cli/core` bundle left by an old
+// `pnpm build` must not shadow the current `core/` (a silent-wrong-library
+// tar pit; see FOLLOWUP.md, "Stale cli/core asset copy"). In a published
+// install (running from node_modules) the shipped copy wins, so a consumer
+// project's sibling `core/` directory is never picked up.
 export function find_bundled(filename: string): string | undefined {
 	const here = path.dirname(fileURLToPath(import.meta.url));
 	const cli_root = path.dirname(here);
-	const candidates = [path.join(cli_root, filename), path.join(cli_root, "..", filename)];
+	const repo_root = path.join(cli_root, "..");
+	const dev_tree = !cli_root.includes("node_modules");
+	const candidates = dev_tree
+		? [path.join(repo_root, filename), path.join(cli_root, filename)]
+		: [path.join(cli_root, filename), path.join(repo_root, filename)];
 	for (const c of candidates) {
 		if (fs.existsSync(c)) return path.resolve(c);
 	}

package/src/test.ts

@@ -37,9 +37,18 @@ export interface TestFileResult {
 	fails: FailRecord[];
 	benches: BenchRecord[];
 	other: string[];
+	// "LEAK: N allocation(s)" lines the audits runtime printed at exit. Empty
+	// unless the file was run with --audit; a non-empty list fails the file.
+	leaks: string[];
 	// Set when the compiled binary crashed before finishing (e.g. a segfault
 	// in a test). We still surface whatever records it managed to emit.
 	crashed?: string;
+	/**
+	 * The pipeline stage that produced `crashed`, so the report can name it
+	 * accurately — a binary that BUILT fine and then segfaulted before
+	 * emitting any record is not a build failure (see report_file).
+	 */
+	phase?: "parse" | "build" | "setup" | "link" | "run";
 	ms: number;
 }
 
@@ -251,6 +260,14 @@ export function parse_records(stdout: string): RunRecord {
 	return { tests, fails, benches, other };
 }
 
+/** Pull the exit-time audit "LEAK: N allocation(s)" lines out of stdout. */
+export function extract_leaks(stdout: string): string[] {
+	return stdout
+		.split("\n")
+		.map((l) => l.trim())
+		.filter((l) => l.startsWith("LEAK:"));
+}
+
 /**
  * Compile one `*.test.nm` file (with the generated harness) and run it,
  * returning its parsed records and any crash info.
@@ -275,6 +292,7 @@ export function run_test_file(
 		fails: [],
 		benches: [],
 		other: [],
+		leaks: [],
 		ms: 0,
 	};
 
@@ -289,6 +307,7 @@ export function run_test_file(
 	const parsed = parse(source, library, resolved);
 	if (parsed.errors.length) {
 		result.ok = false;
+		result.phase = "parse";
 		result.crashed = parsed.errors
 			.map((e) => `${e.message} (${e.line ?? "?"}:${e.column ?? "?"})`)
 			.join("\n");
@@ -302,6 +321,7 @@ export function run_test_file(
 	});
 	if (buildResult.errors && buildResult.errors.length) {
 		result.ok = false;
+		result.phase = "build";
 		result.crashed = buildResult.errors
 			.map((e) => `${e.message} (${e.line ?? "?"}:${e.column ?? "?"})`)
 			.join("\n");
@@ -321,6 +341,7 @@ export function run_test_file(
 			: find_audit_runtime(path.dirname(resolved));
 		if (!runtime_src || !fs.existsSync(runtime_src)) {
 			result.ok = false;
+			result.phase = "setup";
 			result.crashed =
 				"Audit enabled but audit_runtime.c was not found. Pass --audit-runtime <path>.";
 			result.ms = performance.now() - start;
@@ -367,6 +388,7 @@ export function run_test_file(
 	} catch (err: any) {
 		const stderr = err.stderr ? err.stderr.toString() : (err.message ?? "");
 		result.ok = false;
+		result.phase = "link";
 		result.crashed = `link failed: ${stderr.trim() || "clang error"}`;
 		result.ms = performance.now() - start;
 		return result;
@@ -398,10 +420,21 @@ export function run_test_file(
 	result.fails = records.fails;
 	result.benches = records.benches;
 	result.other = records.other;
+	// Under --audit the exit-time audit check prints "LEAK: N allocation(s)"
+	// to stdout when the malloc/free balance is nonzero. Treat any such line
+	// as a failure so a leaked test file cannot stay green.
+	result.leaks = audit ? extract_leaks(runStdout) : [];
+	// Leak lines are surfaced explicitly above; drop them from the generic
+	// stdout dump so they are not printed twice.
+	if (result.leaks.length) {
+		result.other = result.other.filter((l) => !l.trim().startsWith("LEAK:"));
+	}
 	result.crashed = crashed;
-	// A file "passes" when it reported no failed asserts and didn't crash.
+	if (crashed) result.phase = "run";
+	// A file "passes" when it reported no failed asserts, didn't crash, and
+	// (under --audit) leaked nothing.
 	const failed = result.fails.length > 0 || result.tests.some((t) => t.failed > 0);
-	result.ok = !failed && crashed === undefined;
+	result.ok = !failed && crashed === undefined && result.leaks.length === 0;
 
 	result.ms = performance.now() - start;
 	return result;
@@ -435,7 +468,18 @@ const C = {
 export function report_file(result: TestFileResult): void {
 	const rel = path.relative(process.cwd(), result.file);
 	if (result.crashed && result.tests.length === 0 && result.fails.length === 0) {
-		console.log(` ${C.red("✗")} ${rel} ${C.red("(failed to build)")}`);
+		// Name the stage that actually failed. A binary that linked fine and
+		// then died before emitting any record (e.g. SIGSEGV) is NOT a build
+		// failure — conflating the two sent debugging to the wrong layer.
+		const label =
+			result.phase === "run"
+				? "(crashed before records)"
+				: result.phase === "link"
+					? "(link failed)"
+					: result.phase === "setup"
+						? "(setup failed)"
+						: "(failed to build)";
+		console.log(` ${C.red("✗")} ${rel} ${C.red(label)}`);
 		console.log(C.red(result.crashed));
 		return;
 	}
@@ -453,6 +497,9 @@ export function report_file(result: TestFileResult): void {
 	for (const f of result.fails) {
 		console.log(`   ${C.red("✗")} ${f.test} ${C.dim(">")} ${f.message}`);
 	}
+	for (const leak of result.leaks) {
+		console.log(`   ${C.yellow("⚠")} ${C.yellow(leak)}`);
+	}
 	for (const b of result.benches) {
 		console.log(
 			`   ${C.cyan("⏱")} ${b.label} ${C.dim(`(n=${b.n})`)} ` +
@@ -518,6 +565,7 @@ export function runTests(root: string, options: RunTestsOptions = {}): boolean {
 	const totalTests = results.reduce((a, r) => a + r.tests.length, 0);
 	const totalFailed = results.reduce((a, r) => a + r.tests.reduce((x, t) => x + t.failed, 0), 0);
 	const totalPassed = totalTests - totalFailed;
+	const totalLeaks = results.reduce((a, r) => a + r.leaks.length, 0);
 	const anyFailed = results.some((r) => !r.ok);
 
 	console.log("");
@@ -534,6 +582,12 @@ export function runTests(root: string, options: RunTestsOptions = {}): boolean {
 			(totalFailed ? ` ${C.dim("|")} ${C.red(`${totalFailed} failed`)}` : "") +
 			C.dim(` (${totalTests})`),
 	);
+	if (totalLeaks) {
+		console.log(
+			` ${C.dim("Leaks ")} ${C.yellow(`${totalLeaks} reported`)}` +
+				C.dim(" (--audit; leaked files count as failures)"),
+		);
+	}
 	console.log(` ${C.dim(" Time ")} ${format_duration(elapsed)}`);
 	console.log("");