nomen-lang 0.6.7 → 0.6.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nomen-lang",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "The CLI for the Nomen programming language.",
   "keywords": [],
   "license": "ISC",
@@ -17,7 +17,8 @@
     "dist",
     "src",
     "core",
-    "NOMEN_AGENTS.md"
+    "NOMEN_AGENTS.md",
+    "audit_runtime.c"
   ],
   "type": "module",
   "devDependencies": {

package/src/args.ts

@@ -13,6 +13,8 @@ export interface Args {
 	audit_runtime?: string;
 	check: boolean;
 	release: boolean;
+	/** `nomen test` concurrency (max test files in flight); default = CPU count. */
+	jobs?: string;
 	/** Opt in to FP reassociation: float reductions vectorize under NEON
 	 *  (results may differ in the last ulp vs the scalar loop). */
 	fast_math: boolean;
@@ -39,6 +41,8 @@ const STRING_OPTIONS: Map<string, string> = new Map([
 	["lib", "lib"],
 	["l", "lib"],
 	["audit-runtime", "audit_runtime"],
+	["jobs", "jobs"],
+	["j", "jobs"],
 ]);
 
 const BOOLEAN_OPTIONS: Map<string, string> = new Map([
@@ -160,7 +164,7 @@ export function print_help(): void {
 			"  nomen check --in [file/folder]    Parse and check only",
 			"  nomen format [--in folder]        Reformat every .nm file",
 			"  nomen docs [--in file]            Generate markdown documentation",
-			"  nomen test [--in folder]          Discover and run *.test.nm files",
+			"  nomen test [--in folder]          Discover and run *.test.nm files (binary CWD = --in folder)",
 			"  nomen init <name>                 Scaffold a new project in ./<name>",
 			"  nomen lib-path                    Print the bundled System library path",
 			"",
@@ -174,8 +178,9 @@ export function print_help(): void {
 			"  --platform, -p <name>   Target platform: macos, ios, linux, android, windows, web",
 			"  --lib, -l <path>        Path to System library directory (containing package.jsonc)",
 			"  --audit                 Audit the generated program for memory issues",
-			"  --audit-runtime <path>  Path to audit_runtime.c, linked in when --audit is set",
-			"  --release, -r           Build with optimizations (clang -O2; asm passes on aarch64)",
+			"  --audit-runtime <path>  Path to audit_runtime.c (default: auto-discovered — walk-up or the CLI-bundled copy)",
+			"  --jobs, -j <n>          For `nomen test`: max test files run in parallel (default: CPU count)",
+			"  --release, -r           Build with optimizations (clang -O2; aarch64 asm cleanup passes)",
 			"  --fast-math             Allow FP reassociation (float loop reductions vectorize on aarch64)",
 			"  --check                 For `nomen format`: report files that would change",
 			"  -h, --help              Show this help",

package/src/index.ts

@@ -13,7 +13,7 @@ import parse from "../../src/parse.ts";
 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 { find_bundled, find_bundled_audit_runtime, run_init } from "./init.ts";
 import { build_dir_for, outfile_for } from "./paths.ts";
 import { runTests } from "./test.ts";
 import type Config from "./types/Config.ts";
@@ -104,11 +104,13 @@ try {
 		const root = args.in ?? process.cwd();
 		const filter = args.filter ? new RegExp(args.filter) : undefined;
 		const arch = args.arch ?? "aarch64";
-		const ok = runTests(root, {
+		const ok = await runTests(root, {
 			arch,
 			filter,
 			audit: args.audit,
 			audit_runtime: args.audit_runtime,
+			release: args.release,
+			jobs: args.jobs !== undefined ? parseInt(args.jobs, 10) : undefined,
 		});
 		process.exit(ok ? 0 : 1);
 	}
@@ -282,7 +284,10 @@ function resolve_audit_runtime(config: Config, input_path: string): string | und
 		if (parent === dir) break;
 		dir = parent;
 	}
-	return undefined;
+	// Neither the config nor the walk-up found it: fall back to the runtime
+	// bundled with the CLI (live repo copy in the dev tree, shipped copy when
+	// published) so `--audit` works outside the nomen checkout with no flag.
+	return find_bundled_audit_runtime();
 }
 
 function compile_audit_runtime(config: Config, input_path: string, buildDir: string): string {

package/src/init.ts

@@ -85,6 +85,16 @@ export function find_bundled(filename: string): string | undefined {
 	return undefined;
 }
 
+// The audit runtime for `--audit` builds: the dev tree's LIVE copy
+// (repo_root/src/audit_runtime.c — a stale bundled snapshot must not shadow
+// it, same posture as the cli/core rule above), else the copy shipped at the
+// package root by `scripts/bundle-assets.mjs` in a published install. Lets
+// `nomen test/run --audit` work outside the nomen checkout with no
+// --audit-runtime flag.
+export function find_bundled_audit_runtime(): string | undefined {
+	return find_bundled("src/audit_runtime.c") ?? find_bundled("audit_runtime.c");
+}
+
 /**
  * `nomen init <name>`: scaffold a new project under `./<name>` with a sensible
  * starting layout (package.jsonc, src/main.nm, a starter test, README and an

package/src/test.ts

@@ -1,17 +1,26 @@
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
 
 import build, { default_platform } from "../../src/build.ts";
 import join from "../../src/join.ts";
 import { get_library } from "../../src/lib.ts";
 import parse from "../../src/parse.ts";
-import { find_bundled } from "./init.ts";
+import { find_bundled, find_bundled_audit_runtime } from "./init.ts";
 import { build_dir_for } from "./paths.ts";
 
 const RECORD_PREFIX = "\\nomen|";
 
+// Promise-returning `execFile`: `nomen test` builds and runs each `*.test.nm`
+// file in its own build folder and its own process, so the (latency-bound)
+// clang/link/run subprocesses overlap across files instead of serializing.
+// A rejected error carries the same `.stdout` / `.stderr` / `.signal` /
+// `.code` fields the previous synchronous `execFileSync` catch sites read.
+const execFile_async = promisify(execFile);
+
 // A discovered test function: `pub func <name> = (ref Tester t)`.
 export interface TestFunction {
 	name: string;
@@ -272,13 +281,15 @@ export function extract_leaks(stdout: string): string[] {
  * Compile one `*.test.nm` file (with the generated harness) and run it,
  * returning its parsed records and any crash info.
  */
-export function run_test_file(
+export async function run_test_file(
 	entry_path: string,
 	lib_path: string | undefined,
 	arch: string,
 	audit = false,
 	audit_runtime?: string,
-): TestFileResult {
+	release = false,
+	cwd?: string,
+): Promise<TestFileResult> {
 	const start = performance.now();
 	const source_text = fs.readFileSync(entry_path, "utf8");
 	const tests = extract_test_functions(source_text);
@@ -318,6 +329,7 @@ export function run_test_file(
 	const buildResult = build(parsed.root, {
 		arch: arch as "aarch64" | "c",
 		audit,
+		optimize: release,
 	});
 	if (buildResult.errors && buildResult.errors.length) {
 		result.ok = false;
@@ -336,9 +348,13 @@ export function run_test_file(
 	// "LEAK: N allocation(s)" when the balance is nonzero.
 	let audit_obj: string | undefined;
 	if (audit) {
+		// Explicit flag wins; else walk up from the test file (a nomen
+		// checkout's src/audit_runtime.c); else the runtime bundled with the
+		// CLI (live repo copy in the dev tree, shipped copy when published)
+		// so `--audit` works outside the nomen checkout with no flag.
 		const runtime_src = audit_runtime
 			? path.resolve(audit_runtime)
-			: find_audit_runtime(path.dirname(resolved));
+			: (find_audit_runtime(path.dirname(resolved)) ?? find_bundled_audit_runtime());
 		if (!runtime_src || !fs.existsSync(runtime_src)) {
 			result.ok = false;
 			result.phase = "setup";
@@ -348,7 +364,7 @@ export function run_test_file(
 			return result;
 		}
 		audit_obj = path.join(buildDir, "audit_runtime.o");
-		execFileSync("clang", ["-c", runtime_src, "-o", audit_obj]);
+		await execFile_async("clang", ["-c", runtime_src, "-o", audit_obj]);
 	}
 	const platform = default_platform();
 	// Match the run/build command's emission: ObjC-bearing sources (GUI code
@@ -363,11 +379,28 @@ export function run_test_file(
 	fs.writeFileSync(path.join(buildDir, "main.h"), buildResult.headers ?? "");
 	fs.writeFileSync(codefile, buildResult.code);
 
+	// Companion C (raw-block functions + the pool/fiber/file-scope C infra):
+	// `run`/`build` compile and link it next to the main TU. The aarch64 .s
+	// references its symbols via `bl` (spawn machinery), so dropping it makes
+	// companion-bearing test files fail to link. Same .m/.c rule as the
+	// run/build command's companion emission.
+	let companionfile: string | undefined;
+	if (buildResult.companion) {
+		const comp_ext = platform === "macos" || platform === "ios" ? ".m" : ".c";
+		companionfile = path.join(buildDir, path.basename(entry_path, ".nm") + "_companion" + comp_ext);
+		fs.writeFileSync(companionfile, buildResult.companion);
+	}
+
 	// Link the harness binary. Frameworks are passed on Apple platforms for
 	// the same reason as the run/build command: the joined source may reference
 	// ObjC runtime symbols even when the test body doesn't, and unused
-	// frameworks cost nothing at link time.
+	// frameworks cost nothing at link time. Release mode compiles the C (and
+	// companion C) with -O2, matching the run/build command; the aarch64 .s is
+	// assembled verbatim — its optimizations are the passes enabled via
+	// `optimize` above.
 	const link_args = ["-o", outfile, codefile];
+	if (companionfile) link_args.push(companionfile);
+	if (release) link_args.unshift("-O2");
 	if (audit_obj) link_args.push(audit_obj);
 	if (platform === "macos" || platform === "ios") {
 		link_args.push(
@@ -381,10 +414,7 @@ export function run_test_file(
 		);
 	}
 	try {
-		execFileSync("clang", link_args, {
-			encoding: "utf8",
-			stdio: ["ignore", "pipe", "pipe"],
-		});
+		await execFile_async("clang", link_args, { encoding: "utf8" });
 	} catch (err: any) {
 		const stderr = err.stderr ? err.stderr.toString() : (err.message ?? "");
 		result.ok = false;
@@ -396,16 +426,21 @@ export function run_test_file(
 
 	// Run the binary and collect the records it streams over stdout. A
 	// non-zero exit (crash, abort) still surfaces whatever records were
-	// emitted before the crash; a timeout is treated as a crash.
+	// emitted before the crash; a timeout is treated as a crash. The
+	// documented CWD contract: the binary runs in the `--in` root (the
+	// folder `nomen test` scanned for *.test.nm files), so fixture paths in
+	// tests resolve against that folder regardless of where the CLI was
+	// invoked from.
 	let runStdout = "";
 	let crashed: string | undefined;
 	try {
-		runStdout = execFileSync(outfile, [], {
+		const run = await execFile_async(outfile, [], {
 			encoding: "utf8",
-			stdio: ["ignore", "pipe", "pipe"],
 			timeout: 30_000,
 			maxBuffer: 16 * 1024 * 1024,
+			cwd: cwd ?? process.cwd(),
 		});
+		runStdout = run.stdout;
 	} catch (err: any) {
 		runStdout = err.stdout ? err.stdout.toString() : "";
 		if (err.signal === "SIGTERM") {
@@ -519,12 +554,28 @@ export interface RunTestsOptions {
 	filter?: RegExp;
 	audit?: boolean;
 	audit_runtime?: string;
+	release?: boolean;
+	/**
+	 * Maximum test files built and run concurrently. Each file compiles into
+	 * its own build folder and runs in its own process, so the latency-bound
+	 * clang/link/run steps overlap across files. Defaults to the machine's
+	 * available parallelism; 1 forces the historical sequential order.
+	 */
+	jobs?: number;
+}
+
+/** The default concurrency for `runTests` when no `jobs` is given. */
+export function default_jobs(): number {
+	const n =
+		typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
+	return Math.max(1, n);
 }
 
 /**
  * Locate audit_runtime.c for an audited test build: an explicit path wins,
  * otherwise walk up from `dir` looking for a `src/audit_runtime.c` (the same
- * convention the run/build commands use).
+ * convention the run/build commands use). When both miss, the caller falls
+ * back to the CLI-bundled runtime (`find_bundled_audit_runtime`).
  */
 function find_audit_runtime(dir: string): string | undefined {
 	let cur = dir;
@@ -539,7 +590,7 @@ function find_audit_runtime(dir: string): string | undefined {
 }
 
 /** Discover, run, and report every `*.test.nm` under `root`. */
-export function runTests(root: string, options: RunTestsOptions = {}): boolean {
+export async function runTests(root: string, options: RunTestsOptions = {}): Promise<boolean> {
 	const arch = options.arch ?? "aarch64";
 	const lib = resolve_lib_for(root);
 	const files = collect_test_files(root).filter((f) => !options.filter || options.filter.test(f));
@@ -547,13 +598,37 @@ export function runTests(root: string, options: RunTestsOptions = {}): boolean {
 	console.log(`Found ${files.length} test file(s)\n`);
 
 	const startTime = performance.now();
-
-	const results: TestFileResult[] = [];
-	for (const file of files) {
-		const result = run_test_file(file, lib, arch, options.audit, options.audit_runtime);
-		report_file(result);
-		results.push(result);
-	}
+	// The CWD contract: test binaries run in the --in root, so relative
+	// fixture paths resolve there no matter where the CLI was invoked from.
+	const binary_cwd = path.resolve(root);
+
+	// Bounded-concurrency pool: at most `jobs` files are in flight. The
+	// parse/build halves are synchronous (no internal awaits), so they run
+	// atomically on the main thread between the subprocess awaits — the
+	// compiler's in-process state never interleaves. Results are collected by
+	// file INDEX and reported after the pool drains, so the report stays in
+	// discovery order regardless of completion order (and stdout isn't
+	// interleaved).
+	const jobs = Math.max(1, Math.min(options.jobs ?? default_jobs(), files.length));
+	const results: TestFileResult[] = new Array(files.length);
+	let next = 0;
+	const worker = async (): Promise<void> => {
+		for (;;) {
+			const i = next++;
+			if (i >= files.length) return;
+			results[i] = await run_test_file(
+				files[i],
+				lib,
+				arch,
+				options.audit,
+				options.audit_runtime,
+				options.release,
+				binary_cwd,
+			);
+		}
+	};
+	await Promise.all(Array.from({ length: jobs }, worker));
+	for (const result of results) report_file(result);
 
 	const elapsed = performance.now() - startTime;
 	const totalFiles = results.length;