@bash0816/claude-code 2.1.241 → 2.1.248

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

@@ -0,0 +1,488 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+// ESM test ファイルから CommonJS で import できないため、
+// ここでは基本的な構造をテストする
+test('bunfs-esm-loader module exports initialize, resolve, load functions', async () => {
+  // ESM モジュールを動的 import でテストする
+  const loader = await import('./bunfs-esm-loader.mjs');
+  assert.equal(typeof loader.initialize, 'function');
+  assert.equal(typeof loader.resolve, 'function');
+  assert.equal(typeof loader.load, 'function');
+});
+
+test('resolve() handles child_process and node:child_process specifiers', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const guardPath = path.join(tempDir, 'guard.mjs');
+  fs.writeFileSync(guardPath, 'export default {};');
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: guardPath,
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    const nextResolve = (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    // child_process should resolve to childProcessGuardPath
+    const result1 = loader.resolve('child_process', { parentURL: pathToFileURL(path.join(tempDir, 'dummy-chunk.js')).href }, nextResolve);
+    assert.ok(result1.url.includes(guardPath));
+    assert.equal(result1.shortCircuit, true);
+
+    // node:child_process should also resolve to childProcessGuardPath
+    const result2 = loader.resolve('node:child_process', { parentURL: pathToFileURL(path.join(tempDir, 'dummy-chunk.js')).href }, nextResolve);
+    assert.ok(result2.url.includes(guardPath));
+    assert.equal(result2.shortCircuit, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolve() handles vm and node:vm specifiers', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const vmGuardPath = path.join(tempDir, 'vm-guard.mjs');
+  fs.writeFileSync(vmGuardPath, 'export default {};');
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: vmGuardPath,
+      wsStubPath: path.join(tempDir, 'ws-stub.mjs'),
+    });
+
+    const nextResolve = (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    // vm should resolve to vmGuardPath
+    const result1 = loader.resolve('vm', { parentURL: pathToFileURL(path.join(tempDir, 'dummy-chunk.js')).href }, nextResolve);
+    assert.ok(result1.url.includes(vmGuardPath));
+    assert.equal(result1.shortCircuit, true);
+
+    // node:vm should also resolve to vmGuardPath
+    const result2 = loader.resolve('node:vm', { parentURL: pathToFileURL(path.join(tempDir, 'dummy-chunk.js')).href }, nextResolve);
+    assert.ok(result2.url.includes(vmGuardPath));
+    assert.equal(result2.shortCircuit, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolve() handles ws specifier', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const wsStubPath = path.join(tempDir, 'ws-stub.mjs');
+  fs.writeFileSync(wsStubPath, 'export default {};');
+
+  try {
+    loader.initialize({
+      processOwnedDir: tempDir,
+      sourceBin: '/dummy/bin',
+      childProcessGuardPath: path.join(tempDir, 'guard.mjs'),
+      vmGuardPath: path.join(tempDir, 'vm-guard.mjs'),
+      wsStubPath: wsStubPath,
+    });
+
+    const nextResolve = (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    const result = loader.resolve('ws', { parentURL: pathToFileURL(path.join(tempDir, 'dummy-chunk.js')).href }, nextResolve);
+    assert.ok(result.url.includes(wsStubPath));
+    assert.equal(result.shortCircuit, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolve() resolves /$bunfs/root/ specifiers to real files in processOwnedDir', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  // Create a dummy file in processOwnedDir
+  const dummyFile = path.join(tempDir, 'foo.js');
+  fs.writeFileSync(dummyFile, 'export const foo = 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 nextResolve = async (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    const result = await loader.resolve('/$bunfs/root/foo.js', {}, nextResolve);
+    assert.ok(result.url.includes('foo.js'));
+    assert.equal(result.shortCircuit, true);
+    assert.equal(result.format, 'module');
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolve() rejects path traversal with ..', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-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 nextResolve = (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    assert.throws(
+      () => loader.resolve('/$bunfs/root/../../etc/passwd', {}, nextResolve),
+      /rejected specifier|escapes/,
+    );
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolve() rejects absolute paths', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-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 nextResolve = (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    assert.throws(
+      () => loader.resolve('/$bunfs/root//etc/passwd', {}, nextResolve),
+      /rejected specifier|escapes/,
+    );
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolve() throws error for missing extracted module', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-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 nextResolve = (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    assert.throws(
+      () => loader.resolve('/$bunfs/root/nonexistent.js', {}, nextResolve),
+      /missing extracted module/,
+    );
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolve() calls nextResolve for unknown specifiers', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-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'),
+    });
+
+    let nextResolveCalled = false;
+    const nextResolve = async (spec, ctx) => {
+      nextResolveCalled = true;
+      return { url: `unresolved:${spec}` };
+    };
+
+    await loader.resolve('some-unknown-package', {}, nextResolve);
+    assert.equal(nextResolveCalled, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('load() returns source as-is when import.meta.require is not present', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  const testFile = path.join(tempDir, 'test.js');
+  const sourceCode = 'export const x = 1;';
+  fs.writeFileSync(testFile, sourceCode);
+
+  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 fileUrl = pathToFileURL(testFile).href;
+    const result = await loader.load(fileUrl, {}, async () => ({ source: 'fallback' }));
+
+    assert.equal(result.format, 'module');
+    assert.equal(result.source, sourceCode);
+    assert.equal(result.shortCircuit, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('load() injects polyfill prelude when import.meta.require is present', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  const testFile = path.join(tempDir, 'test.js');
+  const sourceCode = 'const cp = import.meta.require("child_process");';
+  fs.writeFileSync(testFile, sourceCode);
+
+  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 fileUrl = pathToFileURL(testFile).href;
+    const result = await loader.load(fileUrl, {}, async () => ({ source: 'fallback' }));
+
+    assert.equal(result.format, 'module');
+    assert.ok(result.source.includes('__bunfsMetaRequire'));
+    assert.ok(result.source.includes('import __bunfsGuardedChildProcess'));
+    assert.ok(result.source.includes('import __bunfsGuardedVm'));
+    // Check that import.meta.require was replaced with __bunfsMetaRequire
+    assert.ok(result.source.includes('__bunfsMetaRequire("child_process")'));
+    assert.ok(!result.source.includes('import.meta.require("child_process")'));
+    assert.equal(result.shortCircuit, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('load() calls nextLoad for URLs outside processOwnedDir', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-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'),
+    });
+
+    let nextLoadCalled = false;
+    const nextLoad = async (url, ctx) => {
+      nextLoadCalled = true;
+      return { source: 'fallback', format: 'module' };
+    };
+
+    await loader.load('file:///some/other/path/module.js', {}, nextLoad);
+    assert.equal(nextLoadCalled, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('load() hoists the cycle-breaking import.meta.require call in chunk-vmw9kxhv.js', async () => {
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-hoist-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  fs.writeFileSync(path.join(tempDir, 'chunk-y0jj307t.js'), 'export const daemonColdStartGbDefault = () => "fixture";\n');
+  const targetFile = path.join(tempDir, 'chunk-vmw9kxhv.js');
+  const sourceCode = 'var O9=import.meta.require("/$bunfs/root/chunk-y0jj307t.js");\nexport const value = O9.daemonColdStartGbDefault();\n';
+  fs.writeFileSync(targetFile, sourceCode);
+
+  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'),
+      cycleHoists: [{ file: 'chunk-vmw9kxhv.js', targetModule: 'chunk-y0jj307t.js', expectedOccurrences: 1, assertProperties: [] }],
+    });
+
+    const fileUrl = pathToFileURL(targetFile).href;
+    const result = await loader.load(fileUrl, {}, async () => ({ source: 'fallback' }));
+
+    assert.equal(result.format, 'module');
+    assert.ok(result.source.includes('import * as __bunfsHoisted_0 from'));
+    assert.ok(!result.source.includes('var O9=import.meta.require('));
+    assert.ok(result.source.includes('var O9=__bunfsHoisted_0'));
+    assert.equal(result.shortCircuit, true);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('import.meta.require resolves /$bunfs/root/ specifiers via loader integration', async () => {
+  const { registerHooks } = await import('node:module');
+  const loader = await import('./bunfs-esm-loader.mjs');
+  const tempDir = path.join(os.tmpdir(), `bunfs-esm-loader-integration-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    // Create guard files
+    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 {};');
+
+    // Create ESM fixture that will be required via import.meta.require (normal case).
+    // PROCESS_OWNED_DIR only ever contains genuine ESM chunk files extracted from the
+    // Bun esm-chunked bundle (verified against a real 2.1.248 extraction: 0 of 1768
+    // chunk files are CommonJS), so load() always returns format: 'module' for this dir.
+    fs.writeFileSync(path.join(tempDir, 'foo.js'), 'export const value = 42;');
+
+    // Create ESM files for each test scenario
+    const okCallerPath = path.join(tempDir, 'ok-caller.mjs');
+    fs.writeFileSync(okCallerPath, 'export const result = import.meta.require("/$bunfs/root/foo.js").value;\n');
+
+    const traversalCallerPath = path.join(tempDir, 'traversal-caller.mjs');
+    fs.writeFileSync(traversalCallerPath, 'import.meta.require("/$bunfs/root/../../etc/passwd");\n');
+
+    const missingCallerPath = path.join(tempDir, 'missing-caller.mjs');
+    fs.writeFileSync(missingCallerPath, 'import.meta.require("/$bunfs/root/nonexistent.js");\n');
+
+    // Register loader (only once) with data
+    const sourceBin = path.join(tempDir, 'dummy-bin');
+    fs.writeFileSync(sourceBin, '#!/bin/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'),
+      cycleHoists: [
+        { file: 'chunk-vmw9kxhv.js', targetModule: 'chunk-y0jj307t.js', expectedOccurrences: 1, assertProperties: [] },
+      ],
+    });
+    registerHooks({ resolve: loader.resolve, load: loader.load });
+
+    // Test 1: Normal case - should load and resolve correctly
+    const okModule = await import(pathToFileURL(okCallerPath).href);
+    assert.equal(okModule.result, 42);
+
+    // Test 2: Path traversal rejection - should throw error
+    await assert.rejects(
+      () => import(pathToFileURL(traversalCallerPath).href),
+      /rejected specifier|escapes/,
+    );
+
+    // Test 3: Missing module rejection - should throw error
+    await assert.rejects(
+      () => import(pathToFileURL(missingCallerPath).href),
+      /missing extracted module/,
+    );
+
+    // Cycle regression proof: a generic sync-require-into-in-flight-static-import cycle
+    // must throw ERR_REQUIRE_CYCLE_MODULE when NOT hoisted (proves our understanding of
+    // the bug mechanism is correct, independent of the real chunk-y0jj307t.js file).
+    fs.writeFileSync(
+      path.join(tempDir, 'chunk-cycle-demo-target.js'),
+      'import "/$bunfs/root/chunk-vmw9kxhv-a.js";\nexport const daemonColdStartGbDefault = () => "fixture";\n',
+    );
+    fs.writeFileSync(
+      path.join(tempDir, 'chunk-vmw9kxhv-a.js'),
+      'var O9X=import.meta.require("/$bunfs/root/chunk-cycle-demo-target.js");\nexport const value = O9X;\n',
+    );
+    await assert.rejects(
+      () => import(pathToFileURL(path.join(tempDir, 'chunk-vmw9kxhv-a.js')).href),
+      (err) => {
+        assert.equal(err.code, 'ERR_REQUIRE_CYCLE_MODULE');
+        return true;
+      },
+    );
+
+    // Cycle fix proof: the real chunk-vmw9kxhv.js / chunk-y0jj307t.js pair (exact filenames
+    // and declaration text that tryHoistCycleBreakingImport() targets) must resolve cleanly
+    // once hoisting is applied, and the hoisted namespace's property access must work.
+    fs.writeFileSync(
+      path.join(tempDir, 'chunk-y0jj307t.js'),
+      'import "/$bunfs/root/chunk-vmw9kxhv.js";\nexport const daemonColdStartGbDefault = () => "fixture";\n',
+    );
+    fs.writeFileSync(
+      path.join(tempDir, 'chunk-vmw9kxhv.js'),
+      'var O9=import.meta.require("/$bunfs/root/chunk-y0jj307t.js");\nexport const value = O9.daemonColdStartGbDefault();\n',
+    );
+    const hoistedModule = await import(pathToFileURL(path.join(tempDir, 'chunk-vmw9kxhv.js')).href);
+    assert.equal(hoistedModule.value, 'fixture');
+
+    fs.writeFileSync(path.join(tempDir, 'doc.md'), '# Hello\nSome markdown text.\n');
+    fs.writeFileSync(
+      path.join(tempDir, 'md-caller.mjs'),
+      'export const result = import.meta.require("/$bunfs/root/doc.md");\n',
+    );
+    const mdModule = await import(pathToFileURL(path.join(tempDir, 'md-caller.mjs')).href);
+    assert.equal(typeof mdModule.result, 'string');
+    assert.equal(mdModule.result, '# Hello\nSome markdown text.\n');
+
+    fs.writeFileSync(path.join(tempDir, 'note.txt'), 'plain text content');
+    fs.writeFileSync(
+      path.join(tempDir, 'txt-caller.mjs'),
+      'export const result = import.meta.require("/$bunfs/root/note.txt");\n',
+    );
+    const txtModule = await import(pathToFileURL(path.join(tempDir, 'txt-caller.mjs')).href);
+    assert.equal(typeof txtModule.result, 'string');
+    assert.equal(txtModule.result, 'plain text content');
+
+    fs.writeFileSync(
+      path.join(tempDir, 'chunk-alias.js'),
+      'export const ee = import.meta.require;\n',
+    );
+    fs.writeFileSync(
+      path.join(tempDir, 'alias-caller.mjs'),
+      'import { ee } from "/$bunfs/root/chunk-alias.js";\nexport const result = ee("/$bunfs/root/doc.md");\n',
+    );
+    const aliasModule = await import(pathToFileURL(path.join(tempDir, 'alias-caller.mjs')).href);
+    assert.equal(aliasModule.result, '# Hello\nSome markdown text.\n');
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});

package/lib/bunfs-extract.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const { openSync, readSync, closeSync, fstatSync, mkdirSync, writeFileSync, readdirSync, statSync, rmSync } = require('node:fs');
+const path = require('node:path');
+
+const TRAILER = Buffer.from('\n---- Bun! ----\n');
+const OFFSETS_STRUCT_SIZE = 32;
+const MODULE_TABLE_ENTRY_SIZE = 52;
+const SCAN_CHUNK_SIZE = 1024 * 1024;
+const NAPI_LOADER = 10;
+
+function readRange(fd, offset, length) {
+  const buf = Buffer.alloc(length);
+  const bytesRead = readSync(fd, buf, 0, length, offset);
+  if (bytesRead !== length) {
+    throw new Error(`bunfs-extract: short read at offset ${offset} (expected ${length}, got ${bytesRead})`);
+  }
+  return buf;
+}
+
+function findTrailerOffset(fd, fileSize) {
+  for (let end = fileSize; end > 0; end -= SCAN_CHUNK_SIZE) {
+    const start = Math.max(0, end - SCAN_CHUNK_SIZE - TRAILER.length);
+    const len = end - start;
+    const buf = readRange(fd, start, len);
+    const idx = buf.lastIndexOf(TRAILER);
+    if (idx >= 0) return start + idx;
+  }
+  throw new Error('bunfs-extract: StandaloneModuleGraph trailer not found');
+}
+
+function isSafeUint(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function discoverModuleGraph(sourceBin) {
+  const fd = openSync(sourceBin, 'r');
+  try {
+    const fileSize = fstatSync(fd).size;
+    const trailerOffset = findTrailerOffset(fd, fileSize);
+
+    const offsetsStructStart = trailerOffset - OFFSETS_STRUCT_SIZE;
+    if (offsetsStructStart < 0) throw new Error('bunfs-extract: invalid trailer position');
+    const offsetsBuf = readRange(fd, offsetsStructStart, OFFSETS_STRUCT_SIZE);
+    const byteCount = Number(offsetsBuf.readBigUInt64LE(0));
+    const modulesOffset = offsetsBuf.readUInt32LE(8);
+    const modulesLength = offsetsBuf.readUInt32LE(12);
+    const entryPointId = offsetsBuf.readUInt32LE(16);
+
+    if (!isSafeUint(byteCount) || !isSafeUint(modulesOffset) || !isSafeUint(modulesLength)) {
+      throw new Error('bunfs-extract: unsafe integer in Offsets struct');
+    }
+    if (modulesLength % MODULE_TABLE_ENTRY_SIZE !== 0) {
+      throw new Error('bunfs-extract: module table length is not a multiple of entry size');
+    }
+
+    const dataStart = offsetsStructStart - byteCount;
+    if (dataStart < 0) throw new Error('bunfs-extract: computed dataStart is negative');
+
+    const numModules = modulesLength / MODULE_TABLE_ENTRY_SIZE;
+    if (numModules <= 0) throw new Error('bunfs-extract: module table is empty');
+    if (!(entryPointId >= 0 && entryPointId < numModules)) {
+      throw new Error(`bunfs-extract: entry_point_id ${entryPointId} out of range (numModules=${numModules})`);
+    }
+    if (modulesOffset + modulesLength > byteCount) {
+      throw new Error('bunfs-extract: module table extends beyond byte_count');
+    }
+
+    const modTableBuf = readRange(fd, dataStart + modulesOffset, modulesLength);
+
+    const modules = [];
+    const seenNames = new Set();
+    let entryName = null;
+    let entryModule = null;
+    for (let i = 0; i < numModules; i += 1) {
+      const base = i * MODULE_TABLE_ENTRY_SIZE;
+      const nameOff = modTableBuf.readUInt32LE(base);
+      const nameLen = modTableBuf.readUInt32LE(base + 4);
+      const contOff = modTableBuf.readUInt32LE(base + 8);
+      const contLen = modTableBuf.readUInt32LE(base + 12);
+      const loader = modTableBuf[base + 49];
+
+      if (!isSafeUint(nameOff) || !isSafeUint(nameLen) || !isSafeUint(contOff) || !isSafeUint(contLen)) {
+        throw new Error(`bunfs-extract: unsafe integer in module table entry ${i}`);
+      }
+      if (nameOff + nameLen > byteCount) {
+        throw new Error(`bunfs-extract: module ${i} name range out of bounds`);
+      }
+      if (contOff + contLen > byteCount) {
+        throw new Error(`bunfs-extract: module ${i} content range out of bounds`);
+      }
+
+      const name = readRange(fd, dataStart + nameOff, nameLen).toString('utf-8');
+      if (seenNames.has(name)) {
+        throw new Error(`bunfs-extract: duplicate module name ${name}`);
+      }
+      seenNames.add(name);
+
+      const absContOff = dataStart + contOff;
+      if (i === entryPointId) {
+        entryName = name;
+        entryModule = { name, contOff: absContOff, contLen };
+      }
+      if (loader === NAPI_LOADER) continue; // ネイティブ.nodeバイナリは未使用、展開しない
+      if (contLen === 0) continue;
+
+      modules.push({ name, contOff: absContOff, contLen });
+    }
+
+    if (entryName === null) throw new Error('bunfs-extract: entry module not found');
+
+    return { fd, modules, entryName, entryModule, numModules, byteCount };
+  } catch (error) {
+    closeSync(fd);
+    throw error;
+  }
+}
+
+function relPathFromModuleName(name) {
+  const rel = name.replace(/^\/\$bunfs\/root\//, '');
+  if (rel.includes('..') || path.isAbsolute(rel)) {
+    throw new Error(`bunfs-extract: rejected unsafe module name ${name}`);
+  }
+  return rel;
+}
+
+function extractToProcessOwnedDir(sourceBin, ownedDir) {
+  const graph = discoverModuleGraph(sourceBin);
+  const { fd, modules, entryName } = graph;
+  try {
+    mkdirSync(ownedDir, { recursive: true });
+    for (const mod of modules) {
+      const rel = relPathFromModuleName(mod.name);
+      const outPath = path.resolve(ownedDir, rel);
+      if (path.relative(ownedDir, outPath).startsWith('..')) {
+        throw new Error(`bunfs-extract: path escapes owned dir: ${mod.name}`);
+      }
+      mkdirSync(path.dirname(outPath), { recursive: true });
+      const content = readRange(fd, mod.contOff, mod.contLen);
+      writeFileSync(outPath, content);
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return { entryRelPath: relPathFromModuleName(entryName) };
+}
+
+function cleanupStaleOwnedDirs(workdir, prefix, now = Date.now()) {
+  const maxAgeMs = 24 * 60 * 60 * 1000;
+  let entries;
+  try {
+    entries = readdirSync(workdir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!entry.name.startsWith(prefix)) continue;
+    const dirPath = path.join(workdir, entry.name);
+    let stats;
+    try {
+      stats = statSync(dirPath);
+    } catch {
+      continue;
+    }
+    if (Number.isFinite(stats.mtimeMs) && now - stats.mtimeMs < maxAgeMs) continue;
+
+    const pidMatch = entry.name.match(/^esm\.(\d+)\./);
+    if (pidMatch) {
+      const pid = Number(pidMatch[1]);
+      if (Number.isInteger(pid) && pid > 0) {
+        try {
+          process.kill(pid, 0);
+          continue; // ESRCH以外(プロセス生存中、またはEPERM等)は削除対象から除外
+        } catch (error) {
+          if (error && error.code !== 'ESRCH') continue;
+        }
+      }
+    }
+    try {
+      rmSync(dirPath, { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+function prepareProcessOwnedDir(sourceBin, workdir) {
+  const dirName = `esm.${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}.bare-dir`;
+  cleanupStaleOwnedDirs(workdir, 'esm.');
+  const ownedDir = path.join(workdir, dirName);
+  const { entryRelPath } = extractToProcessOwnedDir(sourceBin, ownedDir);
+  return { ownedDir, entryRelPath };
+}
+
+function readEntryContentPrefix(fd, entryModule, maxLength = 256) {
+  const length = Math.min(entryModule.contLen, maxLength);
+  return readRange(fd, entryModule.contOff, length);
+}
+
+module.exports = {
+  discoverModuleGraph,
+  extractToProcessOwnedDir,
+  cleanupStaleOwnedDirs,
+  prepareProcessOwnedDir,
+  readEntryContentPrefix,
+};