@bash0816/claude-code 2.1.245 → 2.1.251

package/lib/native-validators.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const packageDir = path.resolve(__dirname, '..');
+
+function verifyTarball(file, audited, version) {
+  const buf = fs.readFileSync(file);
+  if (audited.tarball_sha256) {
+    const sha256 = crypto.createHash('sha256').update(buf).digest('hex');
+    if (sha256 !== audited.tarball_sha256) {
+      throw new Error(`tarball sha256 mismatch for ${version}`);
+    }
+  }
+  if (audited.tarball_integrity) {
+    const sha512 = `sha512-${crypto.createHash('sha512').update(buf).digest('base64')}`;
+    if (sha512 !== audited.tarball_integrity) {
+      throw new Error(`tarball integrity mismatch for ${version}`);
+    }
+  }
+  if (audited.tarball_size !== undefined && Number(audited.tarball_size) !== buf.length) {
+    throw new Error(`tarball size mismatch for ${version}`);
+  }
+}
+
+function validateOffsets(file, audited, version) {
+  if (audited.entry_format === 'esm-chunked') {
+    validateEsmChunkedOffsets(file, audited, version);
+    return;
+  }
+  validateLegacyCjsOffsets(file, audited, version);
+}
+
+function validateLegacyCjsOffsets(file, audited, version) {
+  const buf = fs.readFileSync(file);
+  const start = Number(audited.entry_js_offset);
+  const end = Number(audited.entry_end_offset);
+  const startMarker = Buffer.from('function(exports, require, module, __filename, __dirname) {// Claude Code is a Beta product');
+  const endMarker = Buffer.from('/$bunfs/root/image-processor.js');
+
+  if (!(start > 0 && end > start && end <= buf.length)) {
+    throw new Error(`invalid audited offsets for ${version}`);
+  }
+  if (!buf.subarray(start, start + startMarker.length).equals(startMarker)) {
+    throw new Error(`audited start offset validation failed for ${version}`);
+  }
+  if (!buf.subarray(end, end + endMarker.length).equals(endMarker)) {
+    throw new Error(`audited end offset validation failed for ${version}`);
+  }
+}
+
+function validateEsmChunkedOffsets(file, audited, version) {
+  // 371MB超のバイナリ全体をreadFileSyncしない(実機でOOM確認済み)。
+  // discoverModuleGraphは範囲readSyncのみでトレイラー・モジュールテーブルを検証する。
+  const { discoverModuleGraph, readEntryContentPrefix } = require(path.join(packageDir, 'lib', 'bunfs-extract.js'));
+  const graph = discoverModuleGraph(file);
+  try {
+    if (!(graph.numModules > 0)) {
+      throw new Error(`esm-chunked module graph is empty for ${version}`);
+    }
+    if (graph.entryName !== '/$bunfs/root/cli') {
+      throw new Error(`esm-chunked entry module name mismatch for ${version}: ${graph.entryName}`);
+    }
+    if (!Object.prototype.hasOwnProperty.call(audited, 'cycle_hoists')) {
+      throw new Error(`esm-chunked audited metadata for ${version} is missing cycle_hoists field`);
+    }
+    if (audited.num_modules !== undefined && graph.numModules !== audited.num_modules) {
+      throw new Error(`esm-chunked num_modules mismatch for ${version}: expected ${audited.num_modules}, got ${graph.numModules}`);
+    }
+    if (audited.byte_count !== undefined && graph.byteCount !== audited.byte_count) {
+      throw new Error(`esm-chunked byte_count mismatch for ${version}: expected ${audited.byte_count}, got ${graph.byteCount}`);
+    }
+    const prefix = readEntryContentPrefix(graph.fd, graph.entryModule, 256).toString('utf8');
+    const codeStart = prefix.replace(/^(\s*\/\/[^\n]*\n)+/, '').replace(/^\(/, '');
+    if (codeStart.startsWith('function(exports, require, module, __filename, __dirname) {')) {
+      throw new Error(`entry module for ${version} is legacy-cjs wrapped, but audited entry_format is esm-chunked`);
+    }
+  } finally {
+    fs.closeSync(graph.fd);
+  }
+}
+
+module.exports = {
+  validateEsmChunkedOffsets,
+  validateLegacyCjsOffsets,
+  validateOffsets,
+  verifyTarball,
+};

package/lib/native-validators.test.js

@@ -0,0 +1,160 @@
+'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 {
+  validateEsmChunkedOffsets,
+} = require('./native-validators.js');
+
+const {
+  discoverModuleGraph,
+} = require('./bunfs-extract.js');
+
+const TRAILER = '\n---- Bun! ----\n';
+
+// StandaloneModuleGraphの最小合成バイナリを構築する。
+// レイアウト: [preamble padding][module contents][module table][Offsets(32byte)][trailer]
+function buildSyntheticBinary({ modules, entryPointId, corruptTrailer = false, preamblePadding = 64 }) {
+  const nameBuffers = modules.map((m) => Buffer.from(m.name, 'utf8'));
+  const contentBuffers = modules.map((m) => Buffer.from(m.content ?? '', 'utf8'));
+
+  const dataParts = [];
+  const nameOffsets = [];
+  const contOffsets = [];
+  let cursor = 0;
+  for (let i = 0; i < modules.length; i += 1) {
+    nameOffsets.push(cursor);
+    dataParts.push(nameBuffers[i]);
+    cursor += nameBuffers[i].length;
+  }
+  for (let i = 0; i < modules.length; i += 1) {
+    contOffsets.push(cursor);
+    dataParts.push(contentBuffers[i]);
+    cursor += contentBuffers[i].length;
+  }
+  const byteCountBeforeTable = cursor;
+
+  const MODULE_TABLE_ENTRY_SIZE = 52;
+  const modTable = Buffer.alloc(MODULE_TABLE_ENTRY_SIZE * modules.length);
+  for (let i = 0; i < modules.length; i += 1) {
+    const base = i * MODULE_TABLE_ENTRY_SIZE;
+    modTable.writeUInt32LE(nameOffsets[i], base);
+    modTable.writeUInt32LE(nameBuffers[i].length, base + 4);
+    modTable.writeUInt32LE(contOffsets[i], base + 8);
+    modTable.writeUInt32LE(contentBuffers[i].length, base + 12);
+    modTable[base + 49] = modules[i].loader ?? 1; // 1 = js
+  }
+  const modulesOffset = byteCountBeforeTable;
+  const modulesLength = modTable.length;
+  const byteCount = byteCountBeforeTable + modulesLength;
+
+  const offsetsBuf = Buffer.alloc(32);
+  offsetsBuf.writeBigUInt64LE(BigInt(byteCount), 0);
+  offsetsBuf.writeUInt32LE(modulesOffset, 8);
+  offsetsBuf.writeUInt32LE(modulesLength, 12);
+  offsetsBuf.writeUInt32LE(entryPointId, 16);
+
+  const trailerBuf = Buffer.from(corruptTrailer ? '\n---- NOT BUN ----\n' : TRAILER, 'utf8');
+
+  return Buffer.concat([
+    Buffer.alloc(preamblePadding),
+    ...dataParts,
+    modTable,
+    offsetsBuf,
+    trailerBuf,
+  ]);
+}
+
+function writeTempBinary(buf) {
+  const file = path.join(os.tmpdir(), `native-validators-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.bin`);
+  fs.writeFileSync(file, buf);
+  return file;
+}
+
+test('validateEsmChunkedOffsets accepts matching num_modules and byte_count', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'export default 1;' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    const graph = discoverModuleGraph(file);
+    try {
+      const audited = {
+        num_modules: graph.numModules,
+        byte_count: graph.byteCount,
+        entry_format: 'esm-chunked',
+        cycle_hoists: [],
+      };
+      assert.doesNotThrow(() => validateEsmChunkedOffsets(file, audited, '9.9.9'));
+    } finally {
+      fs.closeSync(graph.fd);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('validateEsmChunkedOffsets rejects mismatched num_modules', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'export default 1;' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    const graph = discoverModuleGraph(file);
+    try {
+      const audited = {
+        num_modules: graph.numModules + 1, // intentionally wrong
+        byte_count: graph.byteCount,
+        entry_format: 'esm-chunked',
+        cycle_hoists: [],
+      };
+      assert.throws(
+        () => validateEsmChunkedOffsets(file, audited, '9.9.9'),
+        /num_modules mismatch/,
+      );
+    } finally {
+      fs.closeSync(graph.fd);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('validateEsmChunkedOffsets rejects mismatched byte_count', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'export default 1;' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    const graph = discoverModuleGraph(file);
+    try {
+      const audited = {
+        num_modules: graph.numModules,
+        byte_count: graph.byteCount + 1, // intentionally wrong
+        entry_format: 'esm-chunked',
+        cycle_hoists: [],
+      };
+      assert.throws(
+        () => validateEsmChunkedOffsets(file, audited, '9.9.9'),
+        /byte_count mismatch/,
+      );
+    } finally {
+      fs.closeSync(graph.fd);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});

package/lib/prepare-native.js

@@ -2,7 +2,6 @@
 'use strict';
 
 const cp = require('child_process');
-const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -16,6 +15,8 @@ const curlRetries = process.env.CLAUDE_TERMUX_FETCH_RETRIES || '4';
 const curlConnectTimeout = process.env.CLAUDE_TERMUX_FETCH_CONNECT_TIMEOUT || '20';
 const curlMaxTime = process.env.CLAUDE_TERMUX_FETCH_MAX_TIME || '300';
 
+const { validateOffsets, verifyTarball } = require(path.join(packageDir, 'lib', 'native-validators.js'));
+
 if (!item) {
   console.error(`Unsupported audited Claude Code version: ${version}`);
   process.exit(1);
@@ -27,7 +28,7 @@ const nativeDest = path.join(versionDir, 'app', 'node_modules', '@anthropic-ai',
 const sourceBin = path.join(nativeDest, 'claude');
 
 if (fs.existsSync(sourceBin)) {
-  validateOffsets(sourceBin, item);
+  validateOffsets(sourceBin, item, version);
   process.exit(0);
 }
 
@@ -36,7 +37,7 @@ const packDir = fs.mkdtempSync(path.join(os.tmpdir(), `claude-code-${version}-`)
 
 try {
   const tgzPath = fetchNativeTarball(item.native_spec, packDir);
-  verifyTarball(tgzPath, item);
+  verifyTarball(tgzPath, item, version);
 
   const extractDir = path.join(packDir, 'native');
   fs.mkdirSync(extractDir, { recursive: true });
@@ -45,7 +46,7 @@ try {
   fs.rmSync(nativeDest, { recursive: true, force: true });
   fs.mkdirSync(path.dirname(nativeDest), { recursive: true });
   fs.cpSync(path.join(extractDir, 'package'), nativeDest, { recursive: true });
-  validateOffsets(sourceBin, item);
+  validateOffsets(sourceBin, item, version);
 } finally {
   fs.rmSync(packDir, { recursive: true, force: true });
 }
@@ -107,70 +108,3 @@ function fetchNativeTarball(spec, packDir) {
   }
   return path.join(packDir, packEntry.filename);
 }
-
-function verifyTarball(file, audited) {
-  const buf = fs.readFileSync(file);
-  if (audited.tarball_sha256) {
-    const sha256 = crypto.createHash('sha256').update(buf).digest('hex');
-    if (sha256 !== audited.tarball_sha256) {
-      throw new Error(`tarball sha256 mismatch for ${version}`);
-    }
-  }
-  if (audited.tarball_integrity) {
-    const sha512 = `sha512-${crypto.createHash('sha512').update(buf).digest('base64')}`;
-    if (sha512 !== audited.tarball_integrity) {
-      throw new Error(`tarball integrity mismatch for ${version}`);
-    }
-  }
-  if (audited.tarball_size !== undefined && Number(audited.tarball_size) !== buf.length) {
-    throw new Error(`tarball size mismatch for ${version}`);
-  }
-}
-
-function validateOffsets(file, audited) {
-  if (audited.entry_format === 'esm-chunked') {
-    validateEsmChunkedOffsets(file, audited);
-    return;
-  }
-  validateLegacyCjsOffsets(file, audited);
-}
-
-function validateLegacyCjsOffsets(file, audited) {
-  const buf = fs.readFileSync(file);
-  const start = Number(audited.entry_js_offset);
-  const end = Number(audited.entry_end_offset);
-  const startMarker = Buffer.from('function(exports, require, module, __filename, __dirname) {// Claude Code is a Beta product');
-  const endMarker = Buffer.from('/$bunfs/root/image-processor.js');
-
-  if (!(start > 0 && end > start && end <= buf.length)) {
-    throw new Error(`invalid audited offsets for ${version}`);
-  }
-  if (!buf.subarray(start, start + startMarker.length).equals(startMarker)) {
-    throw new Error(`audited start offset validation failed for ${version}`);
-  }
-  if (!buf.subarray(end, end + endMarker.length).equals(endMarker)) {
-    throw new Error(`audited end offset validation failed for ${version}`);
-  }
-}
-
-function validateEsmChunkedOffsets(file, audited) {
-  // 371MB超のバイナリ全体をreadFileSyncしない(実機でOOM確認済み)。
-  // discoverModuleGraphは範囲readSyncのみでトレイラー・モジュールテーブルを検証する。
-  const { discoverModuleGraph, readEntryContentPrefix } = require(path.join(packageDir, 'lib', 'bunfs-extract.js'));
-  const graph = discoverModuleGraph(file);
-  try {
-    if (!(graph.numModules > 0)) {
-      throw new Error(`esm-chunked module graph is empty for ${version}`);
-    }
-    if (graph.entryName !== '/$bunfs/root/cli') {
-      throw new Error(`esm-chunked entry module name mismatch for ${version}: ${graph.entryName}`);
-    }
-    const prefix = readEntryContentPrefix(graph.fd, graph.entryModule, 256).toString('utf8');
-    const codeStart = prefix.replace(/^(\s*\/\/[^\n]*\n)+/, '').replace(/^\(/, '');
-    if (codeStart.startsWith('function(exports, require, module, __filename, __dirname) {')) {
-      throw new Error(`entry module for ${version} is legacy-cjs wrapped, but audited entry_format is esm-chunked`);
-    }
-  } finally {
-    fs.closeSync(graph.fd);
-  }
-}

package/lib/termux-run-claude-native.sh

@@ -55,6 +55,7 @@ export ENTRY_FORMAT
 export ENTRY_JS_OFFSET
 export ENTRY_END_OFFSET
 export CURRENT_CLAUDE_VERSION
+export ENABLE_TOOL_SEARCH="${ENABLE_TOOL_SEARCH:-false}"
 
 _pf=0
 for _a in "$@"; do
@@ -664,8 +665,8 @@ function rewriteNativeChunkSource(source) {
 }
 
 async function esmChunkedMain() {
-  const { prepareProcessOwnedDir } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bunfs-extract.js'));
-  const { register } = require('node:module');
+  const { prepareProcessOwnedDir, extractToProcessOwnedDir } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bunfs-extract.js'));
+  const { registerHooks } = require('node:module');
   const { pathToFileURL } = require('node:url');
 
   const { ownedDir, entryRelPath } = prepareProcessOwnedDir(sourceBin, workdir);
@@ -685,21 +686,37 @@ async function esmChunkedMain() {
     },
     gc: () => {},
     YAML: globalThis.__claudeYaml,
+    zstdDecompressSync: (buf) => require('node:zlib').zstdDecompressSync(buf),
+    zstdDecompress: (buf) => new Promise((res, rej) =>
+      require('node:zlib').zstdDecompress(buf, (e, r) => (e ? rej(e) : res(r)))),
   };
   Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
   globalThis.__claudeBunShim = globalThis.Bun;
   globalThis.__claudeBun = globalThis.Bun;
 
-  register(pathToFileURL(path.join(libDir, 'bunfs-esm-loader.mjs')).href, {
-    parentURL: pathToFileURL(__filename).href,
-    data: {
-      processOwnedDir: ownedDir,
-      sourceBin,
-      childProcessGuardPath: path.join(libDir, 'bunfs-child-process-guard.mjs'),
-      vmGuardPath: path.join(libDir, 'bunfs-vm-guard.mjs'),
-      wsStubPath: path.join(libDir, 'bunfs-ws-stub.mjs'),
-    },
+  let cycleHoists = [];
+  try {
+    const auditedVersions = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'config', 'claude-native-audited-versions.json'));
+    const entry = auditedVersions.versions?.[process.env.CURRENT_CLAUDE_VERSION];
+    if (entry && Array.isArray(entry.cycle_hoists)) {
+      cycleHoists = entry.cycle_hoists;
+    }
+  } catch {
+    // 読み込み失敗時は空配列のまま(fail-closed、既存の同期require経路にフォールバック)
+  }
+
+  const loaderMod = require(path.join(libDir, 'bunfs-esm-loader.mjs'));
+  loaderMod.initialize({
+    processOwnedDir: ownedDir,
+    sourceBin,
+    childProcessGuardPath: path.join(libDir, 'bunfs-child-process-guard.mjs'),
+    vmGuardPath: path.join(libDir, 'bunfs-vm-guard.mjs'),
+    wsStubPath: path.join(libDir, 'bunfs-ws-stub.mjs'),
+    cycleHoists,
+    reExtract: (sb, od) => extractToProcessOwnedDir(sb, od),
   });
+  loaderMod.installFsBunfsInterception();
+  registerHooks({ resolve: loaderMod.resolve, load: loaderMod.load });
 
   const entryUrl = pathToFileURL(path.join(ownedDir, entryRelPath)).href;
 
@@ -1678,8 +1695,8 @@ function rewriteNativeChunkSource(source) {
 }
 
 async function esmChunkedMain() {
-  const { prepareProcessOwnedDir } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bunfs-extract.js'));
-  const { register } = require('node:module');
+  const { prepareProcessOwnedDir, extractToProcessOwnedDir } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bunfs-extract.js'));
+  const { registerHooks } = require('node:module');
   const { pathToFileURL } = require('node:url');
 
   const { ownedDir, entryRelPath } = prepareProcessOwnedDir(sourceBin, workdir);
@@ -1699,21 +1716,37 @@ async function esmChunkedMain() {
     },
     gc: () => {},
     YAML: globalThis.__claudeYaml,
+    zstdDecompressSync: (buf) => require('node:zlib').zstdDecompressSync(buf),
+    zstdDecompress: (buf) => new Promise((res, rej) =>
+      require('node:zlib').zstdDecompress(buf, (e, r) => (e ? rej(e) : res(r)))),
   };
   Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
   globalThis.__claudeBunShim = globalThis.Bun;
   globalThis.__claudeBun = globalThis.Bun;
 
-  register(pathToFileURL(path.join(libDir, 'bunfs-esm-loader.mjs')).href, {
-    parentURL: pathToFileURL(__filename).href,
-    data: {
-      processOwnedDir: ownedDir,
-      sourceBin,
-      childProcessGuardPath: path.join(libDir, 'bunfs-child-process-guard.mjs'),
-      vmGuardPath: path.join(libDir, 'bunfs-vm-guard.mjs'),
-      wsStubPath: path.join(libDir, 'bunfs-ws-stub.mjs'),
-    },
+  let cycleHoists = [];
+  try {
+    const auditedVersions = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'config', 'claude-native-audited-versions.json'));
+    const entry = auditedVersions.versions?.[process.env.CURRENT_CLAUDE_VERSION];
+    if (entry && Array.isArray(entry.cycle_hoists)) {
+      cycleHoists = entry.cycle_hoists;
+    }
+  } catch {
+    // 読み込み失敗時は空配列のまま(fail-closed、既存の同期require経路にフォールバック)
+  }
+
+  const loaderMod = require(path.join(libDir, 'bunfs-esm-loader.mjs'));
+  loaderMod.initialize({
+    processOwnedDir: ownedDir,
+    sourceBin,
+    childProcessGuardPath: path.join(libDir, 'bunfs-child-process-guard.mjs'),
+    vmGuardPath: path.join(libDir, 'bunfs-vm-guard.mjs'),
+    wsStubPath: path.join(libDir, 'bunfs-ws-stub.mjs'),
+    cycleHoists,
+    reExtract: (sb, od) => extractToProcessOwnedDir(sb, od),
   });
+  loaderMod.installFsBunfsInterception();
+  registerHooks({ resolve: loaderMod.resolve, load: loaderMod.load });
 
   const entryUrl = pathToFileURL(path.join(ownedDir, entryRelPath)).href;
 

package/lib/termux-run-claude-native.test.js

@@ -1692,3 +1692,126 @@ test('Bun.spawn forwards top-level stdin in the first stdio position', () => {
     }
   }
 });
+
+// New tests for fs interception and zstd support
+
+// esmChunkedMain() (esm-chunked 形式、今回の fs-intercept 修正の対象) の関数本体だけを抽出する。
+// legacyCjsMain() の Bun shim (zstd 非対応でよい、意図的に無変更) を誤って対象に含めないため、
+// 「both esmChunkedMain blocks have correct hook registration order」テストと同じ境界抽出方式を使う。
+function extractEsmChunkedMainBlocks() {
+  const marker = 'async function esmChunkedMain()';
+  const blocks = [];
+  let offset = 0;
+  while ((offset = script.indexOf(marker, offset)) !== -1) {
+    const blockStart = offset;
+    const blockEnd = script.indexOf('\nasync function', offset + 1);
+    const actualBlockEnd = blockEnd !== -1 ? blockEnd : script.length;
+    blocks.push(script.slice(blockStart, actualBlockEnd));
+    offset = actualBlockEnd;
+  }
+  return blocks;
+}
+
+test('both esmChunkedMain Bun shim blocks contain zstdDecompressSync and zstdDecompress fields', () => {
+  const blocks = extractEsmChunkedMainBlocks();
+  assert.ok(blocks.length >= 2, 'should have at least 2 esmChunkedMain blocks (helper and bootstrap)');
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    assert.ok(
+      block.includes('zstdDecompressSync:'),
+      `Block ${i}: missing zstdDecompressSync field`,
+    );
+    assert.ok(
+      block.includes('zstdDecompress:'),
+      `Block ${i}: missing zstdDecompress field`,
+    );
+  }
+});
+
+test('zstd functions are properly defined for sync decompression', () => {
+  const blocks = extractEsmChunkedMainBlocks();
+  assert.ok(blocks.length >= 1, 'should have at least 1 esmChunkedMain block');
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const syncMatch = block.match(/zstdDecompressSync:\s*\([^)]*\)\s*=>\s*require\('node:zlib'\)\.zstdDecompressSync\([^)]*\)/);
+    assert.ok(syncMatch, `Block ${i}: zstdDecompressSync should call require("node:zlib").zstdDecompressSync`);
+
+    const asyncMatch = block.match(/zstdDecompress:\s*\([^)]*\)\s*=>\s*new Promise/);
+    assert.ok(asyncMatch, `Block ${i}: zstdDecompress should return a Promise`);
+  }
+});
+
+test('zstd decompression works with real zlib.zstd APIs', async () => {
+  const zlib = require('node:zlib');
+
+  // Skip if zstd not available
+  if (typeof zlib.zstdCompressSync !== 'function') {
+    return;
+  }
+
+  const testData = Buffer.from('Hello, compression world!');
+  const compressed = zlib.zstdCompressSync(testData);
+
+  // Test sync decompression
+  const decompressedSync = zlib.zstdDecompressSync(compressed);
+  assert.deepEqual(decompressedSync, testData);
+
+  // Test async decompression
+  const decompressedAsync = await new Promise((resolve, reject) => {
+    zlib.zstdDecompress(compressed, (err, result) => {
+      if (err) reject(err);
+      else resolve(result);
+    });
+  });
+  assert.deepEqual(decompressedAsync, testData);
+});
+
+test('both esmChunkedMain blocks have correct hook registration order', () => {
+  const esmChunkedMarker = 'async function esmChunkedMain()';
+  let blockCount = 0;
+  let offset = 0;
+
+  while ((offset = script.indexOf(esmChunkedMarker, offset)) !== -1) {
+    blockCount++;
+    const blockStart = offset;
+    const blockEnd = script.indexOf('\nasync function', offset + 1);
+    const actualBlockEnd = blockEnd !== -1 ? blockEnd : script.length;
+    const block = script.slice(blockStart, actualBlockEnd);
+
+    // Find the three key operations
+    const initIdx = block.indexOf('loaderMod.initialize({');
+    const interceptIdx = block.indexOf('loaderMod.installFsBunfsInterception()');
+    const registerIdx = block.indexOf('registerHooks({');
+
+    assert.ok(initIdx !== -1, `Block ${blockCount}: missing initialize call`);
+    assert.ok(interceptIdx !== -1, `Block ${blockCount}: missing installFsBunfsInterception call`);
+    assert.ok(registerIdx !== -1, `Block ${blockCount}: missing registerHooks call`);
+
+    // Verify order: initialize < installFsBunfsInterception < registerHooks
+    assert.ok(
+      initIdx < interceptIdx && interceptIdx < registerIdx,
+      `Block ${blockCount}: initialization order incorrect (initialize=${initIdx}, intercept=${interceptIdx}, register=${registerIdx})`,
+    );
+
+    offset = actualBlockEnd;
+  }
+
+  assert.ok(blockCount >= 2, 'should have at least 2 esmChunkedMain blocks');
+});
+
+test('termux-run-claude-native.sh maintains compatibility with new zstd fields', () => {
+  // Verify that the script structure is preserved
+  const hasSourceBin = script.includes('SOURCE_BIN=');
+  const hasWorkdir = script.includes('WORKDIR=');
+  const hasGlobalThis = script.includes('globalThis');
+
+  assert.ok(hasSourceBin, 'script should set SOURCE_BIN');
+  assert.ok(hasWorkdir, 'script should set WORKDIR');
+  assert.ok(hasGlobalThis, 'script should manipulate globalThis');
+
+  // Verify both blocks exist and are distinct
+  const blocks = (script.match(/globalThis\.Bun\s*=\s*{/g) || []);
+  assert.ok(blocks.length >= 2, 'should have at least 2 Bun initializations for helper and bootstrap');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.245",
+  "version": "2.1.251",
   "description": "Unofficial Termux-native Claude Code wrapper with audited native replay",
   "license": "GPL-3.0-only",
   "bin": {
@@ -15,7 +15,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=20.6.0"
+    "node": ">=22.15.0 <23.0.0 || >=23.8.0"
   },
   "keywords": [
     "claude-code",