cabloy 5.1.216 → 5.1.217

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('');

package/repo-e2e/specs/a-commerce.spec.ts

@@ -801,7 +801,7 @@ test(
 
       const addResponse = waitForApiResponse(page, 'POST', '/api/commerce/trade/cart/items');
       await page.getByRole('button', { name: 'Add to cart', exact: true }).click();
-      await addResponse;
+      expect((await addResponse).ok()).toBeTruthy();
 
       await page.getByRole('link', { name: /^Cart/ }).click();
       await expect(page).toHaveURL(/\/commerce\/commerce\/trade\/cart(?:\/|$)/);
@@ -1343,7 +1343,7 @@ test(
       await expect(page.getByText('$45.99')).toBeVisible();
       const addResponse = waitForApiResponse(page, 'POST', '/api/commerce/trade/cart/items');
       await page.getByRole('button', { name: 'Add to cart', exact: true }).click();
-      await addResponse;
+      expect((await addResponse).ok()).toBeTruthy();
       await page.getByRole('link', { name: /^Cart/ }).click();
       await expect(page).toHaveURL(/\/commerce\/commerce\/trade\/cart(?:\/|$)/);
       await page.getByRole('link', { name: 'Checkout', exact: true }).click();
@@ -1662,6 +1662,10 @@ test(
         /\/commerce-admin\/rest\/resource\/commerce-promotion(?:%3A|:|%253A)couponTemplate\/create(?:[/?#]|$)/,
       );
 
+      await expect(adminPage.locator('html')).toHaveAttribute(
+        'data-zova-hydrated',
+        'commerceAdmin',
+      );
       for (const groupName of [
         'Basic Information',
         'Discount Policy',
@@ -1765,6 +1769,10 @@ test(
       expectTableIdentity(parentId);
 
       await adminPage.goto(categoryCreatePath, { waitUntil: 'load' });
+      await expect(adminPage.locator('html')).toHaveAttribute(
+        'data-zova-hydrated',
+        'commerceAdmin',
+      );
       const parentPublication = adminPage
         .getByRole('group', { name: 'Published' })
         .getByRole('combobox');

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

@@ -536,6 +536,10 @@ test(
       expect(profile.ok()).toBeTruthy();
       const profileBody = (await profile.json()).data;
       expect(profileBody.avatar).toEqual(expect.any(String));
+      const avatarResponse = await request.get(profileBody.avatar);
+      expect(avatarResponse.ok()).toBeTruthy();
+      expect(avatarResponse.headers()['content-type']).toMatch(/^image\//);
+      expect((await avatarResponse.body()).length).toBeGreaterThan(0);
       expect(pageErrors).toEqual([]);
       expect(consoleErrors).toEqual([]);
     } finally {

package/repo-e2e/specs/markdown.spec.ts

@@ -590,15 +590,26 @@ test(
       await linkInput.fill('');
       await linkInput.press('Enter');
       await expect(editor.locator('h1 a')).toHaveCount(0);
+      const persistedText = `Link removal saved ${suffix}`;
+      await editor.press('ControlOrMeta+End');
+      await editor.press('Enter');
+      await editor.pressSequentially(persistedText);
+      const productUpdate = waitForApiResponse(
+        adminPage,
+        'PATCH',
+        `${productActionPath}/${productId}`,
+      );
       await adminPage.getByRole('button', { name: 'Submit', exact: true }).click();
+      expect((await productUpdate).ok()).toBeTruthy();
       const productResponseAfterLinkRemoval = await adminPage.request.get(
         `${productActionPath}/${productId}`,
         { headers },
       );
       expect(productResponseAfterLinkRemoval.ok()).toBeTruthy();
-      expect(
-        (await productResponseAfterLinkRemoval.json()).productContentForm.descriptionMarkdown,
-      ).not.toContain('https://example.com/updated');
+      const savedMarkdown = (await productResponseAfterLinkRemoval.json()).productContentForm
+        .descriptionMarkdown;
+      expect(savedMarkdown).toContain(persistedText);
+      expect(savedMarkdown).not.toContain('https://example.com/updated');
       expect(adminPageErrors).toEqual([]);
       expect(adminConsoleErrors).toEqual([]);
     } finally {

package/scripts/generateOpenapiIsolated.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { once } from 'node:events';
 import { createServer } from 'node:http';
+import { resolve } from 'node:path';
 import { test } from 'node:test';
 
 import type { GuardianResult, OwnedProcess } from './runIsolatedTest.ts';
@@ -46,7 +47,7 @@ test('launches only a loopback single-worker test-mode Vona service', () => {
     '--flavor=normal',
     '--mode=test',
   ]);
-  assert.equal(command.cwd, `${ROOT_DIR}/vona`);
+  assert.equal(command.cwd, resolve(ROOT_DIR, 'vona'));
   assert.deepEqual(command.env, {
     CUSTOM: 'keep',
     VONA_TEST_READY_KEY: 'test-key',
@@ -81,6 +82,9 @@ function lifecycleFixture(options: { readyFailure?: boolean; stopFailure?: boole
     finish,
     result,
     dependencies: {
+      // These legacy fixtures assert POSIX signal/stop semantics; Windows cooperative
+      // shutdown is exercised separately with explicit platform injection.
+      platform: 'darwin' as const,
       start: async () => {
         events.push('start');
         return server;