leerness 1.36.299 → 1.36.301

package/scripts/lazy-auto-track-probe.js

@@ -0,0 +1,87 @@
+'use strict';
+// T-0345: `lazy detect --auto-track` registers a task for each new TODO whose file no tracker row references, and
+// only those. A batch that mixed such files with a file a task already referenced registered every new TODO, so the
+// TODOs in the referenced file got tasks of their own as well. known-todos.json gains exactly the registered TODOs.
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const ENV = { ...process.env, LEERNESS_OFFLINE: '1', LEERNESS_NO_PROMPT: '1', LEERNESS_NO_LOCK_WARN: '1', LEERNESS_NO_AUTOCHCP: '1' };
+const arena = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-lazy-auto-track-'));
+let passed = 0, failed = 0, seq = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log('PASS ' + name); }
+  catch (error) { failed++; console.error('FAIL ' + name + ': ' + (error && error.stack || error)); }
+}
+const run = (d, args) => {
+  const r = cp.spawnSync(process.execPath, [CLI, ...args], { cwd: d, env: ENV, encoding: 'utf8', timeout: 120000, windowsHide: true });
+  assert.strictEqual(r.error, undefined, r.error && r.error.message);
+  return r;
+};
+// A project with the given source files and, for each entry of `referenced`, a task whose text names that file.
+function project(files, referenced = []) {
+  const d = path.join(arena, 'p' + (++seq));
+  fs.mkdirSync(d);
+  assert.strictEqual(run(d, ['init', d, '--yes', '--minimal']).status, 0, 'init');
+  for (const [name, text] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(d, name)), { recursive: true });
+    fs.writeFileSync(path.join(d, name), text);
+  }
+  for (const name of referenced) assert.strictEqual(run(d, ['task', 'add', `Clean up ${name}`, '--path', d]).status, 0, 'task add');
+  return d;
+}
+const tasks = d => {
+  const r = run(d, ['task', 'list', '--path', d, '--json']);
+  assert.strictEqual(r.status, 0, r.stdout + r.stderr);
+  const parsed = JSON.parse(r.stdout);
+  return (parsed.tasks || parsed).map(t => t.request);
+};
+const autoTracked = d => tasks(d).filter(request => /^TODO /.test(request)).sort();
+const known = d => {
+  const file = path.join(d, '.leerness', 'known-todos.json');
+  return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')).map(t => `${t.file}:${t.line}`).sort() : null;
+};
+const autoTrack = d => {
+  const r = run(d, ['lazy', 'detect', d, '--auto-track']);
+  assert.ok(r.status === 0 || r.status === 1, 'lazy detect exit ' + r.status + '\n' + r.stdout + r.stderr);
+  return r;
+};
+const SOURCES = {
+  'src/covered.js': '// TODO: first covered note\nfunction a() {}\n// FIXME: second covered note\n',
+  'src/fresh.js': 'function b() {}\n// TODO: fresh note\n',
+};
+try {
+  test('a mixed batch registers only the TODO in the file no task references', () => {
+    const d = project(SOURCES, ['src/covered.js']);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), ['TODO src/fresh.js:2']);
+    assert.deepStrictEqual(known(d), ['src/fresh.js:2']);
+    assert.strictEqual(tasks(d).filter(request => request === 'Clean up src/covered.js').length, 1, 'the referencing task is kept as it was');
+  });
+  test('running it again registers nothing more', () => {
+    const d = project(SOURCES, ['src/covered.js']);
+    autoTrack(d);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), ['TODO src/fresh.js:2']);
+    assert.deepStrictEqual(known(d), ['src/fresh.js:2']);
+  });
+  test('control: with no file referenced, every new TODO is registered', () => {
+    const d = project(SOURCES);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), ['TODO src/covered.js:1', 'TODO src/covered.js:3', 'TODO src/fresh.js:2']);
+    assert.deepStrictEqual(known(d), ['src/covered.js:1', 'src/covered.js:3', 'src/fresh.js:2']);
+  });
+  test('control: with every file referenced, nothing is registered and known-todos.json is not written', () => {
+    const d = project(SOURCES, ['src/covered.js', 'src/fresh.js']);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), []);
+    assert.strictEqual(known(d), null);
+  });
+} finally {
+  fs.rmSync(arena, { recursive: true, force: true });
+}
+console.log(`lazy auto-track probe: ${passed}/${passed + failed} passed (${process.platform})`);
+process.exitCode = failed ? 1 : 0;

package/scripts/lock-probe.js

@@ -35,6 +35,25 @@ const STALL_ABSOLUTE = process.env.LOCKPROBE_STALL_TARGET && path.isAbsolute(pro
 const STALL_PREFIX = String(process.env.LOCKPROBE_STALL_PREFIX || '').replace(/\\/g, '/').replace(/^\.?\/+/, '');
 const STALL_MS = Math.max(0, Math.min(10000, Number(process.env.LOCKPROBE_STALL_MS) || 0));
 const READY_FILE = process.env.LOCKPROBE_READY_FILE ? path.resolve(process.env.LOCKPROBE_READY_FILE) : null;
+// T-0346: a race's second command reports what it did at the stalled target (LOCKPROBE_REACH_TARGET) in
+//   LOCKPROBE_REACH_FILE, each report written after the operation ran: a read, open, stat or existence check of the
+//   target, and the result of its first attempt at the target's lock or at a lock the first command held when it
+//   stalled (EEXIST: contended; success: acquired, so not contended). The first command, given that file as
+//   LOCKPROBE_WAIT_FILE, keeps its publication stalled until a report exists (at most LOCKPROBE_WAIT_MAX_MS) and
+//   then for LOCKPROBE_STALL_MS more. A fixed stall alone could end before the second command had started, and a
+//   report written before the operation (review round 1) could be followed by the operation after the stall ended;
+//   either way the race passed without overlapping anything. scripts/race-overlap.js judges the reports.
+const targetMatcher = raw => {
+  const value = String(raw || '');
+  if (!value) return () => false;
+  if (path.isAbsolute(value)) { const full = norm(value).replace(/\\/g, '/'); return p => norm(p).replace(/\\/g, '/') === full; }
+  const rel = value.replace(/\\/g, '/').replace(/^\.?\/+/, '');
+  return p => relOf(norm(p)) === rel;
+};
+const REACH_FILE = process.env.LOCKPROBE_REACH_FILE ? path.resolve(process.env.LOCKPROBE_REACH_FILE) : null;
+const isReachTarget = REACH_FILE ? targetMatcher(process.env.LOCKPROBE_REACH_TARGET) : () => false;
+const WAIT_FILE = process.env.LOCKPROBE_WAIT_FILE ? path.resolve(process.env.LOCKPROBE_WAIT_FILE) : null;
+const WAIT_MAX_MS = Math.max(0, Math.min(60000, Number(process.env.LOCKPROBE_WAIT_MAX_MS) || 15000));
 let stalled = false;
 const shouldStall = p => {
   if (stalled || STALL_MS <= 0) return false;
@@ -48,11 +67,89 @@ const stall = ms => {
   try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); }
   catch { const until = Date.now() + ms; while (Date.now() < until) {} }
 };
+const _existsRaw = fs.existsSync.bind(fs);
+const _readRaw = fs.readFileSync.bind(fs);
+// A lock the first command held when it stalled (`heldOn` of its ready file, LOCKPROBE_REACH_LOCKS_FILE) counts too:
+// a second command that waits for such a lock is held up by the stalled section, even when it waits there before
+// touching the target, or never touches it (a plan add waiting for the plan lock while a restore publishes the
+// plan archive).
+const REACH_LOCKS_FILE = process.env.LOCKPROBE_REACH_LOCKS_FILE ? path.resolve(process.env.LOCKPROBE_REACH_LOCKS_FILE) : null;
+// Read once, when this preload starts. The race starts the second command only after it read the first command's
+// whole ready file, and the first command rewrites that file only after a report exists, so no rewrite is under
+// way now. Review round 2: the set was read lazily, and a read during a rewrite was cached as "holds no lock", which
+// hid a later lock taken after the release. A file that does not parse within 2 s marks every report
+// `heldUnknown`, and such a race does not count.
+let firstHeld = new Set(), firstHeldKnown = !REACH_LOCKS_FILE;
+if (REACH_LOCKS_FILE && REACH_FILE) {
+  const until = Date.now() + 2000;
+  for (;;) {
+    try { const heldOn = JSON.parse(_readRaw(REACH_LOCKS_FILE, 'utf8')).heldOn; if (Array.isArray(heldOn)) { firstHeld = new Set(heldOn); firstHeldKnown = true; break; } } catch {}
+    if (Date.now() >= until) break;
+    stall(10);
+  }
+}
+const heldByFirst = p => firstHeld.has(relOf(norm(p)));
+// The report holds the first completed access of the target (`read`: how and when) and the result of the first
+// attempt at one of those locks (`lock`: contended or acquired, and when). It is rewritten when either is first set.
+const report = firstHeldKnown ? {} : { heldUnknown: true };
+// Review round 3: a rewrite that failed (EACCES, say) left the earlier report standing, and its read then counted
+// although a later lock was taken after the release. So the report is trusted only with `complete: true`, written
+// when this process exits; a failed write marks it `failed` where it can, and the process exits with 97.
+let reportFailed = false;
+// LOCKPROBE_REPORT_FAIL_AFTER=n (tests of this module only): writes after the n-th fail as a read-only file would,
+// and the report cannot be removed either, the same for every user (a chmod does not stop root).
+const FAIL_AFTER = process.env.LOCKPROBE_REPORT_FAIL_AFTER === undefined ? Infinity : Number(process.env.LOCKPROBE_REPORT_FAIL_AFTER);
+let writes = 0;
+const writeReport = () => {
+  try {
+    if (++writes > FAIL_AFTER) throw Object.assign(new Error('injected report write failure'), { code: 'EACCES' });
+    fs.writeFileSync.call(fs, REACH_FILE, JSON.stringify(report), 'utf8');
+    return true;
+  } catch (error) {
+    reportFailed = true;
+    // Review round 4: fail at once, not only in the closing exit listener: a listener that runs after it could take
+    // a lock whose report then fails to land. The stale report is also removed where possible.
+    process.exitCode = 97;
+    if (writes <= FAIL_AFTER) { try { fs.unlinkSync.call(fs, REACH_FILE); } catch {} }
+    try { process.stderr.write(`lock-probe: the race report could not be written (${error && error.code || error})\n`); } catch {}
+    return false;
+  }
+};
+if (REACH_FILE) {
+  process.on('exit', () => {
+    if (!report.read && !report.lock && !reportFailed) return;
+    if (reportFailed) report.failed = true; else report.complete = true;
+    if (!writeReport() || report.failed) process.exitCode = 97;
+  });
+}
+const isWatchedLock = p => { const lock = String(p); return /\.lock$/i.test(lock) && (isReachTarget(lock.slice(0, -'.lock'.length)) || heldByFirst(lock)); };
+// After a read-type call on the target ran (also when it threw, as for a file missing during a POSIX publication).
+const reachedRead = (p, how) => {
+  if (!REACH_FILE || report.read) return;
+  try { if (isReachTarget(String(p))) { report.read = { target: relOf(norm(p)), how, at: Date.now() }; writeReport(); } } catch {}
+};
+// After a lock attempt ran: `error` is what it threw, or null when it took the lock.
+const reachedLock = (p, error) => {
+  if (!REACH_FILE || report.lock) return;
+  try {
+    if (!isWatchedLock(p)) return;
+    if (error && error.code !== 'EEXIST') return;
+    report.lock = { target: relOf(norm(p)), result: error ? 'contended' : 'acquired', at: Date.now() };
+    writeReport();
+  } catch {}
+};
+for (const [name, how] of [['readFileSync', 'read'], ['existsSync', 'exists'], ['statSync', 'stat'], ['lstatSync', 'stat'], ['accessSync', 'stat']]) {
+  const original = fs[name].bind(fs);
+  fs[name] = function (p, ...a) { try { return original(p, ...a); } finally { reachedRead(p, how); } };
+}
 
 const _mkdir = fs.mkdirSync.bind(fs);
 fs.mkdirSync = function (p, ...a) {
-  const r = _mkdir(p, ...a);
-  try { if (/\.lock$/.test(String(p))) held.add(norm(p)); } catch {}
+  const isLock = /\.lock$/.test(String(p));
+  let r;
+  try { r = _mkdir(p, ...a); } catch (error) { if (isLock) reachedLock(p, error); throw error; }
+  if (isLock) reachedLock(p, null);
+  try { if (isLock) held.add(norm(p)); } catch {}
   return r;
 };
 const _rmdir = fs.rmdirSync.bind(fs);
@@ -64,8 +161,12 @@ fs.rmdirSync = function (p, ...a) {
 // 구버전 고정 파일 락도 계측 호환성을 유지한다.
 const _open = fs.openSync.bind(fs);
 fs.openSync = function (p, flags, ...a) {
-  const r = _open(p, flags, ...a);
-  try { if (String(flags) === 'wx' && /\.lock$/.test(String(p))) held.add(norm(p)); } catch {}
+  const isLock = String(flags) === 'wx' && /\.lock$/.test(String(p));
+  let r;
+  try { r = _open(p, flags, ...a); }
+  catch (error) { if (isLock) reachedLock(p, error); else reachedRead(p, 'open'); throw error; }
+  if (isLock) reachedLock(p, null); else reachedRead(p, 'open');
+  try { if (isLock) held.add(norm(p)); } catch {}
   return r;
 };
 const _unlink = fs.unlinkSync.bind(fs);
@@ -91,14 +192,20 @@ const stallBefore = (to) => {
     if (shouldStall(to)) {
       stalled = true;
       const target = norm(to);
-      if (READY_FILE) {
-        _w(READY_FILE, JSON.stringify({
-          target: relOf(target),
-          locked: held.has(target + '.lock'),
-          heldOn: [...held].map(relOf).sort()
-        }), 'utf8');
+      const ready = { target: relOf(target), locked: held.has(target + '.lock'), heldOn: [...held].map(relOf).sort() };
+      if (READY_FILE) _w(READY_FILE, JSON.stringify(ready), 'utf8');
+      if (WAIT_FILE) {
+        // T-0346: hold the publication until the second command has reached the target, then STALL_MS more. The
+        //   outcome is added to the ready file, which the race reads after both commands exit.
+        const started = Date.now();
+        while (!_existsRaw(WAIT_FILE) && Date.now() - started < WAIT_MAX_MS) stall(10);
+        ready.reached = _existsRaw(WAIT_FILE);
+        ready.waitedMs = Date.now() - started;
+        if (READY_FILE) _w(READY_FILE, JSON.stringify(ready), 'utf8');
       }
       stall(STALL_MS);
+      // When the publication goes on; a read reported after this moment did not see the stalled state.
+      if (WAIT_FILE) { ready.resumedAt = Date.now(); if (READY_FILE) _w(READY_FILE, JSON.stringify(ready), 'utf8'); }
     }
   } catch {}
 };

package/scripts/race-overlap-probe.js

@@ -0,0 +1,148 @@
+'use strict';
+// T-0346: the e2e-concurrency handshake (scripts/lock-probe.js reports, scripts/race-overlap.js judgement) with two
+// small processes instead of leerness commands, so each schedule is fixed. The first process takes
+// .leerness/x.json.lock (and y.json.lock when asked), prepares x.json and renames it into place; the preload stalls
+// that rename. The second process does what each case says. A race may count only when the second process really
+// met the stalled section.
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { overlapOf } = require('./race-overlap');
+
+const PRELOAD = path.join(__dirname, 'lock-probe.js');
+const STALL_MS = 1200;
+const arena = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-race-overlap-'));
+let passed = 0, failed = 0, seq = 0;
+function test(name, fn) {
+  return fn().then(() => { passed++; console.log('PASS ' + name); },
+    error => { failed++; console.error('FAIL ' + name + ': ' + (error && error.stack || error)); });
+}
+const wait = child => new Promise(resolve => child.on('close', code => resolve(code)));
+const nap = ms => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+const readJson = file => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+// Shared by both processes: `sleep(ms)` and `takeLock(name)` (retry on EEXIST, as leerness locks do). The first
+// process holds x.json.lock and, when asked, y.json.lock, a lock the race knows only from the first one's `heldOn`.
+const PRELUDE = `
+  const fs = require('fs'), path = require('path');
+  const hd = path.join(process.argv[1], '.leerness'), target = path.join(hd, 'x.json'), lock = target + '.lock';
+  const other = path.join(hd, 'y.json.lock');
+  const sleep = ms => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  const takeLock = (name = lock) => { for (;;) { try { fs.mkdirSync(name); return; } catch (e) { if (e.code !== 'EEXIST') throw e; sleep(20); } } };
+`;
+const FIRST = PRELUDE + `
+  const both = process.argv[2] === 'both';
+  takeLock(); if (both) takeLock(other);
+  const tmp = target + '.tmp-1-1';
+  fs.writeFileSync(tmp, JSON.stringify({ by: 'first' }));
+  fs.renameSync(tmp, target);
+  if (both) fs.rmdirSync(other);
+  fs.rmdirSync(lock);
+`;
+// `heldFile`: what the second process reads as the first one's held locks: 'ready' (the ready file itself),
+// 'corrupt-after-read' (a copy that the race overwrites with half a JSON object once the second process has
+// reported its read, as a rewrite caught midway would look), or 'corrupt' (half a JSON object from the start).
+// `failAfter`: report writes after that many fail in the second process (LOCKPROBE_REPORT_FAIL_AFTER), as for a
+// report file that turned read-only, whoever runs the test.
+async function race(second, { waitMaxMs = 15000, firstLocks = 'one', heldFile = 'ready', failAfter } = {}) {
+  const d = path.join(arena, 'case-' + (++seq));
+  fs.mkdirSync(path.join(d, '.leerness'), { recursive: true });
+  fs.writeFileSync(path.join(d, '.leerness', 'x.json'), JSON.stringify({ by: 'seed' }));
+  const ready = path.join(d, 'ready.json'), reach = path.join(d, 'reach.json'), heldCopy = path.join(d, 'held.json');
+  const first = cp.spawn(process.execPath, ['--require', PRELOAD, '-e', FIRST, d, firstLocks], { stdio: 'ignore', env: { ...process.env,
+    LOCKPROBE_STALL_TARGET: 'x.json', LOCKPROBE_STALL_MS: String(STALL_MS), LOCKPROBE_READY_FILE: ready,
+    LOCKPROBE_WAIT_FILE: reach, LOCKPROBE_WAIT_MAX_MS: String(waitMaxMs) } });
+  let stalled = false;
+  for (let i = 0; i < 800 && !stalled; i++) { stalled = (readJson(ready) || {}).target === 'x.json'; if (!stalled) nap(10); }
+  const half = '{"target":"x.json","heldOn":["x.js';
+  if (heldFile !== 'ready') fs.writeFileSync(heldCopy, heldFile === 'corrupt' ? half : fs.readFileSync(ready));
+  const started = Date.now();
+  const child = cp.spawn(process.execPath, ['--require', PRELOAD, '-e', PRELUDE + second, d], { stdio: 'ignore', env: { ...process.env,
+    LOCKPROBE_REACH_TARGET: 'x.json', LOCKPROBE_REACH_FILE: reach, LOCKPROBE_REACH_LOCKS_FILE: heldFile === 'ready' ? ready : heldCopy,
+    ...(failAfter === undefined ? {} : { LOCKPROBE_REPORT_FAIL_AFTER: String(failAfter) }) } });
+  if (heldFile === 'corrupt-after-read') {
+    for (let i = 0; i < 1500 && !(readJson(reach) || {}).read; i++) nap(10);
+    fs.writeFileSync(heldCopy, half);
+  }
+  const exits = await Promise.all([wait(first), wait(child)]);
+  const r = { stalled, ready: readJson(ready), reach: readJson(reach), exits, secondStartedAt: started };
+  return { ...r, ...overlapOf(r) };
+}
+(async () => {
+  try {
+    await test('a lock attempt that waits on the stalled section counts', async () => {
+      const r = await race('takeLock(); fs.rmdirSync(lock);');
+      assert.deepStrictEqual(r.exits, [0, 0]);
+      assert.strictEqual(r.reach.lock.result, 'contended', JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test('a delay before the first access does not let the stall end first', async () => {
+      // The schedule of review round 1: the second process is slow to reach its lock attempt. The report is written
+      // after the attempt ran, so the first process is still stalled when it happens.
+      const r = await race('sleep(1500); takeLock(); fs.rmdirSync(lock);');
+      assert.strictEqual(r.reach.lock.result, 'contended', JSON.stringify(r.reach));
+      assert.ok(r.ready.waitedMs >= 1400, 'the first process waited for the report: ' + r.ready.waitedMs);
+      assert.ok(r.reach.lock.at <= r.ready.resumedAt, 'the attempt came before the first process resumed');
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test('a read during the stall followed by a lock taken after the release does not count', async () => {
+      const r = await race(`fs.existsSync(target); sleep(${STALL_MS + 1300}); takeLock(); fs.rmdirSync(lock);`);
+      assert.strictEqual(r.reach.read.how, 'exists');
+      assert.strictEqual(r.reach.lock.result, 'acquired', JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('a command that only reads counts when its read finished while stalled', async () => {
+      const r = await race('fs.readFileSync(target);');
+      assert.ok(['read', 'open'].includes(r.reach.read.how), JSON.stringify(r.reach)); // readFileSync opens through openSync
+      assert.strictEqual(r.reach.lock, undefined);
+      assert.ok(r.reach.read.at <= r.ready.resumedAt);
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test("a lock attempt that waits on another lock the first process holds counts", async () => {
+      const r = await race('takeLock(other); fs.rmdirSync(other);', { firstLocks: 'both' });
+      assert.strictEqual(r.reach.lock.target, 'y.json.lock', JSON.stringify(r.reach));
+      assert.strictEqual(r.reach.lock.result, 'contended');
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test('review round 2: a held-locks file broken after the read does not hide a lock taken after the release', async () => {
+      // The second process read the held locks when it started; a rewrite caught midway later must not change them.
+      const r = await race(`fs.existsSync(target); sleep(${STALL_MS + 1300}); takeLock(other); fs.rmdirSync(other);`,
+        { firstLocks: 'both', heldFile: 'corrupt-after-read' });
+      assert.strictEqual(r.reach.lock && r.reach.lock.result, 'acquired', JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('review round 3: a report that can no longer be rewritten does not let an earlier read count', async () => {
+      // The read report lands; the later "acquired" cannot be written (the first write succeeds, later ones fail).
+      const r = await race(`fs.existsSync(target); sleep(${STALL_MS + 1300}); takeLock(other); fs.rmdirSync(other);`,
+        { firstLocks: 'both', failAfter: 1 });
+      assert.ok(r.reach && r.reach.read && !r.reach.lock && r.reach.complete === undefined, JSON.stringify(r.reach));
+      assert.strictEqual(r.exits[1], 97, 'the second process fails when its report cannot be written');
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('review round 4: a lock taken in a later exit listener whose report fails makes the second process fail', async () => {
+      // The preload's closing listener marks the read report complete (write 2); a listener registered after it then
+      // takes a held lock after the release, and that report (write 3) fails. The completed read report stays, so
+      // only the exit code can tell the race.
+      const r = await race(`fs.existsSync(target); process.on('exit', () => { sleep(${STALL_MS + 1300}); takeLock(other); fs.rmdirSync(other); });`,
+        { firstLocks: 'both', failAfter: 2 });
+      assert.ok(r.reach && r.reach.read && r.reach.complete === true && !r.reach.lock, JSON.stringify(r.reach));
+      assert.strictEqual(r.exits[1], 97, 'the failed write after completion still fails the process');
+    });
+    await test('held locks that cannot be read make the race not count', async () => {
+      const r = await race('takeLock(); fs.rmdirSync(lock);', { heldFile: 'corrupt' });
+      assert.strictEqual(r.reach.heldUnknown, true, JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('a command that never reaches the stalled section does not count', async () => {
+      const r = await race("fs.readFileSync(path.join(process.argv[1], 'ready.json'));", { waitMaxMs: 1500 });
+      assert.strictEqual(r.ready.reached, false);
+      assert.strictEqual(r.reach, null);
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+  } finally {
+    fs.rmSync(arena, { recursive: true, force: true });
+  }
+  console.log(`race overlap probe: ${passed}/${passed + failed} passed (${process.platform})`);
+  process.exitCode = failed ? 1 : 0;
+})();

package/scripts/race-overlap.js

@@ -0,0 +1,28 @@
+'use strict';
+// T-0346: did a race's second command overlap the first command's stalled publication? Judged from the first
+// command's ready file (scripts/lock-probe.js: `reached`, `resumedAt`) and the second command's report (`read`,
+// `lock`), which lock-probe.js writes only after the operation ran.
+//   - A lock attempt that failed with EEXIST (the stalled file's lock, or a lock the first command held when it
+//     stalled) shows that the second command waited on the stalled section.
+//   - A first such attempt that took the lock shows that the first command had already released it: the second
+//     command's locked section ran after the publication, so it did not overlap.
+//   - A command that never tried one of those locks overlapped when its read of the stalled file finished before the
+//     first command resumed. The first command waits for that report, so this holds unless its wait timed out.
+function overlapOf({ stalled, ready, reach }) {
+  if (!stalled || !ready || ready.reached !== true || !reach || (!reach.read && !reach.lock)) {
+    return { overlapped: false, why: 'no report while the first command was stalled' };
+  }
+  // Without the first command's held locks, a lock taken after the release could go unreported.
+  if (reach.heldUnknown) return { overlapped: false, why: "the first command's held locks could not be read" };
+  // Only a report that the second command closed at its exit is whole: a later rewrite may have failed.
+  if (reach.complete !== true || reach.failed) return { overlapped: false, why: 'the report was not completed' };
+  if (reach.lock) {
+    return reach.lock.result === 'contended'
+      ? { overlapped: true, why: 'a lock attempt was contended' }
+      : { overlapped: false, why: 'a lock the first command held was taken without contention' };
+  }
+  if (typeof ready.resumedAt === 'number' && reach.read.at <= ready.resumedAt) return { overlapped: true, why: 'the read finished while stalled' };
+  return { overlapped: false, why: 'the read finished after the first command resumed' };
+}
+
+module.exports = { overlapOf };

package/scripts/release-runtime-probe.js

@@ -1075,12 +1075,15 @@ try {
       || !/name:\s*release runtime \(shell-free npm\)/.test(workflow)) {
     failures.push('CI가 전체 게이트와 Node 24/26 매트릭스에서 릴리스 런타임 프로브를 실행하지 않음');
   }
-  const fullTestStart = workflow.indexOf('\n  test:');
-  const fullTestEnd = workflow.indexOf('\n  release-runtime:', fullTestStart);
-  const fullTestJob = fullTestStart >= 0 && fullTestEnd > fullTestStart
-    ? workflow.slice(fullTestStart, fullTestEnd) : '';
-  if (!/include:\s*[\s\S]*-\s+os:\s*windows-latest\s*[\r\n]+\s*node:\s*24/.test(fullTestJob)
-      || !/-\s+name:\s*e2e\s*[\s\S]*run:\s*node \.\/scripts\/e2e\.js/.test(fullTestJob)) {
+  // T-0359: the full E2E runs in shards; Windows Node 24 must list every shard (1..k) of the e2e job.
+  const ciJobs = require('./ci-shard').workflowJobs(workflow);
+  const e2eJob = ciJobs.test || { entries: [], runs: [], lines: [] };
+  const win24 = e2eJob.entries.filter(e => e.os === 'windows-latest' && e.node === '24');
+  const win24Shards = win24.map(e => Number(e.shard)).sort((a, b) => a - b);
+  if (!win24.length || win24.some(e => e.shards !== win24[0].shards) || win24Shards.length !== Number(win24[0].shards)
+      || win24Shards.some((s, i) => s !== i + 1)
+      || !e2eJob.runs.includes('node ./scripts/e2e.js')
+      || !e2eJob.lines.some(l => /^\s+LEERNESS_E2E_SHARD: \$\{\{ matrix\.shard \}\}\/\$\{\{ matrix\.shards \}\}$/.test(l))) {
     failures.push('Windows Node 24 전체 E2E가 CI test 매트릭스에서 실행되지 않음');
   }