cabloy 5.1.202 → 5.1.203

package/repo-e2e/specs/cabloy-basic.spec.ts

@@ -40,11 +40,23 @@ function collectConsoleErrors(page: Page) {
 
 async function loginAsAdmin(page: Page) {
   await page.goto('/admin/', { waitUntil: 'load' });
+  await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
   if (page.url().includes('/admin/login')) {
-    await page.getByPlaceholder('Your Username').fill('admin');
-    await page.getByPlaceholder('Your Password').fill('123456');
+    const usernameInput = page.getByPlaceholder('Your Username');
+    const passwordInput = page.getByPlaceholder('Your Password');
+    await usernameInput.fill('admin');
+    await passwordInput.fill('123456');
+    await expect(usernameInput).toHaveValue('admin');
+    await expect(passwordInput).toHaveValue('123456');
     await expect(page.getByPlaceholder('Please input captcha')).not.toHaveValue('');
+    const loginResponse = page.waitForResponse(response => {
+      const url = new URL(response.url());
+      return (
+        response.request().method() === 'POST' && url.pathname === '/api/home/user/passport/login'
+      );
+    });
     await page.getByRole('button', { name: 'Login', exact: true }).click();
+    expect((await loginResponse).ok()).toBeTruthy();
     await expect(page).not.toHaveURL(/\/admin\/login(?:\?|$)/);
   }
 
@@ -158,7 +170,7 @@ test(
   async ({ page, request }) => {
     const response = await request.get('/');
     expect(response.ok()).toBeTruthy();
-    expect(response.headers()['cache-control']).toBe('no-cache, no-store, must-revalidate');
+    expect(response.headers()['cache-control']).toBe('public, max-age=600');
     const html = await response.text();
     expect(html.toLowerCase()).not.toContain('data-zova-hydrated');
     expect(html).not.toContain('ssr-body-ready-observer');
@@ -166,9 +178,7 @@ test(
 
     const routeOverrideResponse = await request.get('/demo/basic/routeQueryB');
     expect(routeOverrideResponse.ok()).toBeTruthy();
-    expect(routeOverrideResponse.headers()['cache-control']).toBe(
-      'no-cache, no-store, must-revalidate',
-    );
+    expect(routeOverrideResponse.headers()['cache-control']).toBe('public, max-age=300');
 
     const unlocalizedResponse = await request.get('/demo/basic/state');
     expect(unlocalizedResponse.ok()).toBeTruthy();
@@ -192,7 +202,7 @@ test(
 );
 
 test(
-  'ATP-BASIC-SSR-03: concurrent public routes are non-cacheable in development',
+  'ATP-BASIC-SSR-03: concurrent public routes preserve their cache policies in managed test mode',
   { tag: ['@web', '@smoke'] },
   async ({ request }) => {
     const responses = await Promise.all(
@@ -205,9 +215,13 @@ test(
 
     for (const [index, response] of responses.entries()) {
       expect(response.ok(), `response ${index}`).toBeTruthy();
-      expect(response.headers()['cache-control'], `response ${index}`).toBe(
-        'no-cache, no-store, must-revalidate',
-      );
+      const cacheControl =
+        index % 3 === 0
+          ? 'public, max-age=600'
+          : index % 3 === 1
+            ? 'public, max-age=300'
+            : 'no-cache, no-store, must-revalidate';
+      expect(response.headers()['cache-control'], `response ${index}`).toBe(cacheControl);
     }
   },
 );
@@ -338,6 +352,7 @@ test(
     const consoleErrors = collectConsoleErrors(page);
     try {
       await page.goto('/admin/login', { waitUntil: 'load' });
+      await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
       await page.evaluate(() => {
         indexedDB.deleteDatabase('localforage');
         localStorage.clear();
@@ -346,13 +361,25 @@ test(
       await page.goto('/admin/login?returnTo=/rest/resource/training-student%253Astudent', {
         waitUntil: 'load',
       });
-      await page.getByPlaceholder('Your Username').fill('admin');
-      await page.getByPlaceholder('Your Password').fill('123456');
+      await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+      const usernameInput = page.getByPlaceholder('Your Username');
+      const passwordInput = page.getByPlaceholder('Your Password');
+      await usernameInput.fill('admin');
+      await passwordInput.fill('123456');
+      await expect(usernameInput).toHaveValue('admin');
+      await expect(passwordInput).toHaveValue('123456');
       await expect(page.getByPlaceholder('Please input captcha')).not.toHaveValue('');
 
       const initialSelect = waitForStudentSelect(page);
+      const loginResponse = page.waitForResponse(response => {
+        const url = new URL(response.url());
+        return (
+          response.request().method() === 'POST' && url.pathname === '/api/home/user/passport/login'
+        );
+      });
       await page.getByRole('button', { name: 'Login', exact: true }).click();
       try {
+        expect((await loginResponse).ok()).toBeTruthy();
         await expect(page).toHaveURL(studentResourceUrl);
         await initialSelect;
       } finally {

package/repo-e2e/specs/home-user-account.spec.ts

@@ -591,11 +591,18 @@ test(
   { tag: ['@account', '@admin'] },
   async ({ page }) => {
     await page.goto('/admin/', { waitUntil: 'load' });
+    await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
     if (page.url().includes('/admin/login')) {
-      await page.getByPlaceholder('Your Username').fill('admin');
-      await page.getByPlaceholder('Your Password').fill('123456');
+      const usernameInput = page.getByPlaceholder('Your Username');
+      const passwordInput = page.getByPlaceholder('Your Password');
+      await usernameInput.fill('admin');
+      await passwordInput.fill('123456');
+      await expect(usernameInput).toHaveValue('admin');
+      await expect(passwordInput).toHaveValue('123456');
       await expect(page.getByPlaceholder('Please input captcha')).not.toHaveValue('');
+      const loginResponse = waitForApiResponse(page, 'POST', passportLoginApiPath);
       await page.getByRole('button', { name: 'Login', exact: true }).click();
+      expect((await loginResponse).ok()).toBeTruthy();
       await expect(page).not.toHaveURL(/\/admin\/login(?:\?|$)/);
     }
 

package/scripts/upgrade.test.ts

@@ -0,0 +1,147 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import test from 'node:test';
+
+import { mergeFrameworkE2eAssets, reconcileFrameworkE2ePackageJson } from './upgrade.ts';
+
+const frameworkFiles = [
+  'repo-e2e/config/playwright.config.ts',
+  'repo-e2e/scripts/runE2e.ts',
+  'repo-e2e/specs/cabloy-basic.spec.ts',
+  'repo-e2e/specs/home-user-account.spec.ts',
+  'repo-e2e/specs/a-commerce.spec.ts',
+];
+
+function writeFile(root: string, path: string, content: string): void {
+  const file = resolve(root, path);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, content);
+}
+
+function readPackage(root: string): {
+  scripts: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+} {
+  return JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf-8'));
+}
+
+function fixture(): { root: string; project: string; source: string; dispose(): void } {
+  const root = mkdtempSync(resolve(tmpdir(), 'cabloy-upgrade-e2e-'));
+  const project = resolve(root, 'project');
+  const source = resolve(root, 'source');
+  writeFile(project, '__CABLOY_BASIC__', '');
+  writeFile(
+    project,
+    'package.json',
+    `${JSON.stringify(
+      {
+        scripts: {
+          'test:e2e': 'node repo-e2e/scripts/runE2e.ts --clean',
+          'test:e2e:fast': 'node repo-e2e/scripts/runE2e.ts --fast',
+          'test:project': 'node project-tests.ts',
+        },
+        dependencies: { '@playwright/test': '^1.0.0', 'project-owned': '^2.0.0' },
+        devDependencies: { 'another-tool': '^3.0.0' },
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  writeFile(
+    source,
+    'package.json',
+    `${JSON.stringify({ scripts: { 'test:e2e': 'node repo-e2e/scripts/runE2e.ts' }, devDependencies: { '@playwright/test': '^1.62.1' } })}\n`,
+  );
+  for (const path of frameworkFiles) {
+    writeFile(project, path, `old ${path}`);
+    writeFile(source, path, `new ${path}`);
+  }
+  writeFile(project, 'repo-e2e/specs/project-owned.spec.ts', 'project browser test');
+  writeFile(project, 'repo-e2e/config/playwright.basic.config.ts', 'legacy config');
+  return { root, project, source, dispose: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test('reconciles one managed E2E script and removes only the known retired fast script', () => {
+  const { project, source, dispose } = fixture();
+  try {
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    const first = readFileSync(resolve(project, 'package.json'), 'utf-8');
+    const pkg = readPackage(project);
+    assert.equal(pkg.scripts['test:e2e'], 'node repo-e2e/scripts/runE2e.ts');
+    assert.equal(Object.hasOwn(pkg.scripts, 'test:e2e:fast'), false);
+    assert.equal(pkg.scripts['test:project'], 'node project-tests.ts');
+    assert.deepEqual(pkg.dependencies, { 'project-owned': '^2.0.0' });
+    assert.deepEqual(pkg.devDependencies, {
+      'another-tool': '^3.0.0',
+      '@playwright/test': '^1.62.1',
+    });
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    assert.equal(readFileSync(resolve(project, 'package.json'), 'utf-8'), first);
+  } finally {
+    dispose();
+  }
+});
+
+test('preserves a customized fast alias and project-owned browser specs', () => {
+  const { project, source, dispose } = fixture();
+  try {
+    const pkg = readPackage(project);
+    pkg.scripts['test:e2e:fast'] = 'node project-tests.ts --quick';
+    writeFile(project, 'package.json', `${JSON.stringify(pkg, null, 2)}\n`);
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    mergeFrameworkE2eAssets(false, project, source);
+    assert.equal(readPackage(project).scripts['test:e2e:fast'], 'node project-tests.ts --quick');
+    for (const path of frameworkFiles) {
+      assert.equal(readFileSync(resolve(project, path), 'utf-8'), `new ${path}`);
+    }
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/specs/project-owned.spec.ts'), 'utf-8'),
+      'project browser test',
+    );
+    assert.equal(existsSync(resolve(project, 'repo-e2e/config/playwright.basic.config.ts')), false);
+  } finally {
+    dispose();
+  }
+});
+
+test('isolated dry-run reports changes without writing files or contacting npm', () => {
+  const { project, source, dispose } = fixture();
+  const before = readFileSync(resolve(project, 'package.json'), 'utf-8');
+  try {
+    reconcileFrameworkE2ePackageJson(true, project, source);
+    mergeFrameworkE2eAssets(true, project, source);
+    assert.equal(readFileSync(resolve(project, 'package.json'), 'utf-8'), before);
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/scripts/runE2e.ts'), 'utf-8'),
+      'old repo-e2e/scripts/runE2e.ts',
+    );
+    assert.equal(existsSync(resolve(project, 'repo-e2e/config/playwright.basic.config.ts')), true);
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/specs/project-owned.spec.ts'), 'utf-8'),
+      'project browser test',
+    );
+  } finally {
+    dispose();
+  }
+});
+
+test('Start edition is not reconciled by the Basic framework E2E upgrader', () => {
+  const { project, source, dispose } = fixture();
+  try {
+    rmSync(resolve(project, '__CABLOY_BASIC__'));
+    writeFile(project, '__CABLOY_START__', '');
+    const before = readFileSync(resolve(project, 'package.json'), 'utf-8');
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    mergeFrameworkE2eAssets(false, project, source);
+    assert.equal(readFileSync(resolve(project, 'package.json'), 'utf-8'), before);
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/scripts/runE2e.ts'), 'utf-8'),
+      'old repo-e2e/scripts/runE2e.ts',
+    );
+  } finally {
+    dispose();
+  }
+});

package/scripts/upgrade.ts

@@ -68,7 +68,8 @@ const FRAMEWORK_E2E_FILES_CABLOY_BASIC: string[] = [
   'repo-e2e/specs/a-commerce.spec.ts',
 ];
 
-const FRAMEWORK_E2E_SCRIPT_NAMES_CABLOY_BASIC: string[] = ['test:e2e', 'test:e2e:fast'];
+const FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC = 'test:e2e';
+const LEGACY_FRAMEWORK_E2E_FAST_SCRIPT_CABLOY_BASIC = 'node repo-e2e/scripts/runE2e.ts --fast';
 
 const FRAMEWORK_E2E_DEV_DEPENDENCY_CABLOY_BASIC = '@playwright/test';
 
@@ -147,9 +148,9 @@ function copyDirectory(src: string, dest: string): void {
   cpSync(src, dest, { recursive: true, filter: shouldCopyPath });
 }
 
-function resolveEdition(): 'basic' | 'start' {
-  const hasBasic = existsSync(resolve(ROOT_DIR, '__CABLOY_BASIC__'));
-  const hasStart = existsSync(resolve(ROOT_DIR, '__CABLOY_START__'));
+function resolveEdition(rootDir = ROOT_DIR): 'basic' | 'start' {
+  const hasBasic = existsSync(resolve(rootDir, '__CABLOY_BASIC__'));
+  const hasStart = existsSync(resolve(rootDir, '__CABLOY_START__'));
   if (hasBasic === hasStart) {
     throw new Error(
       hasBasic
@@ -226,12 +227,16 @@ async function extractTarball(tarballPath: string, targetDir: string): Promise<v
   }
 }
 
-function mergeFrameworkE2eAssets(dryRun?: boolean): void {
-  if (!isCabloyBasic()) return;
+export function mergeFrameworkE2eAssets(
+  dryRun?: boolean,
+  rootDir = ROOT_DIR,
+  tempDir = TEMP_DIR,
+): void {
+  if (resolveEdition(rootDir) !== 'basic') return;
 
   for (const dir of FRAMEWORK_E2E_DIRS_CABLOY_BASIC) {
-    const src = resolve(TEMP_DIR, dir);
-    const dest = resolve(ROOT_DIR, dir);
+    const src = resolve(tempDir, dir);
+    const dest = resolve(rootDir, dir);
     if (!existsSync(src)) {
       throw new Error(`Expected framework E2E directory in package: ${dir}`);
     }
@@ -243,8 +248,8 @@ function mergeFrameworkE2eAssets(dryRun?: boolean): void {
   }
 
   for (const file of FRAMEWORK_E2E_FILES_CABLOY_BASIC) {
-    const src = resolve(TEMP_DIR, file);
-    const dest = resolve(ROOT_DIR, file);
+    const src = resolve(tempDir, file);
+    const dest = resolve(rootDir, file);
     if (!existsSync(src)) {
       throw new Error(`Expected framework E2E file in package: ${file}`);
     }
@@ -265,7 +270,7 @@ function mergeFrameworkE2eAssets(dryRun?: boolean): void {
     'repo-e2e/specs/a-commerce/commerce.spec.ts',
   ];
   for (const file of legacyFrameworkFiles) {
-    const dest = resolve(ROOT_DIR, file);
+    const dest = resolve(rootDir, file);
     if (!existsSync(dest)) continue;
     if (dryRun) {
       log(`  [dry-run] Remove legacy framework E2E file: ${file}`);
@@ -334,11 +339,15 @@ function reconcileGovernanceAssets(dryRun?: boolean): void {
   }
 }
 
-function reconcileFrameworkE2ePackageJson(dryRun?: boolean): void {
-  if (!isCabloyBasic()) return;
+export function reconcileFrameworkE2ePackageJson(
+  dryRun?: boolean,
+  rootDir = ROOT_DIR,
+  tempDir = TEMP_DIR,
+): void {
+  if (resolveEdition(rootDir) !== 'basic') return;
 
-  const projectPackagePath = resolve(ROOT_DIR, 'package.json');
-  const sourcePackagePath = resolve(TEMP_DIR, 'package.json');
+  const projectPackagePath = resolve(rootDir, 'package.json');
+  const sourcePackagePath = resolve(tempDir, 'package.json');
   const projectPackage = readPackageJson(projectPackagePath);
   const sourcePackage = readPackageJson(sourcePackagePath);
   const sourcePlaywrightVersion =
@@ -349,19 +358,30 @@ function reconcileFrameworkE2ePackageJson(dryRun?: boolean): void {
     );
   }
 
+  const sourceScript = sourcePackage.scripts?.[FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC];
+  if (!sourceScript) {
+    throw new Error(
+      `Expected framework E2E script in package.json: ${FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC}`,
+    );
+  }
+
   let changed = false;
-  for (const name of FRAMEWORK_E2E_SCRIPT_NAMES_CABLOY_BASIC) {
-    const sourceValue = sourcePackage.scripts?.[name];
-    if (!sourceValue) {
-      throw new Error(`Expected framework E2E script in package.json: ${name}`);
-    }
-    if (projectPackage.scripts?.[name] === sourceValue) continue;
+  if (projectPackage.scripts?.[FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC] !== sourceScript) {
     changed = true;
     if (dryRun) {
-      log(`  [dry-run] Set package.json scripts.${name}`);
+      log(`  [dry-run] Set package.json scripts.${FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC}`);
     } else {
       projectPackage.scripts ??= {};
-      projectPackage.scripts[name] = sourceValue;
+      projectPackage.scripts[FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC] = sourceScript;
+    }
+  }
+
+  if (projectPackage.scripts?.['test:e2e:fast'] === LEGACY_FRAMEWORK_E2E_FAST_SCRIPT_CABLOY_BASIC) {
+    changed = true;
+    if (dryRun) {
+      log('  [dry-run] Remove package.json scripts.test:e2e:fast (retired framework value)');
+    } else {
+      delete projectPackage.scripts['test:e2e:fast'];
     }
   }
 
@@ -635,7 +655,9 @@ async function main(): Promise<void> {
   }
 }
 
-main().catch(err => {
-  console.error(`\nUpgrade failed: ${err.message}`);
-  process.exit(1);
-});
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch(err => {
+    console.error(`\nUpgrade failed: ${err.message}`);
+    process.exit(1);
+  });
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.157",
+  "version": "1.1.158",
   "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.155",
+  "version": "1.1.156",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

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

@@ -2,6 +2,7 @@ import type { glob } from '@cabloy/module-glob';
 import type { VonaConfigMeta, VonaMetaFlavor, VonaMetaMode } from '@cabloy/module-info';
 
 import { BeanCliBase } from '@cabloy/cli';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import nodemon from 'nodemon';
 import { rimraf } from 'rimraf';
@@ -11,10 +12,23 @@ import type { VonaBinConfigOptions } from './toolsBin/types.ts';
 import { getImportEsm } from '../utils.ts';
 import { generateVonaMeta } from './toolsBin/generateVonaMeta.ts';
 
+export function resolveDevMode(mode: unknown): 'dev' | 'test' {
+  if (mode === undefined || mode === 'dev') return 'dev';
+  if (mode === 'test') return 'test';
+  throw new Error('Invalid --mode: expected dev or test');
+}
+
+export function resolveTestWorkers(mode: 'dev' | 'test', workers: unknown): number | undefined {
+  if (mode !== 'test') return workers as number | undefined;
+  if (workers === undefined || workers === 1) return 1;
+  throw new Error('--mode=test requires --workers=1');
+}
+
 declare module '@cabloy/cli' {
   interface ICommandArgv {
     workers?: number;
     flavor?: VonaMetaFlavor;
+    mode?: VonaMetaMode;
   }
 }
 
@@ -30,17 +44,49 @@ export class CliBinDev extends BeanCliBase {
 
   async _dev(projectPath: string) {
     const { argv } = this.context;
-    const mode: VonaMetaMode = 'dev';
+    const mode = resolveDevMode(argv.mode);
+    const workers = resolveTestWorkers(mode, argv.workers);
     const flavor: VonaMetaFlavor = argv.flavor || 'normal';
     const configMeta: VonaConfigMeta = { flavor, mode };
     const configOptions: VonaBinConfigOptions = {
       appDir: projectPath,
       runtimeDir: '.vona',
-      workers: argv.workers,
+      workers,
     };
-    const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
-    await this._run(projectPath, modulesMeta);
-    await rimraf(path.join(projectPath, '.vona'));
+    try {
+      const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+      if (mode === 'test') {
+        await this._runTest(projectPath);
+      } else {
+        await this._run(projectPath, modulesMeta);
+      }
+    } finally {
+      await rimraf(path.join(projectPath, '.vona'));
+    }
+  }
+
+  async _runTest(projectPath: string) {
+    const child = spawn(process.execPath, [getImportEsm(), '.vona/bootstrap.ts'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+    const forwardSignal = (signal: NodeJS.Signals) => child.kill(signal);
+    const onInterrupt = () => forwardSignal('SIGINT');
+    const onTerminate = () => forwardSignal('SIGTERM');
+    process.on('SIGINT', onInterrupt);
+    process.on('SIGTERM', onTerminate);
+    try {
+      await new Promise<void>((resolve, reject) => {
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+          if (code === 0) resolve();
+          else reject(new Error(`Test-mode dev server exited: ${signal ?? code}`));
+        });
+      });
+    } finally {
+      process.off('SIGINT', onInterrupt);
+      process.off('SIGTERM', onTerminate);
+    }
   }
 
   async _run(projectPath: string, _modulesMeta: Awaited<ReturnType<typeof glob>>) {

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

@@ -3,7 +3,7 @@ export default {
   info: {
     version: '5.0.0',
     title: 'Cli: Bin: Dev',
-    usage: 'npm run vona :bin:dev -- [--workers=] [--flavor=]',
+    usage: 'npm run vona :bin:dev -- [--workers=] [--flavor=] [--mode=dev|test]',
   },
   options: {
     workers: {
@@ -14,5 +14,10 @@ export default {
       description: 'flavor',
       type: 'string',
     },
+    mode: {
+      description: 'dev or test',
+      type: 'string',
+      choices: ['dev', 'test'],
+    },
   },
 };

package/vona/packages-cli/cli-set-api/test/binDevMode.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it } from 'node:test';
+
+import { CliBinDev, resolveDevMode, resolveTestWorkers } from '../src/lib/bean/cli.bin.dev.ts';
+import command from '../src/lib/command/bin.dev.ts';
+
+describe('bin.dev mode', () => {
+  it('defaults to dev and accepts test explicitly', () => {
+    assert.equal(resolveDevMode(undefined), 'dev');
+    assert.equal(resolveDevMode('dev'), 'dev');
+    assert.equal(resolveDevMode('test'), 'test');
+    assert.deepEqual(command.options.mode.choices, ['dev', 'test']);
+  });
+
+  it('rejects invalid modes before runtime generation', () => {
+    for (const value of ['', 'prod', 'unknown', true, ['dev', 'test'], null]) {
+      assert.throws(() => resolveDevMode(value), /Invalid --mode: expected dev or test/);
+    }
+  });
+
+  it('forces one worker in test mode without changing dev workers', () => {
+    assert.equal(resolveTestWorkers('test', undefined), 1);
+    assert.equal(resolveTestWorkers('test', 1), 1);
+    assert.equal(resolveTestWorkers('dev', undefined), undefined);
+    assert.equal(resolveTestWorkers('dev', 3), 3);
+    for (const workers of [0, 2, '1', null, [1]]) {
+      assert.throws(() => resolveTestWorkers('test', workers), /requires --workers=1/);
+    }
+  });
+
+  it('supervises test-mode bootstrap exit without starting a server', async () => {
+    const projectPath = mkdtempSync(join(tmpdir(), 'vona-bin-dev-mode-'));
+    try {
+      mkdirSync(join(projectPath, '.vona'));
+      writeFileSync(join(projectPath, '.vona/register.js'), '');
+      const cli = Object.create(CliBinDev.prototype) as CliBinDev;
+      for (const code of [0, 7]) {
+        writeFileSync(join(projectPath, '.vona/bootstrap.ts'), `process.exit(${code});`);
+        if (code === 0) {
+          await cli._runTest(projectPath);
+        } else {
+          await assert.rejects(cli._runTest(projectPath), /Test-mode dev server exited: 7/);
+        }
+      }
+    } finally {
+      rmSync(projectPath, { recursive: true, force: true });
+    }
+  });
+});