deadbyte-mcp 0.15.45 → 0.15.47

package/scripts/r73-atomic-benchmark.mjs

@@ -0,0 +1,39 @@
+import {createHash} from 'node:crypto';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {performance} from 'node:perf_hooks';
+import {pathToFileURL} from 'node:url';
+
+const baseline=process.argv[2];
+if(!baseline||!path.isAbsolute(baseline))throw new Error('absolute verified predecessor source required');
+const candidate=path.resolve('src/atomic-mutation.mjs');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const modules={baseline:(await import(pathToFileURL(baseline))).atomicMutation,
+  candidate:(await import(pathToFileURL(candidate))).atomicMutation};
+const rounds=[];
+for(const order of [['baseline','candidate'],['candidate','baseline'],['baseline','candidate'],['candidate','baseline']]){
+  for(const label of order){
+    const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r73-bench-'));
+    const target=path.join(root,'value.bin');
+    const initial=Buffer.from('before');await writeFile(target,initial);
+    const readState=async file=>{const bytes=await readFile(file);return {exists:true,sha256:sha(bytes)};};
+    let prior=sha(initial);
+    const times=[];
+    try{
+      for(let i=0;i<110;i++){
+        const next=Buffer.from(`bounded replacement ${i}`);
+        const start=performance.now();
+        await modules[label]({target,bytes:next,expected:prior,readState,
+          assertExpected(state,expected){if(state.sha256!==expected)throw new Error('benchmark identity drift');}});
+        const elapsed=performance.now()-start;
+        if(i>=10)times.push(elapsed);
+        prior=sha(next);
+      }
+      times.sort((a,b)=>a-b);
+      const at=q=>Number(times[Math.ceil(q*times.length)-1].toFixed(4));
+      rounds.push({label,n:times.length,p50_ms:at(.5),p95_ms:at(.95),max_ms:at(1)});
+    }finally{await rm(root,{recursive:true,force:true});}
+  }
+}
+console.log(JSON.stringify({schema:'deadbyte.r73-atomic-benchmark.v1',workload:'exact-precondition fsync+rename on isolated Windows scratch',rounds}));

package/src/atomic-mutation.mjs

@@ -1,6 +1,8 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { open, rename, rm, stat } from 'node:fs/promises';
+import { open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import {performance} from 'node:perf_hooks';
+import {acquireKernelExclusiveLock, verifyKernelLockBinary} from './kernel-lock-r74.mjs';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const LOCK_WAIT_MS = 10;
@@ -9,20 +11,90 @@ const LOCK_STALE_MS = 120000;
 
 async function acquireMutationLock(target) {
   const lock = `${target}.deadbyte-mutation.lock`;
-  const started = Date.now();
+  const kernelLock = `${target}.deadbyte-mutation.lock.kernel`;
+  const ownership = `${process.pid}:${Date.now()}:${randomBytes(16).toString('hex')}`;
+  const verified = await verifyKernelLockBinary();
+
+  if (verified.ok && process.env.DEADBYTE_R74_KERNEL_LOCK !== '0') {
+    try {
+      const existing = await readFile(lock, 'utf8').catch(() => null);
+      if (existing && existing.includes('abandoned')) {
+        throw new Error('atomic mutation lock abandoned; reconciliation required');
+      }
+    } catch (err) {
+      if (err.message.includes('abandoned')) throw err;
+    }
+
+    const releaseKernel = await acquireKernelExclusiveLock(kernelLock, {
+      timeoutMs: LOCK_TIMEOUT_MS,
+      pollMs: LOCK_WAIT_MS
+    });
+
+    try {
+      await writeFile(lock, ownership);
+    } catch (err) {
+      await releaseKernel().catch(() => {});
+      throw err;
+    }
+
+    return async () => {
+      let ownershipLost = false;
+      try {
+        const onDisk = await readFile(lock, 'utf8').catch(() => null);
+        if (onDisk !== ownership) {
+          ownershipLost = true;
+        }
+      } finally {
+        await releaseKernel().catch(() => {});
+        await rm(kernelLock, {force: true}).catch(() => {});
+        if (!ownershipLost) {
+          await rm(lock, {force: true}).catch(() => {});
+        }
+      }
+      if (ownershipLost) {
+        throw new Error('atomic mutation lock ownership lost');
+      }
+    };
+  }
+
+  const started = performance.now();
   while (true) {
     try {
       const handle = await open(lock, 'wx', 0o600);
-      await handle.writeFile(`${process.pid}\\n${Date.now()}\\n`);
-      await handle.sync();
-      await handle.close();
-      return async () => { await rm(lock, { force: true }).catch(() => {}); };
+      try {
+        await handle.writeFile(ownership);
+        await handle.sync();
+        await handle.close();
+      } catch (error) {
+        await handle.close().catch(() => {});
+        try { await rm(lock, {force:true}); }
+        catch { error.lock_cleanup_failed = true; }
+        throw error;
+      }
+      return async () => {
+        if (await readFile(lock, 'utf8').catch(() => null) !== ownership)
+          throw new Error('atomic mutation lock ownership lost');
+        await rm(lock, { force: true });
+      };
     } catch (error) {
       if (error?.code !== 'EEXIST') throw error;
-      if (Date.now() - started >= LOCK_TIMEOUT_MS) throw new Error('atomic mutation lock timed out');
+      if (performance.now() - started >= LOCK_TIMEOUT_MS) throw new Error('atomic mutation lock timed out');
       try {
         const info = await stat(lock);
-        if (Date.now() - info.mtimeMs > LOCK_STALE_MS) await rm(lock, { force: true }).catch(() => {});
+        if (Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+          const contents = await readFile(lock, 'utf8').catch(() => null);
+          const owner = Number(/^\d+/.exec(contents??'')?.[0]);
+          let ownerAlive = true;
+          if (Number.isSafeInteger(owner) && owner > 0) {
+            try { process.kill(owner, 0); }
+            catch (error) { ownerAlive = error?.code !== 'ESRCH'; }
+          }
+          if (!ownerAlive) {
+            // A check-then-unlink race can remove a *new* writer's lock. Without
+            // an atomic compare-and-delete primitive, preserve evidence and stop.
+            throw new Error('atomic mutation lock abandoned; reconciliation required');
+          }
+        }
       } catch (statError) {
         if (statError?.code !== 'ENOENT') throw statError;
       }
@@ -47,6 +119,8 @@ export async function atomicMutation({
     throw new Error('atomic mutation requires readState and assertExpected');
   }
   const releaseLock = await acquireMutationLock(target);
+  let committed = false;
+  let operationFailure = null;
   try {
     const before = await readState(target);
     assertExpected(before, expected);
@@ -68,6 +142,7 @@ export async function atomicMutation({
       if (authorityCheck) await authorityCheck();
 
       await rename(temp, target);
+      committed = true;
     } catch (error) {
       if (handle) await handle.close().catch(() => {});
       await rm(temp, { force: true }).catch(() => {});
@@ -87,7 +162,22 @@ export async function atomicMutation({
       failure.expected_after_sha256 = expectedAfter;
       throw failure;
     }
+  } catch (error) {
+    operationFailure = error;
+    throw error;
   } finally {
-    await releaseLock();
+    try { await releaseLock(); }
+    catch (error) {
+      if (operationFailure) operationFailure.lock_cleanup_failed = true;
+      else {
+        error.lock_cleanup_failed = true;
+        if (committed) {
+          error.outcome = 'FAILED_AFTER_UNKNOWN_EFFECT';
+          error.side_effect_state = 'unknown';
+          error.expected_after_sha256 = sha256Bytes(bytes);
+        }
+        throw error;
+      }
+    }
   }
 }