@bash0816/claude-code 2.1.248 → 2.1.252

package/lib/bunfs-esm-loader.test.js

@@ -486,3 +486,878 @@ test('import.meta.require resolves /$bunfs/root/ specifiers via loader integrati
     fs.rmSync(tempDir, { recursive: true, force: true });
   }
 });
+
+// Recovery tests for missing module scenario
+
+// T1: resolve() がチャンク欠落を回復する
+test('T1: resolve() recovers chunk deletion by calling reExtract', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t1-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    const guardPath = path.join(tempDir, 'guard.mjs');
+    fs.writeFileSync(guardPath, 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const targetFile = path.join(tempDir, 'target.js');
+    fs.writeFileSync(targetFile, 'export const x = 1;');
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: guardPath,
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: (sb, od) => {
+        reExtractCalls++;
+        fs.writeFileSync(targetFile, 'export const x = 1;');
+      },
+    });
+
+    // Delete file
+    fs.unlinkSync(targetFile);
+
+    // resolve() should trigger recovery
+    const result = loader.resolve('/$bunfs/root/target.js', {}, () => ({}));
+    assert.ok(result.url);
+    assert.equal(reExtractCalls, 1);
+    assert.ok(fs.existsSync(targetFile));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T2: load() が readFileSync ENOENT を回復する
+test('T2: load() recovers readFileSync ENOENT by calling reExtract', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t2-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const targetFile = path.join(tempDir, 'target.js');
+    const originalSource = 'export const y = 2;';
+    fs.writeFileSync(targetFile, originalSource);
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: () => {
+        reExtractCalls++;
+        fs.writeFileSync(targetFile, originalSource);
+      },
+    });
+
+    // Delete file
+    fs.unlinkSync(targetFile);
+
+    // load() should trigger recovery
+    const result = await loader.load(pathToFileURL(targetFile).href, {}, async () => ({}));
+    assert.ok(result.source);
+    assert.equal(reExtractCalls, 1);
+    assert.ok(result.source.includes('y = 2'));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T3: tryHoistCycleBreakingImports の hoist 対象欠落を回復する
+test('T3: tryHoistCycleBreakingImports recovers missing hoist target', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t3-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const srcFile = path.join(tempDir, 'src.js');
+    fs.writeFileSync(srcFile, 'import.meta.require("/$bunfs/root/tgt.js");\n');
+
+    const tgtFile = path.join(tempDir, 'tgt.js');
+    fs.writeFileSync(tgtFile, 'export const target = 1;');
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      cycleHoists: [{ file: 'src.js', targetModule: 'tgt.js', expectedOccurrences: 1, assertProperties: [] }],
+      reExtract: () => {
+        reExtractCalls++;
+        fs.writeFileSync(tgtFile, 'export const target = 1;');
+      },
+    });
+
+    // Delete target
+    fs.unlinkSync(tgtFile);
+
+    // load() should trigger hoisting and recovery
+    const result = await loader.load(pathToFileURL(srcFile).href, {}, async () => ({}));
+    assert.ok(result.source);
+    assert.equal(reExtractCalls, 1);
+    assert.ok(result.source.includes('__bunfsHoisted_'));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T4: recoverMissing 直接 — 失敗上限 MAX_CONSEC_FAILURES=3
+test('T4: recoverMissing respects MAX_CONSEC_FAILURES limit of 3', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t4-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const missingPath = path.join(tempDir, 'missing.js');
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: () => {
+        reExtractCalls++;
+        // Do not recreate file - simulate failure
+      },
+    });
+
+    // Call recoverMissing 4 times with advancing time
+    const result1 = loader.recoverMissing(missingPath, 0);
+    const result2 = loader.recoverMissing(missingPath, 10000);
+    const result3 = loader.recoverMissing(missingPath, 20000);
+    const result4 = loader.recoverMissing(missingPath, 30000);
+
+    assert.equal(result1, false);
+    assert.equal(result2, false);
+    assert.equal(result3, false);
+    assert.equal(result4, false);
+    assert.equal(reExtractCalls, 3, 'reExtract should be called exactly 3 times (MAX_CONSEC_FAILURES)');
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T5: recoverMissing 直接 — 連続失敗カウンタは成功でリセット
+test('T5: recoverMissing resets consecutive failures counter on success', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t5-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const testPath = path.join(tempDir, 'test.js');
+
+    let shouldRestore = false;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: () => {
+        if (shouldRestore) {
+          fs.writeFileSync(testPath, 'export const z = 3;');
+        }
+      },
+    });
+
+    // Attempt 1: recovery fails (no file created)
+    shouldRestore = false;
+    const r1 = loader.recoverMissing(testPath, 0);
+    assert.equal(r1, false);
+
+    // Attempt 2: recovery succeeds (file created)
+    shouldRestore = true;
+    const r2 = loader.recoverMissing(testPath, 5000);
+    assert.equal(r2, true);
+
+    // Delete the file again
+    fs.unlinkSync(testPath);
+
+    // Attempt 3: failure again, but counter was reset
+    shouldRestore = false;
+    const r3 = loader.recoverMissing(testPath, 10000);
+    assert.equal(r3, false);
+
+    // Attempt 4: success again (not yet hit limit)
+    shouldRestore = true;
+    const r4 = loader.recoverMissing(testPath, 15000);
+    assert.equal(r4, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T6: recoverMissing 直接 — 3s スロットル
+test('T6: recoverMissing throttles re-extraction for 3 seconds', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t6-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const missingPath = path.join(tempDir, 'missing.js');
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: () => {
+        reExtractCalls++;
+      },
+    });
+
+    // Call at time 10000 (base time)
+    loader.recoverMissing(missingPath, 10000);
+    assert.equal(reExtractCalls, 1);
+
+    // Call at time 11000 (only 1s later, < 3s throttle)
+    loader.recoverMissing(missingPath, 11000);
+    assert.equal(reExtractCalls, 1, 'throttled - should not call reExtract');
+
+    // Call at time 14000 (4s later, > 3s throttle)
+    loader.recoverMissing(missingPath, 14000);
+    assert.equal(reExtractCalls, 2);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T7: TOCTOU — 2回連続で回復できることを確認
+test('T7: recoverMissing handles repeated deletion and recovery', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t7-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const targetFile = path.join(tempDir, 'target.js');
+    fs.writeFileSync(targetFile, 'export const x = 1;');
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: (sb, od) => {
+        reExtractCalls++;
+        fs.writeFileSync(targetFile, 'export const x = 1;');
+      },
+    });
+
+    // First recovery at time 10000
+    fs.unlinkSync(targetFile);
+    // Use recoverMissing with explicit time to bypass throttle
+    loader.recoverMissing(targetFile, 10000);
+    assert.ok(fs.existsSync(targetFile));
+    assert.equal(reExtractCalls, 1);
+
+    // Second recovery at time 14000 (past throttle window)
+    fs.unlinkSync(targetFile);
+    loader.recoverMissing(targetFile, 14000);
+    assert.ok(fs.existsSync(targetFile));
+    assert.equal(reExtractCalls, 2);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T8 (最重要): real が存在するのに require 失敗 → 再展開しない
+test('T8: recoverMissing does not re-extract when real file exists', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-t8-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    const realExistsFile = path.join(tempDir, 'real-exists.js');
+    // Create a file that exists but would throw MODULE_NOT_FOUND on require
+    fs.writeFileSync(realExistsFile, 'throw new Error("internal dependency error");');
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: () => {
+        reExtractCalls++;
+      },
+    });
+
+    // Call recoverMissing with existing file
+    const result = loader.recoverMissing(realExistsFile, Date.now());
+    assert.equal(result, true, 'should return true for existing file');
+    assert.equal(reExtractCalls, 0, 'reExtract should not be called for existing file');
+
+    // Verify the prelude guards against error-code-based recovery for real files
+    const srcFile = path.join(tempDir, 'src.js');
+    fs.writeFileSync(srcFile, 'import.meta.require("/$bunfs/root/real-exists.js");');
+    const result2 = await loader.load(pathToFileURL(srcFile).href, {}, async () => ({}));
+    assert.ok(result2.source);
+    // The source should have __bunfsMetaRequireExistsSync guard (not error-code-based)
+    assert.ok(result2.source.includes('__bunfsMetaRequireExistsSync'));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// T8-exec: recoverMissing の no-reextract-when-file-exists を実行確認
+test('T8-exec: recoverMissing returns true immediately for an existing file without calling reExtract, even under repeated calls', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-t8exec-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+
+    // 存在する実ファイル (require すれば内部依存 MODULE_NOT_FOUND を投げる想定の中身)
+    const realExists = path.join(tempDir, 'has-internal-dep.js');
+    fs.writeFileSync(realExists, "module.exports = require('/definitely/not/here.js');");
+
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: () => { reExtractCalls++; },
+    });
+
+    // ファイルが存在する限り、何度呼んでも即 true・再展開ゼロ
+    for (let i = 0; i < 5; i++) {
+      const r = loader.recoverMissing(realExists, i * 10000);
+      assert.equal(r, true, `call ${i} should return true (file exists)`);
+    }
+    assert.equal(reExtractCalls, 0, 'reExtract must never be called while the target file exists');
+
+    // 実際に require が内部依存で投げることも確認 (元例外が保持されるべき挙動の裏付け)
+    let threw = null;
+    try { require(realExists); } catch (e) { threw = e; }
+    assert.ok(threw, 'require of the file should throw due to its missing internal dependency');
+    assert.equal(reExtractCalls, 0, 'a require-time internal MODULE_NOT_FOUND must not trigger re-extraction');
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+// New tests for fs interception functionality
+
+test('resolveBunfsPath: non-target paths return null', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-resolve-path-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    const result = loader.resolveBunfsPath('/regular/path/file.js');
+    assert.equal(result, null);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolveBunfsPath: rejects path traversal with ..', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-resolve-path-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    assert.throws(
+      () => loader.resolveBunfsPath('/$bunfs/root/../../etc/passwd'),
+      /rejected specifier/,
+    );
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolveBunfsPath: resolves valid /$bunfs/root/ paths correctly', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-resolve-path-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const targetFile = path.join(tempDir, 'foo.js');
+  fs.writeFileSync(targetFile, 'export const x = 1;');
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    const result = loader.resolveBunfsPath('/$bunfs/root/foo.js');
+    assert.ok(result);
+    assert.equal(result, targetFile);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('syncBuiltinESMExports: fs interception requires it for ESM sync', async () => {
+  // installFsBunfsInterception() 自体を、G1/G4 で terra が実機確認した正しい順序
+  // (ESM fixture を先に import してバインディング確定 → fs 差替え(sync前)は旧関数 →
+  // sync 後は新関数) で検証する。ハンドロールした模擬ではなく実装本体を子プロセスで実行する。
+  const { spawnSync } = require('node:child_process');
+  const tempDir = path.join(os.tmpdir(), `bunfs-sync-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const loaderPath = path.join(__dirname, 'bunfs-esm-loader.mjs');
+
+  try {
+    const targetFile = path.join(tempDir, 'target.js');
+    fs.writeFileSync(targetFile, 'export const marker = "REAL_CONTENT";');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+
+    // fixture.mjs: ESM named import を先に確立する側 (installFsBunfsInterception より前に
+    // dynamic import することで、バインディングが patch 前の状態で確定する)
+    const fixturePath = path.join(tempDir, 'fixture.mjs');
+    fs.writeFileSync(fixturePath, `
+import { readFileSync } from 'node:fs';
+export function readIt(p) { return readFileSync(p, 'utf8'); }
+`);
+
+    const testScript = path.join(tempDir, 'test-sync.mjs');
+    fs.writeFileSync(testScript, `
+const tempDir = ${JSON.stringify(tempDir)};
+const targetFile = ${JSON.stringify(targetFile)};
+
+// 1. ESM fixture を先に import (バインディングを patch 前の状態で確定させる)
+const { readIt } = await import(${JSON.stringify(pathToFileURL(fixturePath).href)});
+
+// 2. installFsBunfsInterception() 未適用の状態での素の読み込み確認 (対照)
+const before = readIt(targetFile);
+if (before !== 'export const marker = "REAL_CONTENT";') {
+  console.error('SETUP_FAILED: fixture cannot read target file before patch');
+  process.exit(1);
+}
+
+// 3. fs を差し替える (installFsBunfsInterception 経由、syncBuiltinESMExports 込み)
+const loader = await import(${JSON.stringify(pathToFileURL(loaderPath).href)});
+loader.initialize({
+  processOwnedDir: tempDir,
+  sourceBin: ${JSON.stringify(sourceBin)},
+  childProcessGuardPath: ${JSON.stringify(path.join(tempDir, 'guard.mjs'))},
+  vmGuardPath: ${JSON.stringify(path.join(tempDir, 'vm-guard.mjs'))},
+  wsStubPath: ${JSON.stringify(path.join(tempDir, 'ws-stub.mjs'))},
+});
+loader.installFsBunfsInterception();
+
+// 4. 先に確立した ESM バインディング経由で /$bunfs/root/ パスを読む
+//    → syncBuiltinESMExports() が正しく効いていれば、fixture の readFileSync も
+//    パッチ後の関数を参照し、bunfs パス解決が機能するはず
+const afterViaBinding = readIt('/$bunfs/root/target.js');
+if (afterViaBinding !== 'export const marker = "REAL_CONTENT";') {
+  console.error('SYNC_FAILED: pre-bound ESM readFileSync did not pick up the fs interception patch');
+  process.exit(1);
+}
+console.log('SYNC_OK');
+process.exit(0);
+`);
+
+    const result = spawnSync('node', [testScript], { encoding: 'utf8' });
+    assert.equal(result.status, 0, `Script failed (status=${result.status}): stdout=${result.stdout} stderr=${result.stderr}`);
+    assert.ok(result.stdout.includes('SYNC_OK'), `expected SYNC_OK marker, got: ${result.stdout}`);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('fs.readFile callback mode: resolves /$bunfs/root/ paths', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-fs-readfile-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const testFile = path.join(tempDir, 'test.js');
+  const testContent = 'export const y = 42;';
+  fs.writeFileSync(testFile, testContent);
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    loader.installFsBunfsInterception();
+
+    // After interception is installed, fs.readFile should resolve bunfs paths
+    const testFsModule = require('node:fs');
+    let callbackCalled = false;
+    let readData = null;
+
+    testFsModule.readFile('/$bunfs/root/test.js', 'utf8', (err, data) => {
+      callbackCalled = true;
+      if (!err) {
+        readData = data;
+      }
+    });
+
+    // Give callback time to execute
+    await new Promise(resolve => setTimeout(resolve, 100));
+    assert.equal(callbackCalled, true);
+    assert.equal(readData, testContent);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('fs.readFile with options: resolves /$bunfs/root/ paths', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-fs-readfile-opts-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const testFile = path.join(tempDir, 'test.txt');
+  const testContent = 'Hello World';
+  fs.writeFileSync(testFile, testContent);
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    loader.installFsBunfsInterception();
+
+    const testFsModule = require('node:fs');
+    let callbackCalled = false;
+    let readData = null;
+
+    testFsModule.readFile('/$bunfs/root/test.txt', { encoding: 'utf8' }, (err, data) => {
+      callbackCalled = true;
+      if (!err) {
+        readData = data;
+      }
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 100));
+    assert.equal(callbackCalled, true);
+    assert.equal(readData, testContent);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('fs.readFileSync: non-bunfs paths unchanged after interception', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-fs-normal-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const normalFile = path.join(tempDir, 'normal.txt');
+  const normalContent = 'Normal File Content';
+  fs.writeFileSync(normalFile, normalContent);
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    loader.installFsBunfsInterception();
+
+    const testFsModule = require('node:fs');
+    const data = testFsModule.readFileSync(normalFile, 'utf8');
+    assert.equal(data, normalContent);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('fs interception: symlink escape detection', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-symlink-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const externalDir = path.join(os.tmpdir(), `bunfs-external-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(externalDir, { recursive: true });
+  const externalFile = path.join(externalDir, 'external.txt');
+  fs.writeFileSync(externalFile, 'External');
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    loader.installFsBunfsInterception();
+
+    // Try to create a symlink (may fail on some platforms)
+    const symlinkPath = path.join(tempDir, 'escape.txt');
+    try {
+      fs.symlinkSync(externalFile, symlinkPath);
+    } catch (e) {
+      // Skip test if symlinks not supported
+      return;
+    }
+
+    const testFsModule = require('node:fs');
+    assert.throws(
+      () => testFsModule.readFileSync('/$bunfs/root/escape.txt'),
+      /escapes owned dir via symlink/,
+    );
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    fs.rmSync(externalDir, { recursive: true, force: true });
+  }
+});
+
+test('installFsBunfsInterception: idempotent (multiple calls are safe)', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-idempotent-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const testFile = path.join(tempDir, 'test.js');
+  fs.writeFileSync(testFile, 'export const z = 1;');
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    // Call installFsBunfsInterception multiple times
+    loader.installFsBunfsInterception();
+    loader.installFsBunfsInterception();
+    loader.installFsBunfsInterception();
+
+    // Verify fs still works
+    const testFsModule = require('node:fs');
+    const data = testFsModule.readFileSync(testFile, 'utf8');
+    assert.ok(data.includes('z = 1'));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('fs interception: rollback on partial failure leaves FS_PATCHED false (retry succeeds)', async () => {
+  // G1で確定した設計: syncBuiltinESMExports() が失敗した場合、3関数を元に戻し
+  // FS_PATCHED は立てない。次回呼出しで再試行できることを外部挙動で証明する
+  // (private 変数を直接読まず、「1回目は throw して起こす失敗後、2回目の呼出しが
+  // 実際にパッチを完了する」ことで FS_PATCHED===false だったことを証明する)。
+  const { spawnSync } = require('node:child_process');
+  const tempDir = path.join(os.tmpdir(), `bunfs-rollback-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const loaderPath = path.join(__dirname, 'bunfs-esm-loader.mjs');
+
+  try {
+    const targetFile = path.join(tempDir, 'target.js');
+    fs.writeFileSync(targetFile, 'export const marker = "REAL_CONTENT";');
+    fs.writeFileSync(path.join(tempDir, 'guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'vm-guard.mjs'), 'export default {};');
+    fs.writeFileSync(path.join(tempDir, 'ws-stub.mjs'), 'export default {};');
+    const sourceBin = path.join(tempDir, 'bin');
+    fs.writeFileSync(sourceBin, 'binary content');
+    const normalFile = path.join(tempDir, 'normal.txt');
+    fs.writeFileSync(normalFile, 'NORMAL_CONTENT');
+
+    const testScript = path.join(tempDir, 'test-rollback.mjs');
+    fs.writeFileSync(testScript, `
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+const tempDir = ${JSON.stringify(tempDir)};
+const normalFile = ${JSON.stringify(normalFile)};
+// ESM namespace ('node:module' の import 経由の名前空間) は読み取り専用のため、
+// installFsBunfsInterception 自体と同じく CJS 側 (require) を可変対象として差し替える。
+const nodeModuleCjs = require('node:module');
+const origFsMod = require('node:fs');
+const origReadFileSync = origFsMod.readFileSync;
+const origReadFile = origFsMod.readFile;
+const origPromisesReadFile = origFsMod.promises.readFile;
+const realSync = nodeModuleCjs.syncBuiltinESMExports;
+
+// 1回目のみ throw するモックへ差し替え。差し替え自体を ESM 側にも伝播させるため
+// 一度だけ本物の syncBuiltinESMExports を呼んでおく (この呼出し自体は失敗しない)。
+let syncCallCount = 0;
+nodeModuleCjs.syncBuiltinESMExports = () => {
+  syncCallCount++;
+  if (syncCallCount === 1) {
+    throw new Error('forced syncBuiltinESMExports failure (test)');
+  }
+  return realSync();
+};
+realSync();
+
+const loader = await import(${JSON.stringify(pathToFileURL(loaderPath).href)});
+loader.initialize({
+  processOwnedDir: tempDir,
+  sourceBin: ${JSON.stringify(sourceBin)},
+  childProcessGuardPath: ${JSON.stringify(path.join(tempDir, 'guard.mjs'))},
+  vmGuardPath: ${JSON.stringify(path.join(tempDir, 'vm-guard.mjs'))},
+  wsStubPath: ${JSON.stringify(path.join(tempDir, 'ws-stub.mjs'))},
+});
+
+// 1回目: syncBuiltinESMExports が throw するため installFsBunfsInterception も throw するはず
+let firstThrew = false;
+try {
+  loader.installFsBunfsInterception();
+} catch (e) {
+  firstThrew = true;
+}
+if (!firstThrew) {
+  console.error('EXPECTED_THROW_MISSING: first installFsBunfsInterception() call did not throw');
+  process.exit(1);
+}
+
+// ロールバック確認: 3関数が元の参照に戻っているか (通常ファイル読み込みが正常動作することで確認)
+const fsMod = require('node:fs');
+if (fsMod.readFileSync !== origReadFileSync || fsMod.readFile !== origReadFile || fsMod.promises.readFile !== origPromisesReadFile) {
+  console.error('ROLLBACK_FAILED: fs functions were not restored to originals after failure');
+  process.exit(1);
+}
+const normalContent = fsMod.readFileSync(normalFile, 'utf8');
+if (normalContent !== 'NORMAL_CONTENT') {
+  console.error('ROLLBACK_BROKEN_READ: normal file read broken after rollback');
+  process.exit(1);
+}
+
+// 2回目: モックは以後成功するため、FS_PATCHED が false のままなら今度は成功するはず
+let secondThrew = false;
+try {
+  loader.installFsBunfsInterception();
+} catch (e) {
+  secondThrew = true;
+  console.error('SECOND_CALL_THREW: ' + e.message);
+}
+if (secondThrew) {
+  console.error('FS_PATCHED_STUCK_TRUE_OR_RETRY_BLOCKED: second call should have succeeded');
+  process.exit(1);
+}
+
+console.log('ROLLBACK_AND_RETRY_OK');
+process.exit(0);
+`);
+
+    const result = spawnSync('node', [testScript], { encoding: 'utf8' });
+    assert.equal(result.status, 0, `Script failed (status=${result.status}): stdout=${result.stdout} stderr=${result.stderr}`);
+    assert.ok(result.stdout.includes('ROLLBACK_AND_RETRY_OK'), `expected ROLLBACK_AND_RETRY_OK marker, got: stdout=${result.stdout} stderr=${result.stderr}`);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('recoverMissing integration: fs interception collaborates with recovery', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-recovery-integration-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const targetFile = path.join(tempDir, 'recovered.js');
+  fs.writeFileSync(targetFile, 'export const recovered = true;');
+  const sourceBin = path.join(tempDir, 'bin');
+  fs.writeFileSync(sourceBin, 'binary content');
+
+  try {
+    let reExtractCalls = 0;
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: sourceBin,
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+      reExtract: (sb, od) => {
+        reExtractCalls++;
+        fs.writeFileSync(targetFile, 'export const recovered = true;');
+      },
+    });
+
+    loader.installFsBunfsInterception();
+
+    // Delete the file
+    fs.unlinkSync(targetFile);
+
+    // Try to read via fs - should trigger recovery
+    const testFsModule = require('node:fs');
+    const data = testFsModule.readFileSync('/$bunfs/root/recovered.js', 'utf8');
+    assert.ok(data.includes('recovered'));
+    assert.equal(reExtractCalls, 1);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});