@neocompose/cli 0.62.1 → 0.62.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.62.2] - 2026-10-02
+
+- Speed up `neo test` after production edits by sharing one indexed compiler context across specs and omitting the push-only source serialization round trip. Production compilation and whole-graph validation still run.
+- Execute spec files in parallel with up to four CPU workers by default. Configure `test.maxWorkers`, override it with `--maxWorkers <n>`, or use `--runInBand` for serial execution. Workers reuse the prepared project and retain per-test fixture and mock isolation.
+- Report worker startup and elapsed execution separately from summed parallel test work.
+
 ## [0.62.1] - 2026-10-02
 
 - Construct populated unordered member defaults through initializers so fresh entries survive test, push, and pull. Keep nested list rows in their existing representation.

package/README.md

@@ -418,12 +418,26 @@ JavaScript regular expression:
 neo test
 neo test Classes/Player.spec.neo
 neo test -t "TakeDamage"
+neo test --maxWorkers=4
+neo test --runInBand
 neo test --reporter=json --outputFile=.neo/test-results.json
 ```
 
-The JSON output file is written atomically. Human and JSON reports break timing
-into total, test-code, and framework-startup durations; human output also gives
-shared startup its own row instead of charging it to the first test.
+Spec files run in parallel with up to four available CPU workers by default.
+Set `test.maxWorkers` in `neo.json` or override it with `--maxWorkers <positive
+integer>`. `--runInBand` overrides both and runs serially. A single selected
+file runs in the main process. Hooks and tests within each file remain ordered;
+fixtures and mocks stay isolated. Reports keep file and test registration order.
+
+The JSON output file is written atomically. Reports distinguish elapsed startup
+and execution from summed test work, which can exceed elapsed time in parallel
+runs. JSON `timings.workerStartupMs` measures worker initialization and
+`timings.executeMs` measures elapsed execution.
+
+Tests compile and validate the local candidate once. They omit the extra source
+serialization and re-lowering rehearsal used by `neo push --dry-run`; production
+syntax, type checks, and whole-graph validation remain required. Spec compilation
+shares one immutable compiler context and schema index across cache misses.
 
 Test compilation metadata and the experimental verified prepared-project cache
 live in `.neo/test-build/`; neither they nor test files are server records.

package/dist/neo.mjs

@@ -38122,6 +38122,7 @@ var init_args = __esm({
       "generate-ids",
       "help",
       "passWithNoTests",
+      "runInBand",
       "no-verify",
       "fix",
       "yes"
@@ -38173,9 +38174,11 @@ var init_args = __esm({
       "outputFile",
       "output-file",
       "testNamePattern",
+      "maxWorkers",
       "test-timeout",
       "testTimeout",
       "passWithNoTests",
+      "runInBand",
       "no-verify"
     ]);
     TEST_ONLY_FLAGS = /* @__PURE__ */ new Set([
@@ -38183,9 +38186,11 @@ var init_args = __esm({
       "outputFile",
       "output-file",
       "testNamePattern",
+      "maxWorkers",
       "test-timeout",
       "testTimeout",
-      "passWithNoTests"
+      "passWithNoTests",
+      "runInBand"
     ]);
   }
 });
@@ -145290,6 +145295,113 @@ var init_project_integrity = __esm({
   }
 });
 
+// src/test-worker-pool.ts
+import { Worker as Worker5 } from "node:worker_threads";
+var TestWorkerPool;
+var init_test_worker_pool = __esm({
+  "src/test-worker-pool.ts"() {
+    "use strict";
+    TestWorkerPool = class {
+      constructor(workerUrl) {
+        this.workerUrl = workerUrl;
+      }
+      workerUrl;
+      interrupted = false;
+      workers = [];
+      failures = /* @__PURE__ */ new Map();
+      pending = /* @__PURE__ */ new Map();
+      async start(document, count) {
+        await Promise.all(
+          Array.from({ length: count }, async () => {
+            const worker = new Worker5(this.workerUrl);
+            this.workers.push(worker);
+            worker.on(
+              "error",
+              (error) => this.fail(
+                worker,
+                error instanceof Error ? error : new Error(String(error))
+              )
+            );
+            worker.on(
+              "exit",
+              (code) => this.fail(
+                worker,
+                new Error(
+                  `Test worker exited before completing its file (code ${code}).`
+                )
+              )
+            );
+            const response = await this.request(worker, { kind: "init", document });
+            if (response.kind !== "ready")
+              throw new Error("Test worker did not initialize its project.");
+          })
+        );
+      }
+      fail(worker, error) {
+        this.failures.set(worker, error);
+        this.pending.get(worker)?.(error);
+      }
+      request(worker, request) {
+        const failure = this.failures.get(worker);
+        if (failure !== void 0) return Promise.reject(failure);
+        return new Promise((resolve5, reject) => {
+          const cleanup = () => {
+            worker.off("message", onMessage);
+            this.pending.delete(worker);
+          };
+          const onMessage = (response) => {
+            cleanup();
+            if (response.kind === "error") reject(new Error(response.message));
+            else resolve5(response);
+          };
+          const onError = (error) => {
+            cleanup();
+            reject(error);
+          };
+          this.pending.set(worker, onError);
+          worker.once("message", onMessage);
+          try {
+            worker.postMessage(request);
+          } catch (error) {
+            onError(error instanceof Error ? error : new Error(String(error)));
+          }
+        });
+      }
+      async run(jobs, timeoutMs, onResult) {
+        let next = 0;
+        await Promise.all(
+          this.workers.map(async (worker) => {
+            while (!this.interrupted && next < jobs.length) {
+              const job = jobs[next++];
+              const response = await this.request(worker, {
+                kind: "run",
+                ...job,
+                timeoutMs
+              });
+              if (response.kind !== "result")
+                throw new Error("Test worker returned no file result.");
+              onResult(job.spec, response.result);
+            }
+          })
+        );
+      }
+      interrupt() {
+        this.interrupted = true;
+        for (const worker of this.workers) {
+          worker.postMessage({ kind: "interrupt" });
+        }
+      }
+      async stop() {
+        for (const reject of this.pending.values())
+          reject(new Error("Test worker stopped."));
+        await Promise.all(this.workers.map((worker) => worker.terminate()));
+        this.workers.length = 0;
+        this.failures.clear();
+      }
+    };
+  }
+});
+
 // src/neoscript-language-adapter.ts
 function createCliNeoScriptContext(options) {
   const members = [...options.documents.members];
@@ -145299,12 +145411,7 @@ function createCliNeoScriptContext(options) {
     members,
     classes: [...options.documents.classes],
     enums: [...options.documents.enums],
-    interfaces: [...options.documents.interfaces],
-    databaseVM: {
-      memberById: (id2) => members.find(
-        (member) => member.id === id2
-      ) ?? null
-    }
+    interfaces: [...options.documents.interfaces]
   };
   const compilerContext = createNeoScriptDocumentContext({
     vm,
@@ -145346,7 +145453,7 @@ async function validateCliNeoScript(uri, source, context) {
     service.closeDocument(uri);
   }
 }
-function compileCliNeoScript(uri, source, context) {
+function compileCliNeoScript(uri, source, context, projectIndex) {
   const result = compileNeoScriptStrict(
     {
       uri,
@@ -145354,7 +145461,8 @@ function compileCliNeoScript(uri, source, context) {
       version: 1,
       text: source
     },
-    context
+    context,
+    { projectIndex }
   );
   const error = result.diagnostics.find(
     (diagnostic) => diagnostic.severity === "error"
@@ -147354,7 +147462,7 @@ var init_registry2 = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.62.1",
+      cliVersion: "0.62.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -148773,8 +148881,10 @@ var init_registry2 = __esm({
 // src/commands/test.ts
 var test_exports = {};
 __export(test_exports, {
+  executeTestFile: () => executeTestFile,
   inspectNeoTestCompilation: () => inspectNeoTestCompilation,
   maintainNeoTestBuildCache: () => maintainNeoTestBuildCache,
+  prepareTestEvaluator: () => prepareTestEvaluator,
   runTest: () => runTest
 });
 import { createHash as createHash10, randomUUID as randomUUID6 } from "node:crypto";
@@ -148798,6 +148908,7 @@ import {
   resolve as resolve4,
   sep as sep8
 } from "node:path";
+import { availableParallelism } from "node:os";
 import { isDeepStrictEqual } from "node:util";
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -149119,8 +149230,28 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
   );
   return { ...candidate, documentSha256 };
 }
-function compileSpec(workspace, document, absolutePath, projectCompilationHash2) {
-  const scriptDocument = readDocumentArrays(document);
+function createSpecCompiler(document) {
+  const context = withNeoTestPrelude({
+    ...createCliNeoScriptContext({
+      documents: readDocumentArrays(document),
+      kind: "function",
+      thisClass: null
+    }),
+    kind: "function",
+    projectSourceKind: "spec",
+    returnType: { kind: "primitive", name: "void" }
+  });
+  const projectIndex = createProjectIndex(context.project);
+  return (uri, source) => compileCliNeoScript(uri, source, context, projectIndex);
+}
+function lazySpecCompiler(document) {
+  let compiler;
+  return (uri, source) => {
+    compiler ??= createSpecCompiler(document);
+    return compiler(uri, source);
+  };
+}
+function compileSpec(workspace, compile, absolutePath, projectCompilationHash2) {
   const path = relative8(workspace.root, absolutePath).split(sep8).join("/");
   const source = readFileSync19(absolutePath, "utf8");
   const sourceHash = createHash10("sha256").update(source).digest("hex");
@@ -149143,21 +149274,10 @@ function compileSpec(workspace, document, absolutePath, projectCompilationHash2)
     }
   } catch {
   }
-  const baseContext2 = createCliNeoScriptContext({
-    documents: scriptDocument,
-    kind: "function",
-    thisClass: null
-  });
-  const context = withNeoTestPrelude({
-    ...baseContext2,
-    kind: "function",
-    projectSourceKind: "spec",
-    returnType: { kind: "primitive", name: "void" }
-  });
   const compiled = {
     path,
     source,
-    action: compileCliNeoScript(`file://${absolutePath}`, source, context)
+    action: compile(`file://${absolutePath}`, source)
   };
   atomicWrite(
     artifactPath,
@@ -149837,6 +149957,18 @@ function failureFor(error, file, position, member = null) {
 function suiteHasSelectedTests(suite, selected) {
   return suite.tests.some((test) => selected.has(test.id)) || suite.suites.some((child) => suiteHasSelectedTests(child, selected));
 }
+function prepareTestEvaluator(document) {
+  sharedEvaluatorBase(document);
+}
+async function executeTestFile(spec, document, selected, timeoutMs, interrupted = () => false) {
+  return executeRegisteredSpec(
+    registerSpec(spec, document),
+    document,
+    selected,
+    timeoutMs,
+    interrupted
+  );
+}
 async function executeRegisteredSpec(registered, document, selected, timeoutMs, interrupted) {
   const results = [];
   const fileFailures = [];
@@ -150035,8 +150167,11 @@ async function runTest(workspace, options, dependencies = {}) {
   let testDurationMs = 0;
   let exitCode = 0;
   let interrupted = false;
+  let workerPool;
+  let parallelExecution = false;
   const handleSigint = () => {
     interrupted = true;
+    workerPool?.interrupt();
   };
   const assertNotInterrupted = () => {
     if (interrupted) {
@@ -150051,6 +150186,7 @@ async function runTest(workspace, options, dependencies = {}) {
     select: 0,
     compile: 0,
     register: 0,
+    workers: 0,
     execute: 0,
     finalize: 0
   };
@@ -150081,6 +150217,9 @@ async function runTest(workspace, options, dependencies = {}) {
       }
       if (candidate === null) {
         const prepared = dependencies.prepareLocalCandidate === void 0 ? await prepareLocalCandidateV4(workspace, {
+          // Tests need the compiled, validated candidate. Serializing it
+          // back to source and re-lowering is a push dry-run check.
+          fullValidation: false,
           onPhase: (label) => {
             dependencies.progress?.update(label);
           }
@@ -150132,8 +150271,9 @@ async function runTest(workspace, options, dependencies = {}) {
       );
     }
     enterPhase("compile", "Compiling test files\u2026");
+    const compile = lazySpecCompiler(rawDocument);
     specs = selectedPaths.map(
-      (path) => compileSpec(workspace, rawDocument, path, compilationHash)
+      (path) => compileSpec(workspace, compile, path, compilationHash)
     );
     let pattern = null;
     if (options.testNamePattern !== null) {
@@ -150162,21 +150302,54 @@ async function runTest(workspace, options, dependencies = {}) {
       );
     }
     const selectedIds = new Set(selectedTests.map((test) => test.id));
-    enterPhase("execute", "Running tests\u2026");
     const timeoutMs = options.timeoutMs ?? workspace.config.test?.timeoutMs ?? 5e3;
-    for (const entry of registered) {
-      const executed = await executeRegisteredSpec(
-        entry,
-        rawDocument,
-        selectedIds,
-        timeoutMs,
-        () => interrupted
-      );
+    const maxWorkers = options.maxWorkers ?? workspace.config.test?.maxWorkers ?? Math.min(4, availableParallelism());
+    if (!Number.isSafeInteger(maxWorkers) || maxWorkers <= 0) {
+      throw new NeoTestUsageError("--maxWorkers must be a positive integer.");
+    }
+    const jobs = registered.filter(
+      (entry) => (selectedTestCountByFile.get(entry.spec.path) ?? 0) > 0
+    );
+    const workerCount = options.runInBand === true ? 1 : Math.min(maxWorkers, jobs.length);
+    const recordResult = (spec, executed) => {
       results.push(...executed.tests);
       testDurationMs += executed.testDurationMs;
-      fileFailuresByPath.set(entry.spec.path, executed.failures);
+      fileFailuresByPath.set(spec.path, executed.failures);
+    };
+    if (workerCount > 1) {
+      enterPhase("workers", "Starting test workers\u2026");
+      workerPool = new TestWorkerPool(
+        new URL("./test-worker.mjs", import.meta.url)
+      );
+      await workerPool.start(rawDocument, workerCount);
       assertNotInterrupted();
+      parallelExecution = true;
+      enterPhase("execute", "Running tests\u2026");
+      await workerPool.run(
+        jobs.map((entry) => ({
+          spec: entry.spec,
+          selectedIds: entry.tests.filter((test) => selectedIds.has(test.id)).map((test) => test.id)
+        })),
+        timeoutMs,
+        recordResult
+      );
+    } else {
+      enterPhase("execute", "Running tests\u2026");
+      for (const entry of jobs) {
+        recordResult(
+          entry.spec,
+          await executeRegisteredSpec(
+            entry,
+            rawDocument,
+            selectedIds,
+            timeoutMs,
+            () => interrupted
+          )
+        );
+        assertNotInterrupted();
+      }
     }
+    assertNotInterrupted();
     if (results.some((result) => result.status === "failed") || [...fileFailuresByPath.values()].some((failures) => failures.length > 0)) {
       exitCode = 1;
     }
@@ -150184,7 +150357,7 @@ async function runTest(workspace, options, dependencies = {}) {
     const buildManifest = {
       version: 1,
       cliVersion: PROJECT_SCHEMA_CONTRACT.cliVersion,
-      runnerRevision: 3,
+      runnerRevision: 4,
       compilerRevision: NEOSCRIPT_COMPILER_REVISION,
       evaluatorRevision: 4,
       projectFingerprint,
@@ -150204,12 +150377,12 @@ async function runTest(workspace, options, dependencies = {}) {
 `
     );
   } catch (error) {
-    const diagnosticCode = error instanceof NeoTestInterruptedError ? "NEO_TEST_INTERRUPTED" : error instanceof NeoTestPreparedCandidateError ? "NEO_TEST_PREPARED_CANDIDATE" : error instanceof NeoTestUsageError ? "NEO_TEST_USAGE" : error instanceof NeoTestNoTestsError ? "NEO_TEST_NO_TESTS" : error instanceof NeoTestRegistrationError ? "NEO_TEST_REGISTRATION" : phase === "prepare" ? "NEO_TEST_PREPARATION" : phase === "compile" ? "NEO_TEST_COMPILE" : "NEO_TEST_RUNNER";
-    exitCode = error instanceof NeoTestInterruptedError ? 130 : error instanceof NeoTestUsageError || error instanceof NeoTestReportWriteError || error instanceof NeoTestPreparedCandidateError || diagnosticCode === "NEO_TEST_RUNNER" ? 2 : 1;
+    const diagnosticCode = interrupted || error instanceof NeoTestInterruptedError ? "NEO_TEST_INTERRUPTED" : error instanceof NeoTestPreparedCandidateError ? "NEO_TEST_PREPARED_CANDIDATE" : error instanceof NeoTestUsageError ? "NEO_TEST_USAGE" : error instanceof NeoTestNoTestsError ? "NEO_TEST_NO_TESTS" : error instanceof NeoTestRegistrationError ? "NEO_TEST_REGISTRATION" : phase === "prepare" ? "NEO_TEST_PREPARATION" : phase === "compile" ? "NEO_TEST_COMPILE" : "NEO_TEST_RUNNER";
+    exitCode = interrupted || error instanceof NeoTestInterruptedError ? 130 : error instanceof NeoTestUsageError || error instanceof NeoTestReportWriteError || error instanceof NeoTestPreparedCandidateError || diagnosticCode === "NEO_TEST_RUNNER" ? 2 : 1;
     diagnostics.push({
       severity: "error",
       code: diagnosticCode,
-      message: errorMessage2(error),
+      message: interrupted ? "Neo test was interrupted by SIGINT; partial results were written." : errorMessage2(error),
       file: null,
       line: null,
       column: null,
@@ -150217,6 +150390,7 @@ async function runTest(workspace, options, dependencies = {}) {
     });
   }
   finishPhase();
+  await workerPool?.stop();
   dependencies.progress?.stop();
   process.off("SIGINT", handleSigint);
   const failed = results.filter((result) => result.status === "failed").length;
@@ -150226,21 +150400,33 @@ async function runTest(workspace, options, dependencies = {}) {
   );
   const skipped = Math.max(0, selectedTestTotal - results.length);
   const durationMs = performance.now() - performanceStarted;
-  const startupDurationMs = Math.max(0, durationMs - testDurationMs);
+  const startupDurationMs = parallelExecution ? Math.max(0, durationMs - phaseDurations.execute) : Math.max(0, durationMs - testDurationMs);
   const perTestStartupDurationMs = results.reduce(
     (sum, result) => sum + result.startupDurationMs,
     0
   );
   const sharedStartupDurationMs = Math.max(
     0,
-    startupDurationMs - perTestStartupDurationMs
+    startupDurationMs - (parallelExecution ? 0 : perTestStartupDurationMs)
   );
+  const testsByFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const tests = testsByFile.get(result.file) ?? [];
+    tests.push(result);
+    testsByFile.set(result.file, tests);
+  }
   const testFiles = specs.map((spec) => {
-    const tests = results.filter((result) => result.file === spec.path);
+    const tests = testsByFile.get(spec.path) ?? [];
     const failures = fileFailuresByPath.get(spec.path) ?? [];
+    let status = "passed";
+    if (tests.some((test) => test.status === "failed") || failures.length > 0) {
+      status = "failed";
+    } else if (tests.length < (selectedTestCountByFile.get(spec.path) ?? 0) && exitCode !== 0) {
+      status = interrupted ? "interrupted" : "failed";
+    }
     return {
       path: spec.path,
-      status: tests.some((test) => test.status === "failed") || failures.length > 0 ? "failed" : interrupted && tests.length < (selectedTestCountByFile.get(spec.path) ?? 0) ? "interrupted" : "passed",
+      status,
       tests,
       failures
     };
@@ -150276,6 +150462,7 @@ async function runTest(workspace, options, dependencies = {}) {
       selectMs: phaseDurations.select,
       compileMs: phaseDurations.compile,
       registerMs: phaseDurations.register,
+      workerStartupMs: phaseDurations.workers,
       executeMs: phaseDurations.execute,
       finalizeMs: phaseDurations.finalize
     },
@@ -150357,8 +150544,9 @@ async function runTest(workspace, options, dependencies = {}) {
     console.log(
       ` ${color.bold(pad("Tests", 11))} ${formatStatusCounts(report.summary.passed, report.summary.failed, report.summary.tests, report.summary.skipped)}`
     );
+    const timingDetail = parallelExecution ? `test work ${formatTestDuration(report.summary.testDurationMs)}, execution ${formatTestDuration(report.timings.executeMs)}, startup ${formatTestDuration(report.summary.startupDurationMs)}` : `test ${formatTestDuration(report.summary.testDurationMs)}, startup ${formatTestDuration(report.summary.startupDurationMs)}`;
     console.log(
-      ` ${color.bold(pad("Duration", 11))} ${color.bold(`total ${formatTestDuration(report.summary.durationMs)}`)} ${color.dim(`(test ${formatTestDuration(report.summary.testDurationMs)}, startup ${formatTestDuration(report.summary.startupDurationMs)})`)}`
+      ` ${color.bold(pad("Duration", 11))} ${color.bold(`total ${formatTestDuration(report.summary.durationMs)}`)} ${color.dim(`(${timingDetail})`)}`
     );
   }
   if (!report.success) process.exitCode = exitCode;
@@ -150388,9 +150576,10 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
     document
   );
   const errors = [];
+  const compile = lazySpecCompiler(document);
   for (const path of selectedPaths) {
     try {
-      compileSpec(workspace, document, path, compilationHash);
+      compileSpec(workspace, compile, path, compilationHash);
     } catch (error) {
       errors.push({
         file: relative8(workspace.root, path).split(sep8).join("/"),
@@ -150409,6 +150598,7 @@ var TEST_BUILD_CACHE_LIMIT_BYTES, ABANDONED_TEMP_MAX_AGE_MS, TEST_CANDIDATE_CACH
 var init_test = __esm({
   "src/commands/test.ts"() {
     "use strict";
+    init_test_worker_pool();
     init_src();
     init_members();
     init_neoscript2();
@@ -155947,6 +156137,11 @@ ${h("Usage")}
   neo test ${d("[file-or-directory ...]")}
   neo test -t ${d('"name pattern"')}
   neo test ${d("--reporter=json --outputFile=output.json")}
+  neo test ${d("--maxWorkers=4")}
+  neo test ${d("--runInBand")}
+
+Files run in parallel, using up to four available CPU workers by default.
+--maxWorkers overrides neo.json test.maxWorkers; --runInBand runs serially.
 
 Tests execute against the locally compiled candidate graph, including changes
 that have not been pushed. Test files are never included in a push.
@@ -156034,7 +156229,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.62.1");
+    console.log("0.62.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -156360,6 +156555,11 @@ async function main() {
           "--testTimeout must be a positive number of milliseconds."
         );
       }
+      const maxWorkersValue = stringFlag(args, "maxWorkers");
+      const maxWorkers = maxWorkersValue === null ? void 0 : Number(maxWorkersValue);
+      if (maxWorkers !== void 0 && (!Number.isSafeInteger(maxWorkers) || maxWorkers <= 0)) {
+        throw new NeoCliUsageError("--maxWorkers must be a positive integer.");
+      }
       const progress = reporterValue === "default" && process.stdout.isTTY === true ? spinner("Reading local workspace\u2026") : null;
       try {
         const workspace = loadWorkspaceForCommand(args);
@@ -156372,6 +156572,8 @@ async function main() {
             reporter: reporterValue,
             outputFile: stringFlag(args, "outputFile") ?? stringFlag(args, "output-file"),
             passWithNoTests: boolFlag(args, "passWithNoTests"),
+            runInBand: boolFlag(args, "runInBand"),
+            ...maxWorkers === void 0 ? {} : { maxWorkers },
             ...timeoutMs === void 0 ? {} : { timeoutMs }
           },
           progress === null ? {} : { progress }