@bash0816/claude-code 2.1.161 → 2.1.177

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.161
+npm install -g @bash0816/claude-code@2.1.161-2
 ```
 
 ## Update / 更新
@@ -54,6 +54,14 @@ claude update
 npm install -g @bash0816/claude-code@<latest_audited_version>
 ```
 
+If you already have the repo's `2.1.161` release or the official upstream
+`2.1.165` installed, install `2.1.159-13` explicitly. `claude update` will not
+roll a newer installed terminal back to this repo's current audited release.
+
+この repo の `2.1.161` release または official upstream の `2.1.165` を
+すでに入れている端末では、`2.1.159-13` を明示 install してください。
+`claude update` だけでは、より新しい端末をこの repo の現在の audited release に戻しません。
+
 Normal launch also checks the same manifest with a short timeout and prints a notice when a newer audited version is available.
 
 通常起動時も、同じ manifest を短い timeout で確認し、新しい監査済み version があれば通知します。

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

@@ -229,6 +229,26 @@
       "status": "termux_verified"
     },
     "2.1.161": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.161",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.161",
+      "entry_js_offset": 225551924,
+      "entry_end_offset": 241503454,
+      "tarball_integrity": "sha512-rLEzd8/q4UnTLDSAd3eYgog+G0iZ8y6K8yh0gSxf82d7uOkypYaBUkbmFENuHuzIzCIf9Yy/utCJfp6kQFjUow==",
+      "tarball_sha256": "e87d973bbe58593e06c101196f6417f7d950bf777cb9f1a8ff002ebf987ea066",
+      "tarball_size": 74314760,
+      "status": "offset_discovered"
+    },
+    "2.1.161-1": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.161",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.161",
+      "entry_js_offset": 225551924,
+      "entry_end_offset": 241503454,
+      "tarball_integrity": "sha512-rLEzd8/q4UnTLDSAd3eYgog+G0iZ8y6K8yh0gSxf82d7uOkypYaBUkbmFENuHuzIzCIf9Yy/utCJfp6kQFjUow==",
+      "tarball_sha256": "e87d973bbe58593e06c101196f6417f7d950bf777cb9f1a8ff002ebf987ea066",
+      "tarball_size": 74314760,
+      "status": "reverted"
+    },
+    "2.1.161-2": {
       "wrapper_spec": "@anthropic-ai/claude-code@2.1.161",
       "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.161",
       "entry_js_offset": 225551924,
@@ -237,6 +257,24 @@
       "tarball_sha256": "e87d973bbe58593e06c101196f6417f7d950bf777cb9f1a8ff002ebf987ea066",
       "tarball_size": 74314760,
       "status": "termux_verified"
+    },
+    "2.1.165": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.165",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.165",
+      "entry_js_offset": 226798932,
+      "entry_end_offset": 242980856,
+      "tarball_integrity": "sha512-uGwKxRQGTxh3BZGnX096CLf/2us5lUFnk4KerWhG4WCpRiEUSu4TUDojp/S3SUzA//FpM57fViUW07XL3T19lw==",
+      "tarball_sha256": "6dc6d84624bedaf5ff0948b178fdfc9c2724d8051cb00e70559e292055f7155e",
+      "status": "reverted"
+    },
+    "2.1.177": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.177",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.177",
+      "entry_js_offset": 231509988,
+      "entry_end_offset": 248542413,
+      "tarball_integrity": "sha512-qb0K+/xwaZFz9spBUcDX3vNgEFTSNdbDze8AOpU4R9weVrwBY9zAO/OPqxC9qNhb5ZIRnJAZLKiICEeEUHowzA==",
+      "tarball_sha256": "dc6f28ab95d8748528a92e207d0f2d1dcd173855d18f11b8f82c5827bbdcb234",
+      "status": "offset_discovered"
     }
   }
 }

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

@@ -1,8 +1,8 @@
 {
   "manifest_version": 1,
   "package_name": "@bash0816/claude-code",
-  "latest_audited_version": "2.1.161",
-  "latest_candidate_version": "2.1.161",
+  "latest_audited_version": "2.1.161-2",
+  "latest_candidate_version": "2.1.177",
   "previous_stable_version": "2.1.159-13",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

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

@@ -49,7 +49,7 @@ for _a in "$@"; do
 done
 
 if [ "$_pf" = "1" ] && [ "${CLAUDE_TERMUX_STDIN:-}" != "inherit" ]; then
-  _helper=$(mktemp "${TMPDIR:-/tmp}/claude-helper.XXXXXX.js")
+  _helper=$(mktemp "${TERMUX_TMPDIR}/claude-helper.XXXXXX.js")
   trap 'rm -f "$_helper"' EXIT HUP INT TERM
   cat <<'NODE' > "$_helper"
 const fs = require('fs');
@@ -73,8 +73,39 @@ class RequestedExit extends Error {
   }
 }
 
+function cleanupStaleEntryFiles(currentWorkdir = workdir, currentEntryJsOffset = entryJsOffset, currentEntryEndOffset = entryEndOffset, now = Date.now()) {
+  const prefix = `cli.${currentEntryJsOffset}.${currentEntryEndOffset}.`;
+  const suffix = '.bare-path.js';
+  const maxAgeMs = 24 * 60 * 60 * 1000;
+  let entries;
+  try {
+    entries = fs.readdirSync(currentWorkdir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    if (!entry.name.startsWith(prefix) || !entry.name.endsWith(suffix)) continue;
+    const filePath = path.join(currentWorkdir, entry.name);
+    let stats;
+    try {
+      stats = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+    if (Number.isFinite(stats.mtimeMs) && now - stats.mtimeMs < maxAgeMs) continue;
+    try {
+      fs.rmSync(filePath, { force: true });
+    } catch {}
+  }
+}
+
 function ensureEntryFile() {
-  const extractedFile = path.join(workdir, `cli.${entryJsOffset}.${entryEndOffset}.bare-path.js`);
+  cleanupStaleEntryFiles();
+  const extractedFile = path.join(
+    workdir,
+    `cli.${entryJsOffset}.${entryEndOffset}.${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}.bare-path.js`,
+  );
   const len = entryEndOffset - entryJsOffset;
   if (!(len > 0)) throw new Error('invalid replay offsets');
 
@@ -87,15 +118,165 @@ function ensureEntryFile() {
   return extractedFile;
 }
 
+function isFullWidthCodePoint(codePoint) {
+  return Number.isFinite(codePoint) && (
+    codePoint >= 0x1100 && (
+      codePoint <= 0x115f ||
+      codePoint === 0x2329 ||
+      codePoint === 0x232a ||
+      (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+      (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+      (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+      (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+      (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+      (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+      (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+      (codePoint >= 0x1f300 && codePoint <= 0x1f6ff) ||
+      (codePoint >= 0x1fa70 && codePoint <= 0x1faff) ||
+      (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+      (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+    )
+  );
+}
+
+function graphemeWidth(grapheme) {
+  let width = 0;
+  const symbols = Array.from(String(grapheme ?? ''));
+  const codePoints = symbols.map(symbol => symbol.codePointAt(0)).filter(codePoint => Number.isFinite(codePoint));
+  if (codePoints.length === 0) return 0;
+  if (codePoints.length > 1 && codePoints.every(codePoint => codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff)) {
+    return 2;
+  }
+  if (codePoints.includes(0x20e3) || codePoints.includes(0x200d)) {
+    return 2;
+  }
+  if (codePoints.includes(0xfe0f) || codePoints.some(codePoint => codePoint >= 0x2600 && codePoint <= 0x27bf)) {
+    return 2;
+  }
+  for (const symbol of symbols) {
+    const codePoint = symbol.codePointAt(0);
+    if (codePoint === undefined || codePoint === 0) continue;
+    if (codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0)) continue;
+    if (codePoint === 0x200d || codePoint === 0xfe0f) continue;
+    if (/\p{M}/u.test(symbol)) continue;
+    if (isFullWidthCodePoint(codePoint)) return 2;
+    width = 1;
+  }
+  return width;
+}
+
 function stringWidth(value) {
-  const text = String(value ?? '');
+  const text = stripANSI(value);
   if (typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function') {
     const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
     let width = 0;
-    for (const _segment of segmenter.segment(text)) width += 1;
+    for (const segment of segmenter.segment(text)) width += graphemeWidth(segment.segment);
     return width;
   }
-  return Array.from(text).length;
+  return Array.from(text).reduce((width, symbol) => width + graphemeWidth(symbol), 0);
+}
+
+function stripANSI(value) {
+  return String(value ?? '')
+    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, '');
+}
+
+function wrapAnsi(value, columns, options = {}) {
+  const text = String(value ?? '');
+  const width = Number(columns);
+  const hard = options.hard !== false;
+  const trim = options.trim === true;
+  const wordWrap = options.wordWrap !== false;
+  if (!Number.isFinite(width) || width <= 0) return trim ? text.trimEnd() : text;
+
+  const ansiPattern = /\x1B\[[0-?]*[ -/]*[@-~]|\x1B\][^\x07]*(?:\x07|\x1B\\)/g;
+  const segmenter = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
+    ? new Intl.Segmenter('en', { granularity: 'grapheme' })
+    : null;
+  const splitVisible = (chunk) => {
+    if (chunk === '') return [];
+    if (!segmenter) return Array.from(chunk);
+    return Array.from(segmenter.segment(chunk), part => part.segment);
+  };
+  const splitByGrapheme = hard || !wordWrap;
+  let result = '';
+  let currentWidth = 0;
+  let lastIndex = 0;
+  const appendVisible = (chunk) => {
+    const tokens = splitByGrapheme ? splitVisible(chunk) : (chunk.match(/\s+|[^\s]+/gu) || []);
+    for (const token of tokens) {
+      if (token === '\n') {
+        if (trim) result = result.replace(/[ \t]+$/g, '');
+        result += token;
+        currentWidth = 0;
+        continue;
+      }
+      const tokenWidth = stringWidth(token);
+      const isWhitespace = /^\s+$/u.test(token);
+      if (trim && isWhitespace && currentWidth === 0) continue;
+      if (currentWidth > 0 && currentWidth + tokenWidth > width) {
+        if (!splitByGrapheme && !isWhitespace) {
+          result = result.replace(/[ \t]+$/g, '');
+          result += '\n';
+          currentWidth = 0;
+        } else {
+          for (const piece of splitVisible(token)) {
+            const pieceWidth = stringWidth(piece);
+            if (currentWidth > 0 && currentWidth + pieceWidth > width) {
+              if (trim) result = result.replace(/[ \t]+$/g, '');
+              result += '\n';
+              currentWidth = 0;
+            }
+            if (trim && /^\s+$/u.test(piece) && currentWidth === 0) continue;
+            result += piece;
+            currentWidth += pieceWidth;
+          }
+          continue;
+        }
+      }
+      result += token;
+      currentWidth += tokenWidth;
+    }
+  };
+  for (const match of text.matchAll(ansiPattern)) {
+    appendVisible(text.slice(lastIndex, match.index ?? 0));
+    result += match[0];
+    lastIndex = (match.index ?? 0) + match[0].length;
+  }
+  appendVisible(text.slice(lastIndex));
+  return trim ? result.replace(/[ \t]+$/gm, '') : result;
+}
+
+function stableHash(value, seed) {
+  const text = String(value ?? '');
+  let hash = 2166136261;
+  if (seed !== undefined) {
+    const seedText = String(seed ?? '');
+    for (let i = 0; i < seedText.length; i += 1) {
+      hash ^= seedText.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    hash ^= 0x9e3779b9;
+    hash = Math.imul(hash, 16777619);
+  }
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function replaceRequired(source, pattern, replacement, label, expectedCount) {
+  const text = String(source);
+  const matches = text.match(pattern);
+  if (!matches || matches.length === 0) {
+    throw new Error(`rewriteNativeChunkSource: missing ${label}`);
+  }
+  if (expectedCount !== undefined && matches.length !== expectedCount) {
+    throw new Error(`rewriteNativeChunkSource: unexpected ${label} count ${matches.length}`);
+  }
+  return text.replace(pattern, replacement);
 }
 
 function parseScalar(value) {
@@ -244,6 +425,9 @@ function createFakeRequire(realRequire) {
           writable: true,
         });
       }
+      if (context.Bun && globalThis.__claudeYaml) {
+        context.Bun.YAML = globalThis.__claudeYaml;
+      }
     } catch {}
     return context;
   }
@@ -344,25 +528,53 @@ function createFakeRequire(realRequire) {
   };
 }
 
-async function main() {
-  const extractedFile = ensureEntryFile();
-  const code = fs.readFileSync(extractedFile, 'utf8');
-  const patchedCode = code.replace(
-    /^function\(exports, require, module, __filename, __dirname\) \{/,
-    'function(exports, require, module, __filename, __dirname) {var __claudeBun = globalThis.__claudeBunShim;',
-  ).replace(
+function rewriteNativeChunkSource(source) {
+  const rawPrefix = 'function(exports, require, module, __filename, __dirname) {';
+  const injectedPrefix = rawPrefix + 'var __claudeBun = globalThis.__claudeBunShim;';
+  let patched = String(source);
+  patched = replaceRequired(
+    patched,
+    /^function\(exports, require, module, __filename, __dirname\) \{(?:var __claudeBun = globalThis\.__claudeBunShim;)?/,
+    injectedPrefix,
+    'module wrapper prefix',
+    1,
+  );
+  patched = replaceRequired(
+    patched,
     /\btypeof Bun\b/g,
     'typeof __claudeBun',
-  ).replace(
+    'typeof Bun',
+    3,
+  );
+  patched = replaceRequired(
+    patched,
+    /\btypeof globalThis\.Bun\b/g,
+    'typeof globalThis.__claudeBun',
+    'typeof globalThis.Bun',
+    1,
+  );
+  patched = replaceRequired(
+    patched,
+    /\bglobalThis\.Bun\b/g,
+    'globalThis.__claudeBun',
+    'globalThis.Bun',
+    1,
+  );
+  patched = replaceRequired(
+    patched,
     /\bBun\./g,
     '__claudeBun.',
-  ).replace(
-    /function t5q\(q\)\{return Bun\.YAML\.parse\(q\)\}/g,
-    'function t5q(q){return globalThis.__claudeYaml.parse(q)}',
-  ).replace(
-    /function VK6\(q\)\{return Bun\.YAML\.stringify\(q,null,2\)\+`/g,
-    'function VK6(q){return globalThis.__claudeYaml.stringify(q,null,2)+`',
+    'Bun property access',
+    33,
   );
+  return patched;
+}
+
+async function main() {
+  let extractedFile;
+  extractedFile = ensureEntryFile();
+  const code = fs.readFileSync(extractedFile, 'utf8');
+  const patchedCode = rewriteNativeChunkSource(code);
   const fn = eval('(' + patchedCode.replace(/\)\s*$/, '') + ')');
 
   const originalArgv = process.argv.slice();
@@ -389,6 +601,9 @@ async function main() {
     globalThis.Bun = {
       version: '1.1.8',
       stringWidth,
+      wrapAnsi,
+      stripANSI,
+      hash: stableHash,
       which: (cmd) => {
         try {
           return _realChild.execFileSync('which', [String(cmd)], { encoding: 'utf8' }).trim() || null;
@@ -424,9 +639,9 @@ async function main() {
           gte: (a, b) => _cmp(a, b) >= 0,
           lt: (a, b) => _cmp(a, b) < 0,
           lte: (a, b) => _cmp(a, b) <= 0,
-        };
-      })(),
-      YAML: globalThis.__claudeYaml,
+          };
+        })(),
+        YAML: globalThis.__claudeYaml,
     };
     Object.assign(globalThis.__claudeBunShim, globalThis.Bun);
     if (typeof globalThis.__claudeBunShim.gc !== 'function') {
@@ -439,10 +654,13 @@ async function main() {
       throw new RequestedExit(code);
     };
 
+    const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
-    await new Promise(resolve => setTimeout(resolve, 5000));
+    if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
+      await new Promise(resolve => setTimeout(resolve, printWaitMs));
+    }
     if (asyncErrors.length > 0) throw asyncErrors[0];
   } catch (error) {
     if (error instanceof RequestedExit) {
@@ -453,6 +671,11 @@ async function main() {
   } finally {
     process.removeListener('uncaughtException', onAsyncError);
     process.removeListener('unhandledRejection', onAsyncError);
+    if (extractedFile) {
+      try {
+        fs.rmSync(extractedFile, { force: true });
+      } catch {}
+    }
     process.argv = originalArgv;
     process.exit = originalExit;
     try {
@@ -488,7 +711,7 @@ NODE
   trap - EXIT HUP INT TERM
   exit "$_status"
 else
-  _bootstrap=$(mktemp "${TMPDIR:-/tmp}/claude-bootstrap.XXXXXX.js")
+  _bootstrap=$(mktemp "${TERMUX_TMPDIR}/claude-bootstrap.XXXXXX.js")
   trap 'rm -f "$_bootstrap"' EXIT HUP INT TERM
   cat <<'NODE' > "$_bootstrap"
 const fs = require('fs');
@@ -512,8 +735,39 @@ class RequestedExit extends Error {
   }
 }
 
+function cleanupStaleEntryFiles(currentWorkdir = workdir, currentEntryJsOffset = entryJsOffset, currentEntryEndOffset = entryEndOffset, now = Date.now()) {
+  const prefix = `cli.${currentEntryJsOffset}.${currentEntryEndOffset}.`;
+  const suffix = '.bare-path.js';
+  const maxAgeMs = 24 * 60 * 60 * 1000;
+  let entries;
+  try {
+    entries = fs.readdirSync(currentWorkdir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    if (!entry.name.startsWith(prefix) || !entry.name.endsWith(suffix)) continue;
+    const filePath = path.join(currentWorkdir, entry.name);
+    let stats;
+    try {
+      stats = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+    if (Number.isFinite(stats.mtimeMs) && now - stats.mtimeMs < maxAgeMs) continue;
+    try {
+      fs.rmSync(filePath, { force: true });
+    } catch {}
+  }
+}
+
 function ensureEntryFile() {
-  const extractedFile = path.join(workdir, `cli.${entryJsOffset}.${entryEndOffset}.bare-path.js`);
+  cleanupStaleEntryFiles();
+  const extractedFile = path.join(
+    workdir,
+    `cli.${entryJsOffset}.${entryEndOffset}.${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}.bare-path.js`,
+  );
   const len = entryEndOffset - entryJsOffset;
   if (!(len > 0)) throw new Error('invalid replay offsets');
 
@@ -526,15 +780,165 @@ function ensureEntryFile() {
   return extractedFile;
 }
 
+function isFullWidthCodePoint(codePoint) {
+  return Number.isFinite(codePoint) && (
+    codePoint >= 0x1100 && (
+      codePoint <= 0x115f ||
+      codePoint === 0x2329 ||
+      codePoint === 0x232a ||
+      (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+      (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+      (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+      (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+      (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+      (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+      (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+      (codePoint >= 0x1f300 && codePoint <= 0x1f6ff) ||
+      (codePoint >= 0x1fa70 && codePoint <= 0x1faff) ||
+      (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+      (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+    )
+  );
+}
+
+function graphemeWidth(grapheme) {
+  let width = 0;
+  const symbols = Array.from(String(grapheme ?? ''));
+  const codePoints = symbols.map(symbol => symbol.codePointAt(0)).filter(codePoint => Number.isFinite(codePoint));
+  if (codePoints.length === 0) return 0;
+  if (codePoints.length > 1 && codePoints.every(codePoint => codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff)) {
+    return 2;
+  }
+  if (codePoints.includes(0x20e3) || codePoints.includes(0x200d)) {
+    return 2;
+  }
+  if (codePoints.includes(0xfe0f) || codePoints.some(codePoint => codePoint >= 0x2600 && codePoint <= 0x27bf)) {
+    return 2;
+  }
+  for (const symbol of symbols) {
+    const codePoint = symbol.codePointAt(0);
+    if (codePoint === undefined || codePoint === 0) continue;
+    if (codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0)) continue;
+    if (codePoint === 0x200d || codePoint === 0xfe0f) continue;
+    if (/\p{M}/u.test(symbol)) continue;
+    if (isFullWidthCodePoint(codePoint)) return 2;
+    width = 1;
+  }
+  return width;
+}
+
 function stringWidth(value) {
-  const text = String(value ?? '');
+  const text = stripANSI(value);
   if (typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function') {
     const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
     let width = 0;
-    for (const _segment of segmenter.segment(text)) width += 1;
+    for (const segment of segmenter.segment(text)) width += graphemeWidth(segment.segment);
     return width;
   }
-  return Array.from(text).length;
+  return Array.from(text).reduce((width, symbol) => width + graphemeWidth(symbol), 0);
+}
+
+function stripANSI(value) {
+  return String(value ?? '')
+    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, '');
+}
+
+function wrapAnsi(value, columns, options = {}) {
+  const text = String(value ?? '');
+  const width = Number(columns);
+  const hard = options.hard !== false;
+  const trim = options.trim === true;
+  const wordWrap = options.wordWrap !== false;
+  if (!Number.isFinite(width) || width <= 0) return trim ? text.trimEnd() : text;
+
+  const ansiPattern = /\x1B\[[0-?]*[ -/]*[@-~]|\x1B\][^\x07]*(?:\x07|\x1B\\)/g;
+  const segmenter = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
+    ? new Intl.Segmenter('en', { granularity: 'grapheme' })
+    : null;
+  const splitVisible = (chunk) => {
+    if (chunk === '') return [];
+    if (!segmenter) return Array.from(chunk);
+    return Array.from(segmenter.segment(chunk), part => part.segment);
+  };
+  const splitByGrapheme = hard || !wordWrap;
+  let result = '';
+  let currentWidth = 0;
+  let lastIndex = 0;
+  const appendVisible = (chunk) => {
+    const tokens = splitByGrapheme ? splitVisible(chunk) : (chunk.match(/\s+|[^\s]+/gu) || []);
+    for (const token of tokens) {
+      if (token === '\n') {
+        if (trim) result = result.replace(/[ \t]+$/g, '');
+        result += token;
+        currentWidth = 0;
+        continue;
+      }
+      const tokenWidth = stringWidth(token);
+      const isWhitespace = /^\s+$/u.test(token);
+      if (trim && isWhitespace && currentWidth === 0) continue;
+      if (currentWidth > 0 && currentWidth + tokenWidth > width) {
+        if (!splitByGrapheme && !isWhitespace) {
+          result = result.replace(/[ \t]+$/g, '');
+          result += '\n';
+          currentWidth = 0;
+        } else {
+          for (const piece of splitVisible(token)) {
+            const pieceWidth = stringWidth(piece);
+            if (currentWidth > 0 && currentWidth + pieceWidth > width) {
+              if (trim) result = result.replace(/[ \t]+$/g, '');
+              result += '\n';
+              currentWidth = 0;
+            }
+            if (trim && /^\s+$/u.test(piece) && currentWidth === 0) continue;
+            result += piece;
+            currentWidth += pieceWidth;
+          }
+          continue;
+        }
+      }
+      result += token;
+      currentWidth += tokenWidth;
+    }
+  };
+  for (const match of text.matchAll(ansiPattern)) {
+    appendVisible(text.slice(lastIndex, match.index ?? 0));
+    result += match[0];
+    lastIndex = (match.index ?? 0) + match[0].length;
+  }
+  appendVisible(text.slice(lastIndex));
+  return trim ? result.replace(/[ \t]+$/gm, '') : result;
+}
+
+function stableHash(value, seed) {
+  const text = String(value ?? '');
+  let hash = 2166136261;
+  if (seed !== undefined) {
+    const seedText = String(seed ?? '');
+    for (let i = 0; i < seedText.length; i += 1) {
+      hash ^= seedText.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    hash ^= 0x9e3779b9;
+    hash = Math.imul(hash, 16777619);
+  }
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function replaceRequired(source, pattern, replacement, label, expectedCount) {
+  const text = String(source);
+  const matches = text.match(pattern);
+  if (!matches || matches.length === 0) {
+    throw new Error(`rewriteNativeChunkSource: missing ${label}`);
+  }
+  if (expectedCount !== undefined && matches.length !== expectedCount) {
+    throw new Error(`rewriteNativeChunkSource: unexpected ${label} count ${matches.length}`);
+  }
+  return text.replace(pattern, replacement);
 }
 
 function parseScalar(value) {
@@ -633,6 +1037,63 @@ function createFakeRequire(realRequire) {
   const realChild = realRequire('child_process');
   const realVm = realRequire('vm');
 
+  function injectBunIntoContext(context) {
+    if (!context || typeof context !== 'object') return context;
+    try {
+      if (!Object.prototype.hasOwnProperty.call(context, '__claudeYaml')) {
+        Object.defineProperty(context, '__claudeYaml', {
+          value: globalThis.__claudeYaml,
+          configurable: true,
+          writable: true,
+        });
+      }
+      if (!Object.prototype.hasOwnProperty.call(context, '__claudeBunShim')) {
+        Object.defineProperty(context, '__claudeBunShim', {
+          value: globalThis.__claudeBunShim,
+          configurable: true,
+          writable: true,
+        });
+      }
+      if (!Object.prototype.hasOwnProperty.call(context, '__claudeBun')) {
+        Object.defineProperty(context, '__claudeBun', {
+          value: globalThis.__claudeBunShim,
+          configurable: true,
+          writable: true,
+        });
+      }
+      if (Object.prototype.hasOwnProperty.call(context, 'Bun')) {
+        if (context.Bun && typeof context.Bun === 'object' && context.Bun !== globalThis.Bun) {
+          try {
+            context.Bun = globalThis.Bun;
+          } catch {
+            Object.defineProperty(context, 'Bun', {
+              value: globalThis.Bun,
+              configurable: true,
+              writable: true,
+            });
+          }
+        }
+        if (!context.Bun || typeof context.Bun !== 'object') {
+          Object.defineProperty(context, 'Bun', {
+            value: globalThis.Bun,
+            configurable: true,
+            writable: true,
+          });
+        }
+      } else {
+        Object.defineProperty(context, 'Bun', {
+          value: globalThis.Bun,
+          configurable: true,
+          writable: true,
+        });
+      }
+      if (context.Bun && globalThis.__claudeYaml) {
+        context.Bun.YAML = globalThis.__claudeYaml;
+      }
+    } catch {}
+    return context;
+  }
+
   function rewriteArgs(args) {
     if (
       Array.isArray(args) &&
@@ -729,25 +1190,53 @@ function createFakeRequire(realRequire) {
   };
 }
 
-async function main() {
-  const extractedFile = ensureEntryFile();
-  const code = fs.readFileSync(extractedFile, 'utf8');
-  const patchedCode = code.replace(
-    /^function\(exports, require, module, __filename, __dirname\) \{/,
-    'function(exports, require, module, __filename, __dirname) {var __claudeBun = globalThis.__claudeBunShim;',
-  ).replace(
+function rewriteNativeChunkSource(source) {
+  const rawPrefix = 'function(exports, require, module, __filename, __dirname) {';
+  const injectedPrefix = rawPrefix + 'var __claudeBun = globalThis.__claudeBunShim;';
+  let patched = String(source);
+  patched = replaceRequired(
+    patched,
+    /^function\(exports, require, module, __filename, __dirname\) \{(?:var __claudeBun = globalThis\.__claudeBunShim;)?/,
+    injectedPrefix,
+    'module wrapper prefix',
+    1,
+  );
+  patched = replaceRequired(
+    patched,
     /\btypeof Bun\b/g,
     'typeof __claudeBun',
-  ).replace(
+    'typeof Bun',
+    3,
+  );
+  patched = replaceRequired(
+    patched,
+    /\btypeof globalThis\.Bun\b/g,
+    'typeof globalThis.__claudeBun',
+    'typeof globalThis.Bun',
+    1,
+  );
+  patched = replaceRequired(
+    patched,
+    /\bglobalThis\.Bun\b/g,
+    'globalThis.__claudeBun',
+    'globalThis.Bun',
+    1,
+  );
+  patched = replaceRequired(
+    patched,
     /\bBun\./g,
     '__claudeBun.',
-  ).replace(
-    /function t5q\(q\)\{return Bun\.YAML\.parse\(q\)\}/g,
-    'function t5q(q){return globalThis.__claudeYaml.parse(q)}',
-  ).replace(
-    /function VK6\(q\)\{return Bun\.YAML\.stringify\(q,null,2\)\+`/g,
-    'function VK6(q){return globalThis.__claudeYaml.stringify(q,null,2)+`',
+    'Bun property access',
+    33,
   );
+  return patched;
+}
+
+async function main() {
+  let extractedFile;
+  extractedFile = ensureEntryFile();
+  const code = fs.readFileSync(extractedFile, 'utf8');
+  const patchedCode = rewriteNativeChunkSource(code);
   const fn = eval('(' + patchedCode.replace(/\)\s*$/, '') + ')');
 
   const originalArgv = process.argv.slice();
@@ -774,6 +1263,9 @@ async function main() {
     globalThis.Bun = {
       version: '1.1.8',
       stringWidth,
+      wrapAnsi,
+      stripANSI,
+      hash: stableHash,
       which: (cmd) => {
         try {
           return _realChild.execFileSync('which', [String(cmd)], { encoding: 'utf8' }).trim() || null;
@@ -810,8 +1302,8 @@ async function main() {
           lt: (a, b) => _cmp(a, b) < 0,
           lte: (a, b) => _cmp(a, b) <= 0,
         };
-      })(),
-      YAML: globalThis.__claudeYaml,
+        })(),
+        YAML: globalThis.__claudeYaml,
     };
     Object.assign(globalThis.__claudeBunShim, globalThis.Bun);
     if (typeof globalThis.__claudeBunShim.gc !== 'function') {
@@ -827,8 +1319,6 @@ async function main() {
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
-    const _waitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 200);
-    await new Promise(resolve => setTimeout(resolve, _waitMs));
     if (asyncErrors.length > 0) throw asyncErrors[0];
   } catch (error) {
     if (error instanceof RequestedExit) {
@@ -841,17 +1331,25 @@ async function main() {
     process.removeListener('unhandledRejection', onAsyncError);
     process.argv = originalArgv;
     process.exit = originalExit;
-    try {
-      if (originalBun === undefined) {
-        delete process.versions.bun;
-      } else {
-        Object.defineProperty(process.versions, 'bun', { value: originalBun, configurable: true });
+    process.once('exit', () => {
+      if (extractedFile) {
+        try {
+          fs.rmSync(extractedFile, { force: true });
+        } catch {}
       }
-    } catch {}
-    delete globalThis.__claudeYaml;
-    delete globalThis.__claudeBunShim;
-    delete globalThis.__claudeBun;
-    if (hadGlobalBun) globalThis.Bun = originalGlobalBun;
+      try {
+        if (originalBun === undefined) {
+          delete process.versions.bun;
+        } else {
+          Object.defineProperty(process.versions, 'bun', { value: originalBun, configurable: true });
+        }
+      } catch {}
+      delete globalThis.__claudeYaml;
+      delete globalThis.__claudeBunShim;
+      delete globalThis.__claudeBun;
+      if (hadGlobalBun) globalThis.Bun = originalGlobalBun;
+      else delete globalThis.Bun;
+    });
   }
 }
 

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

@@ -0,0 +1,321 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('crypto');
+const child_process = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vm = require('vm');
+
+const scriptPath = path.join(__dirname, 'termux-run-claude-native.sh');
+const script = fs.readFileSync(scriptPath, 'utf8');
+
+function extractBlock(marker, trailer) {
+  const start = script.indexOf(marker);
+  assert.notEqual(start, -1, `missing marker: ${marker}`);
+  const bodyStart = script.indexOf('\n', start);
+  assert.notEqual(bodyStart, -1, `missing body start: ${marker}`);
+  const end = script.indexOf(trailer, bodyStart + 1);
+  assert.notEqual(end, -1, `missing trailer: ${trailer}`);
+  return script.slice(bodyStart + 1, end);
+}
+
+function extractFunction(block, startName, endName) {
+  const start = block.indexOf(startName);
+  assert.notEqual(start, -1, `missing function: ${startName}`);
+  const end = block.indexOf(endName, start);
+  assert.notEqual(end, -1, `missing end marker: ${endName}`);
+  return block.slice(start, end).trimEnd();
+}
+
+function loadHelperApi() {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=');
+  const replaceSource = extractFunction(
+    helperBlock,
+    'function replaceRequired(source, pattern, replacement, label, expectedCount) {',
+    '\n\nfunction parseScalar(value) {',
+  );
+  const fullWidthSource = extractFunction(
+    helperBlock,
+    'function isFullWidthCodePoint(codePoint) {',
+    '\n\nfunction graphemeWidth(grapheme) {',
+  );
+  const graphemeWidthSource = extractFunction(
+    helperBlock,
+    'function graphemeWidth(grapheme) {',
+    '\n\nfunction stringWidth(value) {',
+  );
+  const stringWidthSource = extractFunction(
+    helperBlock,
+    'function stringWidth(value) {',
+    '\n\nfunction stripANSI(value) {',
+  );
+  const stripAnsiSource = extractFunction(
+    helperBlock,
+    'function stripANSI(value) {',
+    '\n\nfunction wrapAnsi(value, columns, options = {}) {',
+  );
+  const cleanupSource = extractFunction(
+    helperBlock,
+    'function cleanupStaleEntryFiles(currentWorkdir = workdir, currentEntryJsOffset = entryJsOffset, currentEntryEndOffset = entryEndOffset, now = Date.now()) {',
+    '\n\nfunction ensureEntryFile() {',
+  );
+  const wrapAnsiSource = extractFunction(
+    helperBlock,
+    'function wrapAnsi(value, columns, options = {}) {',
+    '\n\nfunction stableHash(value, seed) {',
+  );
+  const stableHashSource = extractFunction(
+    helperBlock,
+    'function stableHash(value, seed) {',
+    '\n\nfunction replaceRequired(source, pattern, replacement, label, expectedCount) {',
+  );
+  const rewriteSource = extractFunction(
+    helperBlock,
+    'function rewriteNativeChunkSource(source) {',
+    '\n\nasync function main() {',
+  );
+
+  const context = vm.createContext({ module: { exports: {} }, exports: {}, fs, path });
+  vm.runInContext(
+    `${replaceSource}\n${cleanupSource}\n${fullWidthSource}\n${graphemeWidthSource}\n${stripAnsiSource}\n${stringWidthSource}\n${wrapAnsiSource}\n${stableHashSource}\n${rewriteSource}\nmodule.exports = { replaceRequired, cleanupStaleEntryFiles, isFullWidthCodePoint, graphemeWidth, stripANSI, stringWidth, wrapAnsi, stableHash, rewriteNativeChunkSource };`,
+    context,
+  );
+  return context.module.exports;
+}
+
+function sha256(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+test('helper and bootstrap rewrite helpers stay identical', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=');
+
+  const helperReplace = extractFunction(
+    helperBlock,
+    'function replaceRequired(source, pattern, replacement, label, expectedCount) {',
+    '\n\nfunction parseScalar(value) {',
+  );
+  const bootstrapReplace = extractFunction(
+    bootstrapBlock,
+    'function replaceRequired(source, pattern, replacement, label, expectedCount) {',
+    '\n\nfunction parseScalar(value) {',
+  );
+  const helperRewrite = extractFunction(
+    helperBlock,
+    'function rewriteNativeChunkSource(source) {',
+    '\n\nasync function main() {',
+  );
+  const bootstrapRewrite = extractFunction(
+    bootstrapBlock,
+    'function rewriteNativeChunkSource(source) {',
+    '\n\nasync function main() {',
+  );
+  const helperWrapAnsi = extractFunction(
+    helperBlock,
+    'function wrapAnsi(value, columns, options = {}) {',
+    '\n\nfunction stableHash(value, seed) {',
+  );
+  const helperCleanup = extractFunction(
+    helperBlock,
+    'function cleanupStaleEntryFiles(currentWorkdir = workdir, currentEntryJsOffset = entryJsOffset, currentEntryEndOffset = entryEndOffset, now = Date.now()) {',
+    '\n\nfunction ensureEntryFile() {',
+  );
+  const bootstrapWrapAnsi = extractFunction(
+    bootstrapBlock,
+    'function wrapAnsi(value, columns, options = {}) {',
+    '\n\nfunction stableHash(value, seed) {',
+  );
+  const bootstrapCleanup = extractFunction(
+    bootstrapBlock,
+    'function cleanupStaleEntryFiles(currentWorkdir = workdir, currentEntryJsOffset = entryJsOffset, currentEntryEndOffset = entryEndOffset, now = Date.now()) {',
+    '\n\nfunction ensureEntryFile() {',
+  );
+  const helperStableHash = extractFunction(
+    helperBlock,
+    'function stableHash(value, seed) {',
+    '\n\nfunction replaceRequired(source, pattern, replacement, label, expectedCount) {',
+  );
+  const bootstrapStableHash = extractFunction(
+    bootstrapBlock,
+    'function stableHash(value, seed) {',
+    '\n\nfunction replaceRequired(source, pattern, replacement, label, expectedCount) {',
+  );
+  const helperStringWidth = extractFunction(
+    helperBlock,
+    'function isFullWidthCodePoint(codePoint) {',
+    '\n\nfunction graphemeWidth(grapheme) {',
+  ) + '\n\n' + extractFunction(
+    helperBlock,
+    'function graphemeWidth(grapheme) {',
+    '\n\nfunction stringWidth(value) {',
+  ) + '\n\n' + extractFunction(
+    helperBlock,
+    'function stringWidth(value) {',
+    '\n\nfunction stripANSI(value) {',
+  );
+  const bootstrapStringWidth = extractFunction(
+    bootstrapBlock,
+    'function isFullWidthCodePoint(codePoint) {',
+    '\n\nfunction graphemeWidth(grapheme) {',
+  ) + '\n\n' + extractFunction(
+    bootstrapBlock,
+    'function graphemeWidth(grapheme) {',
+    '\n\nfunction stringWidth(value) {',
+  ) + '\n\n' + extractFunction(
+    bootstrapBlock,
+    'function stringWidth(value) {',
+    '\n\nfunction stripANSI(value) {',
+  );
+
+  assert.equal(helperReplace, bootstrapReplace);
+  assert.equal(helperRewrite, bootstrapRewrite);
+  assert.equal(helperWrapAnsi, bootstrapWrapAnsi);
+  assert.equal(helperCleanup, bootstrapCleanup);
+  assert.equal(helperStableHash, bootstrapStableHash);
+  assert.equal(helperStringWidth, bootstrapStringWidth);
+});
+
+test('print path does not defer cleanup to exit', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=');
+
+  assert.equal(helperBlock.includes('CLAUDE_TERMUX_PRINT_WAIT_MS'), true);
+  assert.equal(helperBlock.includes('setTimeout(resolve, printWaitMs)'), true);
+  assert.equal(helperBlock.includes('process.once(\'exit\''), false);
+  assert.equal(helperBlock.includes('process.removeListener(\'uncaughtException\''), true);
+});
+
+test('bootstrap path defers cleanup to exit', () => {
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=');
+
+  assert.equal(bootstrapBlock.includes('CLAUDE_TERMUX_PRINT_WAIT_MS'), false);
+  assert.equal(bootstrapBlock.includes('setTimeout(resolve, printWaitMs)'), false);
+  assert.equal(bootstrapBlock.includes('process.once(\'exit\''), true);
+  assert.equal(bootstrapBlock.includes('process.removeListener(\'uncaughtException\''), true);
+});
+
+test('entry extraction uses a process-unique filename', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=');
+
+  assert.equal(helperBlock.includes('process.pid'), true);
+  assert.equal(helperBlock.includes('Math.random'), true);
+  assert.equal(bootstrapBlock.includes('process.pid'), true);
+  assert.equal(bootstrapBlock.includes('Math.random'), true);
+});
+
+test('replaceRequired enforces the expected replacement count', () => {
+  const { replaceRequired } = loadHelperApi();
+
+  assert.equal(replaceRequired('abc abc', /abc/g, 'x', 'abc', 2), 'x x');
+  assert.throws(
+    () => replaceRequired('abc abc', /abc/g, 'x', 'abc', 1),
+    /unexpected abc count 2/,
+  );
+});
+
+test('stringWidth treats full-width and combining text as expected', () => {
+  const { stringWidth } = loadHelperApi();
+
+  assert.equal(stringWidth('abc'), 3);
+  assert.equal(stringWidth('あ'), 2);
+  assert.equal(stringWidth('a\u0301'), 1);
+  assert.equal(stringWidth('🙂'), 2);
+  assert.equal(stringWidth('🚀'), 2);
+  assert.equal(stringWidth('🚗'), 2);
+  assert.equal(stringWidth('❤️'), 2);
+  assert.equal(stringWidth('☕️'), 2);
+  assert.equal(stringWidth('🇯🇵'), 2);
+  assert.equal(stringWidth('#️⃣'), 2);
+  assert.equal(stringWidth('👨‍👩‍👧‍👦'), 2);
+  assert.equal(stringWidth('\u001b[31mあ\u001b[0m'), 2);
+  assert.equal(stringWidth('\u001b[36m🇯🇵\u001b[0m'), 2);
+});
+
+test('stableHash incorporates the optional seed', () => {
+  const { stableHash } = loadHelperApi();
+
+  assert.equal(stableHash('abc', 123), stableHash('abc', 123));
+  assert.notEqual(stableHash('abc', 123), stableHash('abc', 456));
+});
+
+test('wrapAnsi respects soft wrap, trim, and no-wrap options', () => {
+  const { wrapAnsi } = loadHelperApi();
+
+  assert.equal(wrapAnsi('abc def', 4, { hard: false }), 'abc\ndef');
+  assert.equal(wrapAnsi('   abc', 10, { trim: true }), 'abc');
+  assert.equal(wrapAnsi('abc   ', 10, { trim: true }), 'abc');
+  assert.equal(wrapAnsi('abc def', 3, { wordWrap: false }).includes('\n'), true);
+  assert.equal(wrapAnsi('ab\u001b[31mcd', 3).includes('\n'), true);
+});
+
+test('cleanupStaleEntryFiles removes only stale extracted files for the same offsets', () => {
+  const { cleanupStaleEntryFiles } = loadHelperApi();
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-termux-'));
+  const tmpdir = fs.mkdtempSync(path.join(tmpRoot, 'work-'));
+  const stale = path.join(tmpdir, 'cli.11.22.123.old.bare-path.js');
+  const fresh = path.join(tmpdir, 'cli.11.22.456.new.bare-path.js');
+  const otherOffsets = path.join(tmpdir, 'cli.33.44.999.old.bare-path.js');
+  try {
+    fs.writeFileSync(stale, 'stale');
+    fs.writeFileSync(fresh, 'fresh');
+    fs.writeFileSync(otherOffsets, 'other');
+    const oldTime = new Date(Date.now() - (2 * 24 * 60 * 60 * 1000));
+    fs.utimesSync(stale, oldTime, oldTime);
+    fs.utimesSync(otherOffsets, oldTime, oldTime);
+
+    cleanupStaleEntryFiles(tmpdir, 11, 22, Date.now());
+
+    assert.equal(fs.existsSync(stale), false);
+    assert.equal(fs.existsSync(fresh), true);
+    assert.equal(fs.existsSync(otherOffsets), true);
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+function buildSyntheticBundleSource() {
+  const typeofBun = Array.from({ length: 3 }, () => 'typeof Bun').join('; ');
+  const bunProps = Array.from({ length: 33 }, (_, index) => `Bun.p${index}`).join('; ');
+  return `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; }`;
+}
+
+test('rewriteNativeChunkSource rewrites the synthetic bundle slice', () => {
+  const { rewriteNativeChunkSource } = loadHelperApi();
+  const source = buildSyntheticBundleSource();
+  const patched = rewriteNativeChunkSource(source);
+
+  assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
+  assert.match(patched, /typeof __claudeBun/);
+  assert.match(patched, /typeof globalThis\.__claudeBun/);
+  assert.match(patched, /globalThis\.__claudeBun/);
+  assert.match(patched, /__claudeBun\./);
+});
+
+test('rewriteNativeChunkSource rejects unexpected replacement counts', () => {
+  const { rewriteNativeChunkSource } = loadHelperApi();
+  const source = buildSyntheticBundleSource().replace('Bun.p30;', '');
+
+  assert.throws(
+    () => rewriteNativeChunkSource(source),
+    /unexpected Bun property access count 32/,
+  );
+});
+
+const tarballPath = path.join(__dirname, '..', 'bash0816-claude-code-2.1.177.tgz');
+
+test('tarball contents match the workspace runner and test file', { skip: !fs.existsSync(tarballPath) }, () => {
+  const tarRunner = child_process.execFileSync('tar', ['-xOf', tarballPath, 'package/lib/termux-run-claude-native.sh']);
+  const tarTest = child_process.execFileSync('tar', ['-xOf', tarballPath, 'package/lib/termux-run-claude-native.test.js']);
+
+  const worktreeRunner = fs.readFileSync(path.join(__dirname, 'termux-run-claude-native.sh'));
+  const worktreeTest = fs.readFileSync(path.join(__dirname, 'termux-run-claude-native.test.js'));
+
+  assert.equal(crypto.createHash('sha256').update(tarRunner).digest('hex'), crypto.createHash('sha256').update(worktreeRunner).digest('hex'));
+  assert.equal(crypto.createHash('sha256').update(tarTest).digest('hex'), crypto.createHash('sha256').update(worktreeTest).digest('hex'));
+  assert.equal(tarRunner.length, worktreeRunner.length);
+  assert.equal(tarTest.length, worktreeTest.length);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.161",
+  "version": "2.1.177",
   "description": "Unofficial Termux-native Claude Code wrapper with audited native replay",
   "license": "Apache-2.0",
   "bin": {