cabloy 5.1.222 → 5.1.224

package/.cabloy-version

@@ -1 +1 @@
-5.1.222
+5.1.224

package/.github/workflows/vona-test-sqlite3.yml

@@ -93,7 +93,7 @@ jobs:
       - name: init
         run: npm run init
       - name: run isolated test infrastructure gate
-        run: node --test scripts/testClaimProcesses.test.ts scripts/runIsolatedTest.test.ts scripts/testClaimCleanup.test.ts scripts/testProcessGuardianWindows.test.ts vona/packages-vona/vona-core/src/lib/core/testClaim.test.ts vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.test.ts vona/packages-vona/vona-core/src/lib/framework/bootstrap.test.ts vona/packages-vona/vona-core/src/lib/framework/useApp.test.ts vona/packages-cli/cli-set-api/test/binBuildEntries.test.ts
+        run: node --test scripts/testClaimProcesses.test.ts scripts/runIsolatedTest.test.ts scripts/testClaimCleanup.test.ts scripts/testProcessGuardianWindows.test.ts vona/packages-vona/vona-core/src/lib/core/testClaim.test.ts vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.test.ts vona/packages-vona/vona-core/src/lib/framework/bootstrap.test.ts vona/packages-vona/vona-core/src/lib/framework/useApp.test.ts vona/packages-cli/cli-set-api/test/binBuildEntries.test.ts vona/packages-cli/cli-set-api/test/binTestPatterns.test.ts
       - name: run A-Pay focused gate
         run: npm run test -- test-pay/test/paymentSession.test.ts test-pay/test/payMock.test.ts test-pay/test/paypalProvider.test.ts test-pay/test/paypalLifecycle.test.ts test-pay/test/stripeProvider.test.ts test-pay/test/stripeLifecycle.test.ts test-pay/test/outbox.test.ts test-pay/test/webhook.test.ts
         working-directory: vona

package/.github/workflows/vona-tsc.yml

@@ -22,6 +22,7 @@ jobs:
           version: '12.14.0'
       - name: init
         run: npm run init
-      - name: tsc
-        run: npm run tsc
-        working-directory: vona
+      - name: typecheck runner tests
+        run: npm run test:typecheck
+      - name: legacy typecheck
+        run: npm run tsc:legacy

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 5.1.224
+
+### Features
+
+- Update functionality.
+
+### Improvements
+
+- Update the release script.
+
+## 5.1.223
+
+### Features
+
+- Add a CLI test command.
+
+### Improvements
+
+- Replace ts-node with swc-core.
+- Refactor TypeScript compilation.
+- Update isolated test coverage.
+- Update dependency lockfile.
+
 ## 5.1.222
 
 ### Features

package/lint-staged.config.mjs

@@ -5,6 +5,8 @@ const OXFMT_IGNORE_PATTERNS = [
   // root original
   '**/.claude',
   '**/.vscode',
+  // Preserve retained evidence bytes and hashes.
+  'repo-specs/**/evidence/**',
   // file type patterns
   '*.min.js',
   '*.code-snippets',

package/oxfmt.config.ts

@@ -7,6 +7,8 @@ export default defineConfig(
       // root original
       '**/.claude',
       '**/.vscode',
+      // Preserve retained evidence bytes and hashes.
+      'repo-specs/**/evidence/**',
       // file type patterns (from vona & zova)
       '*.min.js',
       '*.code-snippets',

package/oxlint.config.ts

@@ -7,6 +7,8 @@ export default defineConfig(
       // root original
       '**/.claude',
       '**/.vscode',
+      // Preserve retained evidence bytes and hashes.
+      'repo-specs/**/evidence/**',
       // glob patterns (from vona & zova, already work from root)
       '**/node_modules',
       '**/dist',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabloy",
-  "version": "5.1.222",
+  "version": "5.1.224",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A Node.js fullstack framework",
   "keywords": [
@@ -50,8 +50,16 @@
     "contract:generate:isolated": "node scripts/generateOpenapiIsolated.ts",
     "test:docs:e2e": "npm run docs:build && playwright test --config repo-e2e/docs/playwright.config.ts",
     "db:reset": "cd vona && npm run db:reset",
-    "tsc": "npm run tsc:zova && pnpm --dir vona run tsc",
+    "tsc": "npm run tsc:native",
+    "tsc:force": "npm run tsc:zova:native && npm run tsc:vona:native:force",
     "tsc:zova": "pnpm --dir zova run tsc",
+    "tsc:native": "npm run tsc:zova:native && npm run tsc:vona:native",
+    "tsc:legacy": "npm run tsc:zova:legacy && pnpm --dir vona run tsc:legacy",
+    "tsc:zova:native": "node scripts/typecheck.ts native zova --noEmit --incremental false --project tsconfig.vue-tsc.json",
+    "tsc:zova:legacy": "node scripts/typecheck.ts typescript zova --noEmit --incremental false --project tsconfig.vue-tsc.json",
+    "tsc:vona:native": "pnpm --dir vona run tsc:native",
+    "tsc:vona:native:force": "pnpm --dir vona run tsc:native:force",
+    "test:typecheck": "node --test scripts/typecheck.test.ts",
     "deps:vona": "pnpm --dir vona run vona :tools:deps",
     "deps:zova": "pnpm --dir zova run zova :tools:deps",
     "format": "oxfmt --check",
@@ -91,6 +99,7 @@
     "@playwright/test": "^1.62.1",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^26.1.2",
+    "@typescript/native": "npm:typescript@7.0.2",
     "husky": "^9.1.7",
     "lerna": "^10.0.0",
     "lint-staged": "^17.0.5",

package/repo-docs/reference/repo-scripts.md

@@ -44,12 +44,43 @@ Cabloy Basic exposes these shared root scripts:
 - `npm run contract:generate:isolated`
 - `npm run db:reset`
 - `npm run tsc`
+- `npm run tsc:force`
+- `npm run tsc:native`
+- `npm run tsc:legacy`
+- `npm run test:typecheck`
 - `npm run docs:dev`
 - `npm run docs:build`
 - `npm run docs:preview`
 
 `npm run init` prepares all Cabloy Basic SSR and REST artifacts with `npm run build:zova:all`, which sequentially builds the Basic and Commerce flavor batches before Vona initialization. Use `build:zova` or `build:zova:commerce` for focused artifact refreshes; use `build:zova:all` only when every shipped Basic flavor must be prepared.
 
+## TypeScript toolchains in Cabloy Basic
+
+Cabloy Basic keeps two TypeScript toolchains: root `@typescript/native` is the exact npm alias `npm:typescript@7.0.2`, while classic `typescript` 5.9.3 remains available for compiler-API consumers and existing tooling. The alias changes the dependency name, not the executable name: its package still declares `bin.tsc`, not a separate `native` or `tsgo` command.
+
+Use the explicit root commands to select the verification toolchain:
+
+| Root command                         | Scope                                                                                                                              |
+| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `npm run tsc` / `npm run tsc:native` | Check Zova, then the complete Vona graph, with native TypeScript; reuse Vona incremental results.                                  |
+| `npm run tsc:force`                  | Check the same scopes with native TypeScript, forcing Vona to rebuild.                                                             |
+| `npm run tsc:legacy`                 | Check the same scopes with classic TypeScript.                                                                                     |
+| `npm run tsc:zova:native`            | Check Zova with native TypeScript.                                                                                                 |
+| `npm run tsc:zova:legacy`            | Check Zova with classic TypeScript.                                                                                                |
+| `npm run tsc:vona:native`            | Check the complete Vona graph with native TypeScript, reusing incremental results.                                                 |
+| `npm run tsc:vona:native:force`      | Force native checking of the complete Vona graph.                                                                                  |
+| `npm run test:typecheck`             | Test compiler selection, argument and failure propagation, Vona graph traversal, and installed compiler versions/API availability. |
+
+`scripts/typecheck.ts` delegates to the package-resolving runner in `vona/packages-cli/cli-set-api/src/lib/typescriptRunner.ts`. It resolves `@typescript/native` or `typescript` from the target workspace, reads that package's `bin.tsc`, and invokes it directly with Node. Native Vona checks use the same runner. This avoids relying on `PATH` or a shared `.bin/tsc` name to identify the selected compiler.
+
+Both explicit Zova checks use `tsconfig.vue-tsc.json` with `--noEmit --incremental false`. Native Vona checks retain build mode (`-b`), visiting the project, every local suite, and every standalone local module, rather than replacing that graph with a root-only no-emit check. The default native check omits `--force`; `tsc:force` adds it without changing the traversal scope. Zova's cache policy is unchanged, so the force distinction applies to Vona. The explicit legacy check continues to force a rebuild. Vona's emitted files and build-info artifacts are shared between compiler versions: run native and legacy checks **serially**, and coordinate them with other operations writing the same artifacts. After switching from TS5 back to native, run `npm run tsc:force` before relying on incremental checks. Forced rebuilding prevents one compiler's incremental state from standing in for verification by the other; it does not isolate their output.
+
+Root `npm run tsc` delegates to incremental `tsc:native` for daily development; use `tsc:force` for full forced verification and `tsc:legacy` for comparison or fallback. The nested Vona and Zova `tsc` defaults, frontend `prerun`, build commands, package publish emitters, and REST emitters remain unchanged. Classic TypeScript remains installed for compiler-JavaScript-API consumers, including SWC configuration loading, Rollup integration, and OpenAPI generation; the existing REST native-preview emitter dependency is also retained.
+
+The native alias is installed at the repository root, not in either nested workspace. Run `pnpm install` at the root after updating the checkout; a missing alias fails with an installation diagnostic rather than silently selecting the legacy compiler. A standalone Vona project using `--compiler=native` must install that alias in its project or an ancestor. Do not use a bare root `tsc`/`pnpm exec tsc` to choose a compiler, because both packages declare the same binary name.
+
+The `vona-tsc` CI workflow runs root `npm run test:typecheck`, then root `npm run tsc:force`, after its existing initialization. The root release workflow also runs `tsc:force` before versioning/publishing (excluding changelog-only and GitHub-release-only runs), and its post-release compensation verification uses the same forced entrypoint. These gates retain forced verification even though daily checking is incremental. Check the active repository before assuming the same aliases or commands exist in Cabloy Start.
+
 ## Test isolation and development data {#test-isolation-and-development-data}
 
 <span id="test-isolation-and-development-data-in-cabloy-basic"></span>

package/scripts/release.ts

@@ -963,6 +963,9 @@ async function release(options: ReleaseOptions): Promise<void> {
   }
 
   runGovernancePreflight(options.dryRun);
+  if (!options.changelogOnly && !options.releaseOnly) {
+    execInherited('npm run tsc', options.dryRun);
+  }
 
   // Determine the version to use
   let version: string;

package/scripts/runIsolatedTest.test.ts

@@ -641,7 +641,6 @@ test(
     try {
       const script = `
       import { writeFileSync } from 'node:fs';
-      writeFileSync(process.argv[1], 'ready');
       process.on('SIGINT', () => {
         setTimeout(() => {
           writeFileSync(process.argv[2], 'stopped');
@@ -649,6 +648,7 @@ test(
         }, 150);
       });
       setInterval(() => {}, 1000);
+      writeFileSync(process.argv[1], 'ready');
     `;
       const pending = runIsolatedProcess(
         process.execPath,

package/scripts/typecheck.test.ts

@@ -0,0 +1,199 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import { CliBinTsc } from '../vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.tsc.ts';
+import {
+  resolveTypeScriptCompiler,
+  runTypeScript,
+} from '../vona/packages-cli/cli-set-api/src/lib/typescriptRunner.ts';
+
+const root = fileURLToPath(new URL('../', import.meta.url));
+
+function writeCompiler(root: string, packageName: string, report?: string) {
+  const dir = path.join(root, 'node_modules', packageName);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    path.join(dir, 'package.json'),
+    JSON.stringify({ name: 'typescript', bin: { tsc: 'compiler.cjs' } }),
+  );
+  writeFileSync(
+    path.join(dir, 'compiler.cjs'),
+    `
+    const fs = require('node:fs');
+    if (process.argv[2] === '--fail') process.exit(3);
+    const report = ${JSON.stringify(report)};
+    if (report) fs.appendFileSync(report, JSON.stringify({ cwd: process.cwd(), args: process.argv.slice(2), compiler: ${JSON.stringify(packageName)} }) + '\\n');
+  `,
+  );
+  return path.join(dir, 'compiler.cjs');
+}
+
+test('selects exact packages, preserving compiler argv, cwd and failures', async () => {
+  const dir = realpathSync(mkdtempSync(path.join(tmpdir(), 'cabloy-typecheck-')));
+  try {
+    const projectPath = path.join(dir, 'project with spaces');
+    mkdirSync(projectPath);
+    await assert.rejects(
+      runTypeScript('native', [], { projectPath }),
+      /Cannot resolve @typescript\/native/,
+    );
+    const report = path.join(dir, 'calls.jsonl');
+    const native = writeCompiler(dir, '@typescript/native', report);
+    const legacy = writeCompiler(projectPath, 'typescript');
+    assert.equal(resolveTypeScriptCompiler('native', projectPath), native);
+    assert.equal(resolveTypeScriptCompiler('typescript', projectPath), legacy);
+    const args = ['--project', 'file with spaces.json', 'literal;argument', '$unchanged'];
+    await runTypeScript('native', args, { projectPath });
+    assert.deepEqual(JSON.parse(readFileSync(report, 'utf8')), {
+      cwd: projectPath,
+      args,
+      compiler: '@typescript/native',
+    });
+    await assert.rejects(runTypeScript('native', ['--fail'], { projectPath }), { exitCode: 3 });
+    await assert.rejects(
+      runTypeScript('native', [], { projectPath, cwd: path.join(dir, 'missing') }),
+      { code: 'ENOENT' },
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('Vona keeps its legacy default and visits the same graph with native', async () => {
+  const dir = realpathSync(mkdtempSync(path.join(tmpdir(), 'cabloy-check-graph-')));
+  try {
+    const report = path.join(dir, 'calls.jsonl');
+    writeCompiler(dir, '@typescript/native', report);
+    const suiteRoot = path.join(dir, 'suite');
+    const moduleRoot = path.join(dir, 'standalone');
+    mkdirSync(suiteRoot);
+    mkdirSync(moduleRoot);
+    const calls: unknown[] = [];
+    const cli = Object.create(CliBinTsc.prototype);
+    Object.defineProperties(cli, {
+      modulesMeta: {
+        value: {
+          suites: {
+            local: { root: suiteRoot, info: { originalName: 'local' } },
+            external: { info: { node_modules: true } },
+          },
+          modulesArray: [
+            { root: moduleRoot, info: { originalName: 'standalone' } },
+            { suite: 'local', info: {} },
+            { info: { node_modules: true } },
+          ],
+        },
+      },
+      helper: {
+        value: {
+          processHelper: {
+            tsc: async (...args: unknown[]) => {
+              calls.push(args);
+            },
+          },
+        },
+      },
+    });
+    await cli._tsc(dir, false);
+    assert.deepEqual(
+      calls,
+      [dir, suiteRoot, moduleRoot].map(cwd => [['-b'], { cwd }]),
+    );
+    for (const force of [false, true]) {
+      for (const builders of [undefined, 1, 2]) {
+        writeFileSync(report, '');
+        await cli._tsc(dir, force, 'native', builders);
+        const nativeCalls = readFileSync(report, 'utf8')
+          .trim()
+          .split('\n')
+          .map(line => JSON.parse(line));
+        const args = force ? ['-b', '--force'] : ['-b'];
+        if (builders !== undefined) args.push('--builders', String(builders));
+        assert.deepEqual(
+          nativeCalls,
+          [dir, suiteRoot, moduleRoot].map(cwd => ({
+            cwd,
+            args,
+            compiler: '@typescript/native',
+          })),
+        );
+      }
+    }
+    assert.equal(calls.length, 3, 'native must not use the legacy binary helper');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('Vona rejects invalid or legacy builder limits before starting compilation', async () => {
+  const cli = Object.create(CliBinTsc.prototype);
+  for (const builders of [0, -1, 1.5, Number.NaN, Infinity, Number.MAX_SAFE_INTEGER + 1]) {
+    await assert.rejects(cli._tsc(root, true, 'native', builders), /positive safe integer/);
+  }
+  await assert.rejects(cli._tsc(root, true, 'typescript', 1), /requires --compiler=native/);
+});
+
+test('root commands retain optional native checks and use legacy in CI', () => {
+  const scripts = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8')).scripts;
+  const vonaScripts = JSON.parse(
+    readFileSync(path.join(root, 'vona/package.original.json'), 'utf8'),
+  ).scripts;
+  assert.equal(scripts.tsc, 'npm run tsc:native');
+  assert.equal(scripts['tsc:native'], 'npm run tsc:zova:native && npm run tsc:vona:native');
+  assert.equal(scripts['tsc:force'], 'npm run tsc:zova:native && npm run tsc:vona:native:force');
+  assert.equal(scripts['tsc:vona:native'], 'pnpm --dir vona run tsc:native');
+  assert.equal(scripts['tsc:vona:native:force'], 'pnpm --dir vona run tsc:native:force');
+  assert.equal(
+    vonaScripts['tsc:native'],
+    'npm run prerun && npm run vona :bin:tsc -- --compiler=native',
+  );
+  assert.equal(vonaScripts['tsc:native:force'], `${vonaScripts['tsc:native']} --force`);
+  assert.equal(vonaScripts['tsc:legacy'], 'npm run prerun && npm run vona :bin:tsc -- --force');
+  assert.equal(scripts['tsc:legacy'], 'npm run tsc:zova:legacy && pnpm --dir vona run tsc:legacy');
+  assert.equal(
+    scripts['tsc:zova:legacy'],
+    'node scripts/typecheck.ts typescript zova --noEmit --incremental false --project tsconfig.vue-tsc.json',
+  );
+  const workflow = readFileSync(path.join(root, '.github/workflows/vona-tsc.yml'), 'utf8');
+  assert.match(workflow, /run: npm run tsc:legacy\s*$/m);
+  assert.doesNotMatch(workflow, /run:.*tsc(?::[\w-]+)*native|npm run tsc:force/);
+});
+
+test('release dry-run keeps forced checks before publishing only', () => {
+  for (const [mode, shouldCheck] of [
+    ['--publish-only', true],
+    ['--changelog-only', false],
+    ['--release-only', false],
+  ] as const) {
+    const result = spawnSync(process.execPath, ['scripts/release.ts', '--dry-run', mode], {
+      cwd: root,
+      encoding: 'utf8',
+      timeout: 30_000,
+    });
+    assert.equal(result.error, undefined);
+    assert.equal(result.status, 0, result.stderr);
+    const check = result.stdout.indexOf('[dry-run] npm run tsc:force');
+    assert.equal(check !== -1, shouldCheck, mode);
+    if (shouldCheck) {
+      assert.ok(result.stdout.indexOf('[dry-run] npm publish') > check);
+    }
+  }
+});
+
+test('installation retains TS5 APIs and exact stable native compiler', () => {
+  for (const workspace of ['.', 'vona', 'zova']) {
+    const require = createRequire(path.join(root, workspace, 'package.json'));
+    const ts = require('typescript');
+    assert.equal(ts.version, '5.9.3');
+    assert.equal(typeof ts.createSourceFile, 'function');
+    assert.match(ts.transpileModule('const value: number = 1;', {}).outputText, /value/);
+  }
+  const require = createRequire(path.join(root, 'package.json'));
+  assert.equal(require('@typescript/native/package.json').version, '7.0.2');
+});

package/scripts/typecheck.ts

@@ -0,0 +1,20 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runTypeScript } from '../vona/packages-cli/cli-set-api/src/lib/typescriptRunner.ts';
+
+const [compiler, workspace, ...args] = process.argv.slice(2);
+if ((compiler !== 'native' && compiler !== 'typescript') || !['vona', 'zova'].includes(workspace)) {
+  console.error(
+    'Usage: node scripts/typecheck.ts <native|typescript> <vona|zova> [compiler arguments]',
+  );
+  process.exitCode = 1;
+} else {
+  const projectPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', workspace);
+  try {
+    await runTypeScript(compiler, args, { projectPath });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = (error as { exitCode?: number }).exitCode ?? 1;
+  }
+}

package/vona/package.original.json

@@ -27,6 +27,9 @@
     "test": "node ../scripts/runIsolatedTest.ts unit",
     "cov": "node ../scripts/runIsolatedTest.ts unit --coverage",
     "tsc": "npm run prerun && npm run vona :bin:tsc",
+    "tsc:native": "npm run prerun && npm run vona :bin:tsc -- --compiler=native",
+    "tsc:native:force": "npm run prerun && npm run vona :bin:tsc -- --compiler=native --force",
+    "tsc:legacy": "npm run prerun && npm run vona :bin:tsc -- --force",
     "build": "npm run prerun && npm run vona :bin:build -- --flavor=normal",
     "build:docker": "npm run prerun && npm run vona :bin:build -- --flavor=docker",
     "start": "pnpm -C ./dist/normal install && node ./dist/normal/bootstrap.js",

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.168",
+  "version": "1.1.169",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.166",
+  "version": "1.1.167",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [
@@ -63,6 +63,7 @@
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-terser": "^1.0.0",
     "@rollup/plugin-typescript": "^12.3.0",
+    "@swc-node/register": "^1.12.1",
     "babel-plugin-transform-typescript-metadata": "^0.3.2",
     "babel-plugin-vona-bean-module": "workspace:^",
     "chalk": "^3.0.0",
@@ -76,7 +77,6 @@
     "randomatic": "^3.1.1",
     "rimraf": "^6.1.3",
     "rollup": "^4.60.1",
-    "ts-node-maintained": "^10.9.6",
     "urllib": "^4.9.0",
     "uuid": "^11.1.0",
     "vona-core": "workspace:^",

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.dev.ts

@@ -165,12 +165,5 @@ export class CliBinDev extends BeanCliBase {
           console.log('App restarted due to: ', files);
         });
     });
-    // await this.helper.spawnExe({
-    //   cmd: 'node',
-    //   args: ['--experimental-transform-types', '--loader=ts-node/esm', '.vona/bootstrap.ts'],
-    //   options: {
-    //     cwd: projectPath,
-    //   },
-    // });
   }
 }

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.test.ts

@@ -4,6 +4,7 @@ import type { VonaConfigMeta, VonaMetaFlavor, VonaMetaMode } from '@cabloy/modul
 import { BeanCliBase } from '@cabloy/cli';
 import { catchError } from '@cabloy/utils';
 import fse from 'fs-extra';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { rimraf } from 'rimraf';
 import { resolveVonaLocalPaths } from 'vona-core';
@@ -20,6 +21,26 @@ declare module '@cabloy/cli' {
   }
 }
 
+export async function runTestChild(args: string[], projectPath: string): Promise<void> {
+  const child = spawn(process.execPath, args, { cwd: projectPath, stdio: 'inherit' });
+  const onInterrupt = () => child.kill('SIGINT');
+  const onTerminate = () => child.kill('SIGTERM');
+  process.on('SIGINT', onInterrupt);
+  process.on('SIGTERM', onTerminate);
+  try {
+    await new Promise<void>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('close', (code, signal) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Test child exited: ${signal ?? code}`));
+      });
+    });
+  } finally {
+    process.off('SIGINT', onInterrupt);
+    process.off('SIGTERM', onTerminate);
+  }
+}
+
 export class CliBinTest extends BeanCliBase {
   async execute() {
     const { argv } = this.context;
@@ -82,13 +103,7 @@ export class CliBinTest extends BeanCliBase {
       patterns.join(','),
     ]);
     // args = args.concat(['--experimental-transform-types', getImportEsm(), testFile, projectPath, (!!argv.coverage).toString(), patterns.join(',')]);
-    await this.helper.spawnExe({
-      cmd: 'node',
-      args,
-      options: {
-        cwd: projectPath,
-      },
-    });
+    await runTestChild(args, projectPath);
   }
 
   async _outputCoverageReportViewer(projectPath: string) {

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.tsc.ts

@@ -1,8 +1,14 @@
 import { BeanCliBase } from '@cabloy/cli';
 
+import type { TypeScriptCompiler } from '../typescriptRunner.ts';
+
+import { runTypeScript } from '../typescriptRunner.ts';
+
 declare module '@cabloy/cli' {
   interface ICommandArgv {
     force: boolean;
+    compiler: TypeScriptCompiler;
+    builders: number;
   }
 }
 
@@ -13,10 +19,23 @@ export class CliBinTsc extends BeanCliBase {
     await super.execute();
     const projectPath = argv.projectPath;
     const force = argv.force;
-    await this._tsc(projectPath, force);
+    await this._tsc(projectPath, force, argv.compiler ?? 'typescript', argv.builders);
   }
 
-  async _tsc(projectPath: string, force: boolean) {
+  async _tsc(
+    projectPath: string,
+    force: boolean,
+    compiler: TypeScriptCompiler = 'typescript',
+    builders?: number,
+  ) {
+    if (builders !== undefined) {
+      if (!Number.isSafeInteger(builders) || builders < 1) {
+        throw new Error('--builders must be a positive safe integer');
+      }
+      if (compiler !== 'native') {
+        throw new Error('--builders requires --compiler=native');
+      }
+    }
     const suiteNames = Object.keys(this.modulesMeta.suites).filter(
       suiteName => !this.modulesMeta.suites[suiteName].info.node_modules,
     );
@@ -35,22 +54,32 @@ export class CliBinTsc extends BeanCliBase {
     if (force) {
       tscArgs.push('--force');
     }
+    if (builders !== undefined) {
+      tscArgs.push('--builders', String(builders));
+    }
+    const check = async (cwd: string) => {
+      if (compiler === 'native') {
+        await runTypeScript(compiler, tscArgs, { projectPath, cwd });
+      } else {
+        await this.helper.processHelper.tsc(tscArgs, { cwd });
+      }
+    };
     // tsc: project
     // eslint-disable-next-line
     console.log(`===>  ${++counter}/${count} project`);
-    await this.helper.processHelper.tsc(tscArgs, { cwd: projectPath });
+    await check(projectPath);
     // suites
     for (const key of suiteNames) {
       const suite = this.modulesMeta.suites[key];
       // eslint-disable-next-line
       console.log(`===>  ${++counter}/${count} suite: ${suite.info.originalName}`);
-      await this.helper.processHelper.tsc(tscArgs, { cwd: suite.root });
+      await check(suite.root);
     }
     // modules
     for (const module of modulesArray) {
       // eslint-disable-next-line
       console.log(`===>  ${++counter}/${count} module: ${module.info.originalName}`);
-      await this.helper.processHelper.tsc(tscArgs, { cwd: module.root });
+      await check(module.root);
     }
     // end
     const timeEnd = Date.now();

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/testCleanupProcess.test.ts

@@ -17,7 +17,7 @@ test('cleanup helper launches via process.execPath and resolves only fake source
     await writeFile(path.join(project, 'package.json'), '{"type":"module"}');
     await writeFile(
       path.join(project, 'tsconfig.json'),
-      '{"compilerOptions":{"module":"NodeNext","moduleResolution":"NodeNext","target":"ESNext","allowImportingTsExtensions":true},"ts-node":{"transpileOnly":true}}',
+      '{"compilerOptions":{"module":"NodeNext","moduleResolution":"NodeNext","target":"ESNext","allowImportingTsExtensions":true}}',
     );
     await writeFile(
       path.join(configDir, 'config.ts'),

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/testCleanupProcess.ts

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 
 // Register before dynamically importing source config/framework (decorators and
 // workspace TS exports). Dependencies resolve from this checkout's Vona install.
-register(import.meta.resolve('ts-node-maintained/esm'), pathToFileURL(`${process.cwd()}/`));
+register(import.meta.resolve('@swc-node/register/esm'), pathToFileURL(`${process.cwd()}/`));
 const require = createRequire(pathToFileURL(path.join(process.cwd(), 'package.json')));
 let queue = Promise.resolve();
 let claim: import('vona-core').TestClaimManifest | undefined;

package/vona/packages-cli/cli-set-api/src/lib/command/bin.tsc.ts

@@ -3,9 +3,19 @@ export default {
   info: {
     version: '5.0.0',
     title: 'Cli: Bin: Tsc',
-    usage: 'npm run vona :bin:tsc -- [--force]',
+    usage: 'npm run vona :bin:tsc -- [--force] [--compiler=typescript|native] [--builders=]',
   },
   options: {
+    compiler: {
+      description:
+        'TypeScript compiler (native requires @typescript/native in the project or repository root)',
+      type: 'string',
+      choices: ['typescript', 'native'],
+    },
+    builders: {
+      description: 'Maximum number of projects to build concurrently (native only)',
+      type: 'number',
+    },
     force: {
       description: 'force',
       type: 'boolean',