@bash0816/claude-code 2.1.241 → 2.1.245

package/README.md

@@ -37,7 +37,7 @@ npm が `claude` bin link を管理する状態になれば、通常の `npm ins
 Latest audited version / 最新監査済み版:
 
 ```sh
-npm install -g @bash0816/claude-code@2.1.240
+npm install -g @bash0816/claude-code@2.1.241
 ```
 
 ## Update / 更新

package/bin/claude

@@ -42,11 +42,18 @@ process.stdout.write(String(item[field]));
 ' "${CONFIG_FILE}" "${CLAUDE_VERSION}" "$1"
 }
 
-ENTRY_JS_OFFSET=$(json_field entry_js_offset)
-ENTRY_END_OFFSET=$(json_field entry_end_offset)
+ENTRY_FORMAT=$(json_field entry_format || echo "legacy-cjs")
 CACHE_DIR="${CLAUDE_TERMUX_PACKAGE_CACHE:-${HOME}/.claude-termux-native-package}/versions/${CLAUDE_VERSION}"
 SOURCE_BIN="${CACHE_DIR}/app/node_modules/@anthropic-ai/claude-code-linux-arm64/claude"
 
+if [ "${ENTRY_FORMAT}" = "esm-chunked" ]; then
+  ENTRY_JS_OFFSET=""
+  ENTRY_END_OFFSET=""
+else
+  ENTRY_JS_OFFSET=$(json_field entry_js_offset)
+  ENTRY_END_OFFSET=$(json_field entry_end_offset)
+fi
+
 if [ ! -f "${SOURCE_BIN}" ]; then
   "$NODE" "${PACKAGE_DIR}/lib/prepare-native.js" "${CLAUDE_VERSION}"
 fi
@@ -58,6 +65,7 @@ fi
 
 SOURCE_BIN="${SOURCE_BIN}" \
 WORKDIR="${CACHE_DIR}/launcher-workdir" \
+ENTRY_FORMAT="${ENTRY_FORMAT}" \
 ENTRY_JS_OFFSET="${ENTRY_JS_OFFSET}" \
 ENTRY_END_OFFSET="${ENTRY_END_OFFSET}" \
 CURRENT_CLAUDE_VERSION="${CLAUDE_VERSION}" \

package/config/claude-native-audited-versions.json

@@ -770,6 +770,14 @@
       "tarball_integrity": "sha512-tHsJhjwcoFyKTCQfYCclKjLtbnbbGKvcrzxUhMb6NDlPw9RrawmjSWUAdla7PtEVPaJsGkjGo4O2MQTlYIT+PA==",
       "tarball_sha256": "41de896e672667bc5b5060419d5a1ff5cfe15b77659d1418b10df5095e38419a",
       "status": "termux_verified"
+    },
+    "2.1.245": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.245",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.245",
+      "entry_format": "esm-chunked",
+      "tarball_integrity": "sha512-Qbn5HnZbYeW4GdifVkDGfcVKqj3/f3U9sfVd3LEaUZh08CcS8D/ptJ76zuBfQUGHJHfToAdNVfak86uJ84b1Dg==",
+      "tarball_sha256": "668662e7b5d91a93cff6c75736e60f3d5d3bed4cbe077ae4feefc63ad1253f4d",
+      "status": "offset_discovered"
     }
   }
 }

package/config/claude-termux-release-manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 1,
   "package_name": "@bash0816/claude-code",
   "latest_audited_version": "2.1.241",
-  "latest_candidate_version": "2.1.241",
+  "latest_candidate_version": "2.1.245",
   "previous_stable_version": "2.1.240",
   "stable_pinned_version": "2.1.220-2",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"

package/lib/bunfs-child-process-guard.mjs

@@ -0,0 +1,18 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const realChildProcess = require('node:child_process');
+const { createGuardedChildProcess } = require('./native-update-guard.js');
+const guarded = createGuardedChildProcess(realChildProcess, (v) => process.stderr.write(v));
+
+export const spawn = guarded.spawn;
+export const execFile = guarded.execFile;
+export const exec = guarded.exec;
+export const spawnSync = guarded.spawnSync;
+export const execFileSync = guarded.execFileSync;
+export const execSync = guarded.execSync;
+export const ChildProcess = realChildProcess.ChildProcess;
+export const fork = realChildProcess.fork;
+export const _forkChild = realChildProcess._forkChild;
+
+export default Object.assign({}, realChildProcess, guarded);

package/lib/bunfs-child-process-guard.test.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+test('bunfs-child-process-guard exports named exports for guarded methods', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  assert.equal(typeof guard.spawn, 'function');
+  assert.equal(typeof guard.execFile, 'function');
+  assert.equal(typeof guard.exec, 'function');
+  assert.equal(typeof guard.spawnSync, 'function');
+  assert.equal(typeof guard.execFileSync, 'function');
+  assert.equal(typeof guard.execSync, 'function');
+});
+
+test('bunfs-child-process-guard exports ChildProcess, fork, _forkChild', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // ChildProcess is a class
+  assert.equal(typeof guard.ChildProcess, 'function');
+  // fork and _forkChild are functions
+  assert.equal(typeof guard.fork, 'function');
+  assert.equal(typeof guard._forkChild, 'function');
+});
+
+test('bunfs-child-process-guard provides default export with all methods', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+  const defaultExport = guard.default;
+
+  assert.ok(defaultExport);
+  assert.equal(typeof defaultExport, 'object');
+  assert.equal(typeof defaultExport.spawn, 'function');
+  assert.equal(typeof defaultExport.execFile, 'function');
+  assert.equal(typeof defaultExport.exec, 'function');
+  assert.equal(typeof defaultExport.spawnSync, 'function');
+  assert.equal(typeof defaultExport.execFileSync, 'function');
+  assert.equal(typeof defaultExport.execSync, 'function');
+  assert.equal(typeof defaultExport.ChildProcess, 'function');
+  assert.equal(typeof defaultExport.fork, 'function');
+  assert.equal(typeof defaultExport._forkChild, 'function');
+});
+
+test('bunfs-child-process-guard blocks official package update via execFileSync', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // Try to execute npm install of official package
+  try {
+    guard.execFileSync('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']);
+    // If it doesn't throw, that's an error (should be blocked)
+    assert.fail('Expected execFileSync to block official package update');
+  } catch (err) {
+    // Should throw with CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED code
+    assert.ok(
+      err.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED' ||
+      err.message.includes('disabled on Termux'),
+      `Expected block error, got: ${err.message}`,
+    );
+  }
+});
+
+test('bunfs-child-process-guard blocks official package update via execSync', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // Try to execute npm install via exec
+  try {
+    guard.execSync('npm install -g @anthropic-ai/claude-code@latest');
+    // If it doesn't throw, that's an error (should be blocked)
+    assert.fail('Expected execSync to block official package update');
+  } catch (err) {
+    // Should throw with CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED code
+    assert.ok(
+      err.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED' ||
+      err.message.includes('disabled on Termux'),
+      `Expected block error, got: ${err.message}`,
+    );
+  }
+});
+
+test('bunfs-child-process-guard allows harmless commands', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // echo is a harmless command and should not be blocked
+  const result = guard.execFileSync('echo', ['hello']);
+  // Verify the command actually executed and produced output
+  assert.equal(result.toString().trim(), 'hello');
+});
+
+test('bunfs-child-process-guard spawn blocks official package install', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // spawn should return a blocked child process (EventEmitter-like)
+  const child = guard.spawn('npm', ['install', '-g', '@anthropic-ai/claude-code']);
+
+  // Blocked spawn should have specific properties
+  assert.equal(child.stdout, null);
+  assert.equal(child.stderr, null);
+  assert.equal(child.stdin, null);
+  assert.equal(child.pid, 0);
+  assert.equal(child.killed, false);
+
+  // Verify it's event-like (has on method or can be used as event emitter)
+  assert.equal(typeof child.kill, 'function');
+});
+
+test('bunfs-child-process-guard does not block other package installs', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // Installing a different package should not be blocked
+  const result = guard.execFileSync('echo', ['@bash0816/claude-code']);
+  // Verify the command actually executed and produced correct output
+  assert.equal(result.toString().trim(), '@bash0816/claude-code');
+});

package/lib/bunfs-esm-loader.mjs

@@ -0,0 +1,74 @@
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+let PROCESS_OWNED_DIR = null;
+let SOURCE_BIN = null;
+let CHILD_PROCESS_GUARD_PATH = null;
+let VM_GUARD_PATH = null;
+let WS_STUB_PATH = null;
+
+export function initialize(data) {
+  PROCESS_OWNED_DIR = data.processOwnedDir;
+  SOURCE_BIN = data.sourceBin;
+  CHILD_PROCESS_GUARD_PATH = data.childProcessGuardPath;
+  VM_GUARD_PATH = data.vmGuardPath;
+  WS_STUB_PATH = data.wsStubPath;
+}
+
+function buildImportMetaRequirePolyfillPrelude(anchorUrl) {
+  return (
+    `import __bunfsGuardedChildProcess from ${JSON.stringify(pathToFileURL(CHILD_PROCESS_GUARD_PATH).href)};\n` +
+    `import __bunfsGuardedVm from ${JSON.stringify(pathToFileURL(VM_GUARD_PATH).href)};\n` +
+    `import { createRequire as __bunfsCreateRequire } from "node:module";\n` +
+    `const __bunfsRealRequire = __bunfsCreateRequire(${JSON.stringify(anchorUrl)});\n` +
+    `const __bunfsMetaRequire = (id) => {\n` +
+    `  if (id === "child_process" || id === "node:child_process") return __bunfsGuardedChildProcess;\n` +
+    `  if (id === "vm" || id === "node:vm") return __bunfsGuardedVm;\n` +
+    `  return __bunfsRealRequire(id);\n` +
+    `};\n`
+  );
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier === 'child_process' || specifier === 'node:child_process') {
+    return { url: pathToFileURL(CHILD_PROCESS_GUARD_PATH).href, shortCircuit: true, format: 'module' };
+  }
+  if (specifier === 'vm' || specifier === 'node:vm') {
+    return { url: pathToFileURL(VM_GUARD_PATH).href, shortCircuit: true, format: 'module' };
+  }
+  if (specifier === 'ws') {
+    return { url: pathToFileURL(WS_STUB_PATH).href, shortCircuit: true, format: 'module' };
+  }
+  if (specifier.startsWith('/$bunfs/root/')) {
+    const rel = specifier.slice('/$bunfs/root/'.length);
+    if (rel.includes('..') || path.isAbsolute(rel)) {
+      throw new Error(`bunfs resolve: rejected specifier ${specifier}`);
+    }
+    const real = path.resolve(PROCESS_OWNED_DIR, rel);
+    if (path.relative(PROCESS_OWNED_DIR, real).startsWith('..')) {
+      throw new Error(`bunfs resolve: path escapes process-owned dir: ${specifier}`);
+    }
+    if (!existsSync(real)) {
+      throw new Error(`bunfs resolve: missing extracted module ${specifier} -> ${real}`);
+    }
+    return { url: pathToFileURL(real).href, shortCircuit: true, format: 'module' };
+  }
+  return nextResolve(specifier, context);
+}
+
+export async function load(url, context, nextLoad) {
+  const ownedPrefix = pathToFileURL(PROCESS_OWNED_DIR + path.sep).href;
+  if (!url.startsWith(ownedPrefix)) {
+    return nextLoad(url, context);
+  }
+  const filePath = fileURLToPath(url);
+  let source = readFileSync(filePath, 'utf8');
+  if (source.includes('import.meta.require')) {
+    const anchorUrl = pathToFileURL(SOURCE_BIN).href;
+    source = buildImportMetaRequirePolyfillPrelude(anchorUrl) +
+      source.replaceAll('import.meta.require', '__bunfsMetaRequire');
+  }
+  return { format: 'module', source, shortCircuit: true };
+}

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

@@ -0,0 +1,329 @@
+'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 = async (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    // child_process should resolve to childProcessGuardPath
+    const result1 = await loader.resolve('child_process', {}, nextResolve);
+    assert.ok(result1.url.includes(guardPath));
+    assert.equal(result1.shortCircuit, true);
+
+    // node:child_process should also resolve to childProcessGuardPath
+    const result2 = await loader.resolve('node:child_process', {}, 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 = async (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    // vm should resolve to vmGuardPath
+    const result1 = await loader.resolve('vm', {}, nextResolve);
+    assert.ok(result1.url.includes(vmGuardPath));
+    assert.equal(result1.shortCircuit, true);
+
+    // node:vm should also resolve to vmGuardPath
+    const result2 = await loader.resolve('node:vm', {}, 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 = async (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    const result = await loader.resolve('ws', {}, 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 = async (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    await assert.rejects(
+      () => 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 = async (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    await assert.rejects(
+      () => 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 = async (spec, ctx) => ({ url: `unresolved:${spec}` });
+
+    await assert.rejects(
+      () => 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 });
+  }
+});