cabloy 5.1.229 → 5.1.231

package/vona/packages-vona/vona-core/src/lib/core/testClaim.test.ts

@@ -1,6 +1,8 @@
 import '@cabloy/json5';
+import type { Socket } from 'node:net';
+
 import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import {
   chmodSync,
   lstatSync,
@@ -11,6 +13,7 @@ import {
   rmSync,
   symlinkSync,
 } from 'node:fs';
+import { createServer } from 'node:http';
 import { hostname, tmpdir } from 'node:os';
 import path from 'node:path';
 import { test } from 'node:test';
@@ -363,6 +366,296 @@ test('broker serializes simultaneous updates and acknowledges durable intent bef
   }
 });
 
+test('broker reports safe failure phases without acknowledging invalid or unreadable claims', async () => {
+  const f = fixture();
+  let broker: Awaited<ReturnType<typeof startTestClaimBroker>> | undefined;
+  try {
+    const { claimPath } = await createTestClaim(f.projectPath, runId, 'unit', owner);
+    broker = await startTestClaimBroker(claimPath);
+    const env = transportEnv(broker.env);
+    const before = await readTestClaimFile(claimPath);
+    await assert.rejects(
+      sendTestClaimEvent(env, { type: 'status', status: 'SECRET_INVALID_STATUS' as any }),
+      { message: 'Managed test allocation registration failed (HTTP 409, validate)' },
+    );
+    assert.equal(await readTestClaimFile(claimPath), before);
+    await assert.rejects(
+      sendTestClaimEvent(
+        { ...env, VONA_TEST_CLAIM_TOKEN: '0'.repeat(64) },
+        { type: 'status', status: 'running' },
+      ),
+      { message: 'Managed test allocation registration failed (HTTP 403)' },
+    );
+    rmSync(claimPath);
+    await assert.rejects(sendTestClaimEvent(env, { type: 'status', status: 'running' }), {
+      message:
+        /^Managed test allocation registration failed \(HTTP 409, read, ENOENT(?:, native [23])?\)$/,
+    });
+  } finally {
+    await broker?.close();
+    f.dispose();
+  }
+});
+
+test(
+  'registration uses fresh connections after a blocked startup without replaying events',
+  { timeout: 45000 },
+  async () => {
+    const requests: {
+      connection: string | undefined;
+      authorization: string | undefined;
+      event: unknown;
+      socket: Socket;
+    }[] = [];
+    const server = createServer(async (req, res) => {
+      let body = '';
+      for await (const chunk of req) body += chunk.toString();
+      requests.push({
+        connection: req.headers.connection,
+        authorization: req.headers.authorization,
+        event: JSON.parse(body),
+        socket: req.socket,
+      });
+      res.writeHead(204).end();
+    });
+    await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+    let child: ReturnType<typeof spawn> | undefined;
+    let exited: Promise<number | null> | undefined;
+    let spawnError: Error | undefined;
+    try {
+      const address = server.address();
+      assert.ok(address && typeof address !== 'string');
+      const env = transportEnv({
+        VONA_TEST_CLAIM_URL: `http://127.0.0.1:${address.port}/event`,
+        VONA_TEST_CLAIM_TOKEN: 'a'.repeat(64),
+      });
+      const events = [
+        { type: 'status', status: 'running' },
+        { type: 'status', status: 'failed' },
+      ];
+      const script = `
+      import { setImmediate } from 'node:timers/promises';
+      import { sendTestClaimEvent } from ${JSON.stringify(new URL('./testClaim.ts', import.meta.url).href)};
+      const [env, events] = JSON.parse(process.argv[1]);
+      await sendTestClaimEvent(env, events[0]);
+      await setImmediate();
+      // Let the parent broker expire an idle connection while startup blocks this event loop.
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 6500);
+      await sendTestClaimEvent(env, events[1]);
+    `;
+      child = spawn(
+        process.execPath,
+        ['--input-type=module', '-e', script, JSON.stringify([env, events])],
+        {
+          stdio: 'ignore',
+          windowsHide: true,
+          timeout: 30000,
+          killSignal: 'SIGKILL',
+        },
+      );
+      child.once('error', error => {
+        spawnError = error;
+      });
+      exited = new Promise(resolve => child!.once('close', code => resolve(code)));
+      assert.equal(await exited, 0, 'claim client child failed');
+      assert.equal(spawnError, undefined);
+      assert.deepEqual(
+        requests.map(request => request.event),
+        events,
+      );
+      assert.deepEqual(
+        requests.map(request => request.connection),
+        ['close', 'close'],
+      );
+      assert.ok(
+        requests.every(request => request.authorization === `Bearer ${env.VONA_TEST_CLAIM_TOKEN}`),
+      );
+      assert.notEqual(requests[0].socket, requests[1].socket);
+    } finally {
+      if (child && child.exitCode === null && child.signalCode === null) child.kill('SIGKILL');
+      await exited;
+      server.closeAllConnections();
+      await new Promise<void>((resolve, reject) =>
+        server.close(error => (error ? reject(error) : resolve())),
+      );
+    }
+  },
+);
+
+test('containment requests do not reuse broker connections', async () => {
+  const requests: { connection: string | undefined; url: string | undefined; socket: Socket }[] =
+    [];
+  const server = createServer((req, res) => {
+    req.resume();
+    req.on('end', () => {
+      requests.push({ connection: req.headers.connection, url: req.url, socket: req.socket });
+      res.writeHead(204).end();
+    });
+  });
+  await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const address = server.address();
+    assert.ok(address && typeof address !== 'string');
+    const env = {
+      ...transportEnv({
+        VONA_TEST_CLAIM_URL: `http://127.0.0.1:${address.port}/event`,
+        VONA_TEST_CLAIM_TOKEN: 'a'.repeat(64),
+      }),
+      [TEST_CLAIM_WINDOWS_GUARDIAN_ENV]: 'windows-e2e-guardian',
+    };
+    const identity = { pid: 123, startTime: '133000000000000001', host: hostname() };
+    await assertTestClaimWindowsJob(env, identity);
+    await new Promise(resolve => setImmediate(resolve));
+    await assertTestClaimWindowsJob(env, identity);
+    assert.deepEqual(
+      requests.map(request => request.url),
+      ['/containment', '/containment'],
+    );
+    assert.deepEqual(
+      requests.map(request => request.connection),
+      ['close', 'close'],
+    );
+    assert.notEqual(requests[0].socket, requests[1].socket);
+  } finally {
+    server.closeAllConnections();
+    await new Promise<void>((resolve, reject) =>
+      server.close(error => (error ? reject(error) : resolve())),
+    );
+  }
+});
+
+test('registration waits beyond ten seconds for acknowledgement without replaying the event', async () => {
+  const received = Promise.withResolvers<() => void>();
+  let requests = 0;
+  const server = createServer((req, res) => {
+    requests++;
+    req.resume();
+    req.on('end', () => received.resolve(() => res.writeHead(204).end()));
+  });
+  let registration: Promise<void> | undefined;
+  await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const address = server.address();
+    assert.ok(address && typeof address !== 'string');
+    const env = transportEnv({
+      VONA_TEST_CLAIM_URL: `http://127.0.0.1:${address.port}/event`,
+      VONA_TEST_CLAIM_TOKEN: 'a'.repeat(64),
+    });
+    let settled = false;
+    registration = sendTestClaimEvent(env, { type: 'status', status: 'running' });
+    void registration.then(
+      () => {
+        settled = true;
+      },
+      () => {
+        settled = true;
+      },
+    );
+    const acknowledge = await received.promise;
+    await new Promise(resolve => setTimeout(resolve, 11000));
+    assert.equal(settled, false);
+    assert.equal(requests, 1);
+    acknowledge();
+    await registration;
+    assert.equal(requests, 1);
+  } finally {
+    server.closeAllConnections();
+    await registration?.catch(() => {});
+    await new Promise<void>((resolve, reject) =>
+      server.close(error => (error ? reject(error) : resolve())),
+    );
+  }
+});
+
+test(
+  'registration has a finite acknowledgement deadline and fails closed without replay',
+  { concurrency: false },
+  async t => {
+    const controller = new AbortController();
+    const timeout = AbortSignal.timeout.bind(AbortSignal);
+    let requests = 0;
+    const server = createServer(req => {
+      requests++;
+      req.resume();
+      req.on('end', () => {
+        timeout(20).addEventListener('abort', () => controller.abort(), { once: true });
+      });
+    });
+    const deadlines: number[] = [];
+    let registration: Promise<void> | undefined;
+    await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+    const mock = t.mock.method(AbortSignal, 'timeout', (milliseconds: number) => {
+      deadlines.push(milliseconds);
+      return controller.signal;
+    });
+    try {
+      const address = server.address();
+      assert.ok(address && typeof address !== 'string');
+      const env = transportEnv({
+        VONA_TEST_CLAIM_URL: `http://127.0.0.1:${address.port}/event`,
+        VONA_TEST_CLAIM_TOKEN: 'a'.repeat(64),
+      });
+      registration = sendTestClaimEvent(env, { type: 'status', status: 'running' });
+      await assert.rejects(registration, {
+        message: 'Managed test allocation registration failed (transport)',
+      });
+      assert.deepEqual(deadlines, [120000]);
+      assert.equal(requests, 1);
+    } finally {
+      mock.mock.restore();
+      server.closeAllConnections();
+      await registration?.catch(() => {});
+      await new Promise<void>((resolve, reject) =>
+        server.close(error => (error ? reject(error) : resolve())),
+      );
+    }
+  },
+);
+
+test('registration diagnostics accept only categorical headers and never response bodies', async () => {
+  let headers: Record<string, string> = {
+    'x-vona-claim-phase': 'write',
+    'x-vona-claim-code': 'EBUSY',
+    'x-vona-claim-native-code': '32',
+  };
+  const server = createServer((req, res) => {
+    req.resume();
+    res.writeHead(409, headers).end('SECRET_RESPONSE_BODY');
+  });
+  await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const address = server.address();
+    assert.ok(address && typeof address !== 'string');
+    const env = transportEnv({
+      VONA_TEST_CLAIM_URL: `http://127.0.0.1:${address.port}/event`,
+      VONA_TEST_CLAIM_TOKEN: 'a'.repeat(64),
+    });
+    await assert.rejects(sendTestClaimEvent(env, { type: 'status', status: 'running' }), {
+      message: 'Managed test allocation registration failed (HTTP 409, write, EBUSY, native 32)',
+    });
+    headers = {
+      'x-vona-claim-phase': 'SECRET_PATH',
+      'x-vona-claim-code': 'SECRET_TOKEN',
+      'x-vona-claim-native-code': '999999',
+    };
+    await assert.rejects(sendTestClaimEvent(env, { type: 'status', status: 'running' }), {
+      message: 'Managed test allocation registration failed (HTTP 409)',
+    });
+    await new Promise<void>((resolve, reject) =>
+      server.close(error => (error ? reject(error) : resolve())),
+    );
+    await assert.rejects(sendTestClaimEvent(env, { type: 'status', status: 'running' }), {
+      message: 'Managed test allocation registration failed (transport)',
+    });
+  } finally {
+    if (server.listening) {
+      await new Promise<void>((resolve, reject) =>
+        server.close(error => (error ? reject(error) : resolve())),
+      );
+    }
+  }
+});
+
 test('database confirmations and process registration cannot precede allocation intent', async () => {
   const f = fixture();
   let broker: Awaited<ReturnType<typeof startTestClaimBroker>> | undefined;

package/vona/packages-vona/vona-core/src/lib/core/testClaim.ts

@@ -662,9 +662,17 @@ export async function startTestClaimBroker(claimPath: string) {
   const update = (event: TestClaimEvent) => {
     if (closing) return Promise.reject(new Error('Test claim broker is closed'));
     const result = queue.then(async () => {
-      const manifest = await loadTestClaim(claimPath);
-      applyEvent(manifest, event);
-      await writeTestClaim(claimPath, manifest);
+      let phase = 'read';
+      try {
+        const manifest = await loadTestClaim(claimPath);
+        phase = 'validate';
+        applyEvent(manifest, event);
+        phase = 'write';
+        await writeTestClaim(claimPath, manifest);
+      } catch (error) {
+        if (error instanceof Error) Object.assign(error, { testClaimPhase: phase });
+        throw error;
+      }
     });
     queue = result.catch(() => {});
     return result;
@@ -692,8 +700,21 @@ export async function startTestClaimBroker(claimPath: string) {
       if (req.url === '/containment') await containment(parseTestClaimJson(body));
       else await update(parseTestClaimJson(body));
       res.writeHead(204).end();
-    } catch {
-      res.writeHead(409).end('Test claim registration rejected');
+    } catch (error) {
+      const failure = error as { testClaimPhase?: string; code?: string; nativeCode?: number };
+      const headers: Record<string, string> = {};
+      if (['read', 'validate', 'write'].includes(failure?.testClaimPhase!))
+        headers['x-vona-claim-phase'] = failure.testClaimPhase!;
+      if (['EEXIST', 'ENOENT', 'EBUSY', 'EACCES', 'EUNSAFE'].includes(failure?.code!))
+        headers['x-vona-claim-code'] = failure.code!;
+      if (
+        Number.isInteger(failure?.nativeCode) &&
+        failure.nativeCode! >= 0 &&
+        failure.nativeCode! <= 65535
+      ) {
+        headers['x-vona-claim-native-code'] = String(failure.nativeCode);
+      }
+      res.writeHead(409, headers).end('Test claim registration rejected');
     }
   });
   server.requestTimeout = 10000;
@@ -753,20 +774,35 @@ export function hasTestClaimTransport(env: TestClaimEnv = process.env) {
 }
 export async function sendTestClaimEvent(env: TestClaimEnv, event: TestClaimEvent) {
   if (!hasTestClaimTransport(env)) return;
+  let response: Response;
   try {
-    const response = await fetch(env[TEST_CLAIM_URL_ENV]!, {
+    response = await fetch(env[TEST_CLAIM_URL_ENV]!, {
       method: 'POST',
       headers: {
         'authorization': `Bearer ${env[TEST_CLAIM_TOKEN_ENV]}`,
+        // Startup can block past the broker's idle timeout; never reuse a stale socket.
+        'connection': 'close',
         'content-type': 'application/json',
       },
       body: JSON.stringify(event),
-      signal: AbortSignal.timeout(10000),
+      // Includes the serialized queue and durable Windows filesystem work (30s per operation).
+      signal: AbortSignal.timeout(120000),
       redirect: 'error',
     });
-    if (response.status !== 204) throw new Error('Registration rejected');
   } catch {
-    throw new Error('Managed test allocation registration failed');
+    throw new Error('Managed test allocation registration failed (transport)');
+  }
+  if (response.status !== 204) {
+    const details = [`HTTP ${response.status}`];
+    const phase = response.headers.get('x-vona-claim-phase');
+    const code = response.headers.get('x-vona-claim-code');
+    const nativeCode = response.headers.get('x-vona-claim-native-code');
+    if (['read', 'validate', 'write'].includes(phase!)) details.push(phase!);
+    if (['EEXIST', 'ENOENT', 'EBUSY', 'EACCES', 'EUNSAFE'].includes(code!)) details.push(code!);
+    if (nativeCode && /^\d{1,5}$/.test(nativeCode) && Number(nativeCode) <= 65535)
+      details.push(`native ${nativeCode}`);
+    await response.body?.cancel().catch(() => {});
+    throw new Error(`Managed test allocation registration failed (${details.join(', ')})`);
   }
 }
 
@@ -784,6 +820,8 @@ export async function assertTestClaimWindowsJob(env: TestClaimEnv, identity: Tes
       method: 'POST',
       headers: {
         'authorization': `Bearer ${env[TEST_CLAIM_TOKEN_ENV]}`,
+        // Startup can block past the broker's idle timeout; never reuse a stale socket.
+        'connection': 'close',
         'content-type': 'application/json',
       },
       body: JSON.stringify(query),

package/vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.test.ts

@@ -164,61 +164,185 @@ test(
   },
 );
 
+async function holdWindowsClaimFile(file: string) {
+  // A native handle denying FILE_SHARE_DELETE prevents replacement. Node opens
+  // with delete sharing, so hold this deliberately through a separate PS7 peer.
+  const { spawn } = await import('node:child_process');
+  const script =
+    '$h=[System.IO.File]::Open($env:VONA_CLAIM_TEST_FILE,[System.IO.FileMode]::Open,[System.IO.FileAccess]::Read,[System.IO.FileShare]::Read);[Console]::Out.WriteLine("ready");[Console]::Out.Flush();[Console]::In.ReadLine()|Out-Null;$h.Dispose()';
+  const child = spawn('pwsh', ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', script], {
+    windowsHide: true,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env, VONA_CLAIM_TEST_FILE: file },
+  });
+  child.stderr.resume();
+  child.stdin.on('error', () => {});
+  const exited = new Promise<void>(resolve => child.once('close', () => resolve()));
+  const release = async () => {
+    child.stdin.end('\n');
+    const timer = setTimeout(() => child.kill(), 5000);
+    try {
+      await exited;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('fixture handle readiness timeout')), 15000);
+      child.once('error', error => {
+        clearTimeout(timer);
+        reject(error);
+      });
+      child.once('exit', () => {
+        clearTimeout(timer);
+        reject(new Error('fixture handle exited'));
+      });
+      let output = '';
+      child.stdout.on('data', chunk => {
+        output += String(chunk);
+        if (output.includes('ready')) {
+          clearTimeout(timer);
+          resolve();
+        }
+      });
+    });
+    return release;
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
+
 test(
-  'Windows replacement failure retains old manifest and removes flushed temporary file',
+  'Windows replacement retries a transient sharing conflict within the same call',
   { skip: process.platform !== 'win32' },
   async () => {
     const f = await fixture();
+    let release: (() => Promise<void>) | undefined;
+    let replacement: Promise<unknown> | undefined;
     try {
       await createTestClaimFile(f.file, 'previous committed inventory');
-      // A native handle denying FILE_SHARE_DELETE prevents replacement. Node opens
-      // with delete sharing, so hold this deliberately through a separate PS7 peer.
-      const { spawn } = await import('node:child_process');
-      const script =
-        '$h=[System.IO.File]::Open($env:VONA_CLAIM_TEST_FILE,[System.IO.FileMode]::Open,[System.IO.FileAccess]::Read,[System.IO.FileShare]::Read);[Console]::Out.WriteLine("ready");[Console]::Out.Flush();[Console]::In.ReadLine()|Out-Null;$h.Dispose()';
-      const child = spawn(
+      release = await holdWindowsClaimFile(f.file);
+      assert.equal(await readTestClaimFile(f.file), 'previous committed inventory');
+      let settled = false;
+      // Attach a rejection handler before polling, including the failure path.
+      replacement = replaceTestClaimFile(f.file, 'new committed inventory').then(
+        () => {
+          settled = true;
+        },
+        error => {
+          settled = true;
+          return error;
+        },
+      );
+      const deadline = Date.now() + 10000;
+      while (!(await readdir(f.directory)).some(name => name.endsWith('.tmp'))) {
+        if (settled) {
+          assert.equal(await replacement, undefined);
+          assert.fail('replacement completed before the held handle was released');
+        }
+        assert.ok(Date.now() < deadline, 'replacement temporary file was not observed');
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+      await release();
+      release = undefined;
+      assert.equal(await replacement, undefined);
+      assert.equal(await readTestClaimFile(f.file), 'new committed inventory');
+      assert.deepEqual(await readdir(f.directory), ['claim.json']);
+    } finally {
+      await release?.();
+      await replacement;
+      await f.close();
+    }
+  },
+);
+
+test(
+  'Windows persistent sharing conflict fails boundedly and retains the old manifest',
+  { skip: process.platform !== 'win32' },
+  async () => {
+    const f = await fixture();
+    let release: (() => Promise<void>) | undefined;
+    try {
+      await createTestClaimFile(f.file, 'previous committed inventory');
+      release = await holdWindowsClaimFile(f.file);
+      assert.equal(await readTestClaimFile(f.file), 'previous committed inventory');
+      const started = performance.now();
+      await assert.rejects(replaceTestClaimFile(f.file, 'uncommitted'), {
+        code: 'EBUSY',
+        nativeCode: 32,
+        message: 'Unsafe Windows test claim filesystem operation (EBUSY, nativeCode=32)',
+      });
+      const elapsed = performance.now() - started;
+      assert.ok(elapsed >= 900 && elapsed < 10000, `bounded retry took ${elapsed}ms`);
+      assert.equal(await readFile(f.file, 'utf8'), 'previous committed inventory');
+      assert.deepEqual(await readdir(f.directory), ['claim.json']);
+      await release();
+      release = undefined;
+      await replaceTestClaimFile(f.file, 'new committed inventory');
+      assert.equal(await readTestClaimFile(f.file), 'new committed inventory');
+    } finally {
+      await release?.();
+      await f.close();
+    }
+  },
+);
+
+test(
+  'Windows replacement rejects a read-only target without changing its contents or attributes',
+  { skip: process.platform !== 'win32' },
+  async () => {
+    const f = await fixture();
+    const attributes = (script: string) =>
+      execFileSync(
         'pwsh',
-        ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', script],
+        [
+          '-NoLogo',
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          `$ErrorActionPreference='Stop';${script}`,
+        ],
         {
           windowsHide: true,
-          stdio: ['pipe', 'pipe', 'pipe'],
+          encoding: 'utf8',
           env: { ...process.env, VONA_CLAIM_TEST_FILE: f.file },
         },
+      ).trim();
+    let original: number | undefined;
+    try {
+      await createTestClaimFile(f.file, 'previous committed inventory');
+      original = Number(
+        attributes('[int][System.IO.File]::GetAttributes($env:VONA_CLAIM_TEST_FILE)'),
+      );
+      assert.ok(Number.isInteger(original));
+      const readOnly = (original & ~128) | 1;
+      attributes(
+        `[System.IO.File]::SetAttributes($env:VONA_CLAIM_TEST_FILE,[System.IO.FileAttributes]${readOnly})`,
+      );
+      assert.equal(await readTestClaimFile(f.file), 'previous committed inventory');
+      await assert.rejects(replaceTestClaimFile(f.file, 'uncommitted'), {
+        code: 'EACCES',
+        nativeCode: 5,
+        message: 'Unsafe Windows test claim filesystem operation (EACCES, nativeCode=5)',
+      });
+      assert.equal(await readTestClaimFile(f.file), 'previous committed inventory');
+      assert.equal(
+        Number(attributes('[int][System.IO.File]::GetAttributes($env:VONA_CLAIM_TEST_FILE)')),
+        readOnly,
       );
+      assert.deepEqual(await readdir(f.directory), ['claim.json']);
+    } finally {
       try {
-        await new Promise<void>((resolve, reject) => {
-          const timer = setTimeout(
-            () => reject(new Error('fixture handle readiness timeout')),
-            15000,
+        if (original !== undefined) {
+          attributes(
+            `[System.IO.File]::SetAttributes($env:VONA_CLAIM_TEST_FILE,[System.IO.FileAttributes]${original})`,
           );
-          child.once('error', error => {
-            clearTimeout(timer);
-            reject(error);
-          });
-          child.once('exit', () => {
-            clearTimeout(timer);
-            reject(new Error('fixture handle exited'));
-          });
-          child.stdout.once('data', chunk => {
-            clearTimeout(timer);
-            assert.match(String(chunk), /ready/);
-            resolve();
-          });
-        });
-        await assert.rejects(replaceTestClaimFile(f.file, 'uncommitted'));
-        assert.equal(await readFile(f.file, 'utf8'), 'previous committed inventory');
-        assert.deepEqual(await readdir(f.directory), ['claim.json']);
+        }
       } finally {
-        child.stdin.end('\n');
-        await new Promise<void>(resolve => {
-          if (child.exitCode !== null) resolve();
-          else child.once('exit', () => resolve());
-        });
+        await f.close();
       }
-      await replaceTestClaimFile(f.file, 'new committed inventory');
-      assert.equal(await readTestClaimFile(f.file), 'new committed inventory');
-    } finally {
-      await f.close();
     }
   },
 );

package/vona/packages-vona/vona-core/src/lib/core/testClaimFilesystemWindows.cs

@@ -209,10 +209,20 @@ namespace Cabloy {
                     bool created = false;
                     try {
                         Write(temp, bytes); created = true;
-                        using (SafeFileHandle h = Open(file, false, GenericRead)) Private(h);
-                        // No COPY_ALLOWED: same-directory local-NTFS replacement only.
-                        // Both files are flushed first. Failure is never acknowledged.
-                        Check(MoveFileExW(temp, file, 1 | 8)); created = false;
+                        for (int attempt = 0; ; attempt++) {
+                            try {
+                                // Surface denied delete sharing as a sharing violation, not a rename access denial.
+                                // Close our own non-delete-sharing handle before attempting the rename.
+                                using (SafeFileHandle h = Open(file, false, GenericRead | DeleteAccess)) Private(h);
+                                // No COPY_ALLOWED: same-directory local-NTFS replacement of the flushed temporary file.
+                                // Failure is never acknowledged.
+                                Check(MoveFileExW(temp, file, 1 | 8));
+                                created = false; break;
+                            } catch (Win32Exception e) {
+                                if ((e.NativeErrorCode != 32 && e.NativeErrorCode != 33) || attempt >= 10) throw;
+                            }
+                            System.Threading.Thread.Sleep(100);
+                        }
                         using (SafeFileHandle h = Open(file, false, GenericRead)) { if (Read(h) != content) throw Unsafe(); }
                     } finally {
                         if (created) {
@@ -222,8 +232,8 @@ namespace Cabloy {
                     return result;
                 }
             } catch (Win32Exception e) {
-                return new Dictionary<string, object> { { "ok", false }, { "code", e.NativeErrorCode == 80 || e.NativeErrorCode == 183 ? "EEXIST" : e.NativeErrorCode == 2 || e.NativeErrorCode == 3 ? "ENOENT" : "EUNSAFE" } };
-            } catch { return new Dictionary<string, object> { { "ok", false }, { "code", "EUNSAFE" } }; }
+                return new Dictionary<string, object> { { "ok", false }, { "code", e.NativeErrorCode == 80 || e.NativeErrorCode == 183 ? "EEXIST" : e.NativeErrorCode == 2 || e.NativeErrorCode == 3 ? "ENOENT" : e.NativeErrorCode == 32 || e.NativeErrorCode == 33 ? "EBUSY" : e.NativeErrorCode == 5 ? "EACCES" : "EUNSAFE" }, { "nativeCode", e.NativeErrorCode } };
+            } catch { return new Dictionary<string, object> { { "ok", false }, { "code", "EUNSAFE" }, { "nativeCode", 0 } }; }
         }
     }
 }