cabloy 5.1.216 → 5.1.218

package/repo-e2e/scripts/managedTest.test.ts

@@ -21,6 +21,7 @@ async function fixture(
     group?: number;
     noProfile?: boolean;
     exited?: boolean;
+    platform?: NodeJS.Platform;
   } = {},
 ) {
   const root = await realpath(await mkdtemp(join(tmpdir(), 'cabloy-managed-browser-')));
@@ -72,7 +73,9 @@ async function fixture(
       VONA_TEST_CLAIM_URL: 'http://127.0.0.1:1234/event',
       VONA_TEST_CLAIM_TOKEN: 'a'.repeat(64),
       TMPDIR: temporaryRoot,
+      ...(options.platform === 'win32' ? { TEMP: temporaryRoot, TMP: temporaryRoot } : {}),
     },
+    platform: options.platform ?? 'linux',
     projectPath,
     sendEvent: async (_env: NodeJS.ProcessEnv, event: TestClaimEvent) => {
       const stage = event.type === 'process' ? event.process.stage : event.type;
@@ -85,13 +88,24 @@ async function fixture(
       if (options.fault === 'inspect') throw new Error('inspection failed');
       return {
         pid,
-        pgid: options.group ?? pid,
-        startTime: 'Wed Oct 14 01:02:03 2026',
+        ...(options.platform === 'win32' ? {} : { pgid: options.group ?? pid }),
+        startTime: options.platform === 'win32' ? '134000000000000000' : 'Wed Oct 14 01:02:03 2026',
         host: 'test-host',
         state: 'S',
         args: '',
       };
     },
+    assertWindowsJob: async (
+      _env: NodeJS.ProcessEnv,
+      identity: { pid: number; startTime: string; host: string },
+    ) => {
+      const role = identity.pid === process.pid ? 'worker' : 'browser';
+      calls.push(`job-${role}`);
+      assert.equal(identity.startTime, '134000000000000000');
+      assert.equal(identity.host, 'test-host');
+      assert.equal(Object.hasOwn(identity, 'pgid'), false);
+      if (options.fault === `job-${role}`) throw new Error('designated Job membership unavailable');
+    },
     waitForGroupExit: async (pgid: number) => {
       calls.push('wait');
       assert.equal(pgid, 4242);
@@ -277,7 +291,7 @@ for (const invalid of ['tmpdir', 'owner', 'transport', 'connect', 'symlink']) {
       if (invalid === 'transport') f.dependencies.env.VONA_TEST_CLAIM_TOKEN = '';
       if (invalid === 'symlink') {
         await rm(f.temporaryRoot, { recursive: true });
-        await symlink(f.root, f.temporaryRoot);
+        await symlink(f.root, f.temporaryRoot, process.platform === 'win32' ? 'junction' : 'dir');
       }
       const options =
         invalid === 'connect'
@@ -364,6 +378,104 @@ test('rejects an explicit external profile argument before launch', async () =>
   }
 });
 
+test('Windows proves worker and browser Job membership without per-browser POSIX claims', async () => {
+  const f = await fixture({ platform: 'win32' });
+  try {
+    await useManagedBrowser(
+      f.browserOptions,
+      async () => {
+        f.calls.push('use');
+      },
+      f.dependencies,
+    );
+    assert.deepEqual(f.calls, [
+      'inspect',
+      'job-worker',
+      'launch',
+      'inspect',
+      'job-browser',
+      'connect',
+      'use',
+      'close',
+    ]);
+    assert.deepEqual(f.events, []);
+  } finally {
+    await f.dispose();
+  }
+});
+
+for (const fault of ['job-worker', 'job-browser', 'launch', 'inspect', 'connect', 'close']) {
+  test(`Windows fails closed on ${fault} without acknowledging browser drainage`, async () => {
+    const f = await fixture({ platform: 'win32', fault });
+    try {
+      await assert.rejects(useManagedBrowser(f.browserOptions, async () => {}, f.dependencies));
+      assert.deepEqual(f.events, []);
+      assert.ok(!f.calls.includes('wait'));
+      if (['job-worker', 'inspect'].includes(fault)) assert.ok(!f.calls.includes('launch'));
+      if (fault === 'job-browser') {
+        assert.ok(f.calls.includes('close'));
+        assert.ok(!f.calls.includes('connect'));
+      }
+    } finally {
+      await f.dispose();
+    }
+  });
+}
+
+for (const variable of ['TEMP', 'TMP', 'TMPDIR', 'temp']) {
+  test(`Windows rejects inherited ${variable} outside its run before browser launch`, async () => {
+    const f = await fixture({ platform: 'win32' });
+    try {
+      const env: NodeJS.ProcessEnv = { ...f.dependencies.env, [variable]: '/unowned' };
+      await assert.rejects(
+        useManagedBrowser(f.browserOptions, async () => {}, { ...f.dependencies, env }),
+        /run-owned temporary paths/,
+      );
+      assert.deepEqual(f.calls, []);
+    } finally {
+      await f.dispose();
+    }
+  });
+}
+
+test('Windows normalizes custom temporary environment names without mutating caller options', async () => {
+  const f = await fixture({ platform: 'win32' });
+  const env = { temp: '/unowned', Tmp: '/unowned', tmpdir: '/unowned', CUSTOM: 'keep' };
+  try {
+    await useManagedBrowser(
+      { ...f.browserOptions, launchOptions: { env } },
+      async () => {},
+      f.dependencies,
+    );
+    assert.deepEqual(f.launchedOptions()?.env, {
+      TEMP: f.temporaryRoot,
+      TMP: f.temporaryRoot,
+      TMPDIR: f.temporaryRoot,
+      CUSTOM: 'keep',
+    });
+    assert.equal(env.temp, '/unowned');
+    assert.equal(env.Tmp, '/unowned');
+    assert.equal(env.tmpdir, '/unowned');
+  } finally {
+    await f.dispose();
+  }
+});
+
+test('Windows closes a browser with an escaping actual profile without connecting', async () => {
+  const f = await fixture({ platform: 'win32', profile: '/unowned/profile' });
+  try {
+    await assert.rejects(
+      useManagedBrowser(f.browserOptions, async () => {}, f.dependencies),
+      /outside its run-owned area/,
+    );
+    assert.deepEqual(f.events, []);
+    assert.ok(f.calls.includes('close'));
+    assert.ok(!f.calls.includes('connect'));
+  } finally {
+    await f.dispose();
+  }
+});
+
 test('discovers exact Chromium and Firefox argv profiles; uses the temporary area for WebKit', () => {
   assert.equal(
     discoverBrowserProfile(['browser', '--user-data-dir=/run/tmp/with spaces']),

package/repo-e2e/scripts/managedTest.ts

@@ -24,6 +24,7 @@ import {
 } from '../../scripts/testClaimProcesses.ts';
 import {
   assertTestClaimSafePath,
+  assertTestClaimWindowsJob,
   getTestClaimPaths,
   hasTestClaimTransport,
   sendTestClaimEvent,
@@ -49,6 +50,11 @@ interface ManagedBrowserDependencies {
   sendEvent: (env: NodeJS.ProcessEnv, event: TestClaimEvent) => Promise<void>;
   inspectProcess: (pid: number) => Promise<TestProcessSnapshot>;
   waitForGroupExit: (pgid: number) => Promise<void>;
+  platform?: NodeJS.Platform;
+  assertWindowsJob?: (
+    env: NodeJS.ProcessEnv,
+    identity: { pid: number; startTime: string; host: string },
+  ) => Promise<void>;
 }
 
 function assertWithin(root: string, target: string) {
@@ -94,6 +100,8 @@ export async function useManagedBrowser(
   },
 ) {
   const { env } = dependencies;
+  const windows = (dependencies.platform ?? process.platform) === 'win32';
+  const assertWindowsJob = dependencies.assertWindowsJob ?? assertTestClaimWindowsJob;
   const runId = env.VONA_TEST_RUN_ID;
   if (!runId || !hasTestClaimTransport(env)) {
     throw new Error('Managed browser requires an isolated test claim transport');
@@ -103,8 +111,16 @@ export async function useManagedBrowser(
   const { dataRoot } = getTestClaimPaths(dependencies.projectPath, runId);
   const temporaryRoot = resolve(dataRoot, 'tmp');
   assertTestRunOwner(dataRoot, runId);
-  if (env.TMPDIR !== temporaryRoot || !lstatSync(temporaryRoot).isDirectory()) {
-    throw new Error('Managed browser requires the inherited run-owned TMPDIR');
+  const tempKeys = windows
+    ? Object.keys(env).filter(key => ['TEMP', 'TMP', 'TMPDIR'].includes(key.toUpperCase()))
+    : ['TMPDIR'];
+  if (
+    (windows &&
+      !['TEMP', 'TMP', 'TMPDIR'].every(name => tempKeys.some(key => key.toUpperCase() === name))) ||
+    tempKeys.some(key => env[key] !== temporaryRoot) ||
+    !lstatSync(temporaryRoot).isDirectory()
+  ) {
+    throw new Error('Managed browser requires inherited run-owned temporary paths');
   }
   assertWithin(dataRoot, temporaryRoot);
 
@@ -120,16 +136,37 @@ export async function useManagedBrowser(
   }
   // Browser profile creation happens in the Playwright worker's inherited
   // TMPDIR. A custom browser environment must not redirect child temp writes.
-  if (launchOptions.env) launchOptions.env = { ...launchOptions.env, TMPDIR: temporaryRoot };
+  if (launchOptions.env) {
+    const browserEnv = { ...launchOptions.env };
+    if (windows) {
+      for (const key of Object.keys(browserEnv)) {
+        if (['TEMP', 'TMP', 'TMPDIR'].includes(key.toUpperCase())) delete browserEnv[key];
+      }
+      browserEnv.TEMP = temporaryRoot;
+      browserEnv.TMP = temporaryRoot;
+    }
+    launchOptions.env = { ...browserEnv, TMPDIR: temporaryRoot };
+  }
+  if (windows) {
+    const identity = await dependencies.inspectProcess(process.pid);
+    if (identity.pid !== process.pid || !identity.startTime || identity.state.startsWith('Z')) {
+      throw new Error('Managed browser worker has no live process identity');
+    }
+    await assertWindowsJob(env, {
+      pid: identity.pid,
+      startTime: identity.startTime,
+      host: identity.host,
+    });
+  }
   const processRecord: TestClaimProcess = {
     id: randomUUID(),
     role: 'browser',
     stage: 'pending',
     profilePath: temporaryRoot,
   };
-  // Acknowledgement precedes spawning. A rejected launch leaves this intent
-  // pending: launchServer may have spawned before it rejects or the worker dies.
-  await dependencies.sendEvent(env, { type: 'process', process: processRecord });
+  // POSIX browsers own independent groups; Windows browsers inherit the verified
+  // guardian Job. Only that guardian can acknowledge whole-Job drainage.
+  if (!windows) await dependencies.sendEvent(env, { type: 'process', process: processRecord });
   const server = await options.browserType.launchServer({
     handleSIGINT: false,
     ...launchOptions,
@@ -147,25 +184,37 @@ export async function useManagedBrowser(
       child.exitCode !== null ||
       child.signalCode !== null ||
       identity.pid !== child.pid ||
-      identity.pgid !== child.pid ||
       !identity.startTime ||
-      identity.state.startsWith('Z')
+      identity.state.startsWith('Z') ||
+      (!windows && identity.pgid !== child.pid)
     ) {
-      throw new Error('Managed browser has no independent live process group');
+      throw new Error(
+        windows
+          ? 'Managed browser has no live process identity'
+          : 'Managed browser has no independent live process group',
+      );
     }
     const profilePath = discoverBrowserProfile(child.spawnargs) ?? temporaryRoot;
     assertWithin(temporaryRoot, profilePath);
-    const record: TestClaimProcess = {
-      ...processRecord,
-      stage: 'registered',
-      pid: identity.pid,
-      pgid: identity.pgid,
-      startTime: identity.startTime,
-      host: identity.host,
-      profilePath,
-    };
-    await dependencies.sendEvent(env, { type: 'process', process: record });
-    registration = record;
+    if (windows) {
+      await assertWindowsJob(env, {
+        pid: identity.pid,
+        startTime: identity.startTime,
+        host: identity.host,
+      });
+    } else {
+      const record: TestClaimProcess = {
+        ...processRecord,
+        stage: 'registered',
+        pid: identity.pid,
+        pgid: identity.pgid,
+        startTime: identity.startTime,
+        host: identity.host,
+        profilePath,
+      };
+      await dependencies.sendEvent(env, { type: 'process', process: record });
+      registration = record;
+    }
     const browser = await options.browserType.connect(server.wsEndpoint(), { slowMo });
     await use(browser);
   } finally {

package/repo-e2e/scripts/managedTestImports.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { mkdtemp, mkdir, rm, symlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { relative, resolve } from 'node:path';
+import { dirname, relative, resolve } from 'node:path';
 import test from 'node:test';
 import { fileURLToPath } from 'node:url';
 
@@ -51,8 +51,60 @@ test('fixture import gate allows type-only imports and catches runtime bypass fo
   );
 });
 
-test('production gate rejects empty trees, bypasses in nested specs, and symlinks', async () => {
-  const root = await mkdtemp(resolve(tmpdir(), 'cabloy-managed-imports-'));
+test('fixture import gate rejects absolute imports even when they point to managedTest', () => {
+  const spec = resolve(specRoot, 'example.spec.ts');
+  assert.deepEqual(
+    violations(`import { test } from ${JSON.stringify(fixturePath.replaceAll('\\', '/'))};`, spec),
+    ['application spec must import test from managedTest'],
+  );
+});
+
+test('production gate rejects directory links, including Windows junctions', async () => {
+  const root = await mkdtemp(resolve(tmpdir(), 'cabloy-managed-directory-link-'));
+  try {
+    const nested = resolve(root, 'nested');
+    await mkdir(nested);
+    await symlink(
+      nested,
+      resolve(root, 'linked'),
+      process.platform === 'win32' ? 'junction' : 'dir',
+    );
+    await assert.rejects(assertManagedTestImports(root), /cannot contain symlinks/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('production gate rejects file symlinks when supported', async t => {
+  // Windows OS temp and the checkout may be on different drives, preventing relative imports.
+  const root = await mkdtemp(resolve(dirname(fixturePath), '.cabloy-managed-file-link-'));
+  try {
+    const spec = resolve(root, 'application.spec.ts');
+    const managedPath = relative(root, fixturePath).replaceAll('\\', '/');
+    await writeFile(spec, `import { test } from ${JSON.stringify(managedPath)};`);
+    await assertManagedTestImports(root);
+    try {
+      await symlink(spec, resolve(root, 'linked.spec.ts'), 'file');
+    } catch (error) {
+      if (
+        process.platform === 'win32' &&
+        ['EPERM', 'EACCES', 'ENOTSUP'].includes((error as NodeJS.ErrnoException).code ?? '')
+      ) {
+        t.skip(
+          `Windows file symlink creation unavailable (${(error as NodeJS.ErrnoException).code})`,
+        );
+        return;
+      }
+      throw error;
+    }
+    await assert.rejects(assertManagedTestImports(root), /cannot contain symlinks/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('production gate rejects empty trees and bypasses in nested specs', async () => {
+  const root = await mkdtemp(resolve(dirname(fixturePath), '.cabloy-managed-imports-'));
   try {
     await assert.rejects(assertManagedTestImports(root), /no specs/);
     const nested = resolve(root, 'nested');
@@ -66,8 +118,6 @@ test('production gate rejects empty trees, bypasses in nested specs, and symlink
     const managedPath = relative(nested, fixturePath).replaceAll('\\', '/');
     await writeFile(spec, `import { test } from ${JSON.stringify(managedPath)};`);
     await assertManagedTestImports(root);
-    await symlink(spec, resolve(root, 'linked.spec.ts'));
-    await assert.rejects(assertManagedTestImports(root), /cannot contain symlinks/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }

package/repo-e2e/scripts/runE2e.test.ts

@@ -0,0 +1,109 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import test from 'node:test';
+
+import { runPlaywright } from './runE2e.ts';
+import { buildSpecFilter, parseE2eArgs } from './runE2eArgs.ts';
+
+function withCli(
+  callback: (fixture: {
+    rootDir: string;
+    configFile: string;
+    specsDir: string;
+    outputFile: string;
+  }) => void,
+  exitCode = 0,
+): void {
+  const rootDir = mkdtempSync(resolve(tmpdir(), 'cabloy e2e café [x]+(y).$-'));
+  try {
+    const packageDir = resolve(rootDir, 'node_modules', '@playwright', 'test');
+    const specsDir = resolve(rootDir, 'specs 中文 [selected]');
+    const configFile = resolve(rootDir, 'config café [ui].ts');
+    const outputFile = resolve(rootDir, 'observed argv.json');
+    mkdirSync(packageDir, { recursive: true });
+    mkdirSync(specsDir);
+    writeFileSync(resolve(rootDir, 'package.json'), JSON.stringify({ type: 'module' }));
+    writeFileSync(
+      resolve(packageDir, 'package.json'),
+      JSON.stringify({ name: '@playwright/test', exports: { './cli': './cli.cjs' } }),
+    );
+    writeFileSync(
+      resolve(packageDir, 'cli.cjs'),
+      `require('node:fs').writeFileSync(${JSON.stringify(outputFile)}, JSON.stringify({
+        args: process.argv.slice(2), cwd: process.cwd(), execPath: process.execPath,
+      })); process.exit(${exitCode});`,
+    );
+    for (const name of ['cabloy-basic', 'home-user-account']) {
+      writeFileSync(resolve(specsDir, `${name}.spec.ts`), '');
+    }
+    callback({ rootDir, configFile, specsDir, outputFile });
+  } finally {
+    rmSync(rootDir, { recursive: true, force: true });
+  }
+}
+
+test('launches the resolved JavaScript CLI through Node without a shell in Unicode/space paths', () => {
+  withCli(fixture => {
+    const playwrightArgs = [
+      '--grep',
+      'café 中文 "quoted" & $HOME; $(not-a-command) | > ignored',
+      '--trace=retain-on-failure',
+      '--output',
+      'artifacts with spaces 中文',
+    ];
+    runPlaywright({
+      ...fixture,
+      parsed: parseE2eArgs(
+        ['cabloy-basic', 'home-user-account', ...playwrightArgs],
+        fixture.specsDir,
+      ),
+    });
+    const observed = JSON.parse(readFileSync(fixture.outputFile, 'utf8'));
+    assert.equal(observed.cwd, realpathSync(fixture.rootDir));
+    assert.equal(observed.execPath, process.execPath);
+    assert.deepEqual(observed.args, [
+      'test',
+      '--config',
+      fixture.configFile,
+      buildSpecFilter(resolve(fixture.specsDir, 'cabloy-basic.spec.ts')),
+      buildSpecFilter(resolve(fixture.specsDir, 'home-user-account.spec.ts')),
+      ...playwrightArgs,
+    ]);
+    for (let index = 0; index < 2; index++) {
+      const name = ['cabloy-basic', 'home-user-account'][index];
+      const selectedPath = resolve(fixture.specsDir, `${name}.spec.ts`).replaceAll('\\', '/');
+      const filter = new RegExp(observed.args[3 + index]);
+      assert.match(selectedPath, filter);
+      assert.doesNotMatch(`${selectedPath}.unselected`, filter);
+      assert.doesNotMatch(selectedPath.replace('.spec.ts', 'XspecXts'), filter);
+    }
+  });
+});
+
+test('keeps all-spec discovery and combines tags without changing additional arguments', () => {
+  withCli(fixture => {
+    runPlaywright({
+      ...fixture,
+      parsed: parseE2eArgs(['--tag', '@web', '--grep=@flow', '--list'], fixture.specsDir),
+    });
+    const observed = JSON.parse(readFileSync(fixture.outputFile, 'utf8'));
+    assert.deepEqual(observed.args, [
+      'test',
+      '--config',
+      fixture.configFile,
+      '--grep=(?=.*(?:@flow))(?=.*@web)',
+      '--list',
+    ]);
+  });
+});
+
+test('propagates the Playwright CLI failure rather than reporting a successful launch', () => {
+  withCli(fixture => {
+    assert.throws(
+      () => runPlaywright({ ...fixture, parsed: parseE2eArgs([], fixture.specsDir) }),
+      (error: Error & { status?: number }) => error.status === 23,
+    );
+  }, 23);
+});

package/repo-e2e/scripts/runE2e.ts

@@ -1,31 +1,46 @@
 import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
 import { createServer } from 'node:net';
 import { resolve } from 'node:path';
 
-import {
-  E2E_CONFIG_FILE,
-  E2E_LOCAL_BASE_URL,
-  E2E_PORT,
-  E2E_ROOT_DIR,
-  E2E_SPECS_DIR,
-} from './e2e.ts';
-import { assertManagedTestImports } from './managedTestImports.ts';
-import { combineGreps, parseE2eArgs } from './runE2eArgs.ts';
-
-function run(command: string, args: string[]): void {
+import type { ParsedE2eArgs } from './runE2eArgs.ts';
+
+import { buildSpecFilter, combineGreps, parseE2eArgs } from './runE2eArgs.ts';
+
+export function runPlaywright(options: {
+  rootDir: string;
+  configFile: string;
+  specsDir: string;
+  parsed: ParsedE2eArgs;
+}): void {
+  const { rootDir, configFile, specsDir, parsed } = options;
+  const require = createRequire(resolve(rootDir, 'package.json'));
+  const cli = require.resolve('@playwright/test/cli');
+  const specFilters = parsed.specNames.map(name =>
+    buildSpecFilter(resolve(specsDir, `${name}.spec.ts`)),
+  );
+  const args = [
+    cli,
+    'test',
+    '--config',
+    configFile,
+    ...specFilters,
+    ...combineGreps(parsed.playwrightArgs, parsed.tags),
+  ];
   // eslint-disable-next-line no-console
-  console.log(`\n===> ${[command, ...args].join(' ')}`);
-  execFileSync(command, args, {
-    cwd: E2E_ROOT_DIR,
+  console.log(`\n===> ${[process.execPath, ...args].join(' ')}`);
+  execFileSync(process.execPath, args, {
+    cwd: rootDir,
     stdio: 'inherit',
+    shell: false,
   });
 }
 
-async function assertPortAvailable(): Promise<void> {
+async function assertPortAvailable(port: number): Promise<void> {
   const server = createServer();
   await new Promise<void>((resolvePromise, reject) => {
     server.once('error', reject);
-    server.listen(E2E_PORT, '127.0.0.1', () => {
+    server.listen(port, '127.0.0.1', () => {
       server.close(error => {
         if (error) reject(error);
         else resolvePromise();
@@ -34,28 +49,32 @@ async function assertPortAvailable(): Promise<void> {
   });
 }
 
-const parsed = parseE2eArgs(process.argv.slice(2), E2E_SPECS_DIR);
-if (
-  process.env.VONA_TEST_RUN_ID &&
-  process.env.APP_NAME !== `cabtest${process.env.VONA_TEST_RUN_ID}`
-) {
-  throw new Error('Managed E2E test identity does not match its run ID');
-}
-if (process.env.VONA_TEST_RUN_ID) {
-  await assertManagedTestImports();
-} else {
-  await assertPortAvailable();
+async function main(): Promise<void> {
+  const { E2E_CONFIG_FILE, E2E_LOCAL_BASE_URL, E2E_PORT, E2E_ROOT_DIR, E2E_SPECS_DIR } =
+    await import('./e2e.ts');
+  const parsed = parseE2eArgs(process.argv.slice(2), E2E_SPECS_DIR);
+  if (
+    process.env.VONA_TEST_RUN_ID &&
+    process.env.APP_NAME !== `cabtest${process.env.VONA_TEST_RUN_ID}`
+  ) {
+    throw new Error('Managed E2E test identity does not match its run ID');
+  }
+  if (process.env.VONA_TEST_RUN_ID) {
+    const { assertManagedTestImports } = await import('./managedTestImports.ts');
+    await assertManagedTestImports();
+  } else {
+    await assertPortAvailable(E2E_PORT);
+  }
+
+  runPlaywright({
+    rootDir: E2E_ROOT_DIR,
+    configFile: E2E_CONFIG_FILE,
+    specsDir: E2E_SPECS_DIR,
+    parsed,
+  });
+
+  // eslint-disable-next-line no-console
+  console.log(`E2E target: ${E2E_LOCAL_BASE_URL}`);
 }
 
-const playwrightCommand = resolve(
-  E2E_ROOT_DIR,
-  'node_modules',
-  '.bin',
-  process.platform === 'win32' ? 'playwright.cmd' : 'playwright',
-);
-const specPaths = parsed.specNames.map(name => resolve(E2E_SPECS_DIR, `${name}.spec.ts`));
-const playwrightArgs = combineGreps(parsed.playwrightArgs, parsed.tags);
-run(playwrightCommand, ['test', '--config', E2E_CONFIG_FILE, ...specPaths, ...playwrightArgs]);
-
-// eslint-disable-next-line no-console
-console.log(`E2E target: ${E2E_LOCAL_BASE_URL}`);
+if (import.meta.main) await main();

package/repo-e2e/scripts/runE2eArgs.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { resolve } from 'node:path';
 import test from 'node:test';
 
-import { buildTagGrep, combineGreps, parseE2eArgs } from './runE2eArgs.ts';
+import { buildSpecFilter, buildTagGrep, combineGreps, parseE2eArgs } from './runE2eArgs.ts';
 
 function withSpecs(callback: (specsDir: string) => void): void {
   const tempDir = mkdtempSync(resolve(tmpdir(), 'cabloy-e2e-args-'));
@@ -70,6 +70,21 @@ test('rejects removed clean and fast options', () => {
   });
 });
 
+test('spec filters normalize Windows paths and escape regex syntax literally', () => {
+  for (const specPath of [
+    '/synthetic/café 中文 [work]+(tree).$/specs/cabloy-basic.spec.ts',
+    'C:\\synthetic\\café 中文 [work]+(tree).$\\specs\\cabloy-basic.spec.ts',
+    '\\\\server\\share with spaces\\café [work]\\specs\\a-commerce.spec.ts',
+  ]) {
+    const normalized = specPath.replaceAll('\\', '/');
+    const filter = new RegExp(buildSpecFilter(specPath));
+    assert.match(normalized, filter);
+    assert.doesNotMatch(`${normalized}.unselected`, filter);
+    assert.doesNotMatch(`prefix${normalized}`, filter);
+    assert.doesNotMatch(normalized.replace('.spec.ts', 'XspecXts'), filter);
+  }
+});
+
 test('combines tags with an existing grep expression', () => {
   assert.equal(buildTagGrep(['@web', '@smoke']), '(?=.*@web)(?=.*@smoke)');
   assert.deepEqual(combineGreps(['--grep', '@flow'], ['@web', '@smoke']), [

package/repo-e2e/scripts/runE2eArgs.ts

@@ -36,6 +36,11 @@ function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+/** Playwright interprets positional file filters as regexes, including on Windows. */
+export function buildSpecFilter(specPath: string): string {
+  return `^${escapeRegExp(specPath.replaceAll('\\', '/'))}$`;
+}
+
 export function buildTagGrep(tags: string[]): string | undefined {
   if (tags.length === 0) return undefined;
   return tags.map(tag => `(?=.*${escapeRegExp(tag)})`).join('');